anson.py3 0.1.0__py3-none-any.whl

anson/io/odysz/anson/x/__init__.py

@@ -0,0 +1,10 @@
+
+class AnsonException:
+    type = "io.odysz.ansons.x.AnsonException"
+    excode = 0
+    err = ""
+
+    def __init__(self, excode: int, template: str, *param: object):
+        super().__init__()
+        self.excode = excode
+        self.err = template if param is None else template.format(param)

anson/io/odysz/ansons.py

@@ -0,0 +1,231 @@
+import importlib
+import sys
+from dataclasses import dataclass, fields, MISSING, Field
+
+import json
+from numbers import Number
+from typing import TypeVar, List, Dict, get_origin, get_args, ForwardRef, Type, Any, Union, Optional
+
+from .common import Utils
+
+TAnson = TypeVar('TAnson', bound='Anson')
+
+java_src_path: str = ''
+
+@dataclass
+class Anson(dict):
+    enclosinguardtypes = set()
+    
+    __type__: str
+    '''ansons.antson.Anson'''
+
+    def __init__(self):
+        super().__init__()
+        t = type(self)
+        self.__type__ = f'{t.__module__}.{t.__name__}'
+
+    def __setitem__(self, key, value):
+        self.__dict__[key] = value
+
+    def __getitem__(self, key):
+        return self.__dict__[key]
+
+    @dataclass()
+    class Trumpfield():
+        '''
+        {name, type, isAnson, antype, factory}
+        '''
+        name: str
+        fieldtype: type
+        origintype: type
+        isAnson: bool
+        elemtype: type
+        antype: str
+        factory: any
+
+    @staticmethod
+    def fields(instance) -> dict[str, Trumpfield]:
+        _FIELDS = '__dataclass_fields__' # see dataclasses.fields()
+        fds = getattr(type(instance), _FIELDS)
+
+        def get_mandatype(t: TypeVar):
+            if isinstance(t, type(Optional[Any])):
+                return get_args(t)[0]
+            elif sys.version_info > (3,10,0) and isinstance(t, type(Any | None)):
+                print(get_args(t))
+                for m in get_args(t):
+                    if m is not type(None):
+                        return m
+            return t
+
+        def figureNormalType(f: Field) -> tuple:
+            try: isAnson = issubclass(f.type, Anson) or isinstance(f.type, Anson)
+            except: isAnson = False
+            return f, get_origin(f.type), get_args(f.type), isAnson
+
+        def figure_list(f: Field, guardTypes: set[Anson]):
+            if not isinstance(f.type, list):
+                raise Exception("Not here")
+
+            ot = list
+
+            try:
+                et = f.type[0].__bound__ if len(f.type[0]) > 0 and isinstance(f.type[0], TypeVar) else get_args(f.type)
+                et = et.__evaluate(globals(), locals(), recursive_guard=guardTypes) if isinstance(et, ForwardRef) else et
+                et = (et)
+            except: et = ()
+            return f, ot, et, False
+
+        def figure_dict(f: Field, envType: set[Anson]) -> tuple:
+            pass
+
+        def toTrump(fn: Field):
+            """
+            Simply & brutally figuring types. We only care about Anson types, the exceptional.
+            :param fn:
+            :return: TrumpField
+            """
+            f = fds[fn]
+            f.type = get_mandatype(f.type)
+
+            if isinstance(f.type, List):
+                f, ot, et, isAnson = figure_list(f, Anson.enclosinguardtypes)
+            elif isinstance(f.type, Dict):
+                f, ot, et, isAnson = figure_dict(f, Anson.enclosinguardtypes)
+            else:
+                f, ot, et, isAnson = figureNormalType(f)
+
+            return Anson.Trumpfield(
+                f.name, f.type,
+                ot, isAnson,
+                None if et is None or len(et) == 0 else et[0],
+                    'str' if f.type == str else
+                    'lst' if ot == list else
+                    'dic' if ot == dict else
+                    'num' if ot is None and issubclass(f.type, Number) else
+                    f.type if isAnson else
+                    'obj',
+                None if f.default_factory is MISSING else f.default_factory)
+
+        return {it: toTrump(it) for it in fds}
+
+    @staticmethod
+    def toList_(lst: list, elemtype: type, ind: int):
+        if elemtype is None or not issubclass(elemtype, Anson): return str(lst)
+        return '[\n' + ','.join([Anson.toBlock_(e, ind + 1) for e in lst]) + ']'
+
+    @staticmethod
+    def toDict_(dic: dict, elemtype: type, ind: int):
+        if elemtype is None or not issubclass(elemtype, Anson): return json.dumps(dic)
+        return '{\n' + ',\n'.join(' ' * (ind * 2 + 2) + Anson.toBlock_(dic[k], ind + 1) for k in dic) + ']'
+
+    def toBlock(self) -> str:
+        return self.toBlock_(0)
+
+    def toFile(self, path: str):
+        with open(path, 'w+') as jf:
+            jf.write(self.toBlock())
+
+    def toBlock_(self, ind: int) -> str:
+        myfds = self.fields(self)
+        s = ' ' * (ind * 2) + '{\n'
+        # incorrect if there is a ignored: lx = len(self.__dict__) - 1
+        has_prvious = False
+        for x, k in enumerate(self.__dict__):
+            if '__type__' == k:
+                if ind == 0:
+                    tp = str(self['__type__']).removeprefix(java_src_path+'.')
+                    if has_prvious: s += ',\n'
+                    s += f'  "type": "{tp}"'
+                    has_prvious = True
+                else: continue # later can figure out type by field's type
+            else:
+                if k not in myfds:
+                    Utils.warn("Field {0}.{1} is not defined in Anson, which is presenting in data object. Value ignored: {1}.",
+                               str(self['__type__']), k, self[k])
+                    continue
+                if has_prvious: s += ',\n'
+                s += f'{" " * (ind * 2 + 2)}"{k}": '
+                v = self[k]
+                s += 'null' if v is None or isinstance(v, Field) \
+                    else f'"{v}"' if isinstance(v, str) \
+                    else v.toBlock_(ind + 1) if myfds[k].isAnson \
+                    else Anson.toList_(v, myfds[k].elemtype, ind + 1) if myfds[k].antype == 'lst' \
+                    else Anson.toDict_(v, myfds[k].elemtype, ind + 1) if myfds[k].antype == 'obj' \
+                    else str(v)
+
+                has_prvious = True
+            # s += ',\n' if x != lx else '\n'
+        return s + ('\n' if has_prvious else '') + ' ' * (ind * 2) + '}'
+
+    @staticmethod
+    def from_dict(v: dict, eletype: type) -> dict:
+        if eletype is None: return v
+
+        d = {}
+        for k in v:
+            d[k] = Anson.from_obj(v[k], eletype)
+        return d
+
+    @staticmethod
+    def from_list(v: list, eletype: type) -> list:
+        if eletype is None: return v
+        return [Anson.from_obj(x, eletype) for x in v]
+
+    @staticmethod
+    def from_obj(obj: dict, typename: Union[str, type]) -> TAnson:
+        def getClass(_typ_: str):
+            parts = _typ_.split('.')
+            # if len(java_src_path) > 0:
+            #     parts.insert(0, java_src_path)
+            module = ".".join(parts[:-1])
+            m = __import__(module if module is not None else '__main__')
+            for comp in parts[1:]:
+                m = getattr(m, comp)
+            return m
+
+        anson = getClass(typename)() if isinstance(typename, str) else typename()
+
+        fds = Anson.fields(anson)
+        if '__type__' not in fds:
+            raise Exception(f'Class {type(anson)} has no field "__type__". Is it a subclass of Anson?')
+
+        for jsonk in obj:
+            k = '__type__' if jsonk == 'type' else jsonk
+            if k != '__type__' and k not in fds:
+                Utils.warn(f'Field ignored: {k}: {obj[k]}')
+                continue
+
+            # else [Anson.from_obj(x, 'str' if thefields[k].elemtype is None else thefields[k].elemtype) for x in obj[jsonk]] if thefields[k].antype == 'obj' else \
+            anson[k] = Anson.from_obj(obj[jsonk], fds[k].antype) if fds[k].isAnson \
+                    else Anson.from_dict(obj[jsonk], fds[k].elemtype) if fds[k].antype == 'obj'\
+                    else Anson.from_list(obj[jsonk], fds[k].elemtype) if fds[k].antype == 'lst' \
+                    else obj[jsonk]
+
+        return anson
+
+    @staticmethod
+    def from_json(jsonstr: str) -> TAnson:
+        obj = json.loads(jsonstr)
+        v = Anson.from_envelope(obj)
+        print(v, type(v))
+        return v
+
+    @staticmethod
+    def from_file(fp: str) -> TAnson:
+        with open(fp, 'r') as file:
+            obj = json.load(file)
+            return Anson.from_envelope(obj)
+
+    @classmethod
+    def java_src(cls, src_root: str = ''):
+        """
+        :param src_root: e. g. 'src'
+        """
+        global java_src_path
+        java_src_path = src_root
+
+    @classmethod
+    def from_envelope(cls, obj: dict):
+        return Anson.from_obj(obj,
+                '.'.join([java_src_path, obj['type']]) if len(java_src_path) > 0 else obj['type'])

anson/io/odysz/common.py

@@ -0,0 +1,83 @@
+'''
+Created on 25 Oct 2019
+
+@author: odys-z@github.com
+'''
+import sys
+from re import match
+from typing import TextIO, Optional, TypeVar
+
+T = TypeVar('T')
+
+
+class LangExt:
+    '''
+    classdocs
+    '''
+
+    def __init__(self, params):
+        '''
+        Constructor
+        '''
+
+    @staticmethod
+    def isblank(s, regex=None):
+        if (s == None):
+            return True
+        if isinstance(s, str):
+            if regex == None or s == "":
+                return len(s) == 0
+            else:
+                return match(s, regex)
+        return False
+
+    @staticmethod
+    def ifnull(a: T, b: T) -> T:
+        return b if a is None else a
+
+    @classmethod
+    def len(cls, obj):
+        return 0 if obj is None else len(obj)
+
+    @staticmethod
+    def str(obj: dict | list):
+        def quot(v) -> str:
+            return f'"{v}"' if type(v) == str else f'"{v.toBlock()}"' if isinstance(v, Anson) else LangExt.str(v)
+        from src.anson.io.odysz.ansons import Anson
+        if type(obj) == dict:
+            s = '{'
+            for k, v in obj.items():
+                # s += f'{"" if len(s) == 1 else ",\n"}"{k}": "{LangExt.str(v)}"'
+                s += f'{"" if len(s) == 1 else ",\n"}"{k}": {quot(v)}'
+            s += '}'
+            return s
+        elif type(obj) == list:
+            s = '['
+            # s += ", ".join(f'"{x}"' if type(x) == str else LangExt.str(x) for x in obj)
+            s += ", ".join(quot(x) for x in obj)
+            return s + ']'
+        elif isinstance(obj, Anson):
+            return obj.toBlock()
+        else:
+            return str(obj)
+
+def log(out: Optional[TextIO], templt: str, *args):
+    try:
+        print(templt if LangExt.isblank(args) else templt.format(*args), file=out)
+    except Exception as e:
+        print(templt, args, e)
+
+
+class Utils:
+    def __init__(self, params):
+        '''
+        Constructor
+        '''
+
+    @staticmethod
+    def logi(templt, *args):
+        log(sys.stdout, templt, *args)
+
+    @staticmethod
+    def warn(templt, *args):
+        log(sys.stderr, templt, *args)

anson_py3-0.1.0.dist-info/METADATA

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: anson.py3
+Version: 0.1.0
+Summary: Anson for Python3
+Project-URL: Homepage, https://github.com/odys-z/antson
+Project-URL: Issues, https://github.com/odys-z/antson/issues
+Author-email: Ody Z <odys.zhou@gmail.com>
+License: Copyright (c) 2025 Ody Z. All rights reserved.
+        
+        This work is licensed under the terms of the MIT license.
+        For a copy, see <https://opensource.org/licenses/MIT>.
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Anson.py3
+
+A testing package ...
+
+```code
+from ansons.anson import Anson
+```
+
+# Install from testpypi
+
+```
+pip install --index-url https://test.pypi.org/simple --extra-index-url https://pypi.org/simple anson.py3
+```
+
+# Guide
+
+- Mapping Java vs Python package structure
+
+Python packages tree is in format of *path/to/module/class*, while java has no node of *module*:
+
+```
+├── io
+│   └── oz
+│       ├── jserv
+│       │   └── docs
+│       │       └── syn
+│       │           └── singleton.py "class AppSettings"
+│       └── syn.py "class AnRegistry, SynodeConfig, SynOrg, YellowPages"
+```
+
+Java packages tree:
+
+```
+.
+└── io
+    └── oz
+        └── jserv
+            └── docs
+                └── syn
+                    ├── singleton
+                    │   └── AppSettings.java
+```
+
+```
+.
+└── io
+    └── oz
+        └── syn
+            ├── AnRegistry.java
+            ├── SynodeConfig.java
+            ├── SynOrg.java
+            └── YellowPages.java
+```
+
+Anson.py3 is using package name path with a top level path. Say, if the json envelope
+define as
+
+```
+{ type: io.oz.syn.AnRegistry,
+  ...
+}
+```
+
+and the user's project tree is:
+
+```
+src
+├── io
+│   └── oz
+│       ├── jserv
+│       │   └── docs
+│       │       └── syn
+│       │           └── singleton.py "class AppSettings"
+│       └── syn.py "class AnRegistry, SynodeConfig, SynOrg, YellowPages"
+main.py
+```
+
+In main.py, call
+
+```code
+Anson.java_src('src')
+```
+
+before
+
+```code
+AnRegistry.from_file(path)
+```
+
+# Issues
+
+- Printing Anson subclasses with non-default field without value initialization will result in errors
+
+If SynOrg.parent is defined as
+
+```
+class SynOrg(Anson)
+    parent: str
+
+    def __init__(self):
+        super().__init__()
+
+```
+
+```
+org = Anson.from_file(...)
+print (org)
+
+Error
+Traceback (most recent call last):
+  File "/home/antson/py3/test/testYellowPages.py", line 18, in testAnregistry
+    print(diction)
+  File "/usr/lib/python3.12/dataclasses.py", line 262, in wrapper
+    result = user_function(self)
+             ^^^^^^^^^^^^^^^^^^^
+  File "<string>", line 3, in __repr__
+  File "/usr/lib/python3.12/dataclasses.py", line 262, in wrapper
+    result = user_function(self)
+             ^^^^^^^^^^^^^^^^^^^
+  File "<string>", line 3, in __repr__
+  File "/usr/lib/python3.12/dataclasses.py", line 262, in wrapper
+    result = user_function(self)
+             ^^^^^^^^^^^^^^^^^^^
+  File "<string>", line 3, in __repr__
+AttributeError: 'SynOrg' object has no attribute 'parent'
+```
+
+# References
+
+- https://packaging.python.org/en/latest/tutorials/packaging-projects/
+
+```python3 -m twine upload --repository testpypi dist/*```
+
+# Troubleshootings
+
+.pypirc
+
+```
+[testpypi]
+repository: https://test.pypi.org/legacy/
+username = __token__
+password = pypi-zzz
+```
+
+```
+python3 -m twine --version
+twine version 6.1.0 (keyring: 25.6.0, packaging: 24.2, requests: 2.31.0, requests-toolbelt: 1.0.0,
+urllib3: 2.0.7, id: 1.5.0)
+python3 -m build
+python3 -m twine upload --repository testpypi dist/*
+```
+
+```
+ERROR   InvalidDistribution: Invalid distribution metadata: unrecognized or malformed field
+        'license-file'; unrecognized or malformed field 'license-expression'  
+```
+
+Install twine 6.1.0 and packaging 24.
+
+```
+pip install packaging -U
+```
+
+See [issue #1216](https://github.com/pypa/twine/issues/1216#issuecomment-2609745412).

anson_py3-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+anson/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anson/io/odysz/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anson/io/odysz/ansons.py,sha256=Na3MF9tnAIlssI3xMcrwcugEMUyzfApLHj1iHWk5ptY,8565
+anson/io/odysz/common.py,sha256=wvuAAxciEsKGRwx2Y_2mAAJnA7PgvXtjnyuA-DhdXd4,2145
+anson/io/odysz/anson/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anson/io/odysz/anson/x/__init__.py,sha256=UHUOTmlyuMySt7cmaupaqy4fUDAJ1cH5oYhSElFcMaI,305
+anson_py3-0.1.0.dist-info/METADATA,sha256=CvaI-KkpoIrU4uO3GS92ixExTUxVx_9QiuyVyEoTw6I,4134
+anson_py3-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+anson_py3-0.1.0.dist-info/licenses/LICENSE,sha256=z_ecrO9KkQ-pyddGEAsjUEOS-igXLy4GnjQE2sEpwlo,1084
+anson_py3-0.1.0.dist-info/RECORD,,

anson_py3-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

anson_py3-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 odys-z
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.