py10x-universe 0.1.3__py3-none-any.whl

core_10x/testlib/ts_tests.py

@@ -0,0 +1,280 @@
+from typing import Any
+from uuid import uuid4
+
+import numpy
+import pytest
+from py10x_core import BTraitableProcessor, XCache
+
+from core_10x.code_samples.person import Person as BasePerson
+from core_10x.package_refactoring import PackageRefactoring
+from core_10x.rc import RC_TRUE
+from core_10x.trait_definition import T
+from core_10x.ts_store import TsDuplicateKeyError
+
+
+class EnhancedPerson(BasePerson):
+    numpy_weight_lbs: Any = T()
+
+    def numpy_weight_lbs_get(self):
+        return numpy.float64(self.weight_lbs)
+
+
+test_classes = {
+    cls_name: type(
+        cls_name,
+        (EnhancedPerson,),
+        {
+            '__module__': __name__,
+            #'s_custom_collection': True
+        },
+    )
+    for cls_name in (f'Person#{uuid4().hex}' for _ in range(2))
+}
+
+globals().update(test_classes)
+Person, Person1 = test_classes.values()
+TEST_COLLECTION = PackageRefactoring.find_class_id(Person)
+TEST_COLLECTION1 = PackageRefactoring.find_class_id(Person1)
+
+# TODO: split out s_custom_collection vs regular tests
+
+
+@pytest.fixture(scope='module')
+def ts_setup(ts_instance):
+    with ts_instance:
+        p = Person(first_name='John', last_name='Doe')  # , _collection_name=TEST_COLLECTION)
+        p.set_values(age=30, weight_lbs=100)
+        assert p._rev == 0
+        assert p.save() == RC_TRUE
+        assert p._rev == 1
+        assert p.save() == RC_TRUE
+        assert p._rev == 1
+
+        p1 = Person1(first_name='Joe', last_name='Doe')  # , _collection_name=TEST_COLLECTION1)
+        p1.set_values(age=32, weight_lbs=200)
+        assert p1.save()
+        assert p1.age == 32
+        assert p1._rev == 1
+
+    yield ts_instance, p, p1
+
+    # Cleanup
+    XCache.clear()
+    BTraitableProcessor.current().end_using()
+    for cn in [TEST_COLLECTION, TEST_COLLECTION1]:
+        ts_instance.delete_collection(cn)
+    assert not {TEST_COLLECTION, TEST_COLLECTION1}.intersection(ts_instance.collection_names('.*'))
+
+
+class TestTSStore:
+    """Test class for TS Store functionality."""
+
+    def test_collection(self, ts_setup):
+        ts_store, _p, _p1 = ts_setup
+        collection = ts_store.collection(TEST_COLLECTION)
+        assert collection is not None
+
+    def test_save(self, ts_setup):
+        ts_store, p, _p1 = ts_setup
+        collection = ts_store.collection(TEST_COLLECTION)
+        serialized_entity = p.serialize_object()
+        _rev = collection.save(serialized_entity.copy())
+        assert p._rev == _rev
+
+        serialized_entity |= {'attr': {'nested': 'value'}}
+        _rev = collection.save(serialized_entity.copy())
+        serialized_entity |= dict(_rev=_rev)
+        assert p._rev + 1 == _rev
+        assert collection.load(p.id().value) == serialized_entity
+
+        # test that nested dictionary replaces rather than updates
+        serialized_entity |= {'attr': {'nested1': 'value1'}}
+        _rev = collection.save(serialized_entity.copy())
+        serialized_entity |= dict(_rev=_rev)
+        assert p._rev + 2 == _rev
+        # assert collection.load(_id) == serialized_entity|{'attr': {'nested': 'value', 'nested1': 'value1'}} #incorrect behavior
+        assert collection.load(p.id().value) == serialized_entity
+
+        # test that dots are not interpreted as nested fields at the top level
+        serialized_entity |= {'attr.nested2': 'value2'}
+        _rev = collection.save(serialized_entity.copy())
+        serialized_entity |= dict(_rev=_rev)
+        assert p._rev + 3 == _rev
+        assert collection.load(p.id().value) == serialized_entity
+
+        # check that we can have dictionary keys starting with $
+        serialized_entity |= {'foo': {'$foo': 1}}
+        # with pytest.raises(pyts_store.errors.WriteError, match="Unrecognized expression '\\$foo',"): #incorrect behavior
+        _rev = collection.save(serialized_entity.copy())
+        serialized_entity |= dict(_rev=_rev)
+        assert p._rev + 4 == _rev
+        assert collection.load(p.id().value) == serialized_entity
+
+        # check that we can *not* have top level keys starting with $ (current behavior, not ideal, but prob. ok)
+        serialized_entity |= {'$foo': 1}
+        with pytest.raises(Exception, match='Use of undefined variable: foo'):
+            _rev = collection.save(serialized_entity.copy())
+        serialized_entity |= dict(_rev=_rev)
+        assert p._rev + 4 == _rev
+        del serialized_entity['$foo']
+        assert collection.load(p.id().value) == serialized_entity
+
+        # test that dots are not interpreted as nested fields at the nested level
+        serialized_entity |= {'attr': {'nested.value': 1}}
+        _rev = collection.save(serialized_entity.copy())
+        serialized_entity |= dict(_rev=_rev)
+        assert p._rev + 5 == _rev
+        assert collection.load(p.id().value) == serialized_entity
+
+        # check that we can unset fields
+        del serialized_entity['attr']
+        _rev = collection.save(serialized_entity.copy())
+        serialized_entity |= dict(_rev=_rev)
+        assert p._rev + 6 == _rev
+        assert collection.load(p.id().value) == serialized_entity
+
+    def test_delete_restore(self, ts_setup):
+        ts_store, p, _p1 = ts_setup
+        collection = ts_store.collection(TEST_COLLECTION)
+        serialized_entity = p.serialize_object()
+        id_value = serialized_entity['_id']
+        assert collection.delete(id_value)
+        assert collection.load(id_value) is None
+        # TODO: restore is not implemented so use save_new meanwhile
+        # assert collection.restore(id_value)
+        collection.save_new(serialized_entity)
+        assert collection.load(id_value) == serialized_entity
+
+    def test_find(self, ts_setup):
+        ts_store, p, _p1 = ts_setup
+        collection = ts_store.collection(TEST_COLLECTION)
+        result = collection.find()
+        assert next(iter(result)) == p.serialize_object()
+        assert list(result) == []
+
+    def test_load(self, ts_setup):
+        ts_store, p, _p1 = ts_setup
+        collection = ts_store.collection(TEST_COLLECTION)
+        id_value = p.id().value
+        result = collection.load(id_value)
+        assert result == p.serialize_object()
+
+    def test_delete(self, ts_setup):
+        ts_store, _p, p1 = ts_setup
+        collection = ts_store.collection(TEST_COLLECTION1)
+        id_value = p1.id().value
+        result = collection.delete(id_value)
+        assert result
+        result = collection.load(id_value)
+        assert result is None
+
+    def test_save_new_with_overwrite(self, ts_setup):
+        """Test save_new with overwrite=True flag."""
+        ts_store, p, _p1 = ts_setup
+        collection = ts_store.collection(TEST_COLLECTION)
+        serialized_entity = p.serialize_object()
+        id_value = serialized_entity['_id']
+
+        # Try to save_new with overwrite=True on existing document
+        result = collection.save_new(serialized_entity.copy(), overwrite=True)
+        assert result == 1
+        assert collection.load(id_value) == serialized_entity
+
+    def test_save_new_with_set_operation(self, ts_setup):
+        """Test save_new with $set MongoDB-style operation."""
+        ts_store, _p, _p1 = ts_setup
+        collection = ts_store.collection(TEST_COLLECTION)
+
+        # Create a new document with $set
+        doc_id = 'test_doc_123'
+        serialized_entity = {'$set': {'_id': doc_id, 'name': 'Test Document', 'value': 42}}
+
+        result = collection.save_new(serialized_entity)
+        assert result == 1
+
+        loaded = collection.load(doc_id)
+        assert loaded == serialized_entity['$set'] | {'_rev': 1}
+
+    def test_save_new_duplicate_key_error(self, ts_setup):
+        """Test that save_new raises TsDuplicateKeyError when inserting duplicate without overwrite."""
+        ts_store, _p, _p1 = ts_setup
+        collection = ts_store.collection(TEST_COLLECTION)
+
+        # Test 1: Duplicate without $set
+        doc_id = 'duplicate_test_123'
+        serialized_entity = {'_id': doc_id, 'name': 'First Document'}
+
+        result = collection.save_new(serialized_entity)
+        assert result == 1
+
+        # Try to insert the same document again without overwrite (no $set)
+        with pytest.raises(TsDuplicateKeyError, match=f'Duplicate key error collection.*dup key.*{doc_id}'):
+            collection.save_new(serialized_entity, overwrite=False)
+
+        # Test 2: Duplicate with $set
+        doc_id2 = 'duplicate_test_456'
+        serialized_entity2 = {'$set': {'_id': doc_id2, 'name': 'First Document with $set'}}
+
+        result = collection.save_new(serialized_entity2)
+        assert result == 1
+
+        # Try to insert the same document again without overwrite (with $set)
+        with pytest.raises(TsDuplicateKeyError, match=f'Duplicate key error collection.*dup key.*{doc_id2}'):
+            collection.save_new(serialized_entity2, overwrite=False)
+
+    def test_save_new_with_set_and_overwrite(self, ts_setup):
+        """Test save_new with $set and overwrite=True."""
+        ts_store, _p, _p1 = ts_setup
+        collection = ts_store.collection(TEST_COLLECTION)
+
+        doc_id = 'set_overwrite_test_123'
+        # First insert
+        serialized_entity1 = {'_id': doc_id, 'name': 'Original'}
+        result = collection.save_new(serialized_entity1)
+        assert result == 1
+
+        # Update with $set and overwrite=True
+        serialized_entity2 = {'$set': {'_id': doc_id, 'name': 'Updated', 'new_field': 'new_value'}}
+        result = collection.save_new(serialized_entity2, overwrite=True)
+        assert result == 1
+
+        loaded = collection.load(doc_id)
+        assert loaded['name'] == 'Updated'
+        assert loaded['new_field'] == 'new_value'
+
+    def test_ts_class_association_ts_uri_resolution(self, ts_setup):
+        """Test that TsClassAssociation.ts_uri correctly resolves store URIs for classes and their subclasses."""
+        from core_10x.py_class import PyClass
+        from core_10x.traitable import NamedTsStore, T, Traitable, TsClassAssociation
+
+        ts_store, _p, _p1 = ts_setup
+
+        class Dummy1(Traitable):
+            text: str = T(T.ID)
+
+        class Dummy2(Traitable):
+            text: str = T(T.ID)
+
+        class Dummy3(Dummy2): ...
+
+        dummy_uri1 = 'mongodb://localhost/dummy1'
+        dummy_uri2 = 'mongodb://localhost/dummy2'
+
+        with ts_store:
+            # Create and save NamedTsStore objects
+            ns1 = NamedTsStore(logical_name='dummy1', uri=dummy_uri1, _replace=True)
+            ns1.save()
+            ns2 = NamedTsStore(logical_name='dummy2', uri=dummy_uri2, _replace=True)
+            ns2.save()
+
+            # Create and save TsClassAssociation objects
+            name1 = PyClass.name(Dummy1)
+            name2 = PyClass.name(Dummy2)
+            TsClassAssociation(py_canonical_name=name1, ts_logical_name='dummy1', _replace=True).save()
+            TsClassAssociation(py_canonical_name=name2, ts_logical_name='dummy2', _replace=True).save()
+
+            # Class-specific association
+            assert TsClassAssociation.ts_uri(Dummy1) == dummy_uri1
+
+            # Subclass should inherit parent's association if it has none of its own
+            assert TsClassAssociation.ts_uri(Dummy3) == dummy_uri2

core_10x/trait.py

@@ -0,0 +1,377 @@
+from __future__ import annotations
+
+import ast
+import copy
+import functools
+import inspect
+import locale
+import platform
+import sys
+from inspect import Parameter
+from types import GenericAlias
+from typing import get_origin, get_type_hints
+
+from py10x_core import BTrait
+
+from core_10x.named_constant import NamedConstant
+from core_10x.rc import RC
+from core_10x.trait_definition import T, TraitDefinition, Ui
+from core_10x.xnone import XNone
+
+
+class Trait(BTrait):
+    # TODO: re-enable __slots__ when the dust settles..
+    # __slots__ = ('t_def','getter_params')
+    s_datatype_traitclass_map = {}
+
+    @staticmethod
+    def register_by_datatype(trait_class, data_type):
+        assert inspect.isclass(trait_class) and issubclass(trait_class, Trait), 'trait class must be a subclass of Trait'
+        found = Trait.s_datatype_traitclass_map.get(data_type)
+        assert not found, f'data_type {data_type} for {trait_class} is already registered for {found}'
+        Trait.s_datatype_traitclass_map[data_type] = trait_class
+
+    s_baseclass_traitclass_map = {}
+
+    @staticmethod
+    def register_by_baseclass(trait_class, base_class):
+        assert inspect.isclass(trait_class) and issubclass(trait_class, Trait), 'trait class must be a subclass of Trait'
+        assert inspect.isclass(base_class), 'base class must be a class'
+        found = Trait.s_baseclass_traitclass_map.get(base_class)
+        assert not found, f'base_class {base_class} for {trait_class} is already registered for {found}'
+        Trait.s_baseclass_traitclass_map[base_class] = trait_class
+
+    @staticmethod
+    def real_trait_class(data_type):
+        real_trait_class = Trait.s_datatype_traitclass_map.get(data_type)
+        if real_trait_class:
+            return real_trait_class
+
+        tmap = Trait.s_baseclass_traitclass_map
+        base_class: type
+        for base_class in reversed(tmap):
+            if issubclass(data_type, base_class):
+                return tmap[base_class]
+
+        return generic_trait
+
+    s_ui_hint = None
+
+    def __init_subclass__(cls, data_type: type = None, register: bool = True, base_class: type = False):
+        cls.s_baseclass = base_class
+        if register:
+            assert data_type and inspect.isclass(data_type), f'{cls} - data_type is not valid'
+            if base_class:
+                Trait.register_by_baseclass(cls, data_type)
+            else:
+                Trait.register_by_datatype(cls, data_type)
+
+        assert cls.s_ui_hint, f'{cls} must define s_ui_hint'
+
+    def __init__(self, t_def: TraitDefinition, btrait: BTrait = None):
+        if btrait is None:
+            super().__init__()
+        else:
+            super().__init__(btrait)
+
+        self.t_def = t_def
+        self.getter_params = ()
+
+    def __get__(self, instance, owner):
+        if not self.getter_params:
+            return instance.get_value(self)
+
+        return functools.partial(instance.get_value, self)
+
+    def __set__(self, instance, value):
+        if not self.getter_params:
+            instance.set_value(self, value).throw()
+
+        else:
+            if not isinstance(value, trait_value):
+                raise TypeError(f'May not set a value to {instance.__class__.__name__}.{self.name} as it requires params')
+
+            instance.set_value(self, value.value, *value.args).throw()
+
+    # def __deepcopy__(self, memodict={}):
+    #    return Trait(self.t_def.copy(), btrait = self)
+
+    @staticmethod
+    def create(trait_name: str, t_def: TraitDefinition) -> Trait:
+        dt = t_def.data_type
+        if isinstance(dt, GenericAlias):
+            dt = get_origin(dt)  # get original type, e.g. `list` from `list[int]`
+            # TODO: could be useful to also keep get_args(dt) for extra checking?
+        trait_class = Trait.real_trait_class(dt)
+        trait = trait_class(t_def)
+        trait.set_name(trait_name)
+        trait.data_type = dt
+        trait.flags = t_def.flags.value()
+        trait.default = t_def.default
+        if t_def.fmt:
+            trait.fmt = t_def.fmt
+
+        trait.create_proc()
+
+        trait.post_ctor()
+        ui_hint: Ui = copy.deepcopy(t_def.ui_hint)
+        ui_hint.adjust(trait)
+        trait.ui_hint = ui_hint
+        return trait
+
+    @staticmethod
+    def method_defs(trait_name: str) -> dict:
+        return {
+            f'{trait_name}_{(method_suffix := method_key.lower())}': (method_suffix, method_def)
+            for method_key, method_def in TRAIT_METHOD.s_dir.items()
+        }
+
+    def set_trait_funcs(self, traitable_cls, rc):
+        for method_name, (method_suffix, method_def) in Trait.method_defs(self.name).items():
+            method = getattr(traitable_cls, method_name, None)
+            if method and method_suffix == 'get' and self.t_def.default is not XNone:  # -- getter and default are defined - figure out which to use
+                for cls in traitable_cls.__mro__:
+                    cls_vars = vars(cls)
+                    if method_name in cls_vars:  # -- found method on cls - use method, unless
+                        if isinstance(cls_vars.get(self.name), TraitDefinition):  # -- default is on same cls then - error
+                            rc.add_error(
+                                f'Ambiguous definition for {method_name} on {cls} - both {self.name}.default and {traitable_cls}.{method_name} are defined.'
+                            )
+                    elif isinstance(cls_vars.get(self.name), TraitDefinition):  # -- default found on cls - use default
+                        method = None  # use default
+                    else:
+                        continue
+                    break
+
+            f = method_def.value(self, method, method_suffix, rc)
+            if f:
+                set_f = getattr(self, f'set_f_{method_suffix}')
+                set_f(f, bool(method))
+
+    def create_f_get(self, f, attr_name: str, rc: RC):
+        if not f:  # -- no custom getter, just the default value
+            f = lambda traitable: self.default_value()
+            f.__name__ = 'default_value'
+            params = ()
+
+        else:
+            # TODO: if default is defined in a subclass relative to where the getter is defined, override the getter?
+
+            sig = inspect.signature(f)
+            params = []
+            param: Parameter
+            for pname, param in sig.parameters.items():
+                if pname != 'self':
+                    pkind = param.kind
+                    if pkind != Parameter.POSITIONAL_OR_KEYWORD:
+                        rc.add_error(f'{f.__name__} - {pname} is not a positional parameter')
+                    else:
+                        params.append(param)
+            params = tuple(params)
+
+        self.getter_params = params
+        return f
+
+    def create_f_set(self, f, attr_name: str, rc: RC):
+        if not f:
+            return None
+
+        # -- custom setter
+        resolved_hints = get_type_hints(f, sys.modules[f.__module__].__dict__ if f.__module__ in sys.modules else {}, f.__class__.__dict__)
+        assert resolved_hints.get('return') is RC, f'{f.__name__} - setter must return RC'
+
+        sig = inspect.signature(f)
+        params = tuple(sig.parameters.values())
+        n = len(params)
+        if n < 3:
+            rc.add_error(f'{f.__name__} - setter must have at least 3 parameters: self, trait, value')
+
+        getter_params = self.getter_params
+        if getter_params:
+            if getter_params != tuple(params[3:]):
+                rc.add_error(f'{f.__name__} - setter must have same params as the getter: {getter_params}')
+
+        return f
+
+    def create_f_common_trait_with_value(self, f, attr_name: str, rc: RC):
+        cls = self.__class__
+        # TODO: check f's signature
+        if not f:
+            common_f = getattr(cls, attr_name, None)
+            if common_f:
+                f = lambda obj_or_cls, trait, value: common_f(trait, value)
+                f.__name__ = f'{cls.__name__}.{common_f.__name__}'
+
+        return f
+
+    def create_f_common_trait_with_value_static(self, f, attr_name: str, rc: RC):
+        cls = self.__class__
+        if f:
+            assert isinstance(f.__self__, type), f'{f.__name__} must be declared as @classmethod'
+        else:
+            f = getattr(cls, attr_name, None)
+        return self.create_f_common_trait_with_value(f, attr_name, rc)
+
+    def create_f_choices(self, f, attr_name: str, rc: RC):
+        cls = self.__class__
+        if not f:
+            choices_f = getattr(cls, attr_name, None)
+            if choices_f:
+                f = lambda obj, trait: choices_f(trait)
+                f.__name__ = f'{cls.__name__}.{choices_f.__name__}'
+
+        return f
+
+    def create_f_plain(self, f, attr_name: str, rc: RC):
+        return f
+
+    # =======================================================================================================================
+    #   Formatting
+    # =======================================================================================================================
+    # fmt: off
+    s_locales = {
+        'Windows':      'USA',
+        'Linux':        'en_US',
+    }
+    # fmt: on
+
+    def locale_change(self, old_value, value):
+        if value:
+            return value
+
+        try:
+            return locale.setlocale(locale.LC_NUMERIC, self.__class__.s_locales.get(platform.system(), 'en_US'))
+        except Exception:
+            return None
+
+    def _format(self, fmt: str) -> str:
+        if not fmt:
+            fmt = ':'
+        else:
+            c = fmt[0]
+            if c != '!' and c != ':':
+                fmt = ':' + fmt
+
+        return f'{{{fmt}}}'
+
+    def use_format_str(self, fmt: str, value) -> str:
+        if isinstance(value, str) and not fmt:
+            return value
+        return self._format(fmt).format(value)
+
+    # ===================================================================================================================
+    #   Trait Interface
+    # ===================================================================================================================
+
+    def post_ctor(self): ...
+
+    def check_integrity(self, cls, rc: RC):
+        pass
+
+    def default_value(self):
+        return self.default
+
+    def same_values(self, value1, value2) -> bool:
+        raise NotImplementedError
+
+    def from_any(self, value):
+        if isinstance(value, self.data_type):
+            return value
+
+        if isinstance(value, str):
+            return self.from_str(value)
+
+        return self.from_any_xstr(value)
+
+    def from_str(self, s: str):
+        lit = ast.literal_eval(s)
+        return self.from_any_xstr(lit)
+
+    def from_any_xstr(self, value):
+        raise NotImplementedError
+
+    def to_str(self, v) -> str:
+        return self.use_format_str(self.fmt, v)
+
+    def is_acceptable_type(self, data_type: type) -> bool:
+        return data_type is self.data_type
+
+    def serialize(self, value):
+        raise NotImplementedError
+
+    def deserialize(self, value) -> RC:
+        raise NotImplementedError
+
+    def to_id(self, value) -> str:
+        raise NotImplementedError
+
+    def choices(self):
+        return XNone
+
+    # TODO: unify XNone/None conversions with object serialization/deserializatoin in c++
+    # TODO: call these from c++ directly in place of f_serialize/f_deserialize?
+    def serialize_value(self, value, replace_xnone=False):
+        return None if replace_xnone and value is XNone else self.f_serialize(self, value)
+
+    def deserialize_value(self, value, replace_none=False):
+        return XNone if replace_none and value is None else self.f_deserialize(self, value)
+
+    # ===================================================================================================================
+
+
+# ---- Methods Associated with a trait
+# fmt: off
+class TRAIT_METHOD(NamedConstant):
+    GET                 = Trait.create_f_get
+    SET                 = Trait.create_f_set
+    VERIFY              = Trait.create_f_plain
+    FROM_STR            = Trait.create_f_common_trait_with_value
+    FROM_ANY_XSTR       = Trait.create_f_common_trait_with_value
+    IS_ACCEPTABLE_TYPE  = Trait.create_f_common_trait_with_value
+    TO_STR              = Trait.create_f_common_trait_with_value
+    SERIALIZE           = Trait.create_f_common_trait_with_value_static
+    DESERIALIZE         = Trait.create_f_common_trait_with_value_static
+    TO_ID               = Trait.create_f_common_trait_with_value
+    CHOICES             = Trait.create_f_choices
+    STYLE_SHEET         = Trait.create_f_plain
+# fmt: on
+
+
+class generic_trait(Trait, register=False):
+    s_ui_hint = Ui.NONE
+
+    def post_ctor(self):
+        assert not self.flags_on(T.ID), f'generic trait {self.name} may not be an ID trait'
+        assert self.flags_on(T.RUNTIME), f'generic trait {self.name} must be a RUNTIME trait'
+
+    def is_acceptable_type(self, data_type: type) -> bool:
+        return issubclass(data_type, self.data_type)
+
+    def same_values(self, value1, value2) -> bool:
+        return value1 is value2
+
+
+class trait_value:
+    def __init__(self, value, *args):
+        self.value = value
+        self.args = args
+
+    def __call__(self, *args, **kwargs): ...
+
+
+class BoundTrait:
+    def __init__(self, obj, trait: Trait):
+        self.obj = obj
+        self.trait = trait
+        # self.args = ()
+
+    def __getattr__(self, attr_name):
+        trait_attr = getattr(self.trait, attr_name, None)
+        if trait_attr:
+            # if callable(trait_attr):
+            return trait_attr
+
+        return lambda: getattr(self.obj, attr_name)(self.trait)
+
+    def __call__(self):
+        return self.trait