Ruby shoes flavored tkinter.

gui, shoes, tkinter
pip install sneakers==0.0.1



A TkInter wrapper for python inspired by the GUI library Shoes for Ruby.

This is intended to make it easier to create simple GUI interfaces quickly. All these classes inheret from their TkInter counterparts so you can use them just as you would their original TkInter counterparts if need be.

To use this library you can star import to get access to all classes and functions;

from sneakers import *

How to create windows

Context managers are used to create windows, stacks (columns) and flows (rows).

For example, this is how a context manager is used to make a window;

from sandals import *
with window("My window"):
label("Hello world")

Manipulating buttons example

The way stacks and flows work was intended to be the same as with the Ruby library Shoes, but it's not quite there yet. Info on how they're meant to work can be found on the Ruby Shoes website:

As mentioned below, the library needs to be ideally be rewritten to use TkInter grids, rather than just packing elements in different ways, which is something I'm working on at the moment. The @button and other GUI decorators

Adding the decorator


to a function adds a button that triggers that function. The button is located in whatever context manager the function is defined in.

For example, this code will create a window with a button, which when clicked will create a popup;

from sandals import *
with window():
@button("Create a popup box")
def makePopupBox():
showInfo(message = "You clicked the button")

Button example

Checkboxes, radio buttons, spin boxes, scale bars, and option menus can all be applied as decorators in a similar way. They are also located in whatever context manager (window, stack or flow) the function is defined in. For example, here is a simple implementation of a check box to change a boolean;

@checkBox("Is the oven on?", checked = True)
def ovenOn(checked):
	theOvenIsOn = checked

And here is a simple example of how to implement an options menu;

label("How's the oven?")
@optionMenu("clean", "dirty", "broken")
def ovenState(option):
	print "The oven is", option

All these decorators can also be used as classes where this is more convenient. Manipulating buttons

Because these decorators inherit from their TkInter classes, they can be used as normal (i.e. not as decorators) and then configured using e.g. my_button.config(**kwargs).

Buttons can be altered even when created as a decorator, as they are added as a function attribute of the function they are applied to, so can be accessed via e.g. my_function.button.

All the TkInter adjectives used to modify buttons - such as DISABLE and NORMAL which describe the state of a disabled and enabled button respectively - are imported as well.

Here is an example where this method is used to disable a button created using a decorator;

from sandals import *
with window():
@button("This button does nothing")
def doNothing():

@button("Disable button")
def disableButton():
	doNothing.button.config(state = DISABLED)
Manipulating buttons example

The @repeat and @loop decorators

Two new decorators are included which you might not necessarily associate with a GUI library; The @repeat and @loop decorators.

These create a thread that repeats or loops the function the decorator is applied to. Once the context the decorated function is defined in is destroyed (e.g. closing a window) then that thread is stopped and the function will stop repeating or looping. As an example, here is a function that repeats once a minute;

def clock():
	print "A minute has passed"

The repeat and loop decorators are inspired by similar methods in Shoes, which turn out to be more useful than you might expect when designing a GUI.

Changing and reading text in GUI elements

How the text in labels and other GUI elements is changed to try and make them easier to work with.

A slightly more complex example that demonstrates this;

from sandals import *
with window("This is a window"):
    label("This is a label",
    font = "Verdana 24 bold underline")
    with stack(padx=10):
        myLabel = label("This text changes")
        @button("Change the above text",
            font = "Veranda 12 italic")
        def change_that_text():
            myLabel.text = "OMG it changed"
        with flow(pady=10):
            edit = editBox("edit me")
            @button("<-read edit box")
            def read_edit_box():
				= "Edit box says: "
				+ edit.text)
Simple example
Complete example -- has a more complete example of how to use the different methods, context managers, etc. which should look like this;

Complex example


  • Add to pip.
  • Add support for ttk
  • Rewrite to use tkinter grids as well as pack.
  • Retools this readme.
  • Add attribution from previous repositories.