py10x-universe 0.1.3__py3-none-any.whl

core_10x/global_cache.py

@@ -0,0 +1,121 @@
+import inspect
+
+from core_10x.xnone import XNone
+
+# ===================================================================================================================================
+#   @cache must be used to cache results of function calls globally (at the process level)
+#
+#   Notes:
+#
+#   - non-hashable args are NOT supported for performance reasons
+#   - args MUST follow the declaration order for performance reasons (otherwise, the same result may be cached multiple times
+#       e.g. f(a=1, b=2) and f(b=2, a=1)
+#   - the most common 'users' are class methods
+# ===================================================================================================================================
+ARGS_KWARGS = (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)
+
+
+def cache(f):
+    sig = inspect.signature(f)
+    params = sig.parameters
+    num_args = len(params)
+    if num_args == 0:
+        return _cache_no_args(f)
+
+    if num_args == 1:
+        for param in params.values():
+            if param.kind not in ARGS_KWARGS and param.default is inspect.Parameter.empty:
+                return _cache_single_arg(f)
+
+    return _cache_with_args(f)
+
+
+def _cache_no_args(f):
+    the_value = [XNone]
+
+    def getter():
+        v = the_value[0]
+        if v is XNone:
+            the_value[0] = v = f()
+        return v
+
+    def clear():
+        the_value[0] = XNone
+
+    getter.__name__ = f.__name__
+    getter.value = the_value
+    getter.clear = clear
+    return getter
+
+
+def _cache_single_arg(f):
+    the_cache = {}
+
+    def getter(arg):
+        value = the_cache.get(arg, the_cache)  # -- will throw if arg is not hashable!
+        if value is the_cache:  # -- i.e., arg is seen for the first time
+            value = f(arg)
+            the_cache[arg] = value
+
+        return value
+
+    getter.__name__ = f.__name__
+    getter.cache = the_cache
+    getter.clear = lambda: the_cache.clear()
+    return getter
+
+
+def _cache_with_args(f):
+    the_cache = {}
+
+    def getter(*args, **kwargs):
+        key = *args, *tuple(kwargs.items())
+        value = the_cache.get(key, the_cache)  # -- will throw if key is not hashable!
+        if value is the_cache:  # -- i.e., key is seen for the first time
+            value = f(*args, **kwargs)
+            the_cache[key] = value
+
+        return value
+
+    getter.__name__ = f.__name__
+    getter.cache = the_cache
+    getter.clear = lambda: the_cache.clear()
+    return getter
+
+
+def standard_key(args: tuple, kwargs: dict) -> tuple:
+    sorted_kwargs = tuple((k, kwargs[k]) for k in sorted(kwargs))
+    return *args, *sorted_kwargs
+
+
+# ========= The singleton
+
+
+def ___operator_new(cls, *args, **kwargs):
+    key = standard_key((cls, *args), kwargs)
+    ptr = cls.___instances.get(key)
+    if not ptr:
+        ptr = object.__new__(cls)
+        cls.___ctor(ptr, *args, **kwargs)
+        cls.___instances[key] = ptr
+    return ptr
+
+
+def ___operator_reset(cls):
+    cls.___instances = {}
+
+
+def singleton(cls):
+    cls.___instances = {}
+    cls.__new__ = ___operator_new
+    cls.___ctor = cls.__init__
+    cls.__init__ = lambda self, *args, **kwargs: None
+    cls._reset_singleton = lambda: ___operator_reset(cls)
+    return cls
+
+
+# def hash_key( obj ) -> int:
+#     try:
+#         return hash( obj )
+#     except Exception:
+#         return hash(str(obj))

core_10x/manual_tests/calendar_test.py

@@ -0,0 +1,35 @@
+if __name__ == '__main__':
+
+    from datetime import date
+
+    from core_10x.xxcalendar import Calendar, CalendarAdjustment
+
+    us_c = Calendar(_replace = True,
+        name                = 'US',
+        non_working_days    = [
+            date(2025,1,1), date(2025,1,20), date(2025,2,17), date(2025,5,26), date(2025,7,4),
+            date(2025,9,1), date(2025,10,13), date(2025,11,11), date(2025,11,27), date(2025,12, 25)
+        ]
+    )
+
+    uk_c = Calendar(_replace = True,
+        name                = 'UK',
+        non_working_days    = [
+            date(2025,1,1), date(2025,4,18), date(2025,5,5), date(2025,5,26), date(2025,8,25),
+            date(2025,12, 25), date(2025,12, 26)
+        ]
+    )
+
+    c = Calendar.union('US', 'UK')
+    union_nwds = c.non_working_days
+
+    c2 = Calendar.intersection('US', 'UK')
+    cross_nwds = c2.non_working_days
+
+    sofr_adjust = CalendarAdjustment(_replace = True,
+        name        = 'SOFR',
+        add_days    = [date(2019, 4, 4)]
+    )
+
+    ca = Calendar(name = 'US', adjusted_for = 'SOFR')
+    nwds_ca = ca.non_working_days

core_10x/manual_tests/ctor_update_bug.py

@@ -0,0 +1,58 @@
+from core_10x.traitable import RC, RC_TRUE, RT, T, Traitable
+
+
+class Cross(Traitable):
+    cross: str = RT(T.ID) // 'e.g., GBP/USD or CHF/JPY'
+
+    base_ccy: str = RT(T.ID_LIKE) // 'Base (left) currency'
+    quote_ccy: str = RT(T.ID_LIKE) // 'Quote (right) currency'
+
+    def cross_get(self) -> str:
+        return f'{self.base_ccy}/{self.quote_ccy}'
+
+    def cross_set(self, trait, cross: str) -> RC:
+        parts = cross.split('/')
+        assert len(parts) == 2
+        c1, c2 = parts
+        rc1 = self.set_value('base_ccy', c1)
+        rc2 = self.set_value('quote_ccy', c2)
+        if rc1 and rc2:
+            return RC_TRUE
+        rc = RC(True)
+        rc <<= rc1
+        rc <<= rc2
+        return rc
+
+
+if __name__ == '__main__':
+    cross = 'A/B'
+
+    # -- Does not complain that non-ID traits can't be set during initialization.
+    # -- Note the T.ID_LIKE declaration!
+    c1 = Cross(base_ccy='A', quote_ccy='B')
+
+    # -- Apparently, after setting base_ccy and quote_ccy, the cross is correct, but the id is wrong!
+    # -- This is also fixed by the T.ID_LIKE declaration!
+    c2 = Cross(_replace=True, base_ccy='A', quote_ccy='B')
+    assert c2.id().value == 'A/B'
+
+    # #-- Case 1 - doesn't allow to create the second instance claiming it sets non-ID traits
+    # c1 = Cross(cross = cross)
+    # try:
+    #     c2 = Cross(cross = cross)
+    # except Exception as e:
+    #     print(e)
+    #
+    # #-- Case 2 - update is "working" exactly as the ctor
+    # try:
+    #     c3 = Cross.update(cross = cross)
+    # except Exception as e:
+    #     print(e)
+    #
+    # #-- Case 3: update complains about not setting at least one ID-trait - WRONG!
+    # try:
+    #     c4 = Cross.update(base_ccy = 'A', quote_ccy = 'B')
+    # except Exception as e:
+    #     print(e)
+    #
+    # #-- Case 4:

core_10x/manual_tests/debug_graph_on.py

@@ -0,0 +1,17 @@
+from datetime import date
+
+from infra_10x.mongodb_store import MongoStore
+
+from core_10x.code_samples.person import Person
+from core_10x.exec_control import GRAPH_ON
+
+if __name__ == '__main__':
+
+    with MongoStore.instance(hostname ='localhost', dbname='test', username='', password=''):
+        p = Person(first_name = 'Ilya', last_name = 'Pevzner')
+        p.dob = date(1971,7,1)
+        p.save()
+        p.dob = date(1971,7,3)
+        assert p.dob== date(1971,7,3)
+        with GRAPH_ON():
+            assert p.dob == date(1971,7,3)  # FIX: fails here!

core_10x/manual_tests/debug_graphoff_inside_graph_on.py

@@ -0,0 +1,28 @@
+from core_10x.code_samples.person import Person
+from core_10x.exec_control import BTP, GRAPH_OFF, GRAPH_ON
+from core_10x.xnone import XNone
+
+
+def test():
+    p = Person(first_name = 'Sasha', last_name = 'Davidovich')
+    #p.weight_lbs = 100
+    #assert p.weight == 100
+
+    p.invalidate_value(p.T.weight)
+    p.invalidate_value(p.T.weight_lbs)
+
+    assert p.weight is XNone
+
+if __name__ == '__main__':
+
+    with GRAPH_ON(convert_values = True, debug = True):
+        print(BTP.current().flags())
+        test()
+        with GRAPH_OFF():
+            test()
+
+    p = Person(first_name = 'Sasha', last_name = 'Davidovich')
+    with GRAPH_ON(convert_values = True):
+        p.weight_lbs = 'a'
+
+

core_10x/manual_tests/enum_bits_test.py

@@ -0,0 +1,17 @@
+from core_10x.named_constant import EnumBits
+
+
+class STATE(EnumBits):
+    RESERVED    = ()
+    RUNTIME     = ()
+    ID          = ()
+
+class XSTATE(STATE):
+    EXPENSIVE   = ()
+
+if __name__ == '__main__':
+    r = STATE.RUNTIME | STATE.RESERVED | STATE.ID
+
+    r2 = r - STATE.RESERVED
+
+    e = XSTATE.EXPENSIVE

core_10x/manual_tests/env_vars_trivial_test.py

@@ -0,0 +1,12 @@
+
+if __name__ == '__main__':
+    from datetime import date
+
+    from core_10x.environment_variables import EnvVars, XDateTime
+
+    d = date.today()
+    print(XDateTime.date_to_str(d))
+
+    df_10x = EnvVars.date_format
+    print(XDateTime.date_to_str(d))
+

core_10x/manual_tests/existing_traitable.py

@@ -0,0 +1,33 @@
+if __name__ == '__main__':
+    from core_10x.code_samples.person import Person
+
+    ppl_stored = [
+        Person(last_name='Davidovich', first_name='Sasha', weight_lbs=170, _replace=True),
+        Person(last_name='Pevzner', first_name='Ilya', weight_lbs=200, _replace=True),
+        Person(last_name='Lesin', first_name='Alex', weight_lbs=190, _replace=True),
+        Person(last_name='Smith', first_name='John', weight_lbs=180, _replace=True),
+    ]
+
+    id_traits = ('last_name', 'first_name')
+    existing_id_traits = [{name: p.get_value(name) for name in id_traits} for p in ppl_stored]
+
+    ppl_found = [Person.existing_instance(**id_values) for id_values in existing_id_traits]
+
+    assert ppl_found == ppl_stored
+
+    p1 = Person.existing_instance(last_name='Smith', first_name='John')
+    assert p1
+
+    p2 = Person.existing_instance(last_name='Smith', first_name='Josh', _throw=False)
+    assert not p2
+
+    id1 = ppl_found[0].id()
+    p3 = Person.existing_instance_by_id(_id=id1)
+
+    id1_val = id1.value
+    p4 = Person.existing_instance_by_id(_id_value=id1_val)
+    assert p3 == p4
+
+    id2_val = 'Smith|Josh'
+    p5 = Person.existing_instance_by_id(_id_value=id2_val, _throw=False)
+    assert not p5

core_10x/manual_tests/k10x_test1.py

@@ -0,0 +1,13 @@
+from py10x_core import NODE_TYPE, BasicNode
+
+from core_10x.xnone import XNone  # -- keep
+
+n1 = BasicNode.create(NODE_TYPE.BASIC_GRAPH)
+n1.assign('whatever')
+
+n2 = BasicNode.create(NODE_TYPE.BASIC_GRAPH)
+n2.set(100)
+
+n2.add_parent(n1)
+
+n2.set('Asya')

core_10x/manual_tests/named_constant_test.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+from math import exp, log
+
+from core_10x.named_constant import (
+    Enum,
+    EnumBits,
+    ErrorCode,
+    NamedConstant,
+    NamedConstantTable,
+    NamedConstantValue,
+    Nucleus,
+)
+
+
+class COLOR(NamedConstant, lowercase_values = True):
+    RED         = ()
+    BLUE        = ()
+    GREEN       = ()
+    LIGHTGREEN  = ()
+
+class XCOLOR(COLOR):
+    BLACK       = ()
+    WHITE       = ()
+
+class WEIGHT(NamedConstant):
+    LB  = ()
+    KG  = ()
+    CT  = ()
+
+class COMPOUNDING(NamedConstant):
+    SIMPLE      = ()
+    ANNUAL      = ()
+    SEMI_ANNUAL = ()
+    QUARTERLY   = ()
+    MONTHLY     = ()
+    WEEKLY      = ()
+    CONTINUOUS  = ()
+
+class COMPOUND_TRANSFORM(NamedConstant):
+    RATE_TO_ACCRUAL = ()
+    ACCRUAL_TO_RATE = ()
+
+
+COLOR_WEIGHT = NamedConstantValue(
+    COLOR,
+    RED         = 10,
+    BLUE        = 20,
+    GREEN       = 30,
+    LIGHTGREEN  = 35
+)
+
+COLOR_CODE = NamedConstantValue(
+    COLOR,
+    RED         = 1.0,
+    BLUE        = 11.1,
+    GREEN       = 12.2,
+    LIGHTGREEN  = 13.3
+)
+
+COMPOUNDING_TRANSFORM_TABLE = NamedConstantTable(COMPOUNDING, COMPOUND_TRANSFORM,
+   #               RATE_TO_ACCRUAL                             ACCRUAL_TO_RATE
+   SIMPLE      = ( lambda t, r:  1. + r * t,                   lambda t, a: (a - 1.) / t                       if t else 0. ),
+   ANNUAL      = ( lambda t, r: (1. + r      ) **  t,          lambda t, a:  a ** (1. / t)       - 1.          if t else 0. ),
+   SEMI_ANNUAL = ( lambda t, r: (1. + r /  2.) ** (t *  2.),   lambda t, a: (a ** (1. / t /  2.) - 1.) * 2.    if t else 0. ),
+   QUARTERLY   = ( lambda t, r: (1. + r /  4.) ** (t *  4.),   lambda t, a: (a ** (1. / t /  4.) - 1.) * 4.    if t else 0. ),
+   MONTHLY     = ( lambda t, r: (1. + r / 12.) ** (t * 12.),   lambda t, a: (a ** (1. / t / 12.) - 1.) * 12.   if t else 0. ),
+   WEEKLY      = ( lambda t, r: (1. + r / 52.) ** (t * 52.),   lambda t, a: (a ** (1. / t / 52.) - 1.) * 52.   if t else 0. ),
+   CONTINUOUS  = ( lambda t, r: exp(r * t),                    lambda t, a: log(a) / t ),
+)
+
+class EVEN_NUMBER(Enum, step = 2):
+    ZERO    = ()
+    TWO     = ()
+    FOUR    = ()
+
+class A_PROBLEM(ErrorCode):
+    DOES_NOT_EXIST  = 'Entity {cls}.{id} does not exist'
+    REV_CONFLICT    = 'Entity {cls}.{id} - revision {rev} is outdated'
+    SAVE_FAILED     = 'Failed to save entity {cls}.{id}'
+
+class ICON(EnumBits):
+    FILE = ('material/file',)
+    STOP = ('material/stop',)
+
+class TEXT_ALIGN(NamedConstant):
+    s_vertical = 0xf << 4
+
+    LEFT = 1
+    CENTER = 6
+    RIGHT = 11
+    TOP = LEFT << 4
+    V_CENTER = CENTER << 4
+    BOTTOM = RIGHT << 4
+
+    @classmethod
+    def from_str(cls, s: str) -> TEXT_ALIGN:
+        return super().from_str(s.upper()) # type: ignore[return-value]
+
+    def rio_attr(self) -> str:
+        return 'align_y' if self.value & self.s_vertical else 'align_x'
+
+    def rio_value(self) -> float:
+        return ((self.value >> 4 if self.value & self.s_vertical else self.value)-1) /10
+
+if __name__ == '__main__':
+    from core_10x.manual_tests.named_constant_test import COLOR, XCOLOR
+
+    print( COLOR.LIGHTGREEN.value)
+    sgreen = Nucleus.serialize_any(COLOR.GREEN, False)
+    swhite = Nucleus.serialize_any(XCOLOR.WHITE, False)
+    print(sgreen)
+    print(swhite)
+
+    assert Nucleus.deserialize_dict(swhite) is XCOLOR.WHITE
+    #print(COLOR_WEIGHT.GREEN, COLOR_CODE.GREEN) #TODO: FIX!
+
+    print(A_PROBLEM.REV_CONFLICT(cls = 'XXX', id = '145678', rev = '3'))
+
+    x,y = TEXT_ALIGN.from_str('left'), TEXT_ALIGN.from_str('v_center')
+    print( x, y, x.rio_attr(), y.rio_attr(), x.value, y.value, x.rio_value(), y.rio_value() )

core_10x/manual_tests/nucleus_trivial_test.py

@@ -0,0 +1,42 @@
+if __name__ == '__main__':
+    from datetime import date, datetime
+
+    from core_10x.named_constant import Enum, EnumBits
+    from core_10x.nucleus import Nucleus
+
+    class COLOR(Enum):
+        RED     = ()
+        GREEN   = ()
+        BLUE    = ()
+
+    class STATE(EnumBits):
+        RUNNING     = ()
+        SUSPENDED   = ()
+        ABORTED     = ()
+
+    data = {
+        bool:           False,
+        int:            100,
+        type(None):     None,
+        float:          1e-6,
+        complex:        complex(5.43, -7.1),
+        str:            'plain text',
+        datetime:       datetime.now(),
+        date:           date.today(),
+        list:           [ 10, 5.1, 'label', datetime.now(), date(2020, 1, 1), ['a', 100], dict( a = 1, b = 2) ],
+        tuple:          ( 10, 5.1, 'label', datetime.now(), date(2020, 1, 1), ['a', 100], dict( a = 1, b = 2) ),
+        dict:           { 1: 1, 'a': 'abc', 'b': [ 10, 100. ], 'c': dict(x = -100, y = -200) },
+        COLOR:          COLOR.GREEN,
+        STATE:          STATE.RUNNING | STATE.SUSPENDED
+    }
+
+    serialized_data     = { dt: Nucleus.serialize_any(v, False) for dt, v in data.items() }
+    deserialized_data   = { dt: Nucleus.deserialize_any(v, None) for dt, v in serialized_data.items() }
+
+    for dt, value in data.items():
+        s_value = deserialized_data.get(dt, deserialized_data)
+        if s_value is deserialized_data:
+            print(f'{dt} is missing')
+        else:
+            if s_value != value:
+                print(f'{dt}:\nexpected\n{value}\ngot\n{s_value}')

core_10x/manual_tests/polars_test.py

@@ -0,0 +1,14 @@
+import polars as pl
+from infra_10x.mongodb_store import MongoStore
+
+from core_10x.code_samples.person import Person
+
+if __name__=='__main__':
+    with MongoStore.instance(hostname ='localhost', dbname='test', username='', password=''):
+        objs = Person.load_many()
+        df = pl.DataFrame([o.serialize_object() for o in objs])
+        print(df)
+        df.write_database('people',connection="postgresql:///postgres?host=/tmp",engine='adbc',if_table_exists='replace')
+
+        df2 = pl.read_database('people',connection="postgresql:///postgres?host=/tmp",engine='adbc')
+        print(df2)

core_10x/manual_tests/py_class_test.py

@@ -0,0 +1,4 @@
+from core_10x.nucleus import Nucleus
+from core_10x.py_class import PyClass
+
+ed = PyClass.find_related_class(Nucleus, 'ui10x', 'Editor')

core_10x/manual_tests/rc_test.py

@@ -0,0 +1,42 @@
+from core_10x.rc import RC, RC_TRUE, Enum, ErrorCode
+
+
+class CONDITION(Enum):
+    BEGIN   = ()
+    MAIN    = ()
+    END     = ()
+
+class A_PROBLEM(ErrorCode):
+    DOES_NOT_EXIST  = 'Entity {cls}.{id} does not exist'
+    REV_CONFLICT    = 'Entity {cls}.{id} - revision {rev} is outdated'
+    SAVE_FAILED     = 'Failed to save entity {cls}.{id}'
+
+rc = RC_TRUE
+print(rc)
+
+try:
+    rc.add_error('error')
+    raise AssertionError('must have thrown')
+except Exception as e:
+    print(str(e))
+
+rc = RC(CONDITION.MAIN, dict( a = 1, b = 1))
+print(rc)
+
+rc.add_data([100, 200])
+print(rc)
+
+rc1 = RC(False, 'just an error')
+print(rc1)
+try:
+    rc1.throw()
+except Exception as e:
+    print(str(e))
+
+rc = RC(A_PROBLEM.REV_CONFLICT, dict(cls = 'XXX', id = '123456', rev = 3))
+print(rc)
+
+rc = RC(True)
+rc.add_error('First error')
+rc.add_error(rc1)
+print(rc)

core_10x/manual_tests/rdate_test.py

@@ -0,0 +1,12 @@
+if __name__ == '__main__':
+
+       from core_10x.rdate import RDate
+
+
+       r = RDate('3M')
+       r2 = RDate('10Y')
+
+       c = r.conversion_freq_multiplier(r2.freq)
+
+       x = r.equate_freq(r2)
+

core_10x/manual_tests/reference_serialization_bug.py

@@ -0,0 +1,19 @@
+from py10x_core import BTraitableProcessor
+
+from core_10x.code_samples.person import Person
+from core_10x.trait_definition import T
+
+
+class MarriedPerson(Person):
+    spouse: Person = T()
+
+
+if __name__ == '__main__':
+    from core_10x.manual_tests.reference_serialization_bug import MarriedPerson
+
+    with BTraitableProcessor.create_root():
+        MarriedPerson(first_name='Ilya', last_name='Pevzner', spouse=MarriedPerson(first_name='Tatiana', last_name='Pevzner'), _replace=True).save(
+            save_references=True
+        )
+
+    assert type(MarriedPerson(first_name='Ilya', last_name='Pevzner').spouse) is MarriedPerson

core_10x/manual_tests/resource_trivial_test.py

@@ -0,0 +1,10 @@
+import keyring
+
+from core_10x.ts_store import TsStore
+
+db1 = TsStore.instance_from_uri('mongodb://localhost:27017/mkt_data')
+print(db1.collection_names())
+
+user = 'admin'
+db2 = TsStore.instance_from_uri(f'mongodb://{user}:{keyring.get_password("mongodb_local", user)}@localhost:27018/test')
+print(db2.collection_names())

core_10x/manual_tests/store_uri_test.py

@@ -0,0 +1,6 @@
+from core_10x.code_samples.person import Person
+
+p = Person(first_name = 'John', last_name = 'Doe')
+p.save()
+
+ppl = Person.load_many()

core_10x/manual_tests/trait_definition_test.py

@@ -0,0 +1,19 @@
+import inspect
+
+from core_10x.trait_definition import T
+
+
+class X:
+    user_id: str    = T(T.ID | T.RUNTIME)   #, Ui('User ID', tip = 'OS login', min_width = 50))
+    age: int        = T()
+    #model: any      = RT()
+
+
+annotations = inspect.get_annotations(X)
+
+#dir = TraitDefinition.dir( X.__dict__, annotations, {} )
+
+#tdef: TraitDefinition = dir['user_id']
+
+# t = Trait(tdef)
+# t2 = copy.deepcopy(t)

core_10x/manual_tests/trait_filter_test.py

@@ -0,0 +1,15 @@
+from core_10x.code_samples.person import Person
+from core_10x.exec_control import CACHE_ONLY
+from core_10x.trait_filter import BETWEEN, NE, OR, f
+
+if __name__ == '__main__':
+    with CACHE_ONLY():
+        p = Person(first_name = 'Sasha', last_name = 'Davidovich')
+
+    r = OR(
+        f(age=BETWEEN(50, 70), first_name=NE('Sasha')),
+        f(age=17)
+    )
+
+    print(r.prefix_notation())
+    print(r.eval(p))