py10x-core 0.1.12__py3-none-any.whl

core_10x/__init__.py

@@ -0,0 +1,47 @@
+# from os import path
+#
+# pp = path.dirname(path.abspath(__file__))
+# path_to_core_10x = path.dirname(pp)
+import atexit
+
+from py10x_kernel import CORE_10X, PyLinkage, XCache
+
+
+# fmt: off
+def cleanup():
+    XCache.clear()
+    PyLinkage.clear()
+
+atexit.register(cleanup)
+
+PyLinkage.init({
+    CORE_10X.PACKAGE_NAME:                              __name__,
+
+    CORE_10X.XNONE_MODULE_NAME:                         'xnone',
+    CORE_10X.XNONE_CLASS_NAME:                          'XNone',
+
+    CORE_10X.RC_MODULE_NAME:                            'rc',
+    CORE_10X.RC_TRUE_NAME:                              'RC_TRUE',
+
+    CORE_10X.NUCLEUS_MODULE_NAME:                       'nucleus',
+    CORE_10X.NUCLEUS_CLASS_NAME:                        'Nucleus',
+
+    CORE_10X.ANONYMOUS_MODULE_NAME:                     'traitable',
+    CORE_10X.ANONYMOUS_CLASS_NAME:                      'AnonymousTraitable',
+
+    CORE_10X.TRAITABLE_ID_MODULE_NAME:                  'traitable_id',
+    CORE_10X.TRAITABLE_ID_CLASS_NAME:                   'ID',
+
+    CORE_10X.TRAIT_METHOD_ERROR_MODULE_NAME:            'trait_method_error',
+    CORE_10X.TRAIT_METHOD_ERROR_CLASS_NAME:             'TraitMethodError',
+
+    CORE_10X.PACKAGE_REFACTORING_MODULE_NAME:           'package_refactoring',
+    CORE_10X.PACKAGE_REFACTORING_CLASS_NAME:            'PackageRefactoring',
+    CORE_10X.PACKAGE_REFACTORING_FIND_CLASS:            'find_class',
+    CORE_10X.PACKAGE_REFACTORING_FIND_CLASS_ID:         'find_class_id',
+})
+
+try:
+    from dev_10x.version import __version__
+except ImportError:
+    __version__ = '0.0.0+unknown'  # fallback for dev envs

core_10x/apps/runme_1st_app.py

@@ -0,0 +1,81 @@
+from core_10x.environment_variables import EnvVars
+
+from core_10x.ts_store import TsStore, ResourceSpec
+from core_10x.traitable import NamedTsStore, TsClassAssociation
+
+
+def main(username: str = '', password: str = ''):
+    v_main_uri: EnvVars.Var = EnvVars.var.main_ts_store_uri
+    if not v_main_uri:
+        print(
+f"""
+Environment variable {EnvVars.var_name(v_main_uri.attr_name)} is not defined
+Main Traitable Store is not specified, thus you must explicitly instantiate and use a particular Traitable Store, e.g.:
+
+    with TsStore.instance_from_uri('mongodb://public_mongo_host.abc.com/test'):     #-- no authentication
+        # your code
+        ...
+        
+    or
+
+    #-- Authentication is required
+    password = 'a VeryStrongPassword!'
+    with TsStore.instance_from_uri('mongodb://protected_mongo_host.abc.com/test', username = 'xyz', password = password):
+        # your code
+        ...
+"""
+        )
+        #-- there is nothing more to do
+        return
+
+    print(
+f"""
+Main Traitable Store is specified (Environment variable {EnvVars.var_name(v_main_uri.attr_name)} = {v_main_uri.value})
+It means that Traitable objects would be sought and saved in the above store.  
+"""
+    )
+
+    main_spec = TsStore.spec_from_uri(v_main_uri.value)
+    is_running, with_auth = main_spec.resource_class.is_running_with_auth(main_spec.hostname())
+    if not is_running:
+        print(f'Main Traitable Store {v_main_uri.value} is not running')
+        return
+
+    if with_auth:
+        print(f"Main Traitable Store {v_main_uri.value} requires authentication. Let's check if a Vault is specified." )
+
+        v_vault_uri = EnvVars.var.vault_ts_store_uri
+        if not v_vault_uri:
+            print(f"No Vault is specified (Environment variable {EnvVars.var_name(v_vault_uri.attr_name)} is not defined). Exiting...")
+            return
+
+        print(
+f"""
+Vault Store is specified (Environment variable {EnvVars.var_name(v_vault_uri.attr_name)} = {v_vault_uri.value})
+It means that some Traitable Stores in use (as well as other resources) require authentication.
+In order to use the Vault "automagically", you need to run "add_vault utiliry" entering your password to the Vault and your XX MasterPassword.
+"""
+        )
+        return
+
+    main_store = main_spec.resource_class.instance(**main_spec.kwargs)
+    v_class_assoc = EnvVars.var.use_ts_store_per_class
+    if v_class_assoc:
+        print(
+f"""
+Different Traitable Stores may be used for different subclasses of Traitable (Environment variable {EnvVars.var_name(v_class_assoc.attr_name)} = {v_class_assoc.value})
+Checking further...
+"""
+        )
+
+        main_store.begin_using()
+
+        available_stores = NamedTsStore.load_many()
+
+
+if __name__ == '__main__':
+
+    import sys
+
+    main(*sys.argv[1:])
+

core_10x/attic/backbone/backbone_store.py

@@ -0,0 +1,59 @@
+from core_10x.environment_variables import EnvVars
+from core_10x.global_cache import cache
+from core_10x.ts_store import TsStore
+
+
+class BackboneStore:
+    """
+    Backbone Store instance should exist for every build area. It may be run with or without authentication required.
+    If authentication is required, it must have a special-purpose user SIDEKICK with read-only permissions and must have the following databases:
+    - admin
+    - _backbone_    - collections:
+        - bound data domains;
+        - users;
+        - user groups;
+        - ...
+    - _vault_       - collections of Resource Accessors (per username)
+    - _shadow_      - collections of 'Shadow' (user-password-encrypted private key) for each user (for exporting sec keys for a new user's computer)
+
+    """
+
+    # fmt: off
+    SIDEKICK_USER       = 'sidekick'
+    BACKBONE_DB_NAME    = '_backbone_'
+    VAULT_DB_NAME       = '_vault_'
+    SHADOW_DB_NAME      = '_shadow_'
+    # fmt: on
+
+    @classmethod
+    @cache
+    def bb_store(cls) -> TsStore:  # -- BB Store
+        cls_name = EnvVars.backbone_store_class_name
+        cls.hostname = hostname = EnvVars.backbone_store_host_name
+        if not cls_name or not hostname:
+            return None
+
+        cls.store_cls = store_cls = TsStore.store_class(cls_name)
+
+        is_running, with_auth = store_cls.is_running_with_auth(hostname)
+        if not is_running:
+            raise OSError(f'{store_cls.s_driver_name}({hostname}) is not running')
+
+        cls.with_auth = with_auth
+        if with_auth:
+            cls.username = cls.SIDEKICK_USER
+            cls.password = cls.SIDEKICK_USER
+        else:
+            cls.username = ''
+            cls.password = ''
+
+        return store_cls.instance(hostname=hostname, dbname=cls.BACKBONE_DB_NAME, username=cls.username, password=cls.password)
+
+    @classmethod
+    @cache
+    def store(cls, db_name: str) -> TsStore:
+        bb_store = cls.bb_store()
+        if db_name == cls.BACKBONE_DB_NAME:
+            return bb_store
+
+        return cls.store_cls.instance(hostname=cls.hostname, dbname=db_name, username=cls.username, password=cls.password)

core_10x/attic/backbone/backbone_traitable.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from core_10x.attic.backbone.backbone_store import BackboneStore
+from core_10x.traitable import T, Traitable, TraitDefinition
+
+if TYPE_CHECKING:
+    from core_10x.traitable import RC
+    from core_10x.ts_store import TsStore
+
+
+class BackboneTraitable(Traitable):
+    @classmethod
+    def build_trait_dir(cls) -> RC:
+        for trait_def in cls.__dict__.values():
+            if isinstance(trait_def, TraitDefinition):
+                trait_def.flags_change(T.EVAL_ONCE)
+
+        return Traitable.build_trait_dir()
+
+    @classmethod
+    def store(cls) -> TsStore:
+        return BackboneStore.bb_store()
+
+
+class VaultTraitable(BackboneTraitable):
+    @classmethod
+    def store(cls) -> TsStore:
+        return BackboneStore.store(BackboneStore.VAULT_DB_NAME)

core_10x/attic/backbone/backbone_user.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from py10x_kernel import OsUser
+
+from core_10x.traitable import RT, T
+from core_10x.attic.backbone.backbone_traitable import BackboneTraitable
+from infra_10x.namespace import FUNCTIONAL_ACCOUNT_PREFIX, USER_ADMIN_SUFFIX
+from core_10x.global_cache import cache
+from core_10x.trait_filter import f
+
+
+class BackboneUserGroup(BackboneTraitable):
+    # fmt: off
+    name: str           = T(T.ID)
+    description: str    = T()
+    everyone: bool      = T(False)
+    is_admin: bool      = T(False)
+    is_reserved: bool   = T(False)
+    builtin_roles: list = T()
+    user_ids: list      = T()
+
+    users: set          = RT()
+    # fmt: on
+
+    def users_get(self) -> set:
+        return set(self.user_ids)
+
+    def is_member(self, user_id: str) -> bool:
+        return user_id in self.users if not self.everyone else False
+
+
+class BackboneUser(BackboneTraitable):
+    # fmt: off
+    user_id: str        = T(T.ID)   // 'OS login'
+    suspended: bool     = T(False)
+    public_key: bytes   = T()
+
+    is_admin: bool      = RT()
+    downloaded: bool    = RT(False)
+    builtin_roles: list = RT()
+    # fmt: on
+
+    def user_id_get(self) -> str:
+        return OsUser.me.name()
+
+    def is_admin_get(self) -> bool:
+        for group in BackboneUserGroup.collection().find(f(is_admin=True)):
+            if group.is_member(self.user_id):
+                return True
+
+        return False
+
+    def admin_id(self) -> str:
+        return f'{self.user_id}_{USER_ADMIN_SUFFIX}' if self.is_admin else ''
+
+    @classmethod
+    def regular_id(cls, admin_id: str) -> str:
+        return admin_id.split(f'_{USER_ADMIN_SUFFIX}')[0]
+
+    @classmethod
+    def is_functional_account(cls, user_id: str) -> bool:
+        return user_id.split('-', 1) == FUNCTIONAL_ACCOUNT_PREFIX
+
+    @classmethod
+    @cache
+    def me(cls) -> BackboneUser:
+        return cls.existing_instance(user_id=OsUser.me.name())

core_10x/attic/backbone/bound_data_domain.py

@@ -0,0 +1,49 @@
+from core_10x.attic.backbone.backbone_traitable import RT, BackboneTraitable, T
+from core_10x.attic.data_domain import DataDomain
+from core_10x.environment_variables import EnvVars
+from core_10x.resource import Resource
+from core_10x.xnone import XNone
+
+
+class ResourceSpec(BackboneTraitable):
+    # fmt: off
+    build_area: str         = T(T.ID)
+    name: str               = T(T.ID)
+    resource_class: type    = T()
+    resource_kwargs: dict   = T()
+
+    resource: Resource      = RT()
+    # fmt: on
+
+    def build_area_get(self) -> str:
+        return EnvVars.sdlc_area
+
+    def name_get(self) -> str:
+        kwargs = self.resource_kwargs
+        return kwargs.get(Resource.HOSTNAME_TAG, XNone)
+
+    def resource_get(self) -> Resource:
+        cls = self.resource_class
+        assert issubclass(cls, Resource), f'{cls} is not a subclass of Resource'
+        return cls.instance(**self.resource_kwargs)
+
+
+class BoundDataDomain(BackboneTraitable):
+    # fmt: off
+    domain: DataDomain.__class__    = T(T.ID)
+    build_area: str                 = T(T.ID)
+    bound_categories: dict          = T()
+    # fmt: on
+
+    def build_area_get(self) -> str:
+        return EnvVars.sdlc_area
+
+    def resource(self, category: str, throw: bool = True) -> Resource:
+        r_spec_id: str = self.bound_categories.get(category)
+        if not r_spec_id:
+            if throw:
+                raise ValueError(f'{self.domain} - unknown category {category}')
+            return None
+
+        r_spec = ResourceSpec(_id=r_spec_id)
+        return r_spec.resource

core_10x/attic/backbone/vault.py

@@ -0,0 +1,38 @@
+from datetime import datetime
+
+from core_10x.attic.backbone.backbone_traitable import RC, T, VaultTraitable
+from core_10x.attic.vault import SecKeys
+
+
+class ResourceAccessor(VaultTraitable):
+    # fmt: off
+    resource_name: str      = T(T.ID)
+    #username: str           = T(T.ID)
+
+    login: str              = T()
+    password: bytes         = T()
+    last_updated: datetime  = T()
+    # fmt: on
+
+    def last_updated_get(self) -> datetime:
+        return datetime.utcnow()
+
+
+class Vault:
+    ANY_HOST = '.'
+
+    @staticmethod
+    def save_resource_accessor(username: str, hostname: str, login: str, password: str, public_key: bytes = None) -> RC:
+        assert login and password, 'login and password must not be empty'
+
+        pwd = SecKeys.encrypt(password, public_key=public_key)
+        if pwd is None:
+            return RC(False, 'Security Keys are missing. If you are using a new computer, please run "xx user new machine" from your shell')
+
+        ra = ResourceAccessor(hostname=hostname)
+        ra.reload()
+        rc = ra.set_values(login=login, password=pwd)
+        if not rc:
+            return rc
+
+        ra.save()

core_10x/attic/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/attic/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/attic/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/attic/package_manifest.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from core_10x.attic.data_domain import GeneralDomain
+from core_10x.py_class import PyClass
+from core_10x.resource import TS_STORE
+
+if TYPE_CHECKING:
+    from core_10x.resource import ResourceRequirements
+
+
+class PackageManifest:
+    """
+    To associate a subclass of Traitable to a particular Data Domain Category
+    it must have a record in a package manifest file.
+    Example:
+        # module x.etrading_domain
+        class ETradingDomain(DataDomain):
+            GENERAL     = TS_STORE()
+            ORDERS      = TS_STORE()
+            ALGO_ORDERS = TS_STORE()
+            ...
+
+        #module x.y.order
+        class Order(Traitable):
+            ...
+
+        class AlgoOrder(Order):
+            ...
+
+
+        #module x.y._package_manifest
+        from x.etrading_domain import ETradingDomain as ET
+
+        manifest = dict(        #-- variable manifest: dict must be defined as follows
+            _category = ET.GENERAL,     #-- default category for Traitables in x.y package, if any
+
+            order = dict(                   #-- specific association(s) for any module inside x.y package, if any
+                _category = ET.ORDERS           #-- default category for Traitables in x.y.order, if any
+
+                AlgoOrder = ET.ALGO_ORDERS      #-- specific association class x.y.order.AlgoOrder, if any
+                ...
+            ),
+            ...
+        )
+
+        If no association could be found for a subclass of Traitable, the default association will be used: GeneralDomain.GENERAL
+    """
+
+    # fmt: off
+    SYMBOL      = '_package_manifest.manifest'
+    CATEGORY    = '_category'
+    # fmt: on
+
+    @staticmethod
+    def _resource_requirements(cls) -> ResourceRequirements:
+        module = cls.__module__
+        parts = module.split('.')
+        if len(parts) < 2:
+            return None  # -- should be at least package.module, so it's most probably '__main__.Class'
+
+        package = '.'.join(parts[:-1])
+        man_def: dict = PyClass.find_symbol(f'{package}.{PackageManifest.SYMBOL}')
+        if not man_def:
+            return None
+
+        short_module = parts[-1]
+        module_entry = man_def.get(short_module)
+        if module_entry:
+            rr: ResourceRequirements = module_entry.get(cls.__name__)
+            if not rr:
+                rr = module_entry.get(PackageManifest.CATEGORY)
+                if rr:
+                    return rr
+
+        return man_def.get(PackageManifest.CATEGORY)
+
+    @staticmethod
+    def resource_requirements(cls) -> ResourceRequirements:
+        rr = PackageManifest._resource_requirements(cls) or GeneralDomain.GENERAL
+        assert rr.resource_type is TS_STORE, f'{cls} - invalid category in the _package_manifest'
+        return rr
+
+    # -- TODO: handle parent classes, if ResourceRequirements for the class in not found