py10x-universe 0.1.3__py3-none-any.whl

core_10x/ui_hint.py

@@ -0,0 +1,153 @@
+import copy
+import functools
+
+from py10x_core import BTraitFlags as T
+
+from core_10x.named_constant import Enum
+
+
+class UiHint:
+    # fmt: off
+    #-- Flags
+    HIDDEN      = 0x1
+    READ_ONLY   = 0x2
+    SELECT_ONLY = 0x4
+    SEPARATOR   = 0x8
+
+    #-- Stylesheet Attributes
+    FG_COLOR        = 'color'
+    BG_COLOR        = 'background-color'
+    FONT            = 'font-family'
+    FONT_STYLE      = 'font-style'
+    FONT_WEIGHT     = 'font-weight'
+    BORDER_WEIGHT   = 'border-weight'
+    BORDER_WIDTH    = 'border-width'
+    BORDER_COLOR    = 'border-color'
+    BORDER_STYLE    = 'border-style'
+
+    class WIDGET_TYPE(Enum):
+        NONE        = ()
+        LINE        = ()
+        TEXT        = ()
+        TEXT4LIST   = ()
+        PASSWORD    = ()
+        CHECK       = ()
+        CHOICE      = ()
+        PIXMAP      = ()
+        PUSH        = ()
+        FILE        = ()
+    # fmt: on
+    @staticmethod
+    def partial(widget_type_fn, **params):
+        return functools.partial(widget_type_fn, **params)
+
+    def __init__(self, label: str = None, flags: int = 0x0, tip: str = None, widget_type: WIDGET_TYPE = None, **params):
+        self.label: str = label
+        self.flags: int = flags
+        self.tip: str = tip
+        self.widget_type = widget_type
+        self.params: dict = params
+
+    def adjust(self, trait):
+        if self.label is None:
+            self.label = ' '.join(p.capitalize() for p in trait.name.split('_'))
+
+        if self.tip is None:
+            self.tip = self.label
+
+        if self.widget_type is None:
+            self.widget_type = trait.s_ui_hint.widget_type
+
+        trait_flags = trait.flags
+        if trait_flags & T.HIDDEN.value():
+            self.flags |= self.HIDDEN
+        if trait_flags & T.READONLY.value():
+            self.flags |= self.READ_ONLY
+
+    def flags_on(self, flags: int) -> bool:
+        return bool(self.flags & flags)
+
+    def set_reset_flags(self, to_set: int, to_reset: int = 0x0):
+        self.flags = (self.flags | to_set) & ~to_reset
+
+    def param(self, param_name: str, default_value):
+        return self.params.get(param_name, default_value)
+
+    @staticmethod
+    def line(label: str = None, flags: int = 0x0, tip: str = None, min_width: int = 1, align_h: int = 1, **kwargs):
+        return Ui(label=label, flags=flags, tip=tip, widget_type=Ui.WIDGET_TYPE.LINE, min_width=min_width, align_h=align_h, **kwargs)
+
+    @staticmethod
+    def text(label: str = None, flags: int = 0x0, tip: str = None, min_width: int = 1, **kwargs):
+        return Ui(label=label, flags=flags, tip=tip, widget_type=Ui.WIDGET_TYPE.TEXT, min_width=min_width, **kwargs)
+
+    @staticmethod
+    def text4list(label: str = None, flags: int = 0x0, tip: str = None, min_width: int = 1, **kwargs):
+        return Ui(label=label, flags=flags, tip=tip, widget_type=Ui.WIDGET_TYPE.TEXT4LIST, min_width=min_width, **kwargs)
+
+    @staticmethod
+    def password(label: str = None, flags: int = 0x0, tip: str = None, min_width: int = 10, **kwargs):
+        return Ui(label=label, flags=flags, tip=tip, widget_type=Ui.WIDGET_TYPE.PASSWORD, min_width=min_width, **kwargs)
+
+    @staticmethod
+    def check(label: str = None, flags: int = 0x0, tip: str = None, right_label: bool = False, align_h: int = 1, **kwargs):
+        return Ui(label=label, flags=flags, tip=tip, widget_type=Ui.WIDGET_TYPE.CHECK, right_label=right_label, align_h=align_h, **kwargs)
+
+    @staticmethod
+    def choice(label: str = None, flags: int = 0x0, tip: str = None, align_h: int = 1, **kwargs):
+        return Ui(label=label, flags=flags, tip=tip, widget_type=Ui.WIDGET_TYPE.CHOICE, align_h=align_h, **kwargs)
+
+    @staticmethod
+    def pixmap(label: str = None, flags: int = 0x0, tip: str = None, w: int = 10, h: int = 10, **kwargs):
+        return Ui(label=label, flags=flags, tip=tip, widget_type=Ui.WIDGET_TYPE.PIXMAP, w=w, h=h, **kwargs)
+
+    @staticmethod
+    def button(label: str = None, flags: int = 0x0, tip: str = None, min_width: int = 1, **kwargs):
+        return Ui(label=label, flags=flags, tip=tip, widget_type=Ui.WIDGET_TYPE.PUSH, min_width=min_width, **kwargs)
+
+    @staticmethod
+    def file(label: str = None, flags: int = 0x0, tip: str = None, min_width: int = 1, **kwargs):
+        return Ui(label=label, flags=flags, tip=tip, widget_type=Ui.WIDGET_TYPE.FILE, min_width=min_width, **kwargs)
+
+
+class UiHintModification(UiHint):
+    # fmt: off
+    def __init__(
+        self,
+        label: str                      = None,
+        flags: int                      = None,
+        tip: str                        = None,
+        widget_type: UiHint.WIDGET_TYPE = None,
+        **params,
+    ):
+        # fmt: on
+        super().__init__(label, flags = flags, tip = tip, widget_type = widget_type, **params)
+
+    def apply(self, ui_hint: UiHint) -> UiHint:
+        hint = copy.deepcopy(ui_hint)
+        if self.label is not None:
+            hint.label = self.label
+
+        flags = self.flags
+        if flags is not None:
+            if isinstance(flags, int):      #-- to_set
+                hint.flags |= flags
+            elif isinstance(flags, tuple):  #-- (to_set, to_reset)
+                hint.flags = (hint.flags | flags[0]) & ~flags[1]
+
+        if self.tip is not None:
+            hint.tip = self.tip
+
+        if self.widget_type is not None:
+            hint.widget_type = self.widget_type
+
+        hint.params.update(self.params)
+
+        return hint
+
+
+# fmt: off
+UiHint.NONE = UiHint(widget_type = UiHint.WIDGET_TYPE.NONE)
+Ui          = UiHint
+UiMod       = UiHintModification
+# fmt: on

core_10x/unit_tests/test_concrete_traits.py

@@ -0,0 +1,156 @@
+from types import NoneType
+
+import pytest
+from core_10x.exec_control import CACHE_ONLY, CONVERT_VALUES_ON, DEBUG_ON
+from core_10x.trait_definition import T
+from core_10x.trait_method_error import TraitMethodError
+from core_10x.traitable import Traitable
+from core_10x.xnone import XNone, XNoneType
+
+
+def _test_i(data_type: type, values, expected_values):
+    assert len(values) == len(expected_values)
+
+    class TestableTraitable(Traitable):
+        xid: int = T(T.ID, default=1)
+        value: data_type = T(1)  # noinspection PyTypeHints
+
+    p = TestableTraitable(xid=1)
+    for v, ev in zip(values, expected_values, strict=True):
+        if isinstance(ev, type) and issubclass(ev, Exception):
+            try:
+                p.value = v
+            except Exception as ex:
+                if not isinstance(ex, ev):
+                    pytest.fail(f'Got {ex} instead of {ev} value {v} for type {data_type}')
+            else:
+                pytest.fail(f'Expected exception {ev} for value {v} for type {data_type}; converted to {p.value}')
+        else:
+            p.value = v
+            assert p.value == ev
+            if ev is None:
+                with pytest.raises(ValueError):
+                    p.serialize_object()
+            elif isinstance(ev, data_type):
+                assert p.T.value.from_any(p.serialize_object()['value']) == ev
+
+
+def _test(data_type, values, expected_types):
+    with CACHE_ONLY():  # TODO: remove when db access is sorted
+        _test_i(data_type, values, expected_types)
+
+
+def generic_test(data_type, values, convert_expected, allowed_types=()):
+    allowed_types = (data_type, NoneType, XNoneType, *allowed_types)
+    debug_expected = [
+        v if isinstance(v, allowed_types) else e if isinstance(e, Exception) else TypeError for v, e in zip(values, convert_expected, strict=True)
+    ]
+    _test(data_type, values, values)
+    with DEBUG_ON():
+        _test(data_type, values, debug_expected)
+    with CONVERT_VALUES_ON():
+        _test(data_type, values, convert_expected)
+        with DEBUG_ON():
+            _test(data_type, values, convert_expected)
+
+
+def test_int_trait():
+    data_type = int
+    values = [180, 180.1, '180', 'abc', None, XNone, '']
+    convert_expected = [180, 180, 180, TypeError, None, XNone, TypeError]
+    generic_test(data_type, values, convert_expected)
+    _test(data_type, values, values)
+
+
+def test_float_trait():
+    data_type = float
+    values = [180, 180.1, '180', 'abc', None, XNone, '']
+    convert_expected = [180.0, 180.1, 180.0, TypeError, None, XNone, TypeError]
+    generic_test(data_type, values, convert_expected, (int, float))
+    _test(data_type, values, values)
+
+
+def test_bool_trait():
+    data_type = bool
+    values = [True, False, 1, 0, 'yes', 'no', 'abc', None, XNone, '', 'true', 'false', '1', '0', 'on', 'off']
+    convert_expected = [
+        True,
+        False,
+        True,
+        False,
+        True,
+        False,
+        TypeError,
+        None,
+        XNone,
+        False,
+        True,
+        False,
+        True,
+        False,
+        True,
+        False,
+    ]
+    generic_test(data_type, values, convert_expected)
+
+
+def test_datetime_trait():
+    from datetime import datetime
+
+    data_type = datetime
+    values = [
+        datetime(2020, 1, 1),
+        '2020-01-01T01:02:03',
+        '2020-01-01 00:00:00',
+        '2020-01-01',
+        1577836800,
+        None,
+        XNone,
+        'abc',
+        '',
+        'Feb 1, 2020 1:2:3',
+    ]
+    convert_expected = [
+        datetime(2020, 1, 1),
+        datetime(2020, 1, 1, 1, 2, 3),
+        datetime(2020, 1, 1),
+        datetime(2020, 1, 1),
+        TraitMethodError,
+        None,
+        XNone,
+        TypeError,
+        TypeError,
+        datetime(2020, 2, 1, 1, 2, 3),
+    ]
+    generic_test(data_type, values, convert_expected)
+
+
+def test_date_trait():
+    from datetime import date
+
+    data_type = date
+    values = [
+        date(2020, 1, 1),
+        '2020-01-01T00:00:00',
+        '2020-01-01 00:00:00',
+        '2020-01-01',
+        1577836800,
+        None,
+        XNone,
+        'abc',
+        '',
+        'Feb 1, 2020',
+    ]
+    convert_expected = [
+        date(2020, 1, 1),
+        date(2020, 1, 1),
+        date(2020, 1, 1),
+        date(2020, 1, 1),
+        TraitMethodError,
+        None,
+        XNone,
+        TypeError,
+        TypeError,
+        date(2020, 2, 1),
+    ]
+    generic_test(data_type, values, convert_expected)

core_10x/unit_tests/test_converters.py

@@ -0,0 +1,51 @@
+"""
+Unit tests for converter methods in py10x traitables.
+Tests verify that converter methods are called when appropriate.
+"""
+
+import pytest
+from core_10x.exec_control import CONVERT_VALUES_OFF, CONVERT_VALUES_ON, DEBUG_OFF, DEBUG_ON, GRAPH_OFF, GRAPH_ON
+from core_10x.traitable import Traitable
+
+
+class Person(Traitable):
+    """Test traitable with converter methods."""
+
+    # Runtime traitable: omit T() so no storage context is required
+    name: bytes
+    status: str
+
+    def name_from_str(self, trait, value: str) -> bytes:
+        """Convert from string - title case the name."""
+        return value.title().encode()
+
+    def name_from_any_xstr(self, trait, value) -> bytes:
+        """Convert from non-string - convert to string and title case."""
+        return str(value).title().encode()
+
+    def status_from_any_xstr(self, trait, value) -> bytes:
+        """Convert any value to lowercase string."""
+        return str(value).lower()
+
+
+@pytest.mark.parametrize('graph_mode', [GRAPH_OFF, GRAPH_ON])
+@pytest.mark.parametrize('debug_mode', [DEBUG_OFF, DEBUG_ON])
+def test_converter_usage_with_execution_modes(graph_mode, debug_mode):
+    """Test that converters work with different execution mode combinations."""
+    with graph_mode(), debug_mode():
+        with CONVERT_VALUES_ON():
+            person = Person(name='john', status=True)
+            assert person.name == b'John'
+            assert person.status == 'true'
+        with CONVERT_VALUES_OFF():
+            person = Person()
+            if debug_mode is DEBUG_ON:
+                with pytest.raises(TypeError):
+                    person.status = True
+                with pytest.raises(TypeError):
+                    person.name = 'john'
+            else:
+                person.name = 'john'
+                person.status = True
+                assert person.status is True
+                assert person.name == 'john'

core_10x/unit_tests/test_curve.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+import math
+from datetime import date
+
+import pytest
+from core_10x.curve import IP_KIND, Curve, CurveParams, DateCurve, TwoFuncInterpolator
+
+
+class TestCurve:
+    def test_update_inserts_sorted_and_overwrites(self):
+        c = Curve()
+
+        # Insert out of order to check internal sorting
+        c.update(5, 50.0, reset=False)
+        c.update(1, 10.0, reset=False)
+        c.update(3, 30.0, reset=False)
+
+        # Overwrite existing point
+        c.update(3, 35.0, reset=False)
+
+        assert c.times == [1, 3, 5]
+        assert c.values == [10.0, 35.0, 50.0]
+
+    def test_value_linear_interpolation(self):
+        c = Curve()
+        c.update_many([0.0, 1.0], [0.0, 2.0], reset=True)
+
+        # Ensure interpolation is allowed for all t by setting a non-None beginning_of_time
+        c.beginning_of_time = 0.0
+
+        # Exact nodes
+        assert c.value(0.0) == pytest.approx(0.0)
+        assert c.value(1.0) == pytest.approx(2.0)
+
+        # Linear interpolation between nodes
+        assert c.value(0.5) == pytest.approx(1.0)
+
+    def test_no_interp_mode(self):
+        c = Curve()
+        c.update_many([0.0, 1.0], [10.0, 20.0], reset=True)
+
+        params = CurveParams()
+        params.ip_kind = IP_KIND.NO_INTERP
+        c.params = params
+
+        # Direct lookup for existing times
+        assert c.value(0.0) == pytest.approx(10.0)
+        assert c.value(1.0) == pytest.approx(20.0)
+
+        # Missing time returns NaN
+        v = c.value(0.5)
+        assert math.isnan(v)
+
+    def test_remove_and_perturb(self):
+        c = Curve()
+        c.update_many([0, 1, 2], [10.0, 20.0, 30.0], reset=True)
+
+        # Remove existing point
+        assert c.remove(1) is True
+        assert c.times == [0, 2]
+        assert c.values == [10.0, 30.0]
+
+        # Removing non-existing point
+        assert c.remove(100) is False
+
+        # Perturb existing point
+        c.beginning_of_time = 0  # allow interpolation/value evaluation
+        before = c.value(2)
+        c.perturb(2, before + 5.0, perturb_existing_only=True)
+        assert c.value(2) == pytest.approx(before + 5.0)
+
+        # Perturb_shift and perturb_proportional reuse value()
+        val_before_shift = c.value(0)
+        c.perturb_shift(0, 3.0, perturb_existing_only=True)
+        assert c.value(0) == pytest.approx(val_before_shift + 3.0)
+
+        val_before_prop = c.value(0)
+        c.perturb_proportional(0, 2.0, perturb_existing_only=True)
+        assert c.value(0) == pytest.approx(val_before_prop * 2.0)
+
+        # perturb_existing_only should assert for unknown point
+        with pytest.raises(AssertionError):
+            c.perturb(100, 1.0, perturb_existing_only=True)
+
+
+class TestTwoFuncInterpolator:
+    def test_requires_in_func_or_in_func_on_arrays(self):
+        with pytest.raises(AssertionError):
+            TwoFuncInterpolator(None, lambda t, v: v)
+
+    def test_composed_interpolation(self):
+        # in_func multiplies values by 2, out_func divides by 2 -- net effect is identity
+        def in_func_on_arrays(xs, ys):
+            return [2.0 * y for y in ys]
+
+        def out_func(t, v):
+            return v / 2.0
+
+        tf = TwoFuncInterpolator(
+            in_func=None,
+            out_func=out_func,
+            in_func_on_arrays=in_func_on_arrays,
+        )
+
+        xs = [0.0, 1.0]
+        ys = [0.0, 10.0]
+
+        ip = tf(xs, ys, kind='linear', fill_value='extrapolate', bounds_error=False)
+
+        # At mid-point we should recover the simple linear interpolation of original ys
+        assert ip(0.5) == pytest.approx(5.0)
+
+
+class TestDateCurve:
+    def test_dates_set_and_get(self):
+        dc = DateCurve()
+
+        d1 = date(2023, 1, 1)
+        d2 = date(2023, 1, 5)
+        dc.dates = [d1, d2]
+
+        # Internal representation must be integer days from epoch
+        assert isinstance(dc.times[0], int)
+        assert dc.dates == [d1, d2]
+
+    def test_update_and_value(self):
+        dc = DateCurve()
+
+        d1 = date(2023, 1, 1)
+        d2 = date(2023, 1, 11)
+
+        dc.update(d1, 0.0, reset=False)
+        dc.update(d2, 10.0, reset=True)
+
+        # Allow interpolation across the whole range
+        dc.beginning_of_time = dc._to_number(d1)
+
+        assert dc.value(d1) == pytest.approx(0.0)
+        assert dc.value(d2) == pytest.approx(10.0)
+
+        mid_date = d1 + (d2 - d1) / 2
+        assert dc.value(mid_date) == pytest.approx(5.0)
+
+    def test_beginning_of_time_helpers(self):
+        dc = DateCurve()
+
+        some_date = date(2020, 6, 15)
+        num = dc._to_number(some_date)
+        assert isinstance(num, int)
+        assert dc._from_number(num) == some_date
+
+        # beginning_of_time_set stores numeric value but exposes date via helper
+        rc = dc.beginning_of_time_set('beginning_of_time', some_date)
+        assert rc
+        assert isinstance(dc.beginning_of_time, int)
+        assert dc.beginning_of_time_as_date() == some_date

core_10x/unit_tests/test_directory.py

@@ -0,0 +1,54 @@
+from core_10x.code_samples.directories import ANIMALS, FISH
+
+
+def test_flatten():
+    f1 = ANIMALS.flatten()
+    assert f1 == {
+        ('Microorganisms',): 'Microorganisms',
+        ('Microorganisms', 'Single Cell'): 'Single Cell',
+        ('Microorganisms', 'Multi Cell'): 'Multi Cell',
+        ('Mollusks',): 'Mollusks',
+        ('Fishes',): 'Fishes',
+        ('Fishes', 'Salt Water'): 'Salt Water',
+        ('Fishes', 'Salt Water', 'Beluga'): 'Beluga',
+        ('Fishes', 'Fresh Water'): 'Fresh Water',
+        ('Amphibia',): 'Amphibia',
+        ('Reptiles',): 'Reptiles',
+        ('Birds',): 'Birds',
+        ('Mammals',): 'Mammals',
+        ('Mammals', 'Cats'): 'Cats',
+        ('Mammals', 'Dogs'): 'Dogs',
+        ('Mammals', 'Bears'): 'Bears',
+        ('Mammals', 'Whales'): 'Whales',
+        ('Mammals', 'Whales', 'Bluewhale'): 'Bluewhale',
+        ('Mammals', 'Whales', 'Orca'): 'Orca',
+        ('Mammals', 'Whales', 'Spermwhale'): 'Spermwhale',
+        ('Mammals', 'Whales', 'Beluga'): 'Beluga',
+    }
+
+    f2 = ANIMALS.flatten(with_root=True)
+    assert f2 == {('Animals',): 'Animals', **{('Animals', *k): v for k, v in f1.items()}}
+
+
+def test_choices():
+    c1 = FISH.choices()
+    assert c1 == {
+        'Pike Family': 'PkF',
+        'Pike Family/Northern Pike': 'NPK',
+        'Pike Family/Muskie': 'MSK',
+        'Pike Family/Pickerel': 'PKL',
+        'Perch Family': 'PeF',
+        'Perch Family/Common Perch': 'PCH',
+        'Perch Family/Yellow Perch': 'YPH',
+        'Perch Family/Walleye': 'WLY',
+        'Perch Family/Sagger': 'SGR',
+        'Carp Family': 'CrF',
+        'Carp Family/Common Carp': 'CRP',
+        'Carp Family/Wild Carp': 'WCP',
+        'Carp Family/Ide': 'IDE',
+        'Carp Family/Bream': 'BRM',
+        'Carp Family/Roach': 'RCH',
+    }
+
+    c2 = FISH.choices(with_root=True)
+    assert c2 == {'Fresh Water Fish': 'FWF', **{f'Fresh Water Fish/{k}': v for k, v in c1.items()}}