underscorepy 0.9.0__py3-none-any.whl

_/records/__init__.py

@@ -0,0 +1,186 @@
+#
+# (c) 2015-2023 Matthew Shaw
+#
+# Authors
+# =======
+# Matthew Shaw <mshaw.cx@gmail.com>
+#
+
+import dataclasses
+import importlib
+import json
+import logging
+
+import sqlalchemy
+import sqlalchemy.ext.asyncio
+
+import _
+
+
+class Record:
+    @classmethod
+    async def _(cls, component_name, **kwds):
+        self = cls()
+        self.component_name = component_name
+        _.records[component_name] = self
+        try:
+            await self.init(**kwds)
+        except TypeError as e:
+            raise _.error('%s', e)
+
+    async def init(self, module, **kwds):
+        try:
+            imported = importlib.import_module(module)
+        except ModuleNotFoundError as e:
+            raise _.error('Unknown module: %s: %s', module, e)
+
+        database = kwds.get('database', None)
+        self.db = _.databases[database] if database else None
+
+        await _.wait(self.load(imported))
+
+    @classmethod
+    async def args(cls, component_name):
+        pass
+
+    def load(self, module):
+        raise NotImplementedError
+
+
+class RecordsInterface:
+    'base class for _.records'
+
+    def __call__(self, **kwds):
+        for k,v in kwds.items():
+            setattr(self, k, v)
+
+    def __getitem__(self, key):
+        return getattr(self, key)
+
+    def __setitem__(self, key, value):
+        setattr(self, key, value)
+
+    @classmethod
+    def _from_dict(cls, **kwds):
+        self = cls()
+        for k,v in kwds.items():
+            setattr(self, k, v)
+        return self
+
+    @classmethod
+    def _from_json(cls, msg):
+        return cls._from_dict(**json.loads(msg))
+
+    def _as_dict(self):
+        _dict = dataclasses.asdict(self)
+        if hasattr(self, '__primary_key__'):
+            _dict[self.__primary_key__] = getattr(self, self.__primary_key__)
+        return _dict
+
+    def _as_json(self, **kwds):
+        return json.dumps(self, cls=_.JSONEncoder, separators=(',',':'), **kwds)
+
+
+def _delimited(records):
+    'prefix each record with its varint length, like a protobuf delimited stream'
+    packed = bytearray()
+    for record in records:
+        data = record._as_binary()
+        size = len(data)
+        while size > 0x7f:
+            packed.append((size & 0x7f) | 0x80)
+            size >>= 7
+        packed.append(size)
+        packed += data
+    return bytes(packed)
+
+
+class HandlerInterface(_.handlers.Protected):
+    def initialize(self):
+        self.content_type = self.get_argument('type', 'json')
+        if self.content_type == 'json':
+            self.set_header('Content-Type', 'application/json; charset=UTF-8')
+        else:
+            self.set_header('Content-Type', 'application/octet-stream')
+
+    async def prepare(self):
+        await super().prepare()
+        # decode here as HTTPErrors raised in initialize drop the connection
+        if self.request.body:
+            try:
+                if self.content_type == 'json':
+                    self.data = json.loads(self.request.body)
+                else:
+                    self.data = self._record._from_binary(self.request.body)
+            except Exception:
+                raise _.HTTPError(400) from None
+        else:
+            self.data = None
+
+    def _record_from_body(self):
+        if self.data is None:
+            raise _.HTTPError(400)
+        # binary bodies are already decoded into a record
+        if self.content_type != 'json':
+            return self.data
+        try:
+            return self._record._from_dict(self.data)
+        except Exception:
+            raise _.HTTPError(400) from None
+
+    def _record_key(self, record_id):
+        # convert the URL path to the primary key column's type
+        try:
+            column = getattr(self._record, self._record.__primary_key__)
+            return column.expression.type.python_type(record_id)
+        except (AttributeError, NotImplementedError):
+            return record_id
+        except ValueError:
+            raise _.HTTPError(404) from None
+
+    @_.auth.records
+    async def get(self, record_id):
+        if not record_id:
+            records = await self._db.find(self._record)
+            if self.content_type == 'json':
+                self.write(dict(data=records))
+            else:
+                self.write(_delimited(records))
+        else:
+            record = await self._db.find_one(self._record, self._record_key(record_id))
+            if record is None:
+                raise _.HTTPError(404)
+            if self.content_type == 'json':
+                self.write(record._as_dict())
+            else:
+                self.write(record._as_binary())
+
+    @_.auth.records
+    async def post(self, record_id, record=None):
+        if record is None:
+            record = self._record_from_body()
+        try:
+            await self._db.insert(record)
+        except _.error as e:
+            raise _.HTTPError(409, e) from None
+        self.set_status(204)
+        #self.write(record._as_dict())
+
+    @_.auth.records
+    async def put(self, record_id, record=None):
+        if record is None:
+            record = self._record_from_body()
+        try:
+            await self._db.upsert(record)
+        except _.error as e:
+            raise _.HTTPError(400, e) from None
+        self.set_status(204)
+
+    @_.auth.records
+    async def delete(self, record_id):
+        if not record_id:
+            raise _.HTTPError(400)
+        count = await self._db.delete(self._record, self._record_key(record_id))
+        if not count:
+            raise _.HTTPError(404)
+        self.set_status(204)

_/records/data.py

@@ -0,0 +1,232 @@
+
+import dataclasses
+import functools
+import inspect
+import logging
+import json
+import typing
+
+import sqlalchemy
+import tornado.web
+
+import _
+
+
+class Data(_.records.Record):
+    async def init(self, module, **kwds):
+        # setup the container beforehand so the data module can use data decorators
+        if hasattr(_, self.component_name):
+            raise _.error('Record name "%s" for "%s" conflicts in _ root', self.component_name, module.__name__)
+        self._container = DataContainer()
+        setattr(_, self.component_name, self._container)
+        await super().init(module, **kwds)
+
+    def load(self, module):
+        self.module_name = module.__name__
+        for name in dir(module):
+            if name.startswith('__'):
+                continue
+
+            if name in self._container._ignore:
+                continue
+
+            # ignore objects that are not classes
+            cls = getattr(module, name)
+            if not isinstance(cls, type(Data)):
+                continue
+
+            # ignore classes outside of module root
+            if not cls.__module__.startswith(self.module_name):
+                continue
+
+            if self.db and not hasattr(cls, f'_{name}__no_table'):
+                try:
+                    record_type = self._data_table(name, cls)
+                except Exception as e:
+                    logging.exception('%s', e)
+            else:
+                if not dataclasses.is_dataclass(cls):
+                    cls = dataclasses.dataclass(init=False, kw_only=True)(cls)
+                record_type = type(name, (DataInterface,cls), {})
+
+            self._container[name] = record_type
+
+            if not hasattr(cls, f'_{name}__no_handler'):
+                self._data_handler(name, record_type)
+
+    def _data_table(self, name, cls, parent=None, parent_key=None, parent_col=None):
+        child_tables = {}
+        annotations = {}
+        members = {
+            '__tablename__'   : name,
+            '__annotations__' : annotations,
+            }
+
+        # make class a dataclass if it isn't already
+        if not dataclasses.is_dataclass(cls):
+            cls = dataclasses.dataclass(init=False, kw_only=True)(cls)
+
+        primary_key = None
+        for field in dataclasses.fields(cls):
+            # check if column should be primary key
+            is_primary_key = field.metadata.get('pkey', False)
+            if is_primary_key:
+                if primary_key:
+                    raise _.error('Only one primary key can be specified')
+                primary_key = field.name
+
+            uniq = field.metadata.get('uniq', False)
+            refs = field.metadata.get('refs', None)
+
+            if refs:
+                annotations[field.name] = sqlalchemy.orm.Mapped[typing.Optional[field.type]]
+                members[field.name] = sqlalchemy.orm.mapped_column(
+                    sqlalchemy.ForeignKey(refs, ondelete="CASCADE"),
+                    init=False,
+                    )
+            elif field.type.__module__.startswith(self.module_name):
+                ref_table_name = f'{name}_{field.name}'
+                annotations[field.name] = sqlalchemy.orm.Mapped[typing.Optional[ref_table_name]]
+                members[field.name] = sqlalchemy.orm.relationship(
+                    back_populates=name,
+                    lazy='joined',
+                    cascade="all, delete-orphan",
+                    init=False,
+                    )
+                child_tables[ref_table_name] = field
+            else:
+                annotations[field.name] = typing.Optional[field.type]
+                members[field.name] = sqlalchemy.orm.mapped_column(
+                    primary_key=is_primary_key,
+                    unique=uniq,
+                    init=False,
+                    )
+
+        if primary_key is None:
+            primary_key = f'{name}_id'
+            members[primary_key] = sqlalchemy.orm.mapped_column(
+                sqlalchemy.INTEGER,
+                primary_key=True,
+                autoincrement=True,
+                init=False,
+                )
+
+        if parent and parent_key and parent_col:
+            members[f'{parent}_{parent_key}'] = sqlalchemy.orm.mapped_column(
+                sqlalchemy.ForeignKey(f'{parent}.{parent_key}', ondelete="CASCADE"),
+                init=False,
+                )
+            members[f'{parent}'] = sqlalchemy.orm.relationship(
+                parent,
+                back_populates=parent_col,
+                lazy='joined',
+                init=False,
+                )
+
+        members['__primary_key__'] = primary_key
+
+        table_type = type(name, (DataInterface,self.db.Base,), members)
+
+        for child_table,field in child_tables.items():
+            child_type = self._data_table(child_table, field.type, parent=name, parent_key=primary_key, parent_col=field.name)
+            setattr(table_type, f'_{field.name}', child_type)
+
+        return table_type
+
+    def _data_handler(self, name, record_type):
+        data_handler = self._container._handlers.get(name)
+        # the default handler needs a table
+        if not data_handler and not hasattr(record_type, '__table__'):
+            return
+
+        types = [data_handler] if data_handler else [_.records.HandlerInterface]
+        types.append(tornado.web.RequestHandler)
+
+        # served at the record name, whichever handler class is used
+        handler_name = data_handler.__name__ if data_handler else name
+        record_handler = type(handler_name, tuple(types), {
+            '_component' : name,
+            '_db'        : self.db,
+            '_record'    : record_type,
+            '__module__' : self.module_name,
+            })
+        
+        _.application._record_handler(self.component_name, record_handler)
+
+
+class DataInterface(_.records.RecordsInterface):
+    @staticmethod
+    def __dataclass(cls, msg, dst):
+        for field in dataclasses.fields(cls):
+            child_cls = getattr(cls, f'_{field.name}', None)
+            if child_cls:
+                child = child_cls()
+                DataInterface.__dataclass(child_cls, msg.get(field.name), child)
+                setattr(dst, field.name, child)
+            else:
+                if field.name in msg:
+                    setattr(dst, field.name, msg[field.name])
+        return dst
+
+    def __call__(self, *args, **kwds):
+        msg = args[0] if args else kwds
+        return DataInterface.__dataclass(self, msg, self)
+
+    @classmethod
+    def _from_dict(cls, *args, **kwds):
+        msg = args[0] if args else kwds
+        return DataInterface.__dataclass(cls, msg, cls())
+
+    @classmethod
+    def _from_json(cls, msg):
+        return DataInterface.__dataclass(cls, json.loads(msg), cls())
+
+    @classmethod
+    def _from_binary(cls, msg):
+        return DataInterface.__dataclass(cls, json.loads(msg), cls())
+
+    def _as_binary(self):
+        # omits an auto-generated primary key but keeps a declared one
+        _dict = dataclasses.asdict(self)
+        return json.dumps(_dict, cls=_.JSONEncoder, separators=(',',':')).encode('utf-8')
+
+
+class DataContainer(_.Container):
+    def __init__(self):
+        super().__init__()
+        self._ignore = set()
+        self._handlers = {}
+
+    # decorator for adding custom handlers for message types
+    def handles(self, _datacls):
+        def wrap(_handler):
+            self._ignore.add(_handler.__name__)
+            self._handlers[_datacls.__name__] = _handler
+            return _handler
+        return wrap
+
+    @staticmethod
+    def dump(obj):
+        return DataInterface.dump(obj)
+
+    @staticmethod
+    def no_table(cls):
+        setattr(cls, f'_{cls.__name__}__no_table', True)
+        return cls
+
+    @staticmethod
+    def no_handler(cls):
+        setattr(cls, f'_{cls.__name__}__no_handler', True)
+        return cls
+
+    @staticmethod
+    def pkey(arg=dataclasses.MISSING):
+        return dataclasses.field(metadata={'pkey':True})
+
+    @staticmethod
+    def uniq(group=None, arg=dataclasses.MISSING):
+        return dataclasses.field(metadata={'uniq':True})
+
+    @staticmethod
+    def refs(table_column):
+        return dataclasses.field(metadata={'refs':table_column})