py10x-universe 0.1.3__py3-none-any.whl

core_10x/manual_tests/trait_flag_modification_test.py

@@ -0,0 +1,42 @@
+from core_10x.trait_definition import M
+from core_10x.traitable import T, Traitable
+from core_10x.xnone import XNone
+
+
+class X(Traitable):
+    x: int = T(T.ID | T.RUNTIME)
+    v: int = T(T.ID | T.RUNTIME)
+
+    def v_get(self):
+        return self.x + 1
+
+
+class Y(X):
+    v: int = M(flags=(None, T.ID), default=3)
+
+
+class Z(Y):
+    v: float = M(default=XNone)
+
+    def v_get(self):
+        return self.x + 3
+
+
+if __name__ == '__main__':
+    x = X(x=1)
+    y = Y(x=1)
+    z = Z(x=1)
+    print(x, x.v)
+    print(y, y.v)
+    print(z, z.v)
+
+    print(getattr(x, '__dict__', 'n/a'))
+    print(getattr(y, '__dict__', 'n/a'))
+    print(getattr(z, '__dict__', 'n/a'))
+
+
+# NOTES:
+# current classes trait.get override base classes trait_get
+# current classes trait_get, overrides base classes trait.get, except if there is a trait modification  in this class, in which case, it needs to reset trait.get
+# en error is thrown if trait_get and trait.get are defined in the same class (or there is a trait modification that does nto reset trait.get)
+# TODO: should trait.default should work just as trait.get?

core_10x/manual_tests/trait_modification_bug.py

@@ -0,0 +1,26 @@
+from core_10x.traitable import RT, M, Traitable
+
+
+class A(Traitable):
+    funny_message: str  = RT()
+
+    def funny_message_get(self):
+        dt = self.T.funny_message.data_type
+        return f'{dt}'
+
+class B(A):
+    funny_message:int   = M()
+
+class C(A):
+    funny_message:float   = M()
+
+    def funny_message_get(self):
+        dt = self.T.funny_message.data_type
+        return f'{dt}'
+
+if __name__ == '__main__':
+    a = A()
+    b = B()
+    c = C()
+
+    print(f'A: {a.funny_message}; B: {b.funny_message}; C: {c.funny_message}')

core_10x/manual_tests/traitable_as_of_test.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from datetime import date, datetime
+
+import pytest
+from infra_10x.mongodb_store import MongoStore
+from typing_extensions import Self
+
+from core_10x.code_samples.person import Person
+from core_10x.exec_control import BTP, CACHE_ONLY, GRAPH_OFF, GRAPH_ON, INTERACTIVE
+from core_10x.rc import RC, RC_TRUE
+from core_10x.traitable import AsOfContext, T
+
+
+class MarriedPerson(Person):
+    spouse: Self = T()
+
+    def spouse_set(self, trait, spouse) -> RC:
+        self.raw_set_value(trait, spouse)
+        if spouse:
+            spouse.raw_set_value(trait, self)
+        return RC_TRUE
+
+
+if __name__ == '__main__':
+    with MongoStore.instance(hostname='localhost', dbname='traitable_history_test'):
+        MarriedPerson.delete_collection()
+        MarriedPerson.s_history_class.delete_collection()
+
+        with BTP.create_root():
+            # Create and save a person
+            person = MarriedPerson(first_name='Alyssa', last_name='Lees', dob=date(1985, 7, 5), _replace=True)
+            person.spouse = MarriedPerson(first_name='James', last_name='Bond', dob=date(1985, 7, 5), _replace=True)
+            person.spouse.save()
+            person.save()
+
+            ts = datetime.utcnow()
+
+            # Update and save again
+            person.dob = date(1985, 7, 6)
+            person.spouse.dob = date(1985, 7, 6)
+            person.save(save_references=True).throw()
+
+            person_id = person.id()
+            print(person.serialize_object())
+
+        with CACHE_ONLY():
+            assert not MarriedPerson.existing_instance_by_id(person_id, _throw=False)
+
+        for ctx in (
+            INTERACTIVE,
+            GRAPH_ON,
+            GRAPH_OFF,
+        ):
+            for as_of in (
+                ts,
+                None,
+            ):
+                with ctx():
+                    person1 = MarriedPerson(person_id)
+                    assert person1.dob == date(1985, 7, 6)
+
+                    person_as_of = MarriedPerson.as_of(person_id, as_of_time=ts)
+
+                    with AsOfContext([MarriedPerson], as_of_time=as_of):
+                        with pytest.raises(RuntimeError, match=r'MarriedPerson/Alyssa|Lees: object not usable - origin cache is not reachable'):
+                            _ = person1.dob
+
+                        with pytest.raises(RuntimeError, match=r'MarriedPerson/Alyssa|Lees: object not usable - origin cache is not reachable'):
+                            _ = person_as_of.dob
+
+                        person2 = MarriedPerson(person_id)
+                        assert person2.dob == (date(1985, 7, 5 + (as_of is None)))
+                        assert person2.spouse.dob == (date(1985, 7, 5 + (as_of is None)))
+
+                    assert person1.spouse.dob == date(1985, 7, 6)
+                    assert person_as_of.dob == date(1985, 7, 5)
+
+                    assert person_as_of.spouse.dob == date(1985, 7, 6)  # note - since no AsOfContext was used, nested objects are not loaded "as_of".
+
+                    with pytest.raises(RuntimeError, match=r'MarriedPerson/Alyssa|Lees: object not usable - origin cache is not reachable'):
+                        _ = person2.dob

core_10x/manual_tests/traitable_heir_test.py

@@ -0,0 +1,39 @@
+from core_10x.traitable_heir import TraitableHeir, T, RT
+
+class Conventions(TraitableHeir):
+    mkt_name: str   = T(T.ID)
+
+    days_to_settle: int = T()
+
+c_dir = dict(Conventions.s_dir)
+
+class XConventions(Conventions):
+    days_to_settle_twice: int   = RT()
+
+    def days_to_settle_twice_get(self):
+        return 2*self.days_to_settle
+
+c_dir2 = Conventions.s_dir
+
+if __name__ == '__main__':
+    from core_10x.manual_tests.traitable_heir_test import Conventions, XConventions
+
+    mkt_name = 'WTI NYMEX'
+    c = Conventions(mkt_name = mkt_name)
+    c.days_to_settle = 2
+    print(c.days_to_settle)
+
+    loc = 'ICE'
+    mkt_name2 = f'{mkt_name} {loc}'
+    c2 = Conventions(mkt_name = mkt_name2)
+    c2._grantor = c
+
+    print(c2.days_to_settle)
+
+    c.days_to_settle = 3
+    print(c2.days_to_settle)
+
+    xc = XConventions(mkt_name = mkt_name)
+    xc._grantor = c
+
+    print(xc.days_to_settle_twice)

core_10x/manual_tests/traitable_history_test.py

@@ -0,0 +1,41 @@
+from datetime import date, datetime
+
+from infra_10x.mongodb_store import MongoStore
+
+from core_10x.code_samples.person import Person
+
+if __name__ == '__main__':
+    with MongoStore.instance(hostname='localhost', dbname='traitable_history_test'):
+        Person.delete_collection()
+        Person.s_history_class.delete_collection()
+
+        # Create and save a person
+        person = Person(first_name='Alyssa', last_name='Lees', dob=date(1985, 7, 5), _replace=True)
+        person.save()
+
+        ts = datetime.utcnow()
+
+        # Update and save again
+        person.dob = date(1985, 7, 6)
+        person.save()
+
+        # Check history
+        history = Person.history()
+
+        # Verify server-side fields
+        for entry in history:
+            print(f'  - Revision {entry["_traitable_rev"]}: {entry["first_name"]} (dob: {entry["dob"]})')
+            print(f'    _who: {entry["_who"]}, _at: {entry["_at"]}')
+
+        assert person.dob == date(1985, 7, 6)
+
+        print(Person.restore(person.id(), timestamp=ts))
+        assert person.dob == date(1985, 7, 5)
+
+        person.reload()
+        assert person.dob == date(1985, 7, 6)
+
+        print(Person.restore(person.id(), timestamp=ts, save=True))
+        assert person.dob == date(1985, 7, 5)
+        person.reload()
+        assert person.dob == date(1985, 7, 5)

core_10x/manual_tests/traitable_serialization_test.py

@@ -0,0 +1,54 @@
+from datetime import date
+
+from core_10x.named_constant import NamedConstant
+from core_10x.traitable import THIS_CLASS, AnonymousTraitable, T, Traitable
+
+
+class MARRITAL_STATUS(NamedConstant):
+    SINGLE      = ()
+    MARRIED     = ()
+    DIVORCED    = ()
+    WIDOWED     = ()
+
+class Address(AnonymousTraitable):
+    street: str     = T()
+    cszip: str      = T()
+
+class Person(Traitable):
+    ssn: str                            = T(T.ID)
+
+    dob: date                           = T()
+    name: str                           = T()
+    gender: bool                        = T()
+    marrital_status: MARRITAL_STATUS    = T()
+
+    spouse: THIS_CLASS                  = T()
+    children: list                      = T()
+
+    address: Address                    = T(T.EMBEDDED)
+
+if __name__ == '__main__':
+    address = Address(street="145 Austin Dr", cszip="Burlington, VT 05401")
+            
+    woman       = Person(ssn = '008-59-6666', name = 'Alice Smith',     dob = date(1972, 8, 21), _replace = True)
+    daughter    = Person(ssn = '008-77-7777', name = 'Ann Smith',       dob = date(1997, 6, 17), _replace = True)
+    son         = Person(ssn = '008-99-5555', name = 'Nathan Smith',    dob = date(1999, 9, 23), _replace = True)
+
+
+    man     = Person(_replace = True,
+        ssn     = '009-87-4444',
+        name    = 'John Smith',
+        gender  = True,
+        dob     = date(1965, 2, 3),
+        marrital_status = MARRITAL_STATUS.MARRIED,
+        spouse = woman,
+        children = [daughter, son],
+        address = address
+    )
+
+    ss = man.serialize_object()
+
+    man2 = Person.deserialize_object(Person.s_bclass, None, ss)
+
+    print(man == man2)
+

core_10x/manual_tests/traitable_trivial_test.py

@@ -0,0 +1,71 @@
+from datetime import date, datetime
+
+from core_10x.code_samples.person import Person
+from core_10x.traitable import T, Traitable, Trait, BTraitFlags
+
+
+class Event(Traitable):
+    at: datetime = T()
+
+class Dummy(Traitable):
+    name: str       = T(T.ID)
+    payload: float  = T(3.1415)
+
+    def name_get(self):
+        return 'AMD'
+
+if __name__ == '__main__':
+    from core_10x.manual_tests.traitable_trivial_test import Dummy, Event
+
+    e = Event()
+    print(e.id_value())
+    rc = e.set_values(at = datetime.now())
+
+    p = Person(first_name = 'Sasha', last_name = 'Davidovich')
+    #print(p.id(), p.full_name)
+
+    # p.full_name = 'Ilya Pevzner'
+    # print(p.full_name)
+    # print(f'first name = {p.first_name}; last name = {p.last_name}')
+
+    p.dob = date(1963, 5, 14)
+    #p.age = 61
+
+    #print(f'older_than(25) = {p.older_than(25)}')
+
+    #try:
+    #    p.older_than = False
+    #except TypeError as ex:
+    #    print(ex)
+
+    #p.older_than = trait_value(False, 25)   #-- set with args!
+    #print(f'older_than(25) = {p.older_than(25)}')
+
+    #print(p.from_any(p.T.older_than(), 'False'))
+
+    p2 = Person(first_name = 'Sasha', last_name = 'Davidovich')
+    #assert p2.age == 61
+    print(p2.age)
+
+    #print(Nucleus.serialize_any(p,False))
+
+    name = 'AMD'
+    d = Dummy()
+    assert d.name == name
+    d.payload = 100.
+
+    d2 = Dummy(name = name)
+    assert d2.name == d.name
+
+    dx = Dummy.existing_instance(name = name)
+    assert dx.payload == 100.
+
+    dx2 = Dummy.existing_instance()
+    assert dx2.payload == 100.
+
+    fn_t    = Person.trait('first_name')
+    wqu_t   = Person.trait('weight_qu')
+    w_t     = Person.trait('weight')
+
+    print(f'first_name = {fn_t.has_custom_getter()}; weight_qu = {wqu_t.has_custom_getter()}; weight = {w_t.has_custom_getter()}')
+

core_10x/manual_tests/trivial_graph_test.py

@@ -0,0 +1,16 @@
+from core_10x.exec_control import CACHE_ONLY
+
+if __name__ == '__main__':
+    from core_10x.code_samples.person import Person
+    from core_10x.exec_control import GRAPH_ON
+
+    with (GRAPH_ON(convert_values = True, debug = True),CACHE_ONLY()):
+        p = Person(first_name = 'John', last_name = 'Smith')
+
+        print(p.full_name)
+        p.dob = '19630514'
+        p.weight_lbs = 170
+
+        ser = p.serialize_object()
+
+    print(p,ser)

core_10x/manual_tests/ts_class_association_test.py

@@ -0,0 +1,64 @@
+from core_10x.code_samples.person import Person
+from core_10x.traitable import NamedTsStore, T, Traitable, TsClassAssociation, TsStore
+
+
+class Dummy1(Traitable):
+    text: str   = T(T.ID)
+
+class Dummy2(Traitable):
+    text: str   = T(T.ID)
+
+class Dummy3(Dummy2):
+    ...
+
+if __name__ == '__main__':
+    from core_10x.environment_variables import EnvVars
+    from core_10x.manual_tests.ts_class_association_test import Dummy1, Dummy2, Dummy3
+    from core_10x.py_class import PyClass
+
+    #-- 0) Create a Person instance and save - must go to the main TsStore - no association
+    p = Person(first_name = 'A', last_name = 'B')
+    p.save().throw()
+    db = TsStore.instance_from_uri(EnvVars.main_ts_store_uri)
+    with db:
+        assert Person.exists_in_store(p.id()), f'Person must have been stored to {EnvVars.main_ts_store_uri}'
+
+    #-- 1) Create NamedTsStore objects referring to all available extra TsStores for Class Associations
+    extra_uris = dict(
+        dummy1 = 'mongodb://localhost/dummy1',
+        dummy2 = 'mongodb://localhost/dummy2',
+    )
+    for name, uri in extra_uris.items():
+        #store = TsStore.instance_from_uri(uri)
+        ns = NamedTsStore(_replace = True,
+            logical_name    = name,
+            uri             = uri,
+        )
+        ns.save().throw()
+
+    #-- 2) Create Class Association for Dummy1 - explicit association for the class
+    TsClassAssociation(_replace = True,
+        py_canonical_name   = PyClass.name(Dummy1),
+        ts_logical_name     = 'dummy1',
+    ).save().throw()
+
+    #-- 3) Create Class Association for Dummy2 - explicit association for the class
+    TsClassAssociation(_replace = True,
+        py_canonical_name   = PyClass.name(Dummy2),
+        ts_logical_name     = 'dummy2',
+    ).save().throw()
+
+    #-- 4) Create an instance of Dummy1 and save it - must go to dummy1 TsStore
+    d1 = Dummy1(text = 'hello dummy1')
+    d1.save().throw()
+    db1 = TsStore.instance_from_uri(extra_uris['dummy1'])
+    with db1:
+        assert Dummy1.exists_in_store(d1.id()), f'Dummy1 must have been associated with {extra_uris["dummy1"]}'
+
+    #-- 5) Create an instance of Dummy3 and save it - must go to dummy2 TsStore because it deriuves from Dummy2 which is associated with dummy2 TsStore
+    d3 = Dummy3(text = 'hello dummy3')
+    d3.save().throw()
+    db2 = TsStore.instance_from_uri(extra_uris['dummy2'])
+    with db2:
+        assert Dummy3.exists_in_store(d3.id()), f'Dummy3 must have been associated with {extra_uris["dummy2"]}'
+

core_10x/manual_tests/ts_trivial_test.py

@@ -0,0 +1,35 @@
+if __name__ == '__main__':
+    from core_10x.code_samples.person import Person
+
+    to_save = True
+
+
+    #print(db.collection_names())
+
+    #Person.collection().delete('Sasha|Davidovich')
+    if to_save:
+        p = Person(first_name = 'Sasha', last_name = 'Davidovich')
+        p.weight_lbs=200
+        rev = p.save()
+
+    else:
+        p = Person(first_name = 'Sasha', last_name = 'Davidovich')
+        p.weight_lbs=200
+
+        print(p.age)
+
+        p.age = 61
+        rev = p.save()
+        print(p.age)
+
+        p.age = -10
+        print(p.age)
+
+        p.reload()
+        print(p.age)
+
+
+
+
+
+