FM / dist-packages

/usr/lib/python3/dist-packages

Name	Size	Mode	Actions
acme/	-	0755	rm
acme-1.21.0.egg-info/	-	0755	rm
apport/	-	0755	rm
apt/	-	0755	rm
aptsources/	-	0755	rm
apt_inst-stubs/	-	0755	rm
apt_pkg-stubs/	-	0755	rm
attr/	-	0755	rm
attrs-21.2.0.egg-info/	-	0755	rm
automat/	-	0755	rm
Automat-20.2.0.egg-info/	-	0755	rm
babel/	-	0755	rm
Babel-2.8.0.egg-info/	-	0755	rm
bcrypt/	-	0755	rm
bcrypt-3.2.0.egg-info/	-	0755	rm
beautifulsoup4-4.10.0.egg-info/	-	0755	rm
blinker/	-	0755	rm
boost/	-	0755	rm
bs4/	-	0755	rm
certbot/	-	0755	rm
certbot-1.21.0.egg-info/	-	0755	rm
certbot_apache/	-	0755	rm
certbot_apache-1.21.0.egg-info/	-	0755	rm
certbot_dns_cloudflare/	-	0755	rm
certbot_dns_cloudflare-1.18.0.egg-info/	-	0755	rm
certbot_nginx/	-	0755	rm
certbot_nginx-1.21.0.egg-info/	-	0755	rm
certifi/	-	0755	rm
certifi-2020.6.20.egg-info/	-	0755	rm
chardet/	-	0755	rm
chardet-4.0.0.egg-info/	-	0755	rm
click/	-	0755	rm
click-8.0.3.egg-info/	-	0755	rm
CloudFlare/	-	0755	rm
cloudflare-2.8.14.egg-info/	-	0755	rm
cloudinit/	-	0755	rm
cloud_init-25.3.egg-info/	-	0755	rm
colorama/	-	0755	rm
colorama-0.4.4.egg-info/	-	0755	rm
CommandNotFound/	-	0755	rm
ConfigArgParse-1.5.3.egg-info/	-	0755	rm
configobj-5.0.6.egg-info/	-	0755	rm
constantly/	-	0755	rm
constantly-15.1.0.egg-info/	-	0755	rm
cryptography/	-	0755	rm
cryptography-3.4.8.egg-info/	-	0755	rm
dbus/	-	0755	rm
dbus_python-1.2.18.egg-info/	-	0755	rm
debian/	-	0755	rm
debian_bundle/	-	0755	rm
distro/	-	0755	rm
distro-1.7.0.egg-info/	-	0755	rm
distro_info-1.1+ubuntu0.2.egg-info/	-	0755	rm
DistUpgrade/	-	0755	rm
fail2ban/	-	0755	rm
fail2ban-0.11.2.egg-info/	-	0755	rm
gi/	-	0755	rm
hamcrest/	-	0755	rm
html5lib/	-	0755	rm
html5lib-1.1.egg-info/	-	0755	rm
httplib2/	-	0755	rm
httplib2-0.20.2.egg-info/	-	0755	rm
HweSupportStatus/	-	0755	rm
hyperlink/	-	0755	rm
hyperlink-21.0.0.egg-info/	-	0755	rm
icu/	-	0755	rm
idna/	-	0755	rm
idna-3.3.egg-info/	-	0755	rm
importlib_metadata/	-	0755	rm
importlib_metadata-4.6.4.egg-info/	-	0755	rm
incremental/	-	0755	rm
incremental-21.3.0.egg-info/	-	0755	rm
janitor/	-	0755	rm
jeepney/	-	0755	rm
jeepney-0.7.1.dist-info/	-	0755	rm
jinja2/	-	0755	rm
Jinja2-3.0.3.egg-info/	-	0755	rm
josepy/	-	0755	rm
josepy-1.10.0.egg-info/	-	0755	rm
jsonpatch-1.32.egg-info/	-	0755	rm
jsonpointer-2.0.egg-info/	-	0755	rm
jsonschema/	-	0755	rm
jsonschema-3.2.0.egg-info/	-	0755	rm
jwt/	-	0755	rm
keyring/	-	0755	rm
keyring-23.5.0.egg-info/	-	0755	rm
landscape/	-	0755	rm
launchpadlib/	-	0755	rm
launchpadlib-1.10.16.egg-info/	-	0755	rm
lazr/	-	0755	rm
lazr.restfulclient-0.14.4.egg-info/	-	0755	rm
lazr.uri-1.0.6.egg-info/	-	0755	rm
lxml/	-	0755	rm
lxml-4.8.0.egg-info/	-	0755	rm
magic/	-	0755	rm
markupsafe/	-	0755	rm
MarkupSafe-2.0.1.egg-info/	-	0755	rm
more_itertools/	-	0755	rm
more_itertools-8.10.0.egg-info/	-	0755	rm
nacl/	-	0755	rm
netifaces-0.11.0.egg-info/	-	0755	rm
oauthlib/	-	0755	rm
oauthlib-3.2.0.egg-info/	-	0755	rm
OpenSSL/	-	0755	rm
packaging/	-	0755	rm
packaging-21.3.egg-info/	-	0755	rm
parsedatetime/	-	0755	rm
parsedatetime-2.6.egg-info/	-	0755	rm
pexpect/	-	0755	rm
pkg_resources/	-	0755	rm
ptyprocess/	-	0755	rm
ptyprocess-0.7.0.dist-info/	-	0755	rm
pyasn1/	-	0755	rm
pyasn1-0.4.8.egg-info/	-	0755	rm
pyasn1_modules/	-	0755	rm
PyGObject-3.42.1.egg-info/	-	0755	rm
pygtkcompat/	-	0755	rm
PyHamcrest-2.0.2.egg-info/	-	0755	rm
PyICU-2.8.1.egg-info/	-	0755	rm
PyJWT-2.3.0.egg-info/	-	0755	rm
pymacaroons/	-	0755	rm
pymacaroons-0.13.0.egg-info/	-	0755	rm
PyNaCl-1.5.0.dist-info/	-	0755	rm
pyOpenSSL-21.0.0.egg-info/	-	0755	rm
pyparsing-2.4.7.egg-info/	-	0755	rm
pyrfc3339/	-	0755	rm
pyRFC3339-1.1.egg-info/	-	0755	rm
pyrsistent/	-	0755	rm
pyrsistent-0.18.1.egg-info/	-	0755	rm
pyserial-3.5.egg-info/	-	0755	rm
python_apt-2.4.0+ubuntu4.1.egg-info/	-	0755	rm
python_debian-0.1.43+ubuntu1.1.egg-info/	-	0755	rm
python_magic-0.4.24.egg-info/	-	0755	rm
pytz/	-	0755	rm
pytz-2022.1.egg-info/	-	0755	rm
PyYAML-5.4.1.egg-info/	-	0755	rm
requests/	-	0755	rm
requests-2.25.1.egg-info/	-	0755	rm
requests_toolbelt/	-	0755	rm
requests_toolbelt-0.9.1.egg-info/	-	0755	rm
secretstorage/	-	0755	rm
SecretStorage-3.3.1.egg-info/	-	0755	rm
serial/	-	0755	rm
service_identity/	-	0755	rm
service_identity-18.1.0.egg-info/	-	0755	rm
setuptools/	-	0755	rm
setuptools-59.6.0.egg-info/	-	0755	rm
six-1.16.0.egg-info/	-	0755	rm
softwareproperties/	-	0755	rm
sos/	-	0755	rm
sos-4.10.2.egg-info/	-	0755	rm
soupsieve/	-	0755	rm
soupsieve-2.3.1.egg-info/	-	0755	rm
ssh_import_id/	-	0755	rm
ssh_import_id-5.11.egg-info/	-	0755	rm
systemd/	-	0755	rm
twisted/	-	0755	rm
Twisted-22.1.0.egg-info/	-	0755	rm
uaclient/	-	0755	rm
ubuntu_pro_client-8001.egg-info/	-	0755	rm
ufw/	-	0755	rm
unattended_upgrades-0.1.egg-info/	-	0755	rm
UpdateManager/	-	0755	rm
urllib3/	-	0755	rm
urllib3-1.26.5.egg-info/	-	0755	rm
wadllib/	-	0755	rm
wadllib-1.3.6.egg-info/	-	0755	rm
webencodings/	-	0755	rm
webencodings-0.5.1.egg-info/	-	0755	rm
yaml/	-	0755	rm
zipp-1.0.0.egg-info/	-	0755	rm
zope/	-	0755	rm
zope.component-4.3.0.egg-info/	-	0755	rm
zope.event-4.4.egg-info/	-	0755	rm
zope.hookable-5.1.0.egg-info/	-	0755	rm
zope.interface-5.4.0.egg-info/	-	0755	rm
_distutils_hack/	-	0755	rm
_yaml/	-	0755	rm
__pycache__/	-	0755	rm
apport_python_hook.py	8063	0644	edit dl rm
apt_inst.cpython-310-x86_64-linux-gnu.so	60064	0644	edit dl rm
apt_pkg.cpython-310-x86_64-linux-gnu.so	347096	0644	edit dl rm
augeas.py	23555	0644	edit dl rm
blinker-1.4.egg-info	3901	0644	edit dl rm
command_not_found-0.3.egg-info	189	0644	edit dl rm
configargparse.py	49875	0644	edit dl rm
configobj.py	89613	0644	edit dl rm
deb822.py	273	0644	edit dl rm
debconf.py	6769	0644	edit dl rm
distro_info.py	12528	0644	edit dl rm
jsonpatch.py	28813	0644	edit dl rm
jsonpointer.py	9796	0644	edit dl rm
lsb_release.py	14901	0644	edit dl rm
netifaces.cpython-310-x86_64-linux-gnu.so	23232	0644	edit dl rm
pexpect-4.8.0.egg-info	2285	0644	edit dl rm
problem_report.py	26867	0644	edit dl rm
pvectorc.cpython-310-x86_64-linux-gnu.so	37552	0644	edit dl rm
pyasn1_modules-0.2.1.egg-info	1722	0644	edit dl rm
pyinotify-0.9.6.egg-info	1421	0644	edit dl rm
pyinotify.py	89010	0644	edit dl rm
pyparsing.py	273365	0644	edit dl rm
python_augeas-0.5.0.egg-info	238	0644	edit dl rm
six.py	34549	0644	edit dl rm
snack.py	31134	0644	edit dl rm
systemd_python-234.egg-info	586	0644	edit dl rm
ufw-0.36.1.egg-info	263	0644	edit dl rm
validate.py	47243	0644	edit dl rm
zipp.py	6914	0644	edit dl rm
zope.component-4.3.0-nspkg.pth	529	0644	edit dl rm
zope.event-4.4-nspkg.pth	529	0644	edit dl rm
zope.hookable-5.1.0-nspkg.pth	529	0644	edit dl rm
zope.interface-5.4.0-nspkg.pth	529	0644	edit dl rm
_cffi_backend.cpython-310-x86_64-linux-gnu.so	194472	0644	edit dl rm
_dbus_bindings.cpython-310-x86_64-linux-gnu.so	168152	0644	edit dl rm
_dbus_glib_bindings.cpython-310-x86_64-linux-gnu.so	23040	0644	edit dl rm
_pyrsistent_version.py	23	0644	edit dl rm
_snack.cpython-310-x86_64-linux-gnu.so	47888	0644	edit dl rm
_version.py	21	0644	edit dl rm

Edit: /usr/lib/python3/dist-packages/snack.py (31134B)

# snack.py: maps C extension module _snack to proper python types in module
# snack.
# The first section is a very literal mapping.
# The second section contains convenience classes that amalgamate
# the literal classes and make them more object-oriented.

"""
This module provides the NEWT Windowing toolkit API for Python
This is a lightweight text-mode windowing library, based on slang.

Classes:

- Widget  
 - Button  
 - CompactButton
 - Checkbox
 - SingleRadioButton
 - Listbox
 - Textbox
 - TextboxReflowed
 - Label
 - Scale
 - Entry
 - Form
 - Grid
 - SnackScreen
 - RadioGroup
 - RadioBar
 - ButtonBar
 - GridFormHelp
 - GridForm
 - CheckboxTree
 - Clistbox

Functions:

- ListboxChoiceWindow
 - ButtonChoiceWindow
 - EntryWindow
"""

from __future__ import absolute_import, print_function, unicode_literals
import _snack
import string
import sys

from _snack import FLAG_DISABLED, FLAGS_SET, FLAGS_RESET, FLAGS_TOGGLE, FD_READ, FD_WRITE, FD_EXCEPT

LEFT = (-1, 0)
DOWN = (-1, -1)
CENTER = (0, 0)
UP = (1, 1)
RIGHT = (1, 0)

snackArgs = {"append":-1}

class Widget:
    """Base class for NEWT toolkit - Do not use directly

methods:

- Widget(self)
     - setCallback(self, obj, data = None) : 
          The callback for when object activated.
          data is passed to obj.
    """
    def setCallback(self, obj, data = None):
        if data:
            self.w.setCallback(obj, data)
        else:
            self.w.setCallback(obj)
            
    def __init__(self):
        raise NotImplementedError

class Button(Widget):
    """Basic button class, takes button text as parameter

method:

- Button(self, text): returns a button
    """
    def __init__(self, text):
        self.w = _snack.button(text)

class CompactButton(Widget):
    """Compact Button class (less frilly button decoration).

methods:

- CompactButton(self,text) : create button, with text.
    """
    def __init__(self, text):
        self.w = _snack.compactbutton(text)

class Checkbox(Widget):
    """A checkbox.

methods:
    
      - Checkbox(self, text, isOn = 0) : text, and boolean as to default value
      - setValue(self)                 : set value
      - value(self, value)             : return checkbox value
      - selected(self)                 : returns boolean
      - setFlags(self, flag, sense)    : set flags

flags:  FLAG_DISABLED, FLAGS_SET, FLAGS_RESET
    """
    def value(self):
        return self.w.checkboxValue

def selected(self):
        return self.w.checkboxValue != 0

def setFlags (self, flag, sense):

return self.w.checkboxSetFlags(flag, sense)

def setValue (self, value):
        return self.w.checkboxSetValue(value)

def __init__(self, text, isOn = 0):
        self.w = _snack.checkbox(text, isOn)

class SingleRadioButton(Widget):
    """Single Radio Button.

methods:
    
     -  SingleRadioButton(text, group, isOn = 0)  : create button
     -  selected(self)                            : returns bool, whether or not is selected.
    """
    
    def selected(self):
        return self.w.key == self.w.radioValue;
    
    def __init__(self, text, group, isOn = 0):
        if group:
            self.w = _snack.radiobutton(text, group.w, isOn)
        else:
            self.w = _snack.radiobutton(text, None, isOn)

class Listbox(Widget):
    """Listbox class.

methods:

- Listbox(self, height, scroll = 0, returnExit = 0, width = 0, showCursor = 0, multiple = 0, border = 0)
     - insert(self, text, item, before) : insert element; before = key to item to insert before, or None.
     - delete(self, item)               : delete item from list.
     - replace(self, text,item)         : Replace a given item's text
     - current(self)                    : returns currently selected item
     - getSelection(self)               : returns a list of selected items
     - setCurrent(self,i tem)           : select current.
     - clear(self)                      : clear listbox
    """
    
    def append(self, text, item):
        key = self.w.listboxAddItem(text)
        self.key2item[key] = item
        self.item2key[item] = key

def insert(self, text, item, before):
        if (not before):
            key = self.w.listboxInsertItem(text, 0)
        else:
            key = self.w.listboxInsertItem(text, self.item2key[before])
        self.key2item[key] = item
        self.item2key[item] = key

def delete(self, item):
        self.w.listboxDeleteItem(self.item2key[item])
        del self.key2item[self.item2key[item]]
        del self.item2key[item]

def replace(self, text, item):
        key = self.w.listboxInsertItem(text, self.item2key[item])
        self.w.listboxDeleteItem(self.item2key[item])
        del self.key2item[self.item2key[item]]
        self.item2key[item] = key
        self.key2item[key] = item

def current(self):
        return self.key2item[self.w.listboxGetCurrent()]

def getSelection(self):
        selection = []
        list = self.w.listboxGetSelection()
        for key in list:
            selection.append(self.key2item[key])
        return selection

def setCurrent(self, item):
        self.w.listboxSetCurrent(self.item2key[item])

def clear(self):
        self.key2item = {}
        self.item2key = {}        
        self.w.listboxClear()

def __init__(self, height, scroll = 0, returnExit = 0, width = 0, showCursor = 0, multiple = 0, border = 0):
        self.w = _snack.listbox(height, scroll, returnExit, showCursor, multiple, border)
        self.key2item = {}
        self.item2key = {}
        if (width):
            self.w.listboxSetWidth(width)

class Textbox(Widget):
    """Textbox, container for text.

methods:

- Textbox(self, width, height, scroll = 0, wrap = 0): scroll, wrap are flags
                                   include scroll bars, or text wrap.
     - setText(text) : set text.
     - setHeight(height): set height.
    """
    
    def setText(self, text):
        self.w.textboxText(text)

def setHeight(self, height):
        self.w.textboxHeight(height)

def __init__(self, width, height, text, scroll = 0, wrap = 0):
        self.w = _snack.textbox(width, height, text, scroll, wrap)

class TextboxReflowed(Textbox):

def __init__(self, width, text, flexDown = 5, flexUp = 10, maxHeight = -1):
        (newtext, width, height) = reflow(text, width, flexDown, flexUp)
        if maxHeight != -1 and height > maxHeight:
            Textbox.__init__(self, width, maxHeight, newtext, 1)
        else:
            Textbox.__init__(self, width, height, newtext, 0)

class Label(Widget):
    """A Label (simple text).

methods:

- Label(self,text)   : create label
     - setText(self,text) : change text.
     - setColors(self, colorset) : change individual colors
    """
    def setText(self, text):
        self.w.labelText(text)

def __init__(self, text):
        self.w = _snack.label(text)

def setColors(self, colorset):
        self.w.labelSetColors(colorset)

class Scale(Widget):
    """A Scale (progress bar).

methods:

- Scale(self,width, total) : create scale; width: size on screen, fullamount: integer.
     - set(self,amount)         : set amount to integer.
    """
    def set(self, amount):
        self.w.scaleSet(amount)

def __init__(self, width, total):
        self.w = _snack.scale(width, total)

class Entry(Widget):
    """Entry widget.

methods:

- Entry(self, width, text = "", hidden = 0, password = 0, scroll = 1, returnExit = 0)
          constructor. hidden doesn't show text, password stars it out,
          scroll includes scroll bars;
          if returnExit is set, return from Form when exiting this element, else
           proceed to next entry widget.
     - value(self): return value.
     - set(text, cursorAtEnd = 1) : set the text
     - setFlags (flag, sense) : flags can be FLAG_DISABLED, FLAGS_SET, FLAGS_RESET, FLAGS_TOGGLE
    """
    def value(self):
        return self.w.entryValue

def set(self, text, cursorAtEnd = 1):
        return self.w.entrySetValue(text, cursorAtEnd)

def setFlags (self, flag, sense):
        return self.w.entrySetFlags(flag, sense)

def __init__(self, width, text = "", hidden = 0, password = 0, scroll = 1, 
         returnExit = 0):
        self.w = _snack.entry(width, text, hidden, password, scroll, returnExit)

# Form uses hotkeys
hotkeys = { "F1" : _snack.KEY_F1, "F2" : _snack.KEY_F2, "F3" : _snack.KEY_F3, 
            "F4" : _snack.KEY_F4, "F5" : _snack.KEY_F5, "F6" : _snack.KEY_F6, 
            "F7" : _snack.KEY_F7, "F8" : _snack.KEY_F8, "F9" : _snack.KEY_F9, 
            "F10" : _snack.KEY_F10, "F11" : _snack.KEY_F11, 
            "F12" : _snack.KEY_F12, "ESC" : _snack.KEY_ESC,
            "ENTER": _snack.KEY_ENTER, "SUSPEND" : _snack.KEY_SUSPEND,
            "BACKSPACE": _snack.KEY_BACKSPACE, "DELETE": _snack.KEY_DELETE,
            "INSERT": _snack.KEY_INSERT, "RESIZE": _snack.KEY_RESIZE,
             " " : ord(" ") }

for n in list(hotkeys.keys()):
    hotkeys[hotkeys[n]] = n
for o,c in [ (ord(c),c) for c in string.ascii_letters+string.digits ]:
    hotkeys[c] = o
    hotkeys[o] = c

class Form:
    """ Base Form class, from which Grid, etc. inherit

methods:

- Form(self, helpArg = None) : constructor. 
     - addHotKey(self, keyname) : keynames of form "F1" through "F12", "ESC"
     - add(self, widget) : Add a widget
     - run(self): run a  form, expecting input
     - draw(self): draw form.
     - setTimer(self, timer) : add a timer
     - watchFile(self, file, flags) : watch a named file
     - setCurrent (self, co): Set a given widget as the current focus
    """
    def addHotKey(self, keyname):
        self.w.addhotkey(hotkeys[keyname])

def add(self, widget):
        if 'hotkeys' in widget.__dict__:
            for key in widget.hotkeys.keys():
                self.addHotKey(key)

if 'gridmembers' in widget.__dict__:
            for w in widget.gridmembers:
                self.add(w)
        elif 'w' in widget.__dict__:
            self.trans[widget.w.key] = widget
            return self.w.add(widget.w)
        return None

def run(self):
        (what, which) = self.w.run()
        if (what == _snack.FORM_EXIT_WIDGET):
            return self.trans[which]
        elif (what == _snack.FORM_EXIT_TIMER):
            return "TIMER"
        elif (what == _snack.FORM_EXIT_FDREADY):
            return self.filemap[which]
        elif (what == _snack.FORM_EXIT_HOTKEY):
            return hotkeys[which]
        raise RuntimeError("EOF or IO error")

def draw(self):
        self.w.draw()
        return None

def __init__(self, helpArg = None):
        self.trans = {}
        self.filemap = {}
        self.w = _snack.form(helpArg)
        # we do the reference count for the helpArg in python! gross
        self.helpArg = helpArg

def setCurrent (self, co):
        self.w.setcurrent (co.w)

def setTimer (self, timer):
        self.w.settimer (timer)

def watchFile (self, file, flags):
        self.filemap[file.fileno()] = file
        self.w.watchfd (file.fileno(), flags)

class Grid:
    """Grid class.

methods:

- place(self,x,y): Return what is placed at (x,y)
     - setField(self, what, col, row, padding = (0, 0, 0, 0),
                anchorLeft = 0, anchorTop = 0, anchorRight = 0,
                anchorBottom = 0, growx = 0, growy = 0):
                used to add widget 'what' to grid.
     - Grid(self, *args): eg. g = Grid(2,3) for 2x3 grid
    """
    def place(self, x, y):
        return self.g.place(x, y)

def setField(self, what, col, row, padding = (0, 0, 0, 0),
         anchorLeft = 0, anchorTop = 0, anchorRight = 0,
         anchorBottom = 0, growx = 0, growy = 0):
        self.gridmembers.append(what)
        anchorFlags = 0
        if (anchorLeft):
            anchorFlags = _snack.ANCHOR_LEFT
        elif (anchorRight):
            anchorFlags = _snack.ANCHOR_RIGHT

if (anchorTop):
            anchorFlags = anchorFlags | _snack.ANCHOR_TOP
        elif (anchorBottom):
            anchorFlags = anchorFlags | _snack.ANCHOR_BOTTOM

gridFlags = 0
        if (growx):
            gridFlags = _snack.GRID_GROWX
        if (growy):
            gridFlags = gridFlags | _snack.GRID_GROWY

if 'g' in what.__dict__:
            return self.g.setfield(col, row, what.g, padding, anchorFlags,
                       gridFlags)
        else:
            return self.g.setfield(col, row, what.w, padding, anchorFlags)
    
    def __init__(self, *args):
        self.g = _snack.grid(*args)
        self.gridmembers = []

colorsets = { "ROOT" : _snack.COLORSET_ROOT,
              "BORDER" : _snack.COLORSET_BORDER,
              "WINDOW" : _snack.COLORSET_WINDOW,
              "SHADOW" : _snack.COLORSET_SHADOW,
              "TITLE" : _snack.COLORSET_TITLE,
              "BUTTON" : _snack.COLORSET_BUTTON,
              "ACTBUTTON" : _snack.COLORSET_ACTBUTTON,
              "CHECKBOX" : _snack.COLORSET_CHECKBOX,
              "ACTCHECKBOX" : _snack.COLORSET_ACTCHECKBOX,
              "ENTRY" : _snack.COLORSET_ENTRY,
              "LABEL" : _snack.COLORSET_LABEL,
              "LISTBOX" : _snack.COLORSET_LISTBOX,
              "ACTLISTBOX" : _snack.COLORSET_ACTLISTBOX,
              "TEXTBOX" : _snack.COLORSET_TEXTBOX,
              "ACTTEXTBOX" : _snack.COLORSET_ACTTEXTBOX,
              "HELPLINE" : _snack.COLORSET_HELPLINE,
              "ROOTTEXT" : _snack.COLORSET_ROOTTEXT,
              "EMPTYSCALE" : _snack.COLORSET_EMPTYSCALE,
              "FULLSCALE" : _snack.COLORSET_FULLSCALE,
              "DISENTRY" : _snack.COLORSET_DISENTRY,
              "COMPACTBUTTON" : _snack.COLORSET_COMPACTBUTTON,
              "ACTSELLISTBOX" : _snack.COLORSET_ACTSELLISTBOX,
              "SELLISTBOX" : _snack.COLORSET_SELLISTBOX }

class SnackScreen:
    """A Screen;

methods:

- Screen(self) : constructor
    - finish(self)
    - resume(self)
    - suspend(self)
    - doHelpCallback(self,arg) call callback with arg
    - helpCallback(self,cb): Set help callback
    - suspendcallback(self,cb, data=None) : set callback. data=data to pass to cb.
    - openWindow(self,left, top, width, height, title): Open a window.
    - pushHelpLine(self,text): put help line on screen. Returns current help line if text=None
    - setColor(self, colorset, fg, bg): Set foreground and background colors;
            colorset = key from snack.colorsets,
            fg & bg = english color names defined by S-Lang
                (ref: S-Lang Library C Programmer's Guide section:
                8.4.4.  Setting Character Attributes)
    """
    def __init__(self):
        _snack.init()
        (self.width, self.height) = _snack.size()
        self.pushHelpLine(None)

def finish(self):
        return _snack.finish()

def resume(self):
        _snack.resume()

def suspend(self):
        _snack.suspend()

def doHelpCallback(self, arg):
        self.helpCb(self, arg)
    
    def helpCallback(self, cb):
        self.helpCb = cb
        return _snack.helpcallback(self.doHelpCallback)

def suspendCallback(self, cb, data = None):
        if data:
            return _snack.suspendcallback(cb, data)
        return _snack.suspendcallback(cb)

def openWindow(self, left, top, width, height, title):
        return _snack.openwindow(left, top, width, height, title)

def pushHelpLine(self, text):
        if (not text):
            return _snack.pushhelpline("*default*")
        else:
            return _snack.pushhelpline(text)

def popHelpLine(self):
        return _snack.pophelpline()

def drawRootText(self, left, top, text):
        return _snack.drawroottext(left, top, text)

def centeredWindow(self, width, height, title):
        return _snack.centeredwindow(width, height, title)

def gridWrappedWindow(self, grid, title, x = None, y = None):
        if x and y:
            return _snack.gridwrappedwindow(grid.g, title, x, y)

return _snack.gridwrappedwindow(grid.g, title)

def popWindow(self, refresh = True):
        if refresh:
            return _snack.popwindow()
        return _snack.popwindownorefresh()

def refresh(self):
        return _snack.refresh()

def setColor(self, colorset, fg, bg):
        if colorset in colorsets:
            return _snack.setcolor(colorsets[colorset], fg, bg)
        else:
           # assume colorset is an integer for the custom color set
           return _snack.setcolor(colorset, fg, bg)

def reflow(text, width, flexDown = 5, flexUp = 5):
    """ returns a tuple of the wrapped text, the actual width, and the actual height
    """
    return _snack.reflow(text, width, flexDown, flexUp)

# combo widgets

class RadioGroup(Widget):
    """ Combo widget: Group of Radio buttons

methods:

- RadioGroup(self): constructor.
     - add(self,title, value, default = None): add a button. Returns button.
     - getSelection(self) : returns value of selected button | None    
    """
    def __init__(self):
        self.prev = None
        self.buttonlist = []

def add(self, title, value, default = None):
        if not self.prev and default == None:
            # If the first element is not explicitly set to
            # not be the default, make it be the default
            default = 1
        b = SingleRadioButton(title, self.prev, default)
        self.prev = b
        self.buttonlist.append((b, value))
        return b

def getSelection(self):
        for (b, value) in self.buttonlist:
            if b.selected(): return value
        return None

class RadioBar(Grid):
    """ Bar of Radio buttons, based on Grid.

methods:

- RadioBar(self, screen, buttonlist) : constructor.
    - getSelection(self): return value of selected button 
    """

def __init__(self, screen, buttonlist):
        self.list = []
        self.item = 0
        self.group = RadioGroup()
        Grid.__init__(self, 1, len(buttonlist))
        for (title, value, default) in buttonlist:
            b = self.group.add(title, value, default)
            self.list.append((b, value))
            self.setField(b, 0, self.item, anchorLeft = 1)
            self.item = self.item + 1

def getSelection(self):
        return self.group.getSelection()

# you normally want to pack a ButtonBar with growx = 1

class ButtonBar(Grid):
    """ Bar of buttons, based on grid.

methods:

- ButtonBar(screen, buttonlist,buttonlist, compact = 0):
     - buttonPressed(self, result):  Takes the widget returned by Form.run and looks to see
                     if it was one of the widgets in the ButtonBar.
    """
    def __init__(self, screen, buttonlist, compact = 0):
        self.list = []
        self.hotkeys = {}
        self.item = 0
        Grid.__init__(self, len(buttonlist), 1)
        for blist in buttonlist:
            if isinstance(blist, str if sys.version >= '3' else basestring):
                title = blist
                value = blist.lower()
            elif len(blist) == 2:
                (title, value) = blist
            else:
                (title, value, hotkey) = blist
                self.hotkeys[hotkey] = value

if compact:
                b = CompactButton(title)
            else:
                b = Button(title)
            self.list.append((b, value))
            self.setField(b, self.item, 0, (1, 0, 1, 0))
            self.item = self.item + 1

def buttonPressed(self, result):    
        if result in self.hotkeys:
            return self.hotkeys[result]

for (button, value) in self.list:
            if result == button:
                return value
        return None

class GridFormHelp(Grid):
    """ Subclass of Grid, for the help form text.

methods:

- GridFormHelp(self, screen, title, help, *args) :
     - add (self, widget, col, row, padding = (0, 0, 0, 0),
            anchorLeft = 0, anchorTop = 0, anchorRight = 0,
            anchorBottom = 0, growx = 0, growy = 0):
     - runOnce(self, x = None, y = None):  pop up the help window
     - addHotKey(self, keyname):
     - setTimer(self, keyname):
     - create(self, x = None, y = None):
     - run(self, x = None, y = None):
     - draw(self):
     - runPopup(self):
     - setCurrent (self, co):
    """
    def __init__(self, screen, title, help, *args):
        self.screen = screen
        self.title = title
        self.form = Form(help)
        self.childList = []
        self.form_created = 0
        args = list(args)
        args[:0] = [self]
        Grid.__init__(*tuple(args))

def add(self, widget, col, row, padding = (0, 0, 0, 0),
            anchorLeft = 0, anchorTop = 0, anchorRight = 0,
            anchorBottom = 0, growx = 0, growy = 0):
        self.setField(widget, col, row, padding, anchorLeft,
                      anchorTop, anchorRight, anchorBottom,
                      growx, growy);
        self.childList.append(widget)

def runOnce(self, x = None, y = None):
        result = self.run(x, y)
        self.screen.popWindow()
        return result

def addHotKey(self, keyname):
        self.form.addHotKey(keyname)

def setTimer(self, keyname):
        self.form.setTimer(keyname)

def create(self, x = None, y = None):
        if not self.form_created:
            self.place(1,1)
            for child in self.childList:
                self.form.add(child)
            self.screen.gridWrappedWindow(self, self.title, x, y)
            self.form_created = 1

def run(self, x = None, y = None):
        self.create(x, y)
        return self.form.run()

def draw(self):
        self.create()
        return self.form.draw()
    
    def runPopup(self):
        self.create()
        self.screen.gridWrappedWindow(self, self.title)
        result = self.form.run()
        self.screen.popWindow()
        return result

def setCurrent (self, co):
        self.form.setCurrent (co)

class GridForm(GridFormHelp):
    """ GridForm class (extends GridFormHelp):

methods:

- GridForm(self, screen, title, *args):
    """
    def __init__(self, screen, title, *args):
        myargs = (self, screen, title, None) + args
        GridFormHelp.__init__(*myargs)

class CheckboxTree(Widget):
    """ CheckboxTree combo widget,

methods:

- CheckboxTree(self, height, scroll = 0, width = None, hide_checkbox = 0, unselectable = 0)
                    constructor.
     - append(self, text, item = None, selected = 0):
     - addItem(self, text, path, item = None, selected = 0):
     - getCurrent(self):
     - getSelection(self):
     - setEntry(self, item, text):
     - setCurrent(self, item):
     - setEntryValue(self, item, selected = 1):
     - getEntryValue(self, item):
    """ 
    def append(self, text, item = None, selected = 0):
        self.addItem(text, (snackArgs['append'], ), item, selected)
    
    def addItem(self, text, path, item = None, selected = 0):
        if item is None:
            item = text
        key = self.w.checkboxtreeAddItem(text, path, selected)
        self.key2item[key] = item
        self.item2key[item] = key

def getCurrent(self):
        curr = self.w.checkboxtreeGetCurrent()
        return self.key2item[curr]

def __init__(self, height, scroll = 0, width = None, hide_checkbox = 0, unselectable = 0):
        self.w = _snack.checkboxtree(height, scroll, hide_checkbox, unselectable)
        self.key2item = {}
        self.item2key = {}
        if (width):
            self.w.checkboxtreeSetWidth(width)

def getSelection(self):
        selection = []
        list = self.w.checkboxtreeGetSelection()
        for key in list:
            selection.append(self.key2item[key])
        return selection

def setEntry(self, item, text):
        self.w.checkboxtreeSetEntry(self.item2key[item], text)

def setCurrent(self, item):
        self.w.checkboxtreeSetCurrent(self.item2key[item])

def setEntryValue(self, item, selected = 1):
        self.w.checkboxtreeSetEntryValue(self.item2key[item], selected)

def getEntryValue(self, item):
        return self.w.checkboxtreeGetEntryValue(self.item2key[item])

def ListboxChoiceWindow(screen, title, text, items, 
            buttons = ('Ok', 'Cancel'), 
            width = 40, scroll = 0, height = -1, default = None,
            help = None):
    """
    - ListboxChoiceWindow(screen, title, text, items, 
            buttons = ('Ok', 'Cancel'), 
            width = 40, scroll = 0, height = -1, default = None,
            help = None):
    """
    if (height == -1): height = len(items)

bb = ButtonBar(screen, buttons)
    t = TextboxReflowed(width, text)
    l = Listbox(height, scroll = scroll, returnExit = 1)
    count = 0
    for item in items:
        if type(item) == tuple:
            (text, key) = item
        else:
            text = item
            key = count

if (default == count):
            default = key
        elif (default == item):
            default = key

l.append(text, key)
        count = count + 1

if (default != None):
        l.setCurrent (default)

g = GridFormHelp(screen, title, help, 1, 3)
    g.add(t, 0, 0)
    g.add(l, 0, 1, padding = (0, 1, 0, 1))
    g.add(bb, 0, 2, growx = 1)

rc = g.runOnce()

return (bb.buttonPressed(rc), l.current())

def ButtonChoiceWindow(screen, title, text, 
               buttons = [ 'Ok', 'Cancel' ], 
               width = 40, x = None, y = None, help = None):
    """
     - ButtonChoiceWindow(screen, title, text, 
               buttons = [ 'Ok', 'Cancel' ], 
               width = 40, x = None, y = None, help = None):
    """
    bb = ButtonBar(screen, buttons)
    t = TextboxReflowed(width, text, maxHeight = screen.height - 12)

g = GridFormHelp(screen, title, help, 1, 2)
    g.add(t, 0, 0, padding = (0, 0, 0, 1))
    g.add(bb, 0, 1, growx = 1)
    return bb.buttonPressed(g.runOnce(x, y))

def EntryWindow(screen, title, text, prompts, allowCancel = 1, width = 40,
        entryWidth = 20, buttons = [ 'Ok', 'Cancel' ], help = None):
    """
    EntryWindow(screen, title, text, prompts, allowCancel = 1, width = 40,
        entryWidth = 20, buttons = [ 'Ok', 'Cancel' ], help = None):
    """
    bb = ButtonBar(screen, buttons);
    t = TextboxReflowed(width, text)

count = 0
    for n in prompts:
        count = count + 1

sg = Grid(2, count)

count = 0
    entryList = []
    for n in prompts:
        if type(n) == tuple:
            (n, e) = n
            if isinstance(e, str if sys.version >= '3' else basestring):
                e = Entry(entryWidth, e)
        else:
            e = Entry(entryWidth)

sg.setField(Label(n), 0, count, padding = (0, 0, 1, 0), anchorLeft = 1)
        sg.setField(e, 1, count, anchorLeft = 1)
        count = count + 1
        entryList.append(e)

g = GridFormHelp(screen, title, help, 1, 3)

g.add(t, 0, 0, padding = (0, 0, 0, 1))
    g.add(sg, 0, 1, padding = (0, 0, 0, 1))
    g.add(bb, 0, 2, growx = 1)

result = g.runOnce()

entryValues = []
    count = 0
    for n in prompts:
        entryValues.append(entryList[count].value())
        count = count + 1

return (bb.buttonPressed(result), tuple(entryValues))

class CListbox(Grid):
    """Clistbox convenience class.

methods:

- Clistbox(self, height, cols, cols_widths, scroll = 0)       : constructor
     - colFormText(self, col_text, align = None, adjust_width = 0) : column text.
     - append(self, col_text, item, col_text_align = None)         :
     - insert(self, col_text, item, before, col_text_align = None)
     - delete(self, item)
     - replace(self, col_text, item, col_text_align = None)
     - current(self) : returns current item
     - setCurrent(self, item): sets an item as current
     - clear(self): clear the listbox
     
     Alignments may be LEFT, RIGHT, CENTER, None
    """
    def __init__(self, height, cols, col_widths, scroll = 0,
                 returnExit = 0, width = 0, col_pad = 1,
                 col_text_align = None, col_labels = None,
                 col_label_align = None, adjust_width=0):

self.cols = cols
        self.col_widths = col_widths[:]
        self.col_pad = col_pad
        self.col_text_align = col_text_align

if col_labels != None:        
            Grid.__init__(self, 1, 2)
            box_y = 1

lstr = self.colFormText(col_labels, col_label_align,
                                                adjust_width=adjust_width)
            self.label = Label(lstr)
            self.setField(self.label, 0, 0, anchorLeft=1)

else:
            Grid.__init__(self, 1, 1)
            box_y = 0

self.listbox = Listbox(height, scroll, returnExit, width)
        self.setField(self.listbox, 0, box_y, anchorRight=1)

def colFormText(self, col_text, align = None, adjust_width=0):
        i = 0
        str = ""
        c_len = len(col_text)
        while (i < self.cols) and (i < c_len):
        
            cstr = col_text[i]
            cstrlen = _snack.wstrlen(cstr)
            if self.col_widths[i] < cstrlen:
                if adjust_width:
                    self.col_widths[i] = cstrlen
                else:
                    cstr = cstr[:self.col_widths[i]]

delta = self.col_widths[i] - _snack.wstrlen(cstr)
                        
            if delta > 0:
                if align == None:
                    a = LEFT
                else:
                    a = align[i]

if a == LEFT:
                    cstr = cstr + (" " * delta)
                if a == CENTER:
                    cstr = (" " * (delta / 2)) + cstr + \
                        (" " * ((delta + 1) / 2))
                if a == RIGHT:
                    cstr = (" " * delta) + cstr

if i != c_len - 1:
                pstr = (" " * self.col_pad)
            else:
                pstr = ""

str = str + cstr + pstr
    
            i = i + 1
    
        return str

def append(self, col_text, item, col_text_align = None):
        if col_text_align == None:
            col_text_align = self.col_text_align
        text = self.colFormText(col_text, col_text_align)
        self.listbox.append(text, item)

def insert(self, col_text, item, before, col_text_align = None):
        if col_text_align == None:
            col_text_align = self.col_text_align
        text = self.colFormText(col_text, col_text_align)
        self.listbox.insert(text, item, before)

def delete(self, item):
        self.listbox.delete(item)

def replace(self, col_text, item, col_text_align = None):
        if col_text_align == None:
            col_text_align = self.col_text_align
        text = self.colFormText(col_text, col_text_align)
        self.listbox.replace(text, item)

def current(self):
        return self.listbox.current()

def setCurrent(self, item):
        self.listbox.setCurrent(item)

def clear(self):
        self.listbox.clear()

def customColorset(x):
    return 30 + x

cmd: