py10x-universe 0.1.3__py3-none-any.whl

core_10x/trait_definition.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import copy
+from collections import defaultdict
+
+from py10x_core import BFlags, BTraitFlags
+from typing_extensions import Never
+
+from core_10x.ui_hint import Ui, UiHintModification
+from core_10x.xnone import XNone, XNoneType
+
+# fmt: off
+#---- Attribute Tags
+NAME_TAG        = 'name'
+DATATYPE_TAG    = 'data_type'
+FLAGS_TAG       = 'flags'
+DEFAULT_TAG     = 'default'
+FORMAT_TAG      = 'fmt'
+PARAMS_TAG      = 'params'
+GETTER_PARAMS_TAG = 'getter_params'
+UI_HINT_TAG     = 'ui_hint'
+# fmt: on
+
+
+class TraitDefinition:
+    # fmt: off
+    __slots__ = (
+        NAME_TAG,
+        DATATYPE_TAG,
+        FLAGS_TAG,
+        DEFAULT_TAG,
+        FORMAT_TAG,
+        PARAMS_TAG,
+        UI_HINT_TAG,
+    )
+
+    s_known_attributes = {
+        DATATYPE_TAG:   lambda: XNoneType,
+        FLAGS_TAG:      lambda: BFlags(0x0),
+        DEFAULT_TAG:    lambda: XNone,
+        FORMAT_TAG:     lambda: '',
+        UI_HINT_TAG:    lambda: Ui(),
+    }
+    # fmt: on
+
+    def __init__(self, *args, **kwargs):
+        """
+        T([default_value,] [t_flags,] [Ui(...),] **kwargs
+        """
+        self.process_args(args, kwargs)
+
+        for tag, def_value_fn in self.s_known_attributes.items():
+            def_value = def_value_fn()
+            value = kwargs.pop(tag, def_value)
+            setattr(self, tag, value)
+
+        self.params = kwargs
+        self.name = None
+
+    def __floordiv__(self, comment):
+        """Add or replace comment in params with // operator"""
+        assert isinstance(comment, str), f'Trait comment must be a string: {comment}'
+        ui_hint = getattr(self, UI_HINT_TAG)
+        ui_hint.tip = comment
+        return self
+
+    def __call__(self, *args, **kwargs):
+        """Prevent IDE from complaining about calling traits with parameters"""
+        ...
+
+    def set_widget_type(self, widget_type: Ui.WIDGET_TYPE):
+        ui_hint = getattr(self, UI_HINT_TAG)
+        ui_hint.widget_type = widget_type
+
+    def copy(self) -> TraitDefinition:
+        return copy.deepcopy(self)
+
+    def flags_change(self, flags_value):
+        dt = type(flags_value)
+        if dt is tuple:
+            assert len(flags_value) == 2, f'Changing {self.name} flags expects (flags_to_set, flags_to_reset)'
+            self.flags.set_reset(*(0 if flag is None else flag.value() for flag in flags_value))
+        else:
+            self.flags.set(flags_value.value())
+
+    @classmethod
+    def process_args(cls, args: tuple, kwargs: dict):
+        """
+        args:
+            optional default_value
+            optional T.flags
+            optional ui hint: Ui(...)
+        kwargs:
+            known attributes and extra params (usually empty)
+        """
+        the_args = list(args)
+        already_processed = defaultdict(bool)
+
+        n = len(the_args)
+        while n:
+            arg = the_args.pop(0)
+            dt = type(arg)
+            if dt is Ui:  # -- only Ui hint is given, no more args
+                assert not already_processed[UI_HINT_TAG], f'Duplicated Ui hint: {args}'
+                assert n == 1, f'No positional args after Ui hint: {args}'
+                kwargs[UI_HINT_TAG] = arg
+                already_processed[UI_HINT_TAG] = True
+
+            elif issubclass(dt, BFlags):  # -- no default value => n <=2
+                assert not already_processed[FLAGS_TAG], f'Duplicated T.flags: {args}'
+                assert n <= 2, f'Too many positional args after T.flags: {args}'
+                kwargs[FLAGS_TAG] = arg
+                already_processed[FLAGS_TAG] = True
+
+            else:  # -- must be a default value
+                assert not already_processed[DEFAULT_TAG], f'Duplicated default value: {args}'
+                kwargs[DEFAULT_TAG] = arg
+                already_processed[DEFAULT_TAG] = True
+
+            n -= 1
+
+
+class TraitModification(TraitDefinition):
+    # fmt: off
+    s_known_attributes = {
+        FLAGS_TAG:      lambda: Never,
+        DEFAULT_TAG:    lambda: Never,
+        FORMAT_TAG:     lambda: Never,
+        UI_HINT_TAG:    UiHintModification
+    }
+
+    s_modifiers = {
+        FLAGS_TAG:      lambda self, flags_modification: self.flags_change(flags_modification),
+        UI_HINT_TAG:    lambda self, ui_hint_modification: setattr(self,UI_HINT_TAG,ui_hint_modification.apply(self.ui_hint))
+    }
+    # fmt: on
+    def apply(self, trait_def: TraitDefinition) -> TraitDefinition:
+        res = trait_def.copy()
+        modifiers = self.__class__.s_modifiers
+        for attr_name in self.__class__.s_known_attributes:
+            modified_value = getattr(self, attr_name)
+            if modified_value is not Never:
+                modifier = modifiers.get(attr_name)
+                if modifier:
+                    modifier(res, modified_value)
+                else:
+                    setattr(res, attr_name, modified_value)
+        res.params.update(self.params)
+        return res
+
+
+class T(BTraitFlags):
+    def __new__(cls, *args, **kwargs) -> TraitDefinition:
+        return TraitDefinition(*args, **kwargs)
+
+    @staticmethod
+    def fg_color(color: str) -> str:
+        return f'color: {color}' if color else ''
+
+    @staticmethod
+    def bg_color(color: str) -> str:
+        return f'background-color: {color}' if color else ''
+
+    @staticmethod
+    def colors(bg_color: str, fg_color: str) -> str:
+        return f'background-color: {bg_color}; color: {fg_color}' if bg_color and fg_color else ''
+
+
+def RT(*args, **kwargs) -> TraitDefinition:  # noqa: N802
+    trait_def = TraitDefinition(*args, **kwargs)
+    trait_def.flags.set(T.RUNTIME.value())
+    return trait_def
+
+
+def M(*args, **kwargs) -> TraitModification:  # noqa: N802
+    return TraitModification(*args, **kwargs)

core_10x/trait_filter.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from py10x_core import BTraitableClass
+
+    from core_10x.trait import Trait
+
+# ===================================================================================================================================
+#
+#   age = LT(value)
+#   name = 'Sasha'      #-- name = EQ('Sasha')
+#   weight = BETWEEN(170, 180, bounds = (True, False)
+#   weight =
+# ===================================================================================================================================
+
+
+# fmt: off
+class _mongo_label:
+    EQ      = '$eq'
+    NE      = '$ne'
+    GT      = '$gt'
+    GE      = '$gte'
+    LT      = '$lt'
+    LE      = '$lte'
+    IN      = '$in'
+    NIN     = '$nin'
+    REGEX   = '$regex'
+    AND     = '$and'
+    OR      = '$or'
+    #NOT     = '$not'
+# fmt: on
+
+LABEL = _mongo_label
+
+
+class _filter(ABC):
+    @abstractmethod
+    def eval(self, left_value) -> bool: ...
+    @abstractmethod
+    def prefix_notation(self, trait: Trait = None, traitable_class: BTraitableClass = None) -> dict: ...
+
+
+class Op(_filter, ABC):
+    label = ''
+
+    def __init_subclass__(cls, label: str = None):
+        if label is None:
+            label = getattr(LABEL, cls.__name__)
+        cls.label = label
+
+    def __new__(cls, expression=None):
+        obj = super().__new__(cls)
+        obj.right_value = expression
+        return obj
+
+    def serialize_right_value(self, trait: Trait = None, traitable_class: BTraitableClass = None) -> dict:
+        return trait.serialize_value(self.right_value, replace_xnone=True) if trait and traitable_class else self.right_value
+
+    def prefix_notation(self, trait: Trait = None, traitable_class: BTraitableClass = None) -> dict:
+        # noinspection PyTypeChecker
+        return {self.label: self.serialize_right_value(trait, traitable_class)}
+
+
+class NOT_EMPTY(Op, label=''):
+    def prefix_notation(self, trait: Trait = None, traitable_class: BTraitableClass = None) -> dict:
+        raise NotImplementedError
+
+    def eval(self, left_value) -> bool:
+        return bool(left_value)
+
+
+class EQ(Op):
+    def eval(self, left_value) -> bool:
+        return left_value == self.right_value
+
+
+class NE(Op):
+    def eval(self, left_value) -> bool:
+        return left_value != self.right_value
+
+
+class GT(Op):
+    def eval(self, left_value) -> bool:
+        return left_value > self.right_value
+
+
+class GE(Op):
+    def eval(self, left_value) -> bool:
+        return left_value >= self.right_value
+
+
+class LT(Op):
+    def eval(self, left_value) -> bool:
+        return left_value < self.right_value
+
+
+class LE(Op):
+    def eval(self, left_value) -> bool:
+        return left_value <= self.right_value
+
+
+class IN(Op):
+    def __new__(cls, values: list | tuple):
+        assert isinstance(values, list) or isinstance(values, tuple), f'{cls.__name__}() requires a list or tuple'
+        return super().__new__(cls, values)
+
+    def serialize_right_value(self, trait: Trait = None, traitable_class: BTraitableClass = None) -> dict:
+        return [trait.serialize_value(value, replace_xnone=True) for value in self.right_value] if trait and traitable_class else self.right_value
+
+    def eval(self, left_value) -> bool:
+        return left_value in self.right_value
+
+
+class NIN(IN):
+    def eval(self, left_value) -> bool:
+        return left_value not in self.right_value
+
+
+# class REGEX(Op):
+
+
+class BETWEEN(Op, label=''):
+    def __new__(cls, a, b, bounds=(True, True)):
+        obj = super().__new__(cls)
+        assert isinstance(bounds, tuple) and len(bounds) == 2, f'{cls.__name__} - (bool, bool) is expected for bounds'
+
+        bound_a, bound_b = bounds
+        obj.left = GE(a) if bound_a else GT(a)
+        obj.right = LE(b) if bound_b else LT(b)
+        return obj
+
+    def eval(self, left_value) -> bool:
+        return self.left.eval(left_value) and self.right.eval(left_value)
+
+    def prefix_notation(self, trait: Trait = None, traitable_class: BTraitableClass = None) -> dict:
+        res = self.left.prefix_notation(trait, traitable_class)
+        res.update(self.right.prefix_notation(trait, traitable_class))
+        return res
+
+
+class BoolOp(Op, ABC, label=''):
+    s_false: IN = IN([])
+
+    @classmethod
+    def _simplify(cls, expressions: tuple, false: IN) -> list: ...
+
+    def __new__(cls, *expressions):
+        expressions = cls._simplify(expressions, cls.s_false)
+        if len(expressions) == 1:
+            return expressions[0]
+
+        obj = super().__new__(cls, expressions)
+        return obj
+
+    def prefix_notation(self, trait: Trait = None, traitable_class: BTraitableClass = None) -> dict:
+        rvalues = [pn for e in self.right_value if (pn := e.prefix_notation(trait, traitable_class))]
+        return {self.label: rvalues} if rvalues else {}
+
+
+class AND(BoolOp):
+    @classmethod
+    def _simplify(cls, expressions, false):
+        return [false] if false in expressions else expressions
+
+    def eval(self, left_value) -> bool:
+        return all(e.eval(left_value) for e in self.right_value)
+
+
+class OR(BoolOp):
+    @classmethod
+    def _simplify(cls, expressions, false):
+        expressions = [expression for expression in expressions if expression is not false]
+        return [false] if not expressions else expressions
+
+    def eval(self, left_value) -> bool:
+        return any(e.eval(left_value) for e in self.right_value)
+
+
+class f(_filter):
+    def __init__(self, _f: _filter = None, _t: BTraitableClass = None, **named_expressions):
+        self.filter = _f
+        self.traitable_class = _t
+        self.named_expressions = {
+            name: expression if isinstance(expression, _filter) else EQ(expression) for name, expression in named_expressions.items()
+        }
+
+    def eval(self, traitable_or_dict) -> bool:
+        if self.filter:
+            if not self.filter.eval(traitable_or_dict):
+                return False
+
+        return all(item.eval(traitable_or_dict[name]) for name, item in self.named_expressions.items())
+
+    def prefix_notation(self, trait: Trait = None, traitable_class: BTraitableClass = None) -> dict:
+        traitable_class = traitable_class or self.traitable_class
+        trait_dir = traitable_class.trait_dir() if traitable_class else {}
+        clause = {name: pn for name, item in self.named_expressions.items() if (pn := item.prefix_notation(trait_dir.get(name), traitable_class))}
+        if self.filter:
+            filter_clause = self.filter.prefix_notation(traitable_class=traitable_class)
+            clause = {AND.label: [filter_clause, clause]} if clause else filter_clause
+
+        return clause

core_10x/trait_method_error.py

@@ -0,0 +1,36 @@
+from core_10x.xnone import XNone
+
+
+class TraitMethodError(Exception):
+    """
+    NOTE: other_exc must be set in except clause ONLY!
+    """
+
+    @staticmethod
+    def create(traitable, traitable_class, trait_name: str, method_name: str, value=XNone, other_exc: Exception = None, args=()):
+        assert other_exc
+
+        if isinstance(other_exc, TraitMethodError):
+            return other_exc
+
+        msg = []
+        traitable_class = traitable_class or traitable.__class__
+        msg.append(f'Failed in {traitable_class}.{trait_name}.{method_name}')
+        if traitable:
+            msg.append(f'    object = {traitable.id()};')
+
+        if value is not XNone:
+            msg.append(f'    value = {value}')
+
+        if args:
+            msg.append(f'    args = {args}')
+
+        if other_exc:
+            msg.append(f'original exception = {type(other_exc).__name__}: {other_exc!s}')
+
+        exc = TraitMethodError('\n'.join(msg))
+
+        if other_exc and (tb := other_exc.__traceback__):
+            exc = exc.with_traceback(tb)
+
+        return exc