py10x-universe 0.1.3__py3-none-any.whl

core_10x/concrete_traits.py

@@ -0,0 +1,356 @@
+import ast
+import inspect
+
+from core_10x.named_constant import EnumBits, NamedConstant
+from core_10x.nucleus import Nucleus
+from core_10x.package_refactoring import PackageRefactoring
+from core_10x.py_class import PyClass
+from core_10x.trait import T, Trait
+from core_10x.ui_hint import Ui
+from core_10x.xdate_time import XDateTime, date, datetime
+from core_10x.xnone import XNone, XNoneType
+
+
+class primitive_trait(Trait, register=False):
+    s_ui_hint = Ui.NONE
+
+    def default_value(self):
+        return self.default
+
+    def same_values(self, value1, value2) -> bool:
+        return value1 == value2
+
+    def from_str(self, s: str):
+        try:
+            v = ast.literal_eval(s)
+            dt = self.data_type
+            return v if type(v) is dt else dt(v)
+        except Exception:
+            return XNone
+
+    def from_any_xstr(self, value):
+        return self.data_type(value)
+
+    # def to_str(self, v) -> str:
+    #      return str(v)
+
+    def to_id(self, v) -> str:
+        return str(v)
+
+    def serialize(self, value):
+        return value
+
+    def deserialize(self, value):
+        return value
+
+
+class bool_trait(primitive_trait, data_type=bool):
+    s_ui_hint = Ui.check()
+
+    # fmt: off
+    FORMATS     = [
+        ('yes',''),
+        ('yes','no'),
+        ('true','false'),
+        ('on','off')
+    ]
+    fmt         = FORMATS[0]
+    # fmt: on
+
+    def to_id(self, value: bool) -> str:
+        return '0' if value else '1'
+
+    def from_str(self, s: str):
+        res = super().from_str(s)
+        if res is not XNone:
+            return res
+        s = s.strip().lower()
+        return next((f[0] == s for f in self.FORMATS if s in f), XNone)
+
+
+class int_trait(primitive_trait, data_type=int):
+    s_ui_hint = Ui.line()
+
+    fmt = ','
+
+
+class float_trait(primitive_trait, data_type=float):
+    s_ui_hint = Ui.line()
+
+    fmt = ',.2f'
+
+    # def from_str(self, s: str) -> RC:
+    #    return RC(True, locale.atof(s))
+
+    def is_acceptable_type(self, data_type: type) -> bool:
+        return data_type is float or data_type is int
+
+
+class str_trait(primitive_trait, data_type=str):
+    s_ui_hint = Ui.line(align_h=-1)
+
+    # pattern = ''
+    # placeholder = ''
+
+    def from_str(self, s: str):
+        return s
+
+    def to_str(self, v) -> str:
+        return v
+
+    def to_id(self, value: str) -> str:
+        return value
+
+
+# class bin_trait(Trait, data_type = bytes):
+#     w = 0   #-- max width, if any and relevant
+#     h = 0   #-- max height, if any and relevant
+#
+# def pixmap(*args, **kwargs):
+#     tdef: TraitDefinition = T(bytes, *args, **kwargs)
+#     tdef.set_widget_type(Ui.WIDGET_TYPE.PIXMAP)
+#     return tdef
+
+
+class datetime_trait(Trait, data_type=datetime):
+    s_ui_hint = Ui.line(align_h=0)
+
+    def from_str(self, s: str):
+        dt = XDateTime.str_to_datetime(s)
+        if dt is None:
+            return XNone
+        return dt
+
+    def from_any_xstr(self, value):
+        dt = XDateTime.to_datetime(value)
+        if dt is None:
+            return XNone
+        return dt
+
+    def to_str(self, v: datetime) -> str:
+        return XDateTime.datetime_to_str(v)
+
+    # s_acceptable_types = { datetime, date, int, str }
+    # def is_acceptable_type(self, data_type: type) -> bool:
+    #     return data_type in self.s_acceptable_types
+
+    # -- NOTES:
+    # -- 1) we believe datetime is mostly acceptable for a storage, e.g., Mongo
+    # -- 2) it is in UTC, so no locale's datetime issues
+
+    def serialize(self, value: datetime):
+        return value
+
+    def deserialize(self, value: datetime):
+        return value
+
+    def to_id(self, value) -> str:
+        return XDateTime.datetime_to_str(value, with_ms=True)
+
+
+class date_trait(Trait, data_type=date):
+    s_ui_hint = Ui.line(min_width=10, align_h=0)
+
+    def from_str(self, s: str):
+        dt = XDateTime.str_to_date(s)
+        if dt is None:
+            return XNone
+        return dt
+
+    def from_any_xstr(self, value):
+        dt = XDateTime.to_date(value)
+        if dt is None:
+            return XNone
+        return dt
+
+    def to_str(self, v: date) -> str:
+        return XDateTime.date_to_str(v)
+
+    # s_acceptable_types = { datetime, date, int, str }
+    # def is_acceptable_type(self, data_type: type) -> bool:
+    #     return data_type in self.s_acceptable_types
+
+    def serialize(self, value: date):
+        return XDateTime.date_to_str(value, format=XDateTime.FORMAT_X10)
+
+    def deserialize(self, value):
+        return XDateTime.str_to_date(value, format=XDateTime.FORMAT_X10)
+
+    def to_id(self, value) -> str:
+        return XDateTime.date_to_str(value)
+
+
+class bytes_trait(Trait, data_type=bytes):
+    s_ui_hint = Ui.NONE
+
+    def to_str(self, value):
+        return value.decode(encoding='utf-8')
+
+    def to_id(self, value) -> str:
+        return self.to_str(value)
+
+    def same_values(self, value1, value2) -> bool:
+        return value1 == value2
+
+    def from_str(self, s: str):
+        return bytes(s, encoding='utf-8')
+
+    def from_any_xstr(self, value):
+        return XNone  # may not be called!
+
+    # def is_acceptable_type(self, data_type: type) -> bool:
+    #    ...
+
+    def serialize(self, value):
+        return value
+
+    def deserialize(self, value):
+        return value
+
+
+class class_trait(Trait, data_type=type):
+    s_ui_hint = Ui.line(align_h=-1)
+
+    def to_str(self, value):
+        return PyClass.name(value)
+
+    def to_id(self, value) -> str:
+        return PackageRefactoring.find_class_id(value)
+
+    def same_values(self, value1, value2) -> bool:
+        return value1 is value2
+
+    def from_str(self, s: str):
+        return PackageRefactoring.find_class(s)
+
+    def from_any_xstr(self, value):
+        return XNone  # may not be called!
+
+    def is_acceptable_type(self, data_type: type) -> bool:
+        return inspect.isclass(data_type)
+
+    def serialize(self, value):
+        return PackageRefactoring.find_class_id(value)
+
+    def deserialize(self, value: str):
+        return PackageRefactoring.find_class(value)
+
+
+class list_trait(Trait, data_type=list):
+    s_ui_hint = Ui.line()
+
+    def to_str(self, v) -> str:
+        return str(v)
+
+    def to_id(self, value) -> str:
+        return str(value)
+
+    def default_value(self) -> list:
+        return list(self.default)
+
+    def serialize(self, value: list):
+        return Nucleus.serialize_list(value, self.flags_on(T.EMBEDDED))
+
+    def deserialize(self, value: list):
+        return Nucleus.deserialize_list(value)
+
+
+class dict_trait(Trait, data_type=dict):
+    s_ui_hint = Ui.line(flags=Ui.SELECT_ONLY)
+
+    def use_format_str(self, fmt: str, value) -> str:
+        return str(value) if not fmt else fmt.join(f"'{key}' -> '{val}'" for key, val in value.items())
+
+    def to_str(self, v) -> str:
+        return str(v)
+
+    def to_id(self, value) -> str:
+        return str(value)
+
+    def default_value(self) -> dict:
+        return dict(self.default)
+
+    def serialize(self, value: dict):
+        return Nucleus.serialize_dict(value, self.flags_on(T.EMBEDDED))
+
+    def deserialize(self, value: dict):
+        return Nucleus.deserialize_dict(value)
+
+
+class any_trait(Trait, data_type=XNoneType):  # -- any
+    s_ui_hint = Ui.NONE
+
+    def to_str(self, v) -> str:
+        return str(v)
+
+    def to_id(self, value) -> str:
+        return str(value)
+
+    def from_str(self, s: str):
+        return None
+
+    def from_any_xstr(self, value):
+        return value
+
+    def is_acceptable_type(self, data_type: type) -> bool:
+        return True
+
+    def serialize(self, value):
+        return Nucleus.serialize_any(value, self.flags_on(T.EMBEDDED))
+
+    def deserialize(self, value):
+        return Nucleus.deserialize_any(value, None)  # expected class unknown
+
+    def same_values(self, value1, value2) -> bool:
+        return value1 is value2
+
+
+class nucleus_trait(Trait, data_type=Nucleus, base_class=True):
+    s_ui_hint = Ui.NONE
+
+    def to_str(self, v) -> str:
+        return self.data_type.to_str(v)
+
+    def to_id(self, v) -> str:
+        return self.data_type.to_id(v)
+
+    def from_str(self, s: str) -> Nucleus:
+        return self.data_type.from_str(s)
+
+    def from_any_xstr(self, value) -> Nucleus:
+        return self.data_type.from_any_xstr(value)
+
+    def is_acceptable_type(self, data_type: type) -> bool:
+        return issubclass(data_type, self.data_type)
+
+    def same_values(self, value1, value2) -> bool:
+        return self.data_type.same_values(value1, value2)
+
+    def serialize(self, value: Nucleus):
+        if type(value) is self.data_type:
+            return value.serialize(self.flags_on(T.EMBEDDED))
+
+        return Nucleus.serialize_any(value, self.flags_on(T.EMBEDDED))
+
+    def deserialize(self, serialized_value) -> Nucleus:
+        if isinstance(serialized_value, dict) and (value := Nucleus.deserialize_record(serialized_value)):
+            return value
+
+        return self.data_type.deserialize(serialized_value)
+
+    def choices(self):
+        return self.data_type.choose_from()
+
+
+class named_constant_trait(nucleus_trait, data_type=NamedConstant, base_class=True):
+    s_ui_hint = Ui.choice(flags=Ui.SELECT_ONLY)
+
+    def is_acceptable_type(self, data_type: type) -> bool:
+        return data_type is self.data_type
+
+
+class flags_trait(nucleus_trait, data_type=EnumBits, base_class=True):
+    s_ui_hint = Ui.line()
+
+    def is_acceptable_type(self, data_type: type) -> bool:
+        return data_type is self.data_type

core_10x/conftest.py

@@ -0,0 +1,12 @@
+import pytest
+
+from core_10x.ts_store import TsStore
+
+
+@pytest.fixture(scope='module')
+def ts_instance():
+    from core_10x.testlib.test_store import TestStore
+
+    assert not TsStore.s_instances
+    yield TestStore.instance()
+    TsStore.s_instances.clear()

core_10x/curve.py

@@ -0,0 +1,321 @@
+from __future__ import annotations
+
+import bisect
+import math
+from datetime import date, timedelta
+from typing import Any
+
+from scipy import interpolate
+
+from core_10x.named_constant import NamedConstant
+from core_10x.traitable import RC, RC_TRUE, RT, AnonymousTraitable, M, T, Traitable
+
+
+class IP_KIND(NamedConstant, lowercase_values=True):
+    # fmt: off
+    #-- NOTE: enum labels specify the minimum number of points required!
+    LINEAR      = ( 2, )
+    NEAREST     = ( 2, )
+    NEAREST_UP  = ( 2, )
+    PREVIOUS    = ( 2, )    #-- return the previous value of the point
+    NEXT        = ( 2, )    #-- ------ the next ----
+    ZERO        = ( 1, )    #-- spline interp of zeroth order
+    SLINEAR     = ( 2, )    #-- spline interp of first order
+    QUADRATIC   = ( 3, )    #-- spline interp of second order
+    CUBIC       = ( 4, )    #-- spline interp of third order
+
+    NO_INTERP   = ( 0, )    #-- NO interp outside of given nodes
+    # fmt: on
+
+    # @classmethod
+    # def labelFromValue( cls, value ) -> int:
+    #     return int( super().labelFromValue( value ) )
+    #
+    # @classmethod
+    # def defaultValueForName( cls, name: str ) -> str:
+    #     return name.replace( '_', '-' ).lower()
+
+
+# -- TODO: it must be derived from AnonymousTraitable. Had to make it RT and derive from Traitable due to a bug - trying to load the embedded portion from its own collection
+class CurveParams(Traitable):
+    # fmt: off
+    DEFAULT_INTERPOLATOR = interpolate.interp1d
+
+    interpolator: Any   = RT(default = DEFAULT_INTERPOLATOR)
+    ip_kind: IP_KIND    = RT(IP_KIND.LINEAR)
+    assume_sorted: bool = RT(True)
+    copy: bool          = RT(False)
+    fill_value: str     = RT('extrapolate')
+    bounds_error: bool  = RT(False)
+    # fmt: on
+
+
+class Curve(AnonymousTraitable):
+    # fmt: off
+    times: list         = T([])       #-- only ints or floats are allowed
+    values: list        = T([])
+    params: CurveParams = RT()  #-- TODO: must be T(T.EMBEDDED)
+
+    beginning_of_time: Any  = T(None)    #-- may be float or int
+
+    interpolator: Any       = RT()
+    min_curve_size: int     = RT()
+    # fmt: on
+
+    def params_get(self) -> CurveParams:
+        return CurveParams()
+
+    def min_curve_size_get(self) -> int:
+        return self.params.ip_kind.label
+
+    def start_time(self):
+        times = self.times
+        return times[0] if times else None
+
+    def end_time(self):
+        times = self.times
+        return times[-1] if times else None
+
+    def update(self, t, value, reset=True):
+        if type(value) is not float:  # -- TODO: we sometimes have np.floats
+            value = float(value)
+
+        times = self.times
+        values = self.values
+        i = bisect.bisect_left(times, t)
+        if i >= len(times):
+            times.append(t)
+            values.append(value)
+        else:
+            if times[i] == t:
+                values[i] = value
+            else:
+                times.insert(i, t)
+                values.insert(i, value)
+
+        self.times = times
+        self.values = values
+        if reset:
+            self.reset()
+
+    def update_many(self, times, values, reset=True):
+        assert len(times) == len(values), 'times and values size mismatch'
+        for i, t in enumerate(times):
+            self.update(t, values[i], reset=False)
+
+        if reset:
+            self.reset()
+
+    def remove(self, t, reset=True) -> bool:
+        times = self.times
+        if t not in times:
+            return False
+
+        values = self.values
+        i = times.index(t)
+        times.pop(i)
+        values.pop(i)
+        if reset:
+            self.reset()
+
+        return True
+
+    def perturb(self, t, new_value, perturb_existing_only=False):
+        if perturb_existing_only:
+            assert t in self.times, f't = {t} is not in the curve'
+
+        values = self.values
+        self.invalidate_value('values')
+        self.values = values
+        self.update(t, new_value)
+
+    def perturb_shift(self, t, value_shift, perturb_existing_only=False):
+        self.perturb(t, self.value(t) + value_shift, perturb_existing_only)
+
+    def perturb_proportional(self, t, value_shift_mult, perturb_existing_only=False):
+        self.perturb(t, self.value(t) * value_shift_mult, perturb_existing_only)
+
+    def interpolator_get(self):
+        params = self.params
+        # fmt: off
+        return params.interpolator(
+            self.times, self.values,
+            kind            = params.ip_kind.value,
+            assume_sorted   = params.assume_sorted,
+            copy            = params.copy,
+            fill_value      = params.fill_value,
+            bounds_error    = params.bounds_error,
+        )
+        # fmt: on
+
+    def value(self, t) -> float:
+        times = self.times
+
+        if self.params.ip_kind is IP_KIND.NO_INTERP:
+            return self.values[times.index(t)] if t in times else math.nan
+
+        if len(times) < self.min_curve_size:
+            if t in times:
+                return self.values[times.index(t)]
+
+        bot = self.beginning_of_time
+        return float(self.interpolator(t)) if (bot is not None) or (t >= bot) else math.nan
+
+    def values_at(self, dates) -> tuple:
+        return tuple(self.value(d) for d in dates)
+
+    def reset(self):
+        self.invalidate_value('interpolator')
+
+    # @classmethod
+    # def _uniqueTimesValues(cls, times: list, values: list, keep_last_update: bool) -> tuple:
+    #     assert len(times) == len(values), f'{len(times)} != {len(values)}: sizes of times and values must be equal'
+    #
+    #     last_t = times[0]
+    #     last_i = 0
+    #     times_unique = [last_t]
+    #     values_unique = [values[0]]
+    #
+    #     for t, v in zip(times, values, strict=True):
+    #         assert t >= last_t, f'times must be a non-decreasing list, but {t} < {last_t}'
+    #
+    #         if t > last_t:
+    #             last_t = t
+    #             last_i += 1
+    #             times_unique.append(t)
+    #             values_unique.append(v)
+    #         else:
+    #             if keep_last_update:
+    #                 values_unique[last_i] = v
+    #
+    #     return (times_unique, values_unique)
+    #
+    # def uniquePointsCurve(self, keep_last_update=True, copy_curve=False) -> Curve:
+    #     times_unique, values_unique = self._uniqueTimesValues(self.times(), self.values(), keep_last_update)
+    #     if copy_curve:
+    #         return self.clone(times=times_unique, values=values_unique)
+    #
+    #     self.times = times_unique
+    #     self.values = values_unique
+    #     self.reset()
+    #     return self
+
+
+class TwoFuncInterpolator:
+    def __init__(self, in_func, out_func, in_func_on_arrays=None, _interpolator=interpolate.interp1d):
+        if in_func:
+            in_func_on_arrays = lambda list_x, list_y: [in_func(x, list_y[i]) for i, x in enumerate(list_x)]
+
+        assert in_func_on_arrays, 'either in_func or in_func_on_arrays must be provided'
+
+        self.in_func = in_func_on_arrays
+        self.out_func = out_func
+        self.interpolator = _interpolator
+
+    def __call__(self, x, y, **kwargs):
+        values = self.in_func(x, y)
+        ip_method = self.interpolator(x, values, **kwargs)
+        out_func = self.out_func
+
+        def _method(t):
+            v = ip_method(t)
+            return out_func(t, v)
+
+        return _method
+
+
+class DateCurve(Curve):
+    beginning_of_time: int = M()  # -- TODO: looks like Any trait fails to get deserialized - bug
+    dates: list = RT()
+
+    s_epoch_date = date(1970, 1, 1)
+
+    @classmethod
+    def _to_number(cls, d) -> int:
+        if isinstance(d, date):
+            return (d - cls.s_epoch_date).days
+        elif isinstance(d, int):
+            return d
+
+        raise ValueError(f'Unexpected value {d}')
+
+    @classmethod
+    def _from_number(cls, x: int) -> date:
+        return cls.s_epoch_date + timedelta(days=x)
+
+    def dates_get(self) -> list:
+        f = self._from_number
+        return [f(x) for x in self.times]
+
+    def dates_set(self, trait, value) -> RC:
+        f = self._to_number  # -- TODO: possibly improve performance by using a different f (which doesn't check the type)
+        times = [f(d) for d in value]
+        return self.set_value('times', times)
+
+    def beginning_of_time_set(self, trait, d) -> RC:
+        t = self._to_number(d)
+        self.raw_set_value(trait, t)
+        return RC_TRUE
+
+    def beginning_of_time_as_date(self) -> date:
+        return self._from_number(self.beginning_of_time)
+
+    def start_time(self) -> date:
+        times = self.dates
+        return times[0] if times else None
+
+    def end_time(self) -> date:
+        times = self.dates
+        return times[-1] if times else None
+
+    def update(self, d: date, value, reset=True):
+        x = self._to_number(d)
+        super().update(x, value, reset=reset)
+
+    def reset(self):
+        super().reset()
+        self.invalidate_value('dates')
+
+    def value(self, d: date) -> float:
+        x = self._to_number(d)
+        return super().value(x)
+
+    def remove(self, d, reset=True):
+        t = self._to_number(d)
+        if super().remove(t, reset=reset):
+            self.invalidate_value('dates')
+
+    def perturb(self, d: date, new_value, perturb_existing_only=False):
+        if perturb_existing_only:
+            assert d in self.dates, f'{d} is not in the curve'
+
+        values = self.values
+        self.invalidate_value('values')
+        self.values = values
+        self.update(d, new_value)
+
+    # def bracketDateNodes(self, d: date) -> tuple:
+    #     t = self._to_number(d)
+    #
+    #     times: list = self.times
+    #     last_time = times[-1]
+    #     first_time = times[0]
+    #     if t > last_time:
+    #         return (self._from_number(last_time), None)
+    #
+    #     if t < first_time:
+    #         return (None, self._from_number(first_time))
+    #
+    #     i = bisect.bisect_left(times, t)
+    #     if times[i] == t:
+    #         d = self._from_number(times[i])
+    #         return (d, d)
+    #
+    #     d_left = self._from_number(times[i - 1])
+    #     d_right = self._from_number(times[i])
+    #     return (d_left, d_right)
+
+    def dates_values(self, min_date: date = None, max_date: date = None) -> list:
+        dates = self.dates
+        values = self.values
+        return [(d, v) for d, v in zip(dates, values, strict=True) if (not min_date or d >= min_date) and (not max_date or d <= max_date)]