py10x-universe 0.1.3__py3-none-any.whl

core_10x/__init__.py

@@ -0,0 +1,42 @@
+# from os import path
+#
+# pp = path.dirname(path.abspath(__file__))
+# path_to_core_10x = path.dirname(pp)
+import atexit
+
+from py10x_core 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',
+})

core_10x/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/backbone/backbone_traitable.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from core_10x.backbone.backbone_store import BackboneStore
+from core_10x.traitable import RT, 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/backbone/backbone_user.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from py10x_core import OsUser
+
+from core_10x.backbone.backbone_traitable import RT, BackboneTraitable, T
+from core_10x.backbone.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/backbone/bound_data_domain.py

@@ -0,0 +1,49 @@
+from core_10x.backbone.backbone_traitable import RT, BackboneTraitable, T
+from core_10x.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/backbone/namespace.py

@@ -0,0 +1,101 @@
+from core_10x.named_constant import NamedConstant
+
+# fmt: off
+BACKBONE_STORE_CLASS_NAME   = 'infra_10x.mongo_db.Mongo'
+#BACKBONE_USER_NAME         = 'core_10x.backbone.backbone_admin.BACKBONE_USER'
+
+AUTO_PASSWORD_LENGTH        = 32
+
+class DB_NAME:
+    ANY         = ''
+    NONE        = '_none'
+    ADMIN       = 'admin'
+    BACKBONE    = '_backbone_'
+    VAULT       = '_vault_'
+    SHADOW      = '_shadow_'
+
+class STANDARD_ROLE:
+    READ            = 'read'
+    READ_ANY        = 'readAnyDatabase'
+    READ_WRITE      = 'readWrite'
+    READ_WRITE_ANY  = 'readWriteAnyDatabase'
+    DB_ADMIN        = 'dbAdmin'
+    DB_ADMIN_ANY    = 'dbAdminAnyDatabase'
+    OWNER           = 'dbOwner'
+    USER_ADMIN      = 'userAdmin'
+    USER_ADMIN_ANY  = 'userAdminAnyDatabase'
+    CLUSTER_ADMIN   = 'clusterAdmin'
+    CLUSTER_MAN     = 'clusterManager'
+    BACKUP          = 'backup'
+    RESTORE         = 'restore'
+    ROOT            = 'root'
+
+class ACTION:
+    FIND            = 'find'
+    INSERT          = 'insert'
+    UPDATE          = 'update'
+    REMOVE          = 'remove'
+    INDEX_LIST      = 'listIndexes'
+    INDEX_CREATE    = 'createIndex'
+    COLL_LIST       = 'listCollections'
+    COLL_STATS      = 'collStats'
+    COLL_RENAME     = 'renameCollectionSameDB'
+    COLL_CREATE     = 'createCollection'
+    COLL_DROP       = 'dropCollection'
+    DB_LIST         = 'listDatabases'
+    DB_STATS        = 'dbStats'
+    CHANGE_STREAME  = 'changeStream'
+
+    CHANGE_OWN_PASSWORD = 'changeOwnPassword'
+
+class PERMISSION:
+    NONE        = []
+    NEW_PWD     = [ ACTION.CHANGE_OWN_PASSWORD ]
+    READ_ONLY   = [ ACTION.FIND ]
+    READ_EX     = [ ACTION.FIND, ACTION.COLL_LIST ]
+    WRITE       = [ ACTION.INSERT, ACTION.UPDATE, ACTION.REMOVE ]
+    INDEX       = [ ACTION.INDEX_LIST, ACTION.INDEX_CREATE ]
+    COLL        = [ ACTION.COLL_LIST, ACTION.COLL_RENAME, ACTION.COLL_STATS, ACTION.COLL_CREATE, ACTION.COLL_DROP ]
+
+    UPDATE      = [ *READ_ONLY, ACTION.UPDATE ]
+    READ_WRITE  = [ *READ_ONLY, *WRITE, *INDEX, *COLL ]
+
+USER_ADMIN_SUFFIX               = 'admin'
+FUNCTIONAL_ACCOUNT_PREFIX       = 'xx'
+FUNCTIONAL_ACCOUNT_DEPARTMENT   = 'XX Functional Accounts'
+
+class USER_ROLE(NamedConstant):
+    NONE        = []
+    VISITOR     = PERMISSION.READ_EX
+    WORKER      = PERMISSION.READ_WRITE
+
+class COLL_PLACEHOLDER:
+    TAG         = '__coll_placeholder'
+    USERNAME    = 'username'
+# fmt: on
+
+
+class CUSTOM_ROLE(NamedConstant):
+    """
+    role_name: e.g., 'VISITOR'
+    permissions_per_db_name: a dict: each key is either a db_name or db_name/collection_name, value is PERMISSION, e.g.,
+    { 'catalog': PERMISSION.READ_ONLY, 'logs/errors': PERMISSION.READ_WRITE }
+    """
+
+    @classmethod
+    def coll_placeholder(cls, value) -> tuple:  # -- (coll_placeholder, stripped_value)
+        cvalue = dict(value)
+        return (cvalue.pop(COLL_PLACEHOLDER.TAG, None), value)
+
+    @classmethod
+    def user_role_name(cls, username: str) -> str:
+        return f'{username.upper()}_USR'
+
+
+# fmt: off
+SECURITY_KEYS_MISSING = 'Sec keys are missing. If you are using a new computer, please run "xx user new machine" from your shell'
+SECURITY_KEYS_INCOMPATIBLE = 'Sec keys are incompatible with an encrypted password'
+
+SECRETS_CLIENT_ARGS     = dict(service_name = 'secretmanager', region_name = 'me-south-1')
+SECRETS_PATH_PREFIX     = '/external-secrets/xx'
+# fmt: on

core_10x/backbone/vault.py

@@ -0,0 +1,38 @@
+from datetime import datetime
+
+from core_10x.backbone.backbone_traitable import RC, T, VaultTraitable
+from core_10x.vault.security_keys 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/code_samples/_package_manifest.py

@@ -0,0 +1,3 @@
+manifest = dict(
+    a = 100,
+)

core_10x/code_samples/directories.py

@@ -0,0 +1,181 @@
+from core_10x.directory import Directory
+
+ANIMALS = Directory.define(
+    'Animals',
+    [
+        'Microorganisms',
+        [
+            'Single Cell',
+            'Multi Cell',
+        ],
+        'Mollusks',
+        'Fishes',
+        [
+            'Salt Water',
+            [
+                'Beluga'
+            ],
+            'Fresh Water',
+        ],
+        'Amphibia',
+        'Reptiles',
+        'Birds',
+        'Mammals',
+        [
+            'Cats',
+            'Dogs',
+            'Bears',
+            'Whales',
+            [
+                'Bluewhale',
+                'Orca',
+                'Spermwhale',
+                'Beluga'
+            ],
+        ],
+    ],
+)
+
+FISH = Directory.define(
+    ( 'FWF', 'Fresh Water Fish' ),
+    [
+        ( 'PkF',    'Pike Family' ),
+        [
+            ( 'NPK',    'Northern Pike' ),
+            ( 'MSK',    'Muskie' ),
+            ( 'PKL',    'Pickerel' ),
+        ],
+        ( 'PeF', 'Perch Family' ),
+        [
+            ( 'PCH',    'Common Perch' ),
+            ( 'YPH',    'Yellow Perch' ),
+            ( 'WLY',    'Walleye' ),
+            ( 'SGR',    'Sagger' ),
+        ],
+        ( 'CrF',    'Carp Family' ),
+        [
+            ( 'CRP',    'Common Carp' ),
+            ( 'WCP',    'Wild Carp' ),
+            ( 'IDE',    'Ide' ),
+            ( 'BRM',    'Bream' ),
+            ( 'RCH',    'Roach' ),
+        ],
+    ],
+)
+
+STANDARD_PIXMAPS = Directory.define(
+    'Standard Pixmaps',
+    [
+        'Title Bar',
+        [
+            'TitleBarMaxButton',
+            'TitleBarCloseButton',
+            'TitleBarNormalButton',
+            'TitleBarShadeButton',
+            'TitleBarUnshadeButton',
+            'TitleBarContextHelpButton',
+        ],
+        'Message Box',
+        [
+            'MessageBoxInformation',
+            'MessageBoxWarning',
+            'MessageBoxCritical',
+            'MessageBoxQuestion',
+        ],
+        'Drive',
+        [
+            'DriveFDIcon',
+            'DriveHDIcon',
+            'DriveCDIcon',
+            'DriveDVDIcon',
+            'DriveNetIcon',
+        ],
+        'Dir',
+        [
+            'DirHomeIcon',
+            'DirOpenIcon',
+            'DirClosedIcon',
+            'DirIcon',
+            'DirLinkIcon',
+            'DirLinkOpenIcon',
+        ],
+        'File',
+        [
+            'FileIcon',
+            'FileLinkIcon',
+            'FileDialogStart',
+            'FileDialogEnd',
+            'FileDialogToParent',
+            'FileDialogNewFolder',
+            'FileDialogDetailedView',
+            'FileDialogInfoView',
+            'FileDialogContentsView',
+            'FileDialogListView',
+            'FileDialogBack',
+        ],
+        'Dialog',
+        [
+            'DialogOkButton',
+            'DialogCancelButton',
+            'DialogHelpButton',
+            'DialogOpenButton',
+            'DialogSaveButton',
+            'DialogCloseButton',
+            'DialogApplyButton',
+            'DialogResetButton',
+            'DialogDiscardButton',
+            'DialogYesButton',
+            'DialogNoButton',
+            'DialogYesToAllButton',
+            'DialogNoToAllButton',
+            'DialogSaveAllButton',
+            'DialogAbortButton',
+            'DialogRetryButton',
+            'DialogIgnoreButton',
+        ],
+        'Arrow',
+        [
+            'ArrowUp',
+            'ArrowDown',
+            'ArrowLeft',
+            'ArrowRight',
+            'ArrowBack',
+            'ArrowRight',
+            'ArrowForward',
+        ],
+        'Media',
+        [
+            'MediaPlay',
+            'MediaStop',
+            'MediaPause',
+            'MediaSkipForward',
+            'MediaSkipBackward',
+            'MediaSeekForward',
+            'MediaSeekBackward',
+            'MediaVolume',
+            'MediaVolumeMuted',
+        ],
+        'Other',
+        [
+            'DesktopIcon',
+            'TrashIcon',
+            'ComputerIcon',
+            'DockWidgetCloseButton',
+            'ToolBarHorizontalExtensionButton',
+            'ToolBarVerticalExtensionButton',
+            'CommandLink',
+            'VistaShield',
+            'BrowserReload',
+            'BrowserStop',
+            'LineEditClearButton',
+            'RestoreDefaultsButton',
+        ],
+    ],
+    #'CustomBase',
+)
+
+if __name__ == '__main__':
+    h1 = FISH.choices()
+
+    f = ANIMALS.flatten()
+    h2 = ANIMALS.choices()

core_10x/code_samples/person.py

@@ -0,0 +1,76 @@
+from datetime import date
+
+from core_10x.named_constant import NamedConstant
+from core_10x.traitable import RC, RC_TRUE, RT, T, Traitable, Ui
+
+
+class WEIGHT_QU( NamedConstant ):
+    LB =    ( 'lb',     1. )
+    KG =    ( 'kg',     2.205 )
+    G =     ( 'g',      0.002205 )
+    CT =    ( 'ct',     0.0004409 )
+
+class Person(Traitable):
+    first_name: str         = T(T.ID)
+    last_name: str          = T(T.ID)
+    dob: date               = T()
+    weight_lbs: float       = T(fmt = ',.4f')
+
+    age: int
+    full_name: str          = RT(T.EXPENSIVE)
+    weight: float
+    weight_qu: WEIGHT_QU    = RT(default = WEIGHT_QU.LB)
+
+    older_than: bool
+
+
+    def dob_set(self, trait, value: date) -> RC:
+        today = date.today()
+        if value and value > today:
+            return RC(False, f'{value} may not be after {today}')
+        return self.raw_set_value(trait, value)
+
+    def full_name_get(self) -> str:
+        return f'{self.first_name} {self.last_name}'
+
+    def full_name_style_sheet(self) -> dict:
+        age = self.age
+        return {Ui.FG_COLOR: 'red' if age < 20 or age > 70 else 'green'}
+
+    def full_name_set(self, trait, value: str) -> RC:
+        parts = value.split(' ')
+        if(len(parts) != 2):
+            return RC(False, f'"{value}" - must be "first_name last_name"')
+
+        self.first_name = parts[0]
+        self.last_name = parts[1]
+        return RC_TRUE
+
+    def age_get(self) -> int:
+        dob = self.dob
+        if not dob:
+            return 0
+
+        today = date.today()
+        years = today.year - dob.year
+        dm = today.month - dob.month
+        if dm < 0:
+            return years - 1
+
+        if dm > 0:
+            return years
+
+        return years - 1 if today.day < dob.day else years
+
+    def older_than_get(self, age: int) -> bool:
+        return self.age > age
+
+    #-- getter and setter for weight trait
+    def weight_get(self) -> float:
+        return self.weight_lbs / self.weight_qu.value
+
+    def weight_set(self, trait, value) -> RC:  #-- trait setter gets its trait and the value and must return RC
+        return self.set_values( weight_lbs = value * self.weight_qu.value)
+
+    def weight_to_str(self, trait, value) -> str:
+        return f'{trait.to_str(value)} {self.weight_qu.label}'