py10x-universe 0.1.3__py3-none-any.whl

core_10x/traitable_cli.py

@@ -0,0 +1,153 @@
+import sys
+
+from core_10x.traitable import RC, RC_TRUE, Traitable
+
+
+class TraitableCli(Traitable):
+    s_master = None
+    s_switch = {}
+
+    def __init_subclass__(cls, _command: str = None, **kwargs):
+        cls.s_switch = {}
+        if cls.s_master is None:  # -- master parser
+            assert _command is None, 'master may not have a command'
+            cls.s_master = cls
+        else:  # -- subordinate parser
+            assert _command and _command.isidentifier(), 'command must be a valid identifier'
+            cls.s_master.s_switch[_command] = cls
+            cls.s_master = cls
+
+        super().__init_subclass__(**kwargs)
+
+    @classmethod
+    def from_command_line(cls) -> tuple:  # -- (RC, Traitable)
+        """
+        Creates an instance of target traitable parsing positional args to obtain the right target class and then taking trait values
+        in the name = value pairs form.
+        One can use any spacing around symbol '=', i.e.: name=value name= value name =value or name = value
+
+        :return:    (rc, traitable) - RC and a traitable according to args and trait values parsed from sys.argv.
+                    rc holds error message(s) if instantiation fails for any reason (traitable is set to None)
+        """
+        _script, *args = sys.argv
+        return cls.instance_from_args(args)
+
+    @classmethod
+    def instance_from_args(cls, input_args: tuple) -> tuple:
+        args = []
+        trait_values = {}
+        rc = cls.parse(input_args, args, trait_values)
+        if not rc:
+            return rc, None
+
+        return cls.instantiate(args, trait_values)
+
+    @classmethod
+    def instantiate(cls, args, trait_values: dict) -> tuple:  # -- (RC, target_traitable)
+        if not args:
+            try:
+                res = cls()
+                for name, value in trait_values.items():
+                    trait = cls.trait(name)
+                    if not trait:
+                        return RC(False, f'unknown attribute {name}\nValid attributes: {", ".join(cls.s_dir)}'), None
+
+                    rc = res.set_value(trait, value)
+                    if not rc:
+                        return RC(False, f'{name}: {rc.err()}'), None
+
+                return RC_TRUE, res
+
+            except Exception as ex:
+                return RC(False, str(ex)), None
+
+        command, *args = args
+        parser = cls.s_switch.get(command)
+        if not parser or not issubclass(parser, TraitableCli):
+            return RC(False, f'Unknown argument {command}'), None
+
+        return parser.instantiate(args, trait_values)
+
+    @classmethod
+    def parse(cls, input_args: tuple, args: list, trait_values: dict) -> RC:  # noqa: C901
+        if not input_args:
+            return RC_TRUE
+
+        trait_name = None
+        deal_with_args = True
+        new_vp = True
+        eq_expected = False
+        for i, arg in enumerate(input_args):
+            if deal_with_args:
+                parts = arg.split('=', 1)
+                n = len(parts)
+                if n == 1:
+                    args.append(arg)
+                else:
+                    deal_with_args = False
+                    eq_expected = False
+                    first, second = parts
+                    if not first and not second:  # -- just '='
+                        if i:
+                            trait_name = args.pop(-1)
+                            new_vp = False
+                        else:
+                            return RC(False, 'May not start with "="')
+
+                    elif first:
+                        if not second:  # -- xxx=
+                            trait_name = first
+                            new_vp = False
+                        else:  # -- xxx=yyy
+                            trait_values[first] = second
+                            new_vp = True
+                    else:  # -- =yyy
+                        if i:
+                            trait_name = args.pop(-1)
+                            trait_values[trait_name] = second
+                            new_vp = True
+                        else:
+                            return RC(False, 'May not start with "="')
+
+            else:
+                parts = arg.split('=', 1)
+                n = len(parts)
+                if new_vp:
+                    trait_name = parts[0]
+                    if n == 1:
+                        eq_expected = True
+                        new_vp = False
+                    else:
+                        value = parts[1]
+                        if value:
+                            trait_values[trait_name] = value
+                            new_vp = True
+                        else:
+                            eq_expected = False
+                            new_vp = False
+                else:
+                    if not eq_expected:
+                        if n == 2:
+                            return RC(False, f'Invalid "=": {input_args[i - 1]} {arg}')
+
+                        trait_values[trait_name] = parts[0]
+                        new_vp = True
+
+                    else:
+                        if n == 1:
+                            return RC(False, f'"=" is expected before {arg}')
+
+                        if parts[0]:
+                            return RC(False, f'{input_args[i - 1]} {arg}')
+
+                        if parts[1]:
+                            trait_values[trait_name] = parts[1]
+                            new_vp = True
+
+                        else:
+                            eq_expected = False
+
+        if not new_vp:
+            return RC(False, f'Value is missing for {trait_name} = ')
+
+        return RC_TRUE

core_10x/traitable_heir.py

@@ -0,0 +1,33 @@
+from core_10x.traitable import Traitable, Trait, T, RT, RC, XNone
+
+class TraitableHeir(Traitable):
+    _grantor: Traitable = T()
+
+    s_grantor_traits = {}
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+
+        cls.s_grantor_traits = dir = {}
+        grantor_trait = cls.trait('_grantor')
+        trait: Trait
+        for trait in cls.traits():
+            if trait is grantor_trait or trait.flags_on(T.RESERVED):
+                continue
+            if not trait.has_custom_getter() and trait.default is XNone:   #-- trait has neither getter nor default value
+                trait.set_f_get(lambda self, trait_name = trait.name: self.heir_getter(trait_name), False)
+                dir[trait.name] = trait
+
+    def heir_getter(self, trait_name: str):
+        grantor = self._grantor
+        if not grantor:
+            return XNone
+        trait = grantor.__class__.trait(trait_name)
+        return grantor.get_value(trait) if trait else XNone
+
+    def serialize_object(self, save_references = False) -> dict:
+        serialized_data = super().serialize_object(save_references = save_references)
+        for name, trait in self.__class__.s_grantor_traits.items():
+            if not self.is_set(trait):
+                del serialized_data[name]
+
+        return serialized_data

core_10x/traitable_id.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from functools import total_ordering
+
+
+@total_ordering
+class ID:
+    __slots__ = ('collection_name', 'value')
+
+    def __init__(self, id_value: str = None, collection_name: str = None):
+        self.value = id_value
+        self.collection_name = collection_name
+
+    def __eq__(self, other: ID):
+        if not isinstance(other, ID):
+            return NotImplemented
+        return self.value == other.value and self.collection_name == other.collection_name
+
+    def __bool__(self):
+        return bool(self.value)
+
+    def __repr__(self):
+        return f'{self.value}' if not self.collection_name else f'{self.collection_name}/{self.value}'
+
+    def __hash__(self):
+        return hash((self.value, self.collection_name))
+
+    def __lt__(self, other: ID) -> bool:
+        if not isinstance(other, ID):
+            return NotImplemented
+        return (self.collection_name, self.value) < (other.collection_name, other.value)

core_10x/ts_store.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+import abc
+from typing import TYPE_CHECKING
+
+from core_10x.exec_control import ProcessContext
+from core_10x.global_cache import standard_key
+from core_10x.py_class import PyClass
+from core_10x.rc import RC
+from core_10x.resource import TS_STORE, Resource, ResourceSpec
+from core_10x.trait_filter import f
+from core_10x.ts_store_type import TS_STORE_TYPE
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+
+class TsDuplicateKeyError(Exception):
+    """Raised when attempting to insert a document with a duplicate key."""
+
+    def __init__(self, collection_name: str, duplicate_key: dict):
+        super().__init__(f'Duplicate key error collection {collection_name} dup key: {duplicate_key} was found while insert was attempted.')
+
+
+class TsCollection(abc.ABC):
+    s_id_tag: str = None
+
+    @abc.abstractmethod
+    def collection_name(self) -> str: ...
+    @abc.abstractmethod
+    def id_exists(self, id_value: str) -> bool: ...
+    @abc.abstractmethod
+    def find(self, query: f = None, _at_most: int = 0, _order: dict = None) -> Iterable: ...
+    @abc.abstractmethod
+    def count(self, query: f = None) -> int: ...
+    @abc.abstractmethod
+    def save_new(self, serialized_traitable: dict, overwrite: bool = False) -> int: ...
+    @abc.abstractmethod
+    def save(self, serialized_traitable: dict) -> int: ...
+    @abc.abstractmethod
+    def delete(self, id_value: str) -> bool: ...
+    @abc.abstractmethod
+    def create_index(self, name: str, trait_name: str | list[tuple[str, int]], **index_args) -> str: ...
+    @abc.abstractmethod
+    def max(self, trait_name: str, filter: f = None) -> dict: ...
+    @abc.abstractmethod
+    def min(self, trait_name: str, filter: f = None) -> dict: ...
+
+    def exists(self, query: f) -> bool:
+        return self.count(query) > 0
+
+    def load(self, id_value: str) -> dict | None:
+        for data in self.find(f(**{self.s_id_tag: id_value})):
+            return data
+
+    def copy_to(self, to_coll: TsCollection, overwrite: bool = False) -> RC:
+        """Copy all documents from this collection to another collection."""
+        rc = RC(True)
+
+        for doc in self.find():
+            try:
+                if not to_coll.save_new(doc, overwrite=overwrite):
+                    rc.add_error(f'Failed to save {doc.get(to_coll.s_id_tag)} to {to_coll.collection_name()}')
+            except TsDuplicateKeyError:
+                if overwrite:
+                    raise  # -- we do not expect an exception in case of overwrite, so raise
+
+        return rc
+
+
+class TsStore(Resource, resource_type=TS_STORE):
+    PROTOCOL = ''
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        assert cls.__mro__[1] is TsStore, 'TsStore must be the first base class'
+        cls.s_instance_kwargs_map = {**TsStore.s_instance_kwargs_map, **cls.s_instance_kwargs_map}
+
+    @staticmethod
+    def store_class(store_class_name: str):
+        cls = PyClass.find(store_class_name, TsStore)
+        assert cls, f'Unknown TsStore class {store_class_name}'
+        return cls
+
+    @classmethod
+    def standard_key(cls, *args, **kwargs) -> tuple:
+        return standard_key(args, kwargs)
+
+    s_instances = {}
+
+    @classmethod
+    def spec_from_uri(cls, uri: str) -> ResourceSpec:
+        parts = uri.split(':', maxsplit=1)
+        protocol = parts[0]
+        ts_class = TS_STORE_TYPE.ts_store_class(protocol)
+        return ResourceSpec(ts_class, ts_class.parse_uri(uri))
+
+    @classmethod
+    def instance(cls, *args, password: str = '', _cache: bool = True, **kwargs) -> TsStore:
+        translated_kwargs = cls.translate_kwargs(kwargs)
+        try:
+            if not _cache:
+                return cls.new_instance(*args, password=password, **translated_kwargs)
+
+            instance_key = cls.standard_key(*args, **kwargs)
+            store = cls.s_instances.get(instance_key)
+            if not store:
+                store = cls.new_instance(*args, password=password, **translated_kwargs)
+                cls.s_instances[instance_key] = store
+
+            return store
+
+        except Exception as e:
+            raise OSError(f'Failed to connect to {cls.s_driver_name}({args}, {translated_kwargs})\nOriginal Exception:\n{e!s}') from e
+
+    # fmt: off
+    s_instance_kwargs_map = {
+        Resource.HOSTNAME_TAG:  (Resource.HOSTNAME_TAG, None),
+        Resource.USERNAME_TAG:  (Resource.USERNAME_TAG, None),
+        Resource.DBNAME_TAG:    (Resource.DBNAME_TAG,   None),
+        Resource.PORT_TAG:      (Resource.PORT_TAG,     None),
+        Resource.SSL_TAG:       (Resource.SSL_TAG,      True),
+        'sst':                  ('sst',                 1000),
+    }
+    # fmt: on
+
+    @classmethod
+    def translate_kwargs(cls, kwargs: dict) -> dict:
+        kwargs_map = cls.s_instance_kwargs_map
+        def_kwargs = {name: def_value for name, (real_name, def_value) in kwargs_map.items()}
+        def_kwargs.update(kwargs)
+        return {kwargs_map[name][0]: value for name, value in def_kwargs.items()}
+
+    @classmethod
+    def new_instance(cls, *args, password: str, **kwargs) -> TsStore:
+        raise NotImplementedError
+
+    @classmethod
+    def parse_uri(cls, uri: str) -> dict:
+        raise NotImplementedError
+
+    def on_enter(self):
+        self.bpc_flags = ProcessContext.reset_flags(ProcessContext.CACHE_ONLY)
+
+    def on_exit(self):
+        ProcessContext.replace_flags(self.bpc_flags)
+
+    @abc.abstractmethod
+    def collection_names(self, regexp: str = None) -> list: ...
+
+    @abc.abstractmethod
+    def collection(self, collection_name: str) -> TsCollection: ...
+
+    @abc.abstractmethod
+    def delete_collection(self, collection_name: str) -> bool: ...
+
+    @classmethod
+    def is_running_with_auth(cls, host_name: str) -> tuple: ...  # -- (is_running, with_auth)
+
+    @abc.abstractmethod
+    def auth_user(self) -> str | None: ...
+
+    def copy_to(self, to_store: TsStore, overwrite: bool = False) -> RC:
+        """Copy all collections from this store to another store."""
+        rc = RC(True)
+
+        for collection_name in self.collection_names():
+            from_coll = self.collection(collection_name)
+            to_coll = to_store.collection(collection_name)
+            rc += from_coll.copy_to(to_coll, overwrite=overwrite)
+
+        return rc

core_10x/ts_store_type.py

@@ -0,0 +1,26 @@
+from core_10x.named_constant import NamedConstant
+from core_10x.py_class import PyClass
+
+
+class TS_STORE_TYPE(NamedConstant):
+    """
+    All known TsStore subclasses must be "registered" here.
+    """
+
+    MONGODB = 'infra_10x.mongodb_store.MongoStore'
+    ...
+
+    @classmethod
+    def ts_store_class(cls, uri_protocol: str):
+        """
+        example: TS_STORE_TYPE.ts_store_class('mongodb')
+        """
+        symbol = cls.s_dir.get(uri_protocol.upper())
+        if symbol is None:
+            raise ValueError(f'Unknown URI protocol: {uri_protocol}')
+
+        ts_class = PyClass.find(symbol.value)
+        if not ts_class:
+            raise TypeError(f'{symbol.value} - unknown TsStore class')
+
+        return ts_class

core_10x/ts_union.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+import heapq
+import itertools
+import operator
+from itertools import zip_longest
+from typing import TYPE_CHECKING
+
+from core_10x.nucleus import Nucleus
+from core_10x.trait_filter import EQ, f
+from core_10x.ts_store import TsCollection, TsStore
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+
+class _OrderKey:
+    __slots__ = ('reverse', 'value')
+
+    @classmethod
+    def _dict_cmp(cls, d: dict, od: dict) -> int:
+        assert isinstance(od, dict), 'can only compare dict to dict'
+
+        for i, oi in zip_longest(d.items(), od.items()):
+            if i == oi:
+                continue
+            if i is None:
+                return -1  # all match, d is shorter
+            if oi is None:
+                return 1  # all match d is longer
+            k, v = i
+            ok, ov = oi
+            if k != ok:
+                return -1 if k < ok else 1 if k > ok else 0  # keys do not match
+            if isinstance(v, dict) and isinstance(ov, dict):
+                return cls._dict_cmp(v, ov)
+            # TODO: handle mismatching types..
+            return -1 if v < ov else 1 if v > ov else 0
+        return 0  # equals..
+
+    def __init__(self, value, reverse: bool):
+        self.value = value
+        self.reverse = reverse
+
+    def __lt__(self, other):
+        assert isinstance(other, _OrderKey), 'can only compare to order key'
+        v = self.value
+        ov = other.value
+        if isinstance(v, dict):
+            return self._dict_cmp(v, ov) < 0 if self.reverse else self._dict_cmp(ov, v) > 0
+        return ov < v if self.reverse else v < ov
+
+    def __eq__(self, other):
+        assert isinstance(other, _OrderKey), 'can only compare to order key'
+        v = self.value
+        ov = other.value
+        return not self._dict_cmp(v, ov) if isinstance(v, dict) else v == ov
+
+    @classmethod
+    def key(cls, item, order):
+        return tuple(cls(value=item.get(k), reverse=v < 0) for k, v in order)
+
+
+class TsUnionCollection(TsCollection):
+    def __init__(self, *collections: TsCollection):
+        self.collections = collections
+
+    def collection_name(self) -> str:
+        return self.collections[0].collection_name() if self.collections else ''
+
+    def find(self, query: f = None, _at_most: int = 0, _order: dict = None) -> Iterable:
+        order = tuple((_order or {'_id': 1}).items())  # FIX: assumes _id is always there!
+        order_key = _OrderKey.key
+        iterables = (collection.find(query, _at_most=_at_most, _order=_order) for collection in self.collections)
+        keyed_iterables = (((order_key(item, order), item) for item in iterable) for iterable in iterables if iterable is not None)
+        results = (item for _, item in heapq.merge(*keyed_iterables, key=operator.itemgetter(0)))
+        return (item for i, item in enumerate(results) if i < _at_most) if _at_most else results
+
+    def save_new(self, serialized_traitable: dict, overwrite: bool = False) -> int:
+        return self.collections[0].save_new(serialized_traitable, overwrite=overwrite)
+
+    def save(self, serialized_traitable):
+        # if serialized_traitable was not loaded from the union head, we need to call save_new
+        id_tag = Nucleus.ID_TAG()
+        if not self.collections[0].exists(f(**{id_tag: EQ(serialized_traitable[id_tag])})):
+            # TODO: optimize by introducing save with overwrite flag to bypass the "inappropriate restore from deleted" check
+            return self.collections[0].save_new(serialized_traitable)
+        return self.collections[0].save(serialized_traitable)
+
+    def delete(self, id_value):
+        # if id_value exists in the union tail, return False as the object wasn't fully deleted
+        return self.collections[0].delete(id_value) and not self.exists(f(**{Nucleus.ID_TAG(): EQ(id_value)}))
+
+    def create_index(self, name: str, trait_name: str | list[tuple[str, int]], **index_args) -> str:
+        # TODO: verify that index exists in the union tail
+        return self.collections[0].create_index(name, trait_name, **index_args)
+
+    def max(self, trait_name: str, filter: f = None) -> dict:
+        results = (result for result in (collection.max(trait_name, filter) for collection in self.collections) if result is not None)
+        return max(results, key=operator.itemgetter(trait_name), default=None)
+
+    def min(self, trait_name: str, filter: f = None) -> dict:
+        results = (result for result in (collection.min(trait_name, filter) for collection in self.collections) if result is not None)
+        return min(results, key=operator.itemgetter(trait_name), default=None)
+
+    def id_exists(self, id_value: str) -> bool:
+        return any(collection.id_exists(id_value) for collection in self.collections)
+
+    def count(self, query: f = None) -> int:
+        return sum(collection.count(query) for collection in self.collections)
+
+    def load(self, id_value: str) -> dict | None:
+        for collection in self.collections:
+            data = collection.load(id_value)
+            if data is not None:
+                return data
+        return None
+
+
+class TsUnion(TsStore, resource_name='TS_UNION'):
+    @classmethod
+    def is_running_with_auth(cls, host_name: str) -> tuple:  # -- (is_running, with_auth)
+        raise NotImplementedError
+
+    @classmethod
+    def standard_key(cls, *args) -> tuple:
+        return tuple(cls.s_resource_type.resource_driver(kw['driver_name']).standard_key(**kw) for kw in args)
+
+    @classmethod
+    def new_instance(cls, *args, **kwargs) -> TsUnion:
+        stores = [cls.s_resource_type.resource_driver(kw.pop('driver_name')).instance(**kw) for kw in args]
+        return TsUnion(*stores)
+
+    def __init__(self, *stores: TsStore):
+        self.stores = stores
+
+    def collection_names(self, regexp: str = None) -> list:
+        return list(set(itertools.chain(*(store.collection_names(regexp) for store in self.stores))))
+
+    def collection(self, collection_name):
+        return TsUnionCollection(*(store.collection(collection_name) for store in self.stores))
+
+    def delete_collection(self, collection_name: str) -> bool:
+        return self.stores[0].delete_collection(collection_name) if self.stores else False
+
+    def auth_user(self) -> str | None:
+        return self.stores[0].auth_user() if self.stores else None