Skip to content

abstract

Full documentation pages are generated for docstring reference only and may contain symbols imported from other modules. Imported symbols are not distinguished from locally defined symbols and will appear in any module that they are imported into. For better information on where symbols should be imported from, review the sourcecode on the github.

FoSpy.ui.sliders.abstract

CTRL_ROWS module-attribute 

CTRL_ROWS = 6

ControlPanel

Source code in FoSpy/ui/sliders/abstract.py 
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
class ControlPanel:
    def __init__(self, rows=CTRL_ROWS):
        self._rowcol = self.row_col_iter()
        self._max_rows = rows

    def addWidget(self, w):
        pass

    def addGroup(self, label, rows=CTRL_ROWS):
        pass

    def row_col_iter(self):
        current_row = 0
        current_col = 0
        while True:
            if current_row >= self._max_rows-1:
                current_row = 0
                current_col += 1
            else:
                current_row += 1
            yield current_row, current_col


    def nextRowCol(self):
        return next(self._rowcol)

_max_rows instance-attribute 

_max_rows = rows

_rowcol instance-attribute 

_rowcol = self.row_col_iter()

__init__ 

__init__(rows=CTRL_ROWS)
Source code in FoSpy/ui/sliders/abstract.py 
16
17
18
def __init__(self, rows=CTRL_ROWS):
    self._rowcol = self.row_col_iter()
    self._max_rows = rows

addGroup 

addGroup(label, rows=CTRL_ROWS)
Source code in FoSpy/ui/sliders/abstract.py 
23
24
def addGroup(self, label, rows=CTRL_ROWS):
    pass

addWidget 

addWidget(w)
Source code in FoSpy/ui/sliders/abstract.py 
20
21
def addWidget(self, w):
    pass

nextRowCol 

nextRowCol()
Source code in FoSpy/ui/sliders/abstract.py 
38
39
def nextRowCol(self):
    return next(self._rowcol)

row_col_iter 

row_col_iter()
Source code in FoSpy/ui/sliders/abstract.py 
26
27
28
29
30
31
32
33
34
35
def row_col_iter(self):
    current_row = 0
    current_col = 0
    while True:
        if current_row >= self._max_rows-1:
            current_row = 0
            current_col += 1
        else:
            current_row += 1
        yield current_row, current_col

SliderPlot

Source code in FoSpy/ui/sliders/abstract.py 
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
class SliderPlot:
    color1 = 'b'
    color2 = 'magenta'
    color3 = 'darkgreen'
    def __init__(self, specs={}, cfg={}, x_label=None, y_label=None, x_ticks=True, y_ticks=True):
        self.specs = specs
        self._unpacked_specs = {}
        self._unpack_specs()
        self.cfg = cfg
        self.sl_rows = _count_sliders(self._unpacked_specs)
        self.sliders = {}
        self.checks = {}
        self.textboxes = {}
        self.plots = {}
        self.plotcolors = {}

        self.bg_color = 'w'
        self.fg_color = 'k'

        if x_label is not None:
            self.setXlabel(x_label)
        if y_label is not None:
            self.setYlabel(y_label)

        self.setXticks(x_ticks)
        self.setYticks(y_ticks)

    def _unpack_specs(self, specs=None):
        specs = specs or self.specs

        for name, spec in specs.items():
            if spec["type"] == "group":
                self._unpack_specs(spec["specs"])
            else:
                self._unpacked_specs[name] = spec

    def update_plot(self, val=None):
        self.update_cfg()

    def update_cfg(self):
        for name, spec in self._unpacked_specs.items():
            if spec["type"] == "scalar":
                NoneVal = spec.get("None", None)
                enabled = self.get_check_enabled(name)
                self.cfg[name] = self.get_slider_val(name) if enabled else NoneVal

            elif spec["type"] == "range":
                lo_enabled = self.get_check_enabled(name + "_min")
                hi_enabled = self.get_check_enabled(name + "_max")

                lo = self.get_slider_val(name + "_min") if lo_enabled else None
                hi = self.get_slider_val(name + "_max") if hi_enabled else None

                self.cfg[name] = [lo, hi]

    def _add_group(self, label, specs, rows=CTRL_ROWS):
        # cache current panel
        panel = self.panel

        # reassign panel to nested group
        self.panel = panel.addGroup(label, rows=rows)

        # build controls in nested group
        self._build_controls(specs)

        # restore cached panel
        self.panel = panel

    def _add_range(self, name, spec):
        lo, hi = spec['default']

        specs = {
            name + "_min": {
                "label": "(min)",
                "min": spec["min"],
                "max": spec["max"],
                "default": lo,
                "digits": _get_digits(spec),
                "type": "scalar"
            },
            name + "_max": {
                "label": "(max)",
                "min": spec["min"],
                "max": spec["max"],
                "default": hi,
                "digits": _get_digits(spec),
                "type": "scalar"
            }
        }

        self._add_group(spec["label"], specs)

    def _build_controls(self, specs=None):
        specs = specs or self.specs
        widget_calls = {
            "scalar": lambda name, spec:
                self._add_scalar(name, spec),
            "range": lambda name, spec:
                self._add_range(name, spec),
            "group": lambda name, spec:
                self._add_group(spec["label"], spec["specs"])
        }
        def skip(name, spec):
            return None

        for name, spec in specs.items():
            widget_calls.get(spec["type"], skip)(name, spec)

        if specs == self.specs:
            self._finish_buttons()

    def _add_button(self, label, callback):
        # TODO: unit test
        raise NotImplementedError("Override in UI subclass")

    def _finish_buttons(self):
        # TODO: unit test
        for label, callback in (
            ("OK", self._ok_clicked),
            ("Reset to defaults", self.revert_cfg),
            ("Save as default", self.save_cfg)
        ):
            self._add_button(label, callback)

    def save_cfg(self):
        # TODO: unit test
        # TODO: abstract config save
        pass

    def revert_cfg(self):
        # TODO: unit test
        # TODO: abstract config revert
        pass

    def _ok_clicked(self):
        raise NotImplementedError("Override in UI subclass")

    def _add_scalar(self, name, spec):
        raise NotImplementedError("Override in UI subclass")

    def get_slider_val(self, spec_name):
        raise NotImplementedError("Override in UI subclass")

    def get_check_enabled(self, spec_name):
        raise NotImplementedError("Override in UI subclass")

    def reset_sticks(self):
        raise NotImplementedError("Override in UI subclass")

    def add_sticks(self, segments):
        raise NotImplementedError("Override in UI subclass")

    def draw_sticks(self):
        raise NotImplementedError("Override in UI subclass")

    def plotXY(self, x, *y, plotset='static',**kwargs):
        raise NotImplementedError("Override in UI subclass")

    def reset_plotsets(self, *plotsets):
        raise NotImplementedError("Override in UI subclass")

    def main_loop(self):
        raise NotImplementedError("Override in UI subclass")

    def setXlabel(self, label):
        raise NotImplementedError("Override in UI subclass")

    def setYlabel(self, label):
        raise NotImplementedError("Override in UI subclass")

    def setXticks(self, on):
        raise NotImplementedError("Override in UI subclass")

    def setYticks(self, on):
        raise NotImplementedError("Override in UI subclass")

_unpacked_specs instance-attribute 

_unpacked_specs = {}

bg_color instance-attribute 

bg_color = 'w'

cfg instance-attribute 

cfg = cfg

checks instance-attribute 

checks = {}

color1 class-attribute instance-attribute 

color1 = 'b'

color2 class-attribute instance-attribute 

color2 = 'magenta'

color3 class-attribute instance-attribute 

color3 = 'darkgreen'

fg_color instance-attribute 

fg_color = 'k'

plotcolors instance-attribute 

plotcolors = {}

plots instance-attribute 

plots = {}

sl_rows instance-attribute 

sl_rows = _count_sliders(self._unpacked_specs)

sliders instance-attribute 

sliders = {}

specs instance-attribute 

specs = specs

textboxes instance-attribute 

textboxes = {}

__init__ 

__init__(
    specs={},
    cfg={},
    x_label=None,
    y_label=None,
    x_ticks=True,
    y_ticks=True,
)
Source code in FoSpy/ui/sliders/abstract.py 
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
def __init__(self, specs={}, cfg={}, x_label=None, y_label=None, x_ticks=True, y_ticks=True):
    self.specs = specs
    self._unpacked_specs = {}
    self._unpack_specs()
    self.cfg = cfg
    self.sl_rows = _count_sliders(self._unpacked_specs)
    self.sliders = {}
    self.checks = {}
    self.textboxes = {}
    self.plots = {}
    self.plotcolors = {}

    self.bg_color = 'w'
    self.fg_color = 'k'

    if x_label is not None:
        self.setXlabel(x_label)
    if y_label is not None:
        self.setYlabel(y_label)

    self.setXticks(x_ticks)
    self.setYticks(y_ticks)

_add_button 

_add_button(label, callback)
Source code in FoSpy/ui/sliders/abstract.py 
153
154
155
def _add_button(self, label, callback):
    # TODO: unit test
    raise NotImplementedError("Override in UI subclass")

_add_group 

_add_group(label, specs, rows=CTRL_ROWS)
Source code in FoSpy/ui/sliders/abstract.py 
 97
 98
 99
100
101
102
103
104
105
106
107
108
def _add_group(self, label, specs, rows=CTRL_ROWS):
    # cache current panel
    panel = self.panel

    # reassign panel to nested group
    self.panel = panel.addGroup(label, rows=rows)

    # build controls in nested group
    self._build_controls(specs)

    # restore cached panel
    self.panel = panel

_add_range 

_add_range(name, spec)
Source code in FoSpy/ui/sliders/abstract.py 
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
def _add_range(self, name, spec):
    lo, hi = spec['default']

    specs = {
        name + "_min": {
            "label": "(min)",
            "min": spec["min"],
            "max": spec["max"],
            "default": lo,
            "digits": _get_digits(spec),
            "type": "scalar"
        },
        name + "_max": {
            "label": "(max)",
            "min": spec["min"],
            "max": spec["max"],
            "default": hi,
            "digits": _get_digits(spec),
            "type": "scalar"
        }
    }

    self._add_group(spec["label"], specs)

_add_scalar 

_add_scalar(name, spec)
Source code in FoSpy/ui/sliders/abstract.py 
179
180
def _add_scalar(self, name, spec):
    raise NotImplementedError("Override in UI subclass")

_build_controls 

_build_controls(specs=None)
Source code in FoSpy/ui/sliders/abstract.py 
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
def _build_controls(self, specs=None):
    specs = specs or self.specs
    widget_calls = {
        "scalar": lambda name, spec:
            self._add_scalar(name, spec),
        "range": lambda name, spec:
            self._add_range(name, spec),
        "group": lambda name, spec:
            self._add_group(spec["label"], spec["specs"])
    }
    def skip(name, spec):
        return None

    for name, spec in specs.items():
        widget_calls.get(spec["type"], skip)(name, spec)

    if specs == self.specs:
        self._finish_buttons()

_finish_buttons 

_finish_buttons()
Source code in FoSpy/ui/sliders/abstract.py 
157
158
159
160
161
162
163
164
def _finish_buttons(self):
    # TODO: unit test
    for label, callback in (
        ("OK", self._ok_clicked),
        ("Reset to defaults", self.revert_cfg),
        ("Save as default", self.save_cfg)
    ):
        self._add_button(label, callback)

_ok_clicked 

_ok_clicked()
Source code in FoSpy/ui/sliders/abstract.py 
176
177
def _ok_clicked(self):
    raise NotImplementedError("Override in UI subclass")

_unpack_specs 

_unpack_specs(specs=None)
Source code in FoSpy/ui/sliders/abstract.py 
69
70
71
72
73
74
75
76
def _unpack_specs(self, specs=None):
    specs = specs or self.specs

    for name, spec in specs.items():
        if spec["type"] == "group":
            self._unpack_specs(spec["specs"])
        else:
            self._unpacked_specs[name] = spec

add_sticks 

add_sticks(segments)
Source code in FoSpy/ui/sliders/abstract.py 
191
192
def add_sticks(self, segments):
    raise NotImplementedError("Override in UI subclass")

draw_sticks 

draw_sticks()
Source code in FoSpy/ui/sliders/abstract.py 
194
195
def draw_sticks(self):
    raise NotImplementedError("Override in UI subclass")

get_check_enabled 

get_check_enabled(spec_name)
Source code in FoSpy/ui/sliders/abstract.py 
185
186
def get_check_enabled(self, spec_name):
    raise NotImplementedError("Override in UI subclass")

get_slider_val 

get_slider_val(spec_name)
Source code in FoSpy/ui/sliders/abstract.py 
182
183
def get_slider_val(self, spec_name):
    raise NotImplementedError("Override in UI subclass")

main_loop 

main_loop()
Source code in FoSpy/ui/sliders/abstract.py 
203
204
def main_loop(self):
    raise NotImplementedError("Override in UI subclass")

plotXY 

plotXY(x, *y, plotset='static', **kwargs)
Source code in FoSpy/ui/sliders/abstract.py 
197
198
def plotXY(self, x, *y, plotset='static',**kwargs):
    raise NotImplementedError("Override in UI subclass")

reset_plotsets 

reset_plotsets(*plotsets)
Source code in FoSpy/ui/sliders/abstract.py 
200
201
def reset_plotsets(self, *plotsets):
    raise NotImplementedError("Override in UI subclass")

reset_sticks 

reset_sticks()
Source code in FoSpy/ui/sliders/abstract.py 
188
189
def reset_sticks(self):
    raise NotImplementedError("Override in UI subclass")

revert_cfg 

revert_cfg()
Source code in FoSpy/ui/sliders/abstract.py 
171
172
173
174
def revert_cfg(self):
    # TODO: unit test
    # TODO: abstract config revert
    pass

save_cfg 

save_cfg()
Source code in FoSpy/ui/sliders/abstract.py 
166
167
168
169
def save_cfg(self):
    # TODO: unit test
    # TODO: abstract config save
    pass

setXlabel 

setXlabel(label)
Source code in FoSpy/ui/sliders/abstract.py 
206
207
def setXlabel(self, label):
    raise NotImplementedError("Override in UI subclass")

setXticks 

setXticks(on)
Source code in FoSpy/ui/sliders/abstract.py 
212
213
def setXticks(self, on):
    raise NotImplementedError("Override in UI subclass")

setYlabel 

setYlabel(label)
Source code in FoSpy/ui/sliders/abstract.py 
209
210
def setYlabel(self, label):
    raise NotImplementedError("Override in UI subclass")

setYticks 

setYticks(on)
Source code in FoSpy/ui/sliders/abstract.py 
215
216
def setYticks(self, on):
    raise NotImplementedError("Override in UI subclass")

update_cfg 

update_cfg()
Source code in FoSpy/ui/sliders/abstract.py 
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
def update_cfg(self):
    for name, spec in self._unpacked_specs.items():
        if spec["type"] == "scalar":
            NoneVal = spec.get("None", None)
            enabled = self.get_check_enabled(name)
            self.cfg[name] = self.get_slider_val(name) if enabled else NoneVal

        elif spec["type"] == "range":
            lo_enabled = self.get_check_enabled(name + "_min")
            hi_enabled = self.get_check_enabled(name + "_max")

            lo = self.get_slider_val(name + "_min") if lo_enabled else None
            hi = self.get_slider_val(name + "_max") if hi_enabled else None

            self.cfg[name] = [lo, hi]

update_plot 

update_plot(val=None)
Source code in FoSpy/ui/sliders/abstract.py 
78
79
def update_plot(self, val=None):
    self.update_cfg()

AssembleSlider 

AssembleSlider(subcls, ui=None)
Source code in FoSpy/ui/sliders/abstract.py 
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
def AssembleSlider(subcls, ui=None):
    from ..available import get_valid_ui, discover_ui_options

    # look for existing slider bindings
    ui_opts = discover_ui_options(__package__)

    # validate ui and route to correct module
    ui = get_valid_ui(ui, options=ui_opts.keys())
    plot_module = ui_opts[ui]

    # construct hybrid class with slider routines and ui bindings
    class SliderPlot(subcls, plot_module.SliderPlot):
        pass

    return SliderPlot

_count_sliders 

_count_sliders(specs)
Source code in FoSpy/ui/sliders/abstract.py 
 3
 4
 5
 6
 7
 8
 9
10
def _count_sliders(specs):
    total = 0
    for sp in specs.values():
        if sp["type"] == "scalar":
            total += 1
        elif sp["type"] == "range":
            total += 2
    return total

_get_digits 

_get_digits(spec)
Source code in FoSpy/ui/sliders/_utils.py 
23
24
25
26
def _get_digits(spec):
    from ...config import values as cfg
    default = cfg.get("slider_digits.default", DEF_DIGITS)
    return spec.get("digits", default)