├── README.md
├── setup.py
├── gui_fun
    └── __init__.py
└── notebooks
    └── tutorial.ipynb


/README.md:
--------------------------------------------------------------------------------
 1 | # gui_fun
 2 | Instantly create a gui for any Python function in a Jupyter notebook.
 3 | 
 4 | The basic idea is that if we create a function, say
 5 | 
 6 | <pre>
 7 |   def add(a,b):
 8 |     return a+b
 9 | </pre>
10 | 
11 | We can create a gui to collect the input (values for "a" and "b") and
12 | call the function to produce output by simply calling:
13 | <pre>
14 |   gui_fun(add)
15 | </pre>
16 | 
17 | For details, see the tutorial notebook.
18 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | from setuptools import setup, find_packages
 2 | 
 3 | setup(
 4 |   name='gui_fun',
 5 |   version='1.0.8',
 6 |   description='Create a basic gui for a function',
 7 |   long_description='''
 8 |   Create a basic gui for a function.
 9 |   Calling gui_fun(func) will generate a sequence of input boxes
10 |   for each argument in func, plus a run button to execute the function.
11 |   The output of gui_fun() is an asyncio.Future that can be queried for
12 |   the result.
13 |   ''',
14 |   url='http://cct.lsu.edu/~sbrandt/',
15 |   author='Steven R. Brandt',
16 |   author_email='steven@stevenrbrandt.com',
17 |   license='LGPL',
18 |   packages=['gui_fun']
19 | )
20 | 


--------------------------------------------------------------------------------
/gui_fun/__init__.py:
--------------------------------------------------------------------------------
  1 | import inspect
  2 | import pickle
  3 | import stat
  4 | import os
  5 | import re
  6 | import html
  7 | from ipywidgets import *
  8 | 
  9 | class ResultStream:
 10 |     def __init__(self):
 11 |         self.results = []
 12 |         self.listeners = []
 13 |     def add_listener(self, listener):
 14 |         self.listeners += [listener]
 15 |     def has_result(self):
 16 |         return len(self.results) > 0
 17 |     def pop_result(self):
 18 |         val = self.results[0]
 19 |         self.results = self.results[1:]
 20 |         return val
 21 |     def add_result(self,result):
 22 |         new_listeners = []
 23 |         for listener in self.listeners:
 24 |             try:
 25 |                 listener(result)
 26 |                 new_listeners += [listener]
 27 |             except Exception as e:
 28 |                 print(e)
 29 |         self.listeners = new_listeners
 30 |         self.results += [result]
 31 | 
 32 | display(HTML("""
 33 | <style>
 34 | .gui_label_style {
 35 |     background: black;
 36 |     color: white;
 37 |     font-weight: bold;
 38 |     padding-left: 5px;
 39 | }
 40 | .off_label_style_1 {
 41 |     background: #DDDDDD;
 42 |     padding-left: 5px;
 43 |     border: black solid 1px;
 44 |     font-weight: bold;
 45 | }
 46 | .off_label_style_0 {
 47 |     padding-left: 5px;
 48 |     border: black solid 1px;
 49 |     font-weight: bold;
 50 | }
 51 | </style>
 52 | """))
 53 | 
 54 | gui_settings = {}
 55 | 
 56 | def settings(f, s):
 57 |     global gui_settings
 58 |     fn = f.__name__
 59 |     mo = str(f.__module__)
 60 |     if mo not in gui_settings:
 61 |         gui_settings[mo] = {}
 62 |     gui_settings[mo][fn] = s
 63 | 
 64 | 
 65 | def load_property(f, tag):
 66 |     if tag == "defaults":
 67 |         return {}
 68 |     fn = f.__name__
 69 |     mo = str(f.__module__)
 70 |     path = os.path.join(os.environ["HOME"],"tmp",mo,fn,tag,"data.txt")
 71 |     if os.path.exists(path):
 72 |         with open(path,"rb") as fd:
 73 |             return pickle.loads(fd.read())
 74 |     return {}
 75 | 
 76 | def store_property(f,r,tag):
 77 |     fn = f.__name__
 78 |     mo = str(f.__module__)
 79 |     dirp = os.path.join(os.environ["HOME"],"tmp",mo,fn,tag)
 80 |     os.makedirs(dirp, exist_ok=True)
 81 |     path = os.path.join(dirp, "data.txt")
 82 |     with open(path, "wb") as fd:
 83 |         os.chmod(path, stat.S_IREAD | stat.S_IWRITE)
 84 |         fd.write(pickle.dumps(r))
 85 |         
 86 | # A length function that returns 0 for None
 87 | def zlen(z):
 88 |     if z is None:
 89 |         return 0
 90 |     else:
 91 |         return len(z)
 92 | 
 93 | # Convert a string from the input. If the string
 94 | # begins with [ or {, it is a list or an array
 95 | # and eval should be called.
 96 | def unstr(s):
 97 |     if type(s) != str:
 98 |         return s
 99 | 
100 |     if s == "None":
101 |         return None
102 |     elif re.match(r'[\[{"]',s):
103 |         return eval(s)
104 |     else:
105 |         return s
106 | 
107 | def BLabel(value,style):
108 |     label = Label(value=value)
109 |     label.add_class(style)
110 |     return label
111 | 
112 | def gui_fun(f, tag="", defaults=None, settings = None):
113 |     global gui_settings
114 |     fn = f.__name__
115 |     mo = str(f.__module__)
116 |     if settings is None:
117 |         if mo in gui_settings:
118 |             settings = gui_settings[mo].get(fn, None)
119 |     if settings is None:
120 |         settings = {}
121 | 
122 |     fargs = inspect.getfullargspec(f)
123 |     # widgets to collect data
124 |     disp = []
125 |     # labels for the widgets, using the description
126 |     # field in the widget seems not to work right.
127 |     # If the description it gets too long and no
128 |     # setting of Layout fixes it.
129 |     desc = []
130 |     disp += [BLabel(value=f.__name__,style='gui_label_style')]
131 |     desc += [Label()]
132 |     index = 1
133 |     for i in range(len(fargs.args)):
134 |         arg = fargs.args[i]
135 |         if arg == "self" and i == 0:
136 |             index = 0
137 |             continue
138 |         a = fargs.annotations.get(arg, None)
139 |         if type(settings.get(arg,"")) == list:
140 |             options = settings.get(arg)
141 |             if type(options[0]) == tuple:
142 |                 value = options[0][1]
143 |             else:
144 |                 value = options[0]
145 |             t = Dropdown(options=options, value=value)
146 |         elif a == list:
147 |             options = a
148 |             if type(options[0]) == tuple:
149 |                 value = options[0][0]
150 |             else:
151 |                 value = options[0]
152 |             t = Dropdown(options=options, value=value)
153 |         elif a == int:
154 |             t = IntText()
155 |         elif a == float:
156 |             t = FloatText()
157 |         elif settings.get(arg,"") == "password" or a == "password":
158 |             t = Password()
159 |         elif settings.get(arg,"") == "textarea" or a == "textarea":
160 |             t = Textarea()
161 |         else:
162 |             t = Text()
163 |         if i % 2 == 0:
164 |             d = BLabel(value=arg,style='off_label_style_1')
165 |         else:
166 |             d = BLabel(value=arg,style='off_label_style_0')
167 |         desc += [d]
168 |         disp += [t]
169 | 
170 |     # Create an array of blank strings to use
171 |     # for default display values
172 |     empty = object()
173 |     r = [empty for i in range(len(fargs.args))]
174 | 
175 |     # Load the default values from the
176 |     # function definitions.
177 |     off = zlen(fargs.args) - zlen(fargs.defaults)
178 |     for i in range(zlen(fargs.defaults)):
179 |         r[i+off] = fargs.defaults[i]
180 | 
181 |     # Load the values stored from the
182 |     # last time this function was invoked.
183 |     if defaults is not None:
184 |         pairs = load_property(f, defaults)
185 |         for i in range(len(fargs.args)):
186 |             r[i] = pairs.get(fargs.args[i], r[i])
187 |     pairs = load_property(f, tag)
188 |     for i in range(len(fargs.args)):
189 |         r[i] = pairs.get(fargs.args[i], r[i])
190 |     for i in range(len(fargs.args)):
191 |         # Don't prompt for the self field of
192 |         # member functions. That is already
193 |         # filled in if gui() is called properly.
194 |         if r[i] == empty:
195 |             pass
196 |         elif fargs.args[i] == "self":
197 |             pass 
198 |         elif type(disp[i+index]) in [Password, Text, Textarea]:
199 |             disp[i+index].value = str(r[i])
200 |         elif type(disp[i+index]) == IntText:
201 |             if r[i] == "":
202 |                 disp[i+index].value = 0
203 |             else:
204 |                 disp[i+index].value = int(r[i])
205 |         elif type(disp[i+index]) == FloatText:
206 |             if r[i] == "":
207 |                 disp[i+index].value = 0
208 |             else:
209 |                 disp[i+index].value = float(r[i])
210 |         elif type(disp[i+index]) == Dropdown:
211 |             disp[i+index].value = r[i]
212 |     run = Button(description="Run")
213 |     retval = ResultStream()
214 |     def gui_run(_):
215 |         vals = []
216 |         pairs = {}
217 |         for i in range(len(fargs.args)):
218 |             if i == 0 and fargs.args[0] == "self":
219 |                 pass
220 |             else:
221 |                 # load the values...
222 |                 d = disp[i+index]
223 |                 # load the argument names...
224 |                 l = desc[i+index]
225 |                 vals += [unstr(d.value)]
226 |                 # store them.
227 |                 pairs[l.value] = d.value
228 |         retval.add_result( f(*vals) )
229 |         # Because we store name value pairs,
230 |         # stored values will still load properly
231 |         # if we change the arguments around.
232 |         store_property(f, pairs, tag)
233 |     run.on_click(gui_run)
234 |     disp += [run]
235 |     desc += [Label()]
236 |     grid = []
237 |     for i in range(len(disp)):
238 |         grid += [desc[i], disp[i]]
239 |     display(GridBox(children=grid, layout=Layout(grid_template_columns='30% 50%')))
240 |     return retval
241 | 
242 | def ctype(x):
243 |     t = type(x)
244 |     if t == int:
245 |         return "itype"
246 |     elif t == float:
247 |         return "ftype"
248 |     elif t == list:
249 |         return "ltype"
250 |     elif t == dict:
251 |         return "dtype"
252 |     elif t == str:
253 |         return "stype"
254 |     elif t == tuple:
255 |         return "ttype"
256 |     else:
257 |         return "otype"
258 | 
259 | def ddata(x):
260 |     if type(x) in [list, set, tuple]:
261 |         out = "<table border=1 cellpadding=35 cellspacing=0>"
262 |         for i,k in enumerate(x):
263 |             out += "<tr><td class='num'>%d</td><td class='%s'>%s</td></tr>" % (i,ctype(k),ddata(k))
264 |         return out + "</table>"
265 |     elif type(x) == dict:
266 |         out = "<table border=1 cellpadding=5 cellspacing=5>"
267 |         for i in x:
268 |             out += "<tr><td class='key'>%s</td><td class='%s'>%s</td></tr>" % (ddata(i),ctype(x[i]),ddata(x[i]))
269 |         return out + "</table>"
270 |     else:
271 |         return html.escape(str(x))
272 | 
273 | def gui_show(x):
274 |     display(HTML("""
275 | <style>
276 | td {
277 |     padding: 3px;
278 | }
279 | td.num {
280 |     padding: 3px;
281 |     background: #ddFFdd;
282 | }
283 | td.key {
284 |     padding: 3px;
285 |     background: #ddddFF;
286 | }
287 | td.itype {
288 |     passing: 10px;
289 |     background: #aaffff;
290 | }
291 | td.ftype {
292 |     passing: 3px;
293 |     background: #ddffff;
294 | }
295 | td.stype {
296 |     passing: 3px;
297 |     background: #ffddff;
298 | }
299 | td.ttype {
300 |     passing: 3px;
301 |     background: #ffffdd;
302 | }
303 | td.otype {
304 |     passing: 3px;
305 |     background: #ffffff;
306 | }
307 | </style>
308 | """))
309 |     display(HTML(ddata(x)))
310 | 


--------------------------------------------------------------------------------
/notebooks/tutorial.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "metadata": {},
  7 |    "outputs": [
  8 |     {
  9 |      "data": {
 10 |       "application/vnd.jupyter.widget-view+json": {
 11 |        "model_id": "2d76e6689f3c4010a255eb1684d60a9b",
 12 |        "version_major": 2,
 13 |        "version_minor": 0
 14 |       },
 15 |       "text/plain": [
 16 |        "HTML(value='\\n<style>\\n.gui_label_style {\\n    background: black;\\n    color: white;\\n    font-weight: bold;\\n…"
 17 |       ]
 18 |      },
 19 |      "metadata": {},
 20 |      "output_type": "display_data"
 21 |     }
 22 |    ],
 23 |    "source": [
 24 |     "from gui_fun import gui_fun, settings"
 25 |    ]
 26 |   },
 27 |   {
 28 |    "cell_type": "markdown",
 29 |    "metadata": {},
 30 |    "source": [
 31 |     "In this example, we start with a function called add that adds two integers together."
 32 |    ]
 33 |   },
 34 |   {
 35 |    "cell_type": "code",
 36 |    "execution_count": 2,
 37 |    "metadata": {},
 38 |    "outputs": [],
 39 |    "source": [
 40 |     "def add(a : int,b : int):\n",
 41 |     "    return a+b"
 42 |    ]
 43 |   },
 44 |   {
 45 |    "cell_type": "markdown",
 46 |    "metadata": {},
 47 |    "source": [
 48 |     "In this next cell, the gui_fun package will\n",
 49 |     "find the argument names and types for \"add\" (if they are supplied) and construct a gui based on the information. The user can fill in the fields and click \"Run\" to execute the function."
 50 |    ]
 51 |   },
 52 |   {
 53 |    "cell_type": "code",
 54 |    "execution_count": 7,
 55 |    "metadata": {},
 56 |    "outputs": [
 57 |     {
 58 |      "data": {
 59 |       "application/vnd.jupyter.widget-view+json": {
 60 |        "model_id": "0b6033572467426483385d9137092c89",
 61 |        "version_major": 2,
 62 |        "version_minor": 0
 63 |       },
 64 |       "text/plain": [
 65 |        "HBox(children=(VBox(children=(Label(value=''), Label(value='a', _dom_classes=('off_label_style_1',)), Label(va…"
 66 |       ]
 67 |      },
 68 |      "metadata": {},
 69 |      "output_type": "display_data"
 70 |     }
 71 |    ],
 72 |    "source": [
 73 |     "r = gui_fun(add)"
 74 |    ]
 75 |   },
 76 |   {
 77 |    "cell_type": "markdown",
 78 |    "metadata": {},
 79 |    "source": [
 80 |     "The return value of gui_fun is something called a \"ResultStream.\" After each invocation of \"add\" by \"gui_fun\" another result can be added to the stream. We can get these values by calling pop_result()."
 81 |    ]
 82 |   },
 83 |   {
 84 |    "cell_type": "code",
 85 |    "execution_count": 8,
 86 |    "metadata": {},
 87 |    "outputs": [
 88 |     {
 89 |      "data": {
 90 |       "text/plain": [
 91 |        "6"
 92 |       ]
 93 |      },
 94 |      "execution_count": 8,
 95 |      "metadata": {},
 96 |      "output_type": "execute_result"
 97 |     }
 98 |    ],
 99 |    "source": [
100 |     "r.pop_result()"
101 |    ]
102 |   },
103 |   {
104 |    "cell_type": "code",
105 |    "execution_count": 14,
106 |    "metadata": {},
107 |    "outputs": [],
108 |    "source": [
109 |     "def foo(li,index:int=4):\n",
110 |     "    print(\"the list is:\",li)\n",
111 |     "    print(\"value at index\",index,\"is\",li[index])"
112 |    ]
113 |   },
114 |   {
115 |    "cell_type": "markdown",
116 |    "metadata": {},
117 |    "source": [
118 |     "If your function has defaults, gui_fun will try to use them. In this case, it gets the default\n",
119 |     "value of 4 from the definition of \"foo\" above."
120 |    ]
121 |   },
122 |   {
123 |    "cell_type": "code",
124 |    "execution_count": 15,
125 |    "metadata": {},
126 |    "outputs": [
127 |     {
128 |      "data": {
129 |       "application/vnd.jupyter.widget-view+json": {
130 |        "model_id": "3338120ab0424bbf926870868ef5d552",
131 |        "version_major": 2,
132 |        "version_minor": 0
133 |       },
134 |       "text/plain": [
135 |        "HBox(children=(VBox(children=(Label(value=''), Label(value='li', _dom_classes=('off_label_style_1',)), Label(v…"
136 |       ]
137 |      },
138 |      "metadata": {},
139 |      "output_type": "display_data"
140 |     },
141 |     {
142 |      "name": "stdout",
143 |      "output_type": "stream",
144 |      "text": [
145 |       "the list is: [1, 2, 3, 4, 5]\n",
146 |       "value at index 4 is 5\n"
147 |      ]
148 |     }
149 |    ],
150 |    "source": [
151 |     "r = gui_fun(foo)"
152 |    ]
153 |   },
154 |   {
155 |    "cell_type": "markdown",
156 |    "metadata": {},
157 |    "source": [
158 |     "By default, gui_fun interprets all arguments that lack type annotation as strings. Note that gui_fun correctly interpreted the first argument as a list. By default, gui_fun will\n",
159 |     "assume that any input beginning with a square bracket, parenthesis, or double quote should be passed to eval()."
160 |    ]
161 |   },
162 |   {
163 |    "cell_type": "markdown",
164 |    "metadata": {},
165 |    "source": [
166 |     "By default, every time you click \"Run\" and the function call does not throw an exception, gui_fun will save the argument values you used. In the future, it will re-use them as default values. This is convenient if you frequently call a function with only small changes. Optionally, you can supply a \"tag\" argument to gui_fun. When the tag is present, any saved default values will be unique to that tag.\n",
167 |     "\n",
168 |     "What if you don't want to make use of saved defaults? Just supply a tag with a value \"defaults.\""
169 |    ]
170 |   },
171 |   {
172 |    "cell_type": "markdown",
173 |    "metadata": {},
174 |    "source": [
175 |     "Now suppose you wish to use gui_fun for some kind of login function and you don't want the password to display. You can do this with settings."
176 |    ]
177 |   },
178 |   {
179 |    "cell_type": "code",
180 |    "execution_count": 16,
181 |    "metadata": {},
182 |    "outputs": [],
183 |    "source": [
184 |     "def login_func(name, passw):\n",
185 |     "    pass"
186 |    ]
187 |   },
188 |   {
189 |    "cell_type": "code",
190 |    "execution_count": 19,
191 |    "metadata": {},
192 |    "outputs": [],
193 |    "source": [
194 |     "from gui_fun import settings\n",
195 |     "settings(login_func, {\"passw\":\"password\"})"
196 |    ]
197 |   },
198 |   {
199 |    "cell_type": "code",
200 |    "execution_count": 20,
201 |    "metadata": {},
202 |    "outputs": [
203 |     {
204 |      "data": {
205 |       "application/vnd.jupyter.widget-view+json": {
206 |        "model_id": "ce4e944a849b4230b43f6f9c33731d82",
207 |        "version_major": 2,
208 |        "version_minor": 0
209 |       },
210 |       "text/plain": [
211 |        "HBox(children=(VBox(children=(Label(value=''), Label(value='name', _dom_classes=('off_label_style_1',)), Label…"
212 |       ]
213 |      },
214 |      "metadata": {},
215 |      "output_type": "display_data"
216 |     }
217 |    ],
218 |    "source": [
219 |     "r = gui_fun(login_func)"
220 |    ]
221 |   },
222 |   {
223 |    "cell_type": "markdown",
224 |    "metadata": {},
225 |    "source": [
226 |     "Settings can also be useful if you want multi-line input..."
227 |    ]
228 |   },
229 |   {
230 |    "cell_type": "code",
231 |    "execution_count": 23,
232 |    "metadata": {},
233 |    "outputs": [
234 |     {
235 |      "data": {
236 |       "application/vnd.jupyter.widget-view+json": {
237 |        "model_id": "0fc89fd02a7449e4948313260726a941",
238 |        "version_major": 2,
239 |        "version_minor": 0
240 |       },
241 |       "text/plain": [
242 |        "HBox(children=(VBox(children=(Label(value=''), Label(value='name', _dom_classes=('off_label_style_1',)), Label…"
243 |       ]
244 |      },
245 |      "metadata": {},
246 |      "output_type": "display_data"
247 |     }
248 |    ],
249 |    "source": [
250 |     "def save_para(name, para):\n",
251 |     "    pass\n",
252 |     "\n",
253 |     "settings(save_para, {\"para\":\"textarea\"})\n",
254 |     "\n",
255 |     "r = gui_fun(save_para)"
256 |    ]
257 |   },
258 |   {
259 |    "cell_type": "markdown",
260 |    "metadata": {},
261 |    "source": [
262 |     "Finally, you can use settings to create a multiple choice dropdown item instead of a textbox."
263 |    ]
264 |   },
265 |   {
266 |    "cell_type": "code",
267 |    "execution_count": 24,
268 |    "metadata": {},
269 |    "outputs": [],
270 |    "source": [
271 |     "settings(add, {\"a\":[(\"one\",1),(\"two\",2),(\"three\",3)]})"
272 |    ]
273 |   },
274 |   {
275 |    "cell_type": "code",
276 |    "execution_count": 26,
277 |    "metadata": {},
278 |    "outputs": [
279 |     {
280 |      "data": {
281 |       "application/vnd.jupyter.widget-view+json": {
282 |        "model_id": "0ca7036669f343178ec431f7712a5dfc",
283 |        "version_major": 2,
284 |        "version_minor": 0
285 |       },
286 |       "text/plain": [
287 |        "HBox(children=(VBox(children=(Label(value=''), Label(value='a', _dom_classes=('off_label_style_1',)), Label(va…"
288 |       ]
289 |      },
290 |      "metadata": {},
291 |      "output_type": "display_data"
292 |     }
293 |    ],
294 |    "source": [
295 |     "r = gui_fun(add,tag=\"ver2\")"
296 |    ]
297 |   },
298 |   {
299 |    "cell_type": "markdown",
300 |    "metadata": {},
301 |    "source": [
302 |     "If you want an action to take place after every call to your function, add a listener."
303 |    ]
304 |   },
305 |   {
306 |    "cell_type": "code",
307 |    "execution_count": 27,
308 |    "metadata": {},
309 |    "outputs": [
310 |     {
311 |      "data": {
312 |       "application/vnd.jupyter.widget-view+json": {
313 |        "model_id": "719c1f23ed6a4014bd91e82f65bd2b1c",
314 |        "version_major": 2,
315 |        "version_minor": 0
316 |       },
317 |       "text/plain": [
318 |        "HBox(children=(VBox(children=(Label(value=''), Label(value='a', _dom_classes=('off_label_style_1',)), Label(va…"
319 |       ]
320 |      },
321 |      "metadata": {},
322 |      "output_type": "display_data"
323 |     },
324 |     {
325 |      "name": "stdout",
326 |      "output_type": "stream",
327 |      "text": [
328 |       "add output: 6\n",
329 |       "add output: 3\n"
330 |      ]
331 |     }
332 |    ],
333 |    "source": [
334 |     "r = gui_fun(add)\n",
335 |     "r.add_listener(lambda val : print(\"add output:\",val))"
336 |    ]
337 |   },
338 |   {
339 |    "cell_type": "markdown",
340 |    "metadata": {},
341 |    "source": [
342 |     "Thanks for taking a look at gui_fun! :)"
343 |    ]
344 |   },
345 |   {
346 |    "cell_type": "code",
347 |    "execution_count": null,
348 |    "metadata": {},
349 |    "outputs": [],
350 |    "source": []
351 |   }
352 |  ],
353 |  "metadata": {
354 |   "kernelspec": {
355 |    "display_name": "Python 3",
356 |    "language": "python",
357 |    "name": "python3"
358 |   },
359 |   "language_info": {
360 |    "codemirror_mode": {
361 |     "name": "ipython",
362 |     "version": 3
363 |    },
364 |    "file_extension": ".py",
365 |    "mimetype": "text/x-python",
366 |    "name": "python",
367 |    "nbconvert_exporter": "python",
368 |    "pygments_lexer": "ipython3",
369 |    "version": "3.7.7"
370 |   }
371 |  },
372 |  "nbformat": 4,
373 |  "nbformat_minor": 4
374 | }
375 | 


--------------------------------------------------------------------------------