csrd-models 0.1.1__tar.gz

csrd_models-0.1.1/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.1
+Name: csrd-models
+Version: 0.1.1
+Summary: 
+Author: aaron
+Author-email: aaron@frostmn.com
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: csrd-utils (>=0.1,<0.2)
+Requires-Dist: pre-commit (>=3.8.0,<4.0.0)
+Description-Content-Type: text/markdown
+
+

csrd_models-0.1.1/pyproject.toml

@@ -0,0 +1,19 @@
+[tool.poetry]
+name = "csrd-models"
+version = "0.1.1"
+description = ""
+authors = ["aaron <aaron@frostmn.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.12"
+pre-commit = "^3.8.0"
+csrd-utils = "^0.1"
+
+[[tool.poetry.source]]
+name = "PyPI"
+priority = "primary"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

csrd_models-0.1.1/src/csrd_models/__init__.py

@@ -0,0 +1,3 @@
+from .entity import Entity
+
+__all__ = ('Entity',)

csrd_models-0.1.1/src/csrd_models/entity/__init__.py

@@ -0,0 +1 @@
+from .entity import Entity

csrd_models-0.1.1/src/csrd_models/entity/_schema.py

@@ -0,0 +1,99 @@
+from typing import Any, Union, get_origin, get_args
+from csrd_utils.string_utils import to_camel, to_title
+
+
+def get_name(obj: Any) -> str:
+    return obj.__name__
+
+
+def _get_properties(obj: Any) -> dict:
+    return {k: obj.__dict__[k] for k in obj.__dict__ if not k.startswith('_')}
+
+
+def map_type(type_: Any):
+    if type(type_) is not str:
+        type_ = get_name(type_)
+
+    return {
+        "str": "string",
+        "int": "integer",
+        "float": "number",
+        "bool": "boolean",
+        "List": "array",
+        "NoneType": 'null'
+    }[type_]
+
+
+def is_union(value: Any) -> bool:
+    return get_origin(get_args(value)[0]) == Union
+
+
+def handle_union(key, name, value):
+    return {
+        # 'title': to_title(key),
+        'items': {'anyOf': [{"type": map_type(x)} for x in get_args(get_args(value)[0])]}, 'type': map_type(name)}
+
+
+def handle_optional(key, name, value, props):
+    return {
+        'type': map_type([x for x in get_args(value) if x is not type(None)][0]),
+        'default': props.get(key, None),
+        'title': to_title(key),
+        'required': False
+    }
+
+
+def build_type(key, value: Any, props = None):
+    name = get_name(value)
+
+    if name in ('str', 'int', 'float', 'bool'):
+        return {
+            'title': to_title(key),
+            'type': map_type(name)
+        }
+
+    if name in ("List",):
+        args = get_args(value)[0]
+        if is_union(value):
+            return handle_union(key, name, value)
+        else:
+            return {
+                'title': to_title(key),
+                'type': map_type(name),
+                'items': {'type': map_type(args)}
+            }
+
+    if name in ("Optional",):
+        return handle_optional(key, name, value, props)
+
+    # this is probably missing some cases
+    return {'$ref': f'#/definitions/{value.__name__}'}
+
+
+def _build_properties(value: Any):
+    props = getattr(value, '__properties__', None)
+    annno = getattr(value, '__annotations__', None)
+    return { to_camel(key): build_type(key, annno[key], props) for key in annno }
+
+
+def _build_schema(cls: Any):
+    return {
+            "properties": _build_properties(cls),
+            "title": get_name(cls),
+            "type": "object"
+    }
+
+
+class _Schema:
+    def __init__(self, __class__):
+        self._set_schema(__class__)
+
+    @classmethod
+    def _set_schema(cls, __class__):
+        setattr(cls, '__annotations__', __class__.__annotations__)
+        setattr(cls, '__name__', __class__.__name__)
+        setattr(cls, '__properties__', _get_properties(__class__))
+
+    @classmethod
+    def dump_schema(cls):
+        return _build_schema(cls)

csrd_models-0.1.1/src/csrd_models/entity/entity.py

@@ -0,0 +1,24 @@
+from ._schema import _Schema
+
+from csrd_utils.string_utils import to_camel
+
+
+class Entity:
+    _schema = _Schema
+
+    def __init__(self, /, **data):
+        self._schema = _Schema(self.__class__)
+        for key, value in data.items():
+            self.__dict__[key] = value
+
+    @property
+    def name(self):
+        return self.__name__
+
+    @classmethod
+    def schema(cls):
+        cls._schema._set_schema(cls)
+        return cls._schema.dump_schema()
+
+    def json(self):
+        return {to_camel(k): self.__dict__[k] for k in self.__dict__ if not k.startswith('_')}