py10x-universe 0.1.3__py3-none-any.whl

core_10x/data_domain.py

@@ -0,0 +1,48 @@
+import re
+
+from core_10x.resource import TS_STORE, ResourceRequirements
+
+
+def _raise_type_error(cls, **kwargs):
+    raise TypeError(f'{cls} - subclassing is not allowed')
+
+
+class DataDomain:
+    s_dir = {}
+
+    s_resource_requirements = {}
+
+    def __init_subclass__(cls, **kwargs):
+        name = cls.name()
+        ed = DataDomain.s_dir.get(name)
+        assert ed is None, f"DataDomain '{name}' is already registered in {ed}"
+        DataDomain.s_dir[name] = cls
+
+        cls.__init_subclass__ = lambda **kwargs: _raise_type_error(cls, **kwargs)
+        category: str
+        rrs = cls.s_resource_requirements
+        for category, resource_reqs in cls.__dict__.items():
+            if isinstance(resource_reqs, ResourceRequirements):
+                assert category.isupper(), f"Category '{category}' must be an uppercase name"
+                resource_reqs.domain = cls
+                resource_reqs.category = category
+                rrs[category] = resource_reqs
+
+        assert rrs, f"DataDomain '{cls} must define at least one category"
+
+    @classmethod
+    def name(cls: str) -> str:
+        return re.sub(r'([a-z])([A-Z])', r'\1_\2', cls.__qualname__).upper()
+
+    @classmethod
+    def resource_requirement(cls, category: str, throw: bool = True) -> ResourceRequirements:
+        rr = cls.s_resource_requirements.get(category)
+        if rr is None and throw:
+            raise ValueError(f"DataDomain {cls} - unknown category '{category}'")
+
+        return rr
+
+
+class GeneralDomain(DataDomain):
+    GENERAL = TS_STORE()
+    ...

core_10x/data_domain_binder.py

@@ -0,0 +1,45 @@
+from core_10x.environment_variables import EnvVars
+from core_10x.global_cache import cache
+from core_10x.py_class import PyClass
+
+
+# ===================================================================================================================================
+#   Data Domain Bindings
+#
+#   from core_10x.data_domain import GeneralDomain
+#   from xxx.yyy.mdu_domain import MDU
+#   ...
+#   DATA_DOMAIN_BINDINGS = dict(
+#       dev = {
+#           GeneralDomain: dict(
+#               GENERAL             = R(TS_STORE.MONGO_DB,          hostname = 'dev.mongo.general.io', tsl = True, ...),
+#           ),
+#
+#           MDU:    dict(
+#               SYMBOLOGY           = R(REL_DB.ORACLE_DB,           hostname = 'dev.oracle.io', a = '...', b = '...'),
+#               MKT_CLOSE_CLUSTER   = R(CLOUD_CLUSTER.RAY_CLUSTER,  hostname = 'dev.ray1.io', ...),
+#           ),
+#       },
+#
+#       prod = {
+#           GeneralDomain: dict(
+#               GENERAL             = R(TS_STORE.MONGO_DB,          hostname = 'prod.mongo.general.io', tsl = True, ...),
+#           ),
+#
+#           MDU:    dict(
+#               SYMBOLOGY           = R(REL_DB.ORACLE_DB,           hostname = 'prod.oracle.io', a = '...', b = '...'),
+#               MKT_CLOSE_CLUSTER   = R(CLOUD_CLUSTER.RAY_CLUSTER,  hostname = 'prod.ray2.io', ...),
+#           ),
+#       },
+#
+#   )
+# ===================================================================================================================================
+class DataDomainBinder:
+    @staticmethod
+    @cache
+    def all_bindings() -> dict:
+        dd_bindings_symbol = EnvVars.data_domain_bindings
+        if not dd_bindings_symbol:
+            return None
+
+        return PyClass.find_symbol(dd_bindings_symbol)

core_10x/directory.py

@@ -0,0 +1,250 @@
+from __future__ import annotations
+
+import inspect
+from typing import Any
+
+from core_10x.entity import Entity
+from core_10x.py_class import PyClass
+from core_10x.xnone import XNone
+
+
+class Directory:
+    @staticmethod
+    def _dir_class(value):
+        if isinstance(value, Entity):
+            return DxEntity
+
+        if inspect.isclass(value) and issubclass(value, Entity):
+            return DxClass
+
+        return Directory
+
+    @staticmethod
+    def instance(value: Any = None, **kwargs) -> Directory:
+        dir_class = Directory._dir_class(value)
+        return dir_class(value=value, **kwargs)
+
+    # fmt: off
+    def __init__(
+        self,
+        name: str           = '',
+        value               = None,
+        members: dict       = None,
+        parent: Directory   = None
+    ):
+        # fmt: on
+        self.check_dir_value(value)
+
+        self.name = name
+        self.value = value
+        self.members = members or {}
+        self.parent = parent
+
+    @classmethod
+    def check_dir_value(cls, value):
+        f = getattr(value, '__hash__', None)
+        assert f, f'Directory value must be hashable ({value})'
+
+    def show_value(self) -> str:
+        return str(self.value) if self.value else self.name
+
+    def is_leaf(self) -> bool:
+        return not self.members
+
+    def subdirs(self) -> dict:
+        return self.members
+
+    def _add_subdir(self, subdir: Directory):
+        self.members[subdir.value] = subdir
+        subdir.parent = self
+
+    def _get_or_add_subdir(self, value, **subdir_values):
+        subdir = self.members.get(value)
+        if subdir is None:
+            subdir = Directory.instance(value, **subdir_values)
+            subdir.parent = self
+            self.members[value] = subdir
+
+        return subdir
+
+    def insert(self, value, *path, **subdir_values):
+        if not path:
+            self._get_or_add_subdir(value, **subdir_values)
+        else:
+            p_value = path[0]
+            subdir = self._get_or_add_subdir(p_value)
+            subdir.insert(value, *path[1:], **subdir_values)
+
+    def insert_many(self, values: list, **subdir_values):
+        for value in values:
+            self._get_or_add_subdir(value, **subdir_values)
+
+    def subdir_at(self, *path) -> Directory:
+        if not path:
+            return self
+
+        subdir = self.members.get(path[0])
+        return subdir.subdir_at(*path[1:]) if subdir else None
+
+    def remove(self, value, *path) -> bool:
+        subdir = self.subdir_at(*path)
+        if not subdir:
+            return False
+
+        return self.members.pop(value, XNone) is not XNone
+
+    def remove_everywhere(self, value):
+        self.remove(value)
+        for subdir in self.members.values():
+            subdir.remove(value)
+
+    def _find_paths(self, value, paths_found: list, *current_path):
+        found = self.members.get(value)
+        if found:
+            paths_found.append((*current_path, value))
+
+        for sub_value, subdir in self.members.items():
+            subdir._find_paths(value, paths_found, *current_path, sub_value)
+
+    def find_paths(self, value) -> list:
+        paths_found = [()] if value == self.value else []
+        self._find_paths(value, paths_found)
+        return paths_found
+
+    def _flatten(self, res: dict, *current_path):
+        path = *current_path, self.value
+        label = self.name
+        if not label:
+            label = self.show_value()
+        res[path] = label
+        for subdir in self.members.values():
+            subdir._flatten(res, *path)
+
+    def flatten(self, with_root: bool = False) -> dict:
+        res = {}
+        if with_root:
+            self._flatten(res)
+        else:
+            for subdir in self.members.values():
+                subdir._flatten(res)
+
+        return res
+
+    def choices(self, with_root: bool = False, path_delimiter: str = '/') -> dict:
+        f = self.flatten(with_root = with_root)
+        v_n_map = { path[-1]: name for path, name in f.items() }
+        res = {}
+        cr = 1
+        for path in f.keys():
+            label = path_delimiter.join(v_n_map[p] for p in path)
+            value = path[-1]
+            already_in = res.get(label)
+            if already_in:
+                if already_in == value:
+                    continue
+
+                label = f'{label}({cr})'
+                cr += 1
+
+            res[label] = value
+
+        return res
+
+    def contains(self, value) -> bool:
+        if self.value == value:
+            return True
+
+        for subdir in self.members.values():
+            if subdir.contains(value):
+                return True
+
+        return False
+
+    def is_value_contained(self, value, by_other_value) -> bool:
+        if self.value == by_other_value:
+            return self.contains(value)
+
+        for subdir in self.members.values():
+            if subdir.is_value_contained(value, by_other_value):
+                return True
+
+        return False
+
+    def _collect_leaf_values(self, res: set, data_accessor):
+        if self.is_leaf():
+            res.add(data_accessor(self.value))
+        else:
+            for subdir in self.members.values():
+                subdir._collect_leaf_values(res, data_accessor)
+
+    def leaf_values(self, data_accessor):       #-- data_accessor: callable(leaf_value)
+        res = set()
+        self._collect_leaf_values(res, data_accessor)
+        return list(res)
+
+    @classmethod
+    def define(cls, value_name, members: list) -> Directory:
+        if isinstance(value_name, tuple):     #-- ( value, name ) is given
+            assert len(value_name) == 2, 'a pair of ( value, name ) is expected'
+            value, name = value_name
+
+        else:       #-- just a value
+            value = value_name
+            name = None
+
+        dir = Directory.instance(value, name = name)
+
+        sub_value_name = None
+        for elem in members:
+            if not sub_value_name:
+                sub_value_name = elem
+                continue
+
+            if isinstance(elem, list):  #-- sub dirs are given
+                sudir = cls.define(sub_value_name, elem)
+                dir._add_subdir(sudir)
+                sub_value_name = None
+
+            else:   #-- no sub dirs are given, just value_name
+                sudir = cls.define(sub_value_name, [])
+                dir._add_subdir(sudir)
+                sub_value_name = elem
+
+        if sub_value_name:
+            sudir = cls.define(sub_value_name, [])
+            dir._add_subdir(sudir)
+
+        return dir
+
+
+class DxEntity(Directory):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.value: Entity
+        self.name = self.value.id()
+
+    @classmethod
+    def check_dir_value(cls, value):
+        assert isinstance(value, Entity), f'entity is expected ({value})'
+
+    def show_value(self) -> str:
+        return self.value.id()  # -- TODO: id_repr()
+
+
+class DxClass(Directory):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        cls = self.value
+        self.name = PyClass.name(cls) if cls else ''
+
+    @classmethod
+    def check_dir_value(cls, value):
+        assert inspect.isclass(value) and issubclass(value, Entity), f'subclass of Entity is expected ({value})'
+
+    # def matching_entities(self) -> dict:
+    #     """
+    #     Applicable for an entity class with a "reasonable" number of entities in the collection
+    #     TODO: need to provide a different mechanism (a view) for huge collections
+    #     """
+    #     cls = self.value
+    #     return { e.id(): e for e in cls.sharedInstances( _cache = self.cache_only(), **self.filters() ) }

core_10x/entity.py

@@ -0,0 +1,8 @@
+from core_10x.rc import RC, RC_TRUE
+from core_10x.trait import Trait
+from core_10x.trait_definition import RT, M, T, Ui
+from core_10x.traitable import Traitable
+
+
+# -- A higher-level Traitable to be used for general purposes
+class Entity(Traitable): ...

core_10x/entity_filter.py

@@ -0,0 +1,5 @@
+from core_10x.traitable import T, Traitable
+
+
+class TraitFilter(Traitable):
+    trait_name: str = T()

core_10x/environment_variables.py

@@ -0,0 +1,147 @@
+import ast
+import os
+
+from py10x_core import OsUser
+
+from core_10x.global_cache import cache
+from core_10x.rc import RC
+from core_10x.xdate_time import XDateTime, date, datetime
+from core_10x.resource import Resource
+
+# ===================================================================================================================================
+#   date_format: str    = default_value
+#
+#   def date_format_apply(cls, fmt: str):
+#     XDateTime.set_default_format(fmt)
+#
+#   datetime_format: str
+#
+#   def datetime_format_get(cls):
+#       return f'{cls.date_format} %H:%M%S'
+#
+#   def datetime_format_apply(cls, value):
+#       ...
+# ===================================================================================================================================
+
+
+class classproperty(property):
+    def __get__(self, obj, objtype: type = None):
+        return self.fget(objtype)
+
+
+class _EnvVars:
+    # fmt: off
+    s_converters = {
+        bool:       lambda s: ast.literal_eval(s.lower().capitalize()),
+        int:        lambda s: ast.literal_eval(s),
+        float:      lambda s: ast.literal_eval(s),
+        str:        lambda s: s,
+        date:       lambda s: XDateTime.str_to_date(s),
+        datetime:   lambda s: XDateTime.str_to_datetime(s),
+        #Resource:   lambda s: Resource
+    }
+    # fmt: on
+
+    @classmethod
+    def _getter(cls, data_type, var_name: str, f_get, f_apply):
+        # print(var_name)
+        str_value = os.getenv(var_name)
+        if str_value is not None:
+            f_convert = cls.s_converters.get(data_type)
+            assert f_convert, f'Unknown data type {data_type}'
+            try:
+                value = f_convert(str_value)
+            except Exception as e:
+                raise TypeError(f'Variable {var_name} - could not convert {str_value} to {data_type}') from e
+        else:
+            try:
+                value = f_get(cls)
+            except Exception as e:
+                rc = RC(False)  # -- capture the exc
+                raise RuntimeError(f'{cls}.{var_name} - failed while getting a value\n{rc.error()}') from e
+
+        if f_apply:
+            try:
+                f_apply.__get__(cls)(value)
+            except Exception as e:
+                rc = RC(False)  # -- capture the exc
+                raise ValueError(f'{cls}.{var_name} - failed while applying value: {value}\n{rc.error()}') from e
+
+        return value
+
+    @classmethod
+    def full_getter(cls, data_type, var_name: str, f_get, f_apply):
+        f = lambda cls: cls._getter(data_type, var_name, f_get, f_apply)
+        # return classmethod(cache(f))
+        return cache(f)
+
+    s_env_name: str = None
+    assert_var = None
+
+    def __init_subclass__(cls, env_name: str = None, **kwargs):
+        assert env_name, 'env_name is required'
+
+        cls.s_env_name = env_name
+        annotations = cls.__annotations__
+        assert annotations, 'No variables are defined'
+
+        cls_dict = cls.__dict__
+        for name, data_type in annotations.items():
+            def_value = cls_dict.get(name)
+            if def_value is None:  # -- no default value, let's locate the getter
+                f_get_name = f'{name}_get'
+                f_get = cls_dict.get(f_get_name)
+                assert f_get, f'Variable {name} must define either a default value or a getter {f_get_name}(cls)'
+                # -- TODO: check signature: f_get(cls)
+            else:
+                f_get = lambda cls, def_value=def_value: def_value
+
+            f_apply_name = f'{name}_apply'
+            f_apply = cls_dict.get(f_apply_name)  # -- f(cls, value)
+
+            var_name = f'{env_name}_{name.upper()}'
+            full_getter = cls.full_getter(data_type, var_name, f_get, f_apply)
+            setattr(cls, name, classproperty(full_getter))
+
+            cls.assert_var = cls.AssertVar(cls)
+
+    class AssertVar:
+        def __init__(self, env_vars_class):
+            self.env_vars_class = env_vars_class
+
+        def __getattr__(self, item):
+            value = getattr(self.env_vars_class, item)
+            if not value:
+                raise AssertionError(f'{self.env_vars_class.s_env_name}_{item.upper()} is not defined')
+            return value
+
+
+class EnvVars(_EnvVars, env_name='XX'):
+    # fmt: off
+    build_area: str
+    parent_build_area: str          = 'dev'
+
+    master_password_key: str        = 'XX_MASTER_PASSWORD'
+
+    examples_ts_store_uri: str      = ''            #-- e.g., mongodb://localhost/examples
+    vault_ts_store_uri: str         = ''            #-- if defined, used to store/auto retrieve security credentials for each user/resource
+    main_ts_store_uri: str          = ''            #-- e.g., 'mongodb://localhost:27018/main'
+    use_ts_store_per_class: bool    = True          #-- use TsStore per Traitable class associations
+    functional_account_prefix: str  = 'xx'          #-- used in user names to distinguish a regular user name from a functional account
+
+    date_format: str = XDateTime.FORMAT_ISO
+
+    sdlc_area: str
+    # fmt: on
+
+    def build_area_get(self) -> str:
+        return OsUser.me.name()
+
+    @classmethod
+    def date_format_apply(cls, value):
+        XDateTime.set_default_format(value)
+
+    def sdlc_area_get(self) -> str:
+        ba = self.build_area
+        pba = self.parent_build_area
+        return f'{ba}/{pba}' if pba else ba

core_10x/exec_control.py

@@ -0,0 +1,84 @@
+from py10x_core import BProcessContext
+from py10x_core import BTraitableProcessor as BTP  # noqa: N817
+
+# TODO: rename DEBUG to TYPE_CHECK?
+# TODO: make CONVERT/DEBUG mode default?
+
+
+def CHANGE_MODE(debug: bool = -1, convert_values: bool = -1):  # noqa: N802
+    return BTP.create(-1, convert_values, debug, True, False)
+
+
+def DEFAULT_CACHE(debug: bool = -1, convert_values: bool = -1):  # noqa: N802
+    return BTP.create(0, convert_values, debug, False, True)
+
+
+def GRAPH_ON(debug: bool = -1, convert_values: bool = -1):  # noqa: N802
+    return BTP.create(1, convert_values, debug, False, False)
+
+
+def GRAPH_OFF(debug: bool = -1, convert_values: bool = -1):  # noqa: N802
+    return BTP.create(0, convert_values, debug, False, False)
+
+
+def DEBUG_ON(convert_values: bool = -1):  # noqa: N802
+    return BTP.create(-1, convert_values, 1, True, False)
+
+
+def DEBUG_OFF(convert_values: bool = -1):  # noqa: N802
+    return BTP.create(-1, convert_values, 0, True, False)
+
+
+def CONVERT_VALUES_ON(debug: bool = -1):  # noqa: N802
+    return BTP.create(-1, 1, debug, True, False)
+
+
+def CONVERT_VALUES_OFF(debug: bool = -1):  # noqa: N802
+    return BTP.create(-1, 0, debug, True, False)
+
+
+def INTERACTIVE():  # noqa: N802
+    return BTP.create_interactive()
+
+
+# noinspection PyMethodOverriding
+class ProcessContext(BProcessContext):
+    @staticmethod
+    def set_flags(flags: int) -> int:
+        old_flags = BProcessContext.BPC.flags()
+        BProcessContext.BPC.set_flags(flags)
+        return old_flags
+
+    @staticmethod
+    def reset_flags(flags: int) -> int:
+        old_flags = BProcessContext.BPC.flags()
+        BProcessContext.BPC.reset_flags(flags)
+        return old_flags
+
+    @staticmethod
+    def replace_flags(flags: int) -> int:
+        old_flags = BProcessContext.BPC.flags()
+        BProcessContext.BPC.replace_flags(flags)
+        return old_flags
+
+    @staticmethod
+    def flags() -> int:
+        return BProcessContext.BPC.flags()
+
+
+class FlagsContext:
+    s_default_flags = 0
+
+    def __init__(self, flags=None):
+        self._flags = flags if flags is not None else self.s_default_flags
+
+    def __enter__(self):
+        self._old_flags = ProcessContext.set_flags(self._flags)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        ProcessContext.BPC.replace_flags(self._old_flags)
+
+
+class CACHE_ONLY(FlagsContext):
+    s_default_flags = ProcessContext.CACHE_ONLY

core_10x/experimental/data_protocol_ex.py

@@ -0,0 +1,34 @@
+import functools
+
+
+class T:
+    def __init__(self, name, get, *args):
+        self.name = name
+        self.get = get
+        self.args = args
+
+    def __get__(self, instance, owner):
+        if not self.args:
+            return self.get(instance)
+
+        return functools.partial(self.get, self)
+
+class E:
+    def __init__(self, fn, ln):
+        self.fn = fn
+        self.ln = ln
+
+    def full_name(self):
+        return f'{self.ln}, {self.fn}'
+
+    def w(self, q):
+        return q * 10
+
+    name    = T('name', full_name )
+    weight  = T('weight', w, 10 )
+
+if __name__ == '__main__':
+    e = E('Sasha', 'Davidovich')
+
+    print(e.name)
+    print(e.weight(5))