slinn-orm 0.0.3__tar.gz

slinn_orm-0.0.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mark
+
+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.

slinn_orm-0.0.3/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: slinn-orm
+Version: 0.0.3
+Summary: ORM for Slinn
+Author-email: Mark Radin <openmiot@gmail.com>
+Requires-Python: >=3.14
+License-File: LICENSE
+Provides-Extra: postgres
+Requires-Dist: asyncpg; extra == "postgres"
+Provides-Extra: sqlite
+Requires-Dist: aiosqlite; extra == "sqlite"
+Provides-Extra: full
+Requires-Dist: slinn-orm[postgres]; extra == "full"
+Requires-Dist: slinn-orm[sqlite]; extra == "full"
+Dynamic: license-file

slinn_orm-0.0.3/orm/__init__.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+from typing import Protocol, Coroutine
+from .order import Order
+from .models import Model
+import re
+
+
+DSN_PATTERN = re.compile(r'^(\w+):(\/\/)?\w*:?.*@?.+(\/)?\w+')
+
+
+class CollectionProtocol(Protocol):
+    async def find(self, _filter: dict, *, fields: tuple[str] = ('*',)) -> list[dict]: ...
+    async def find_one(self, _filter: dict, *, fields: tuple[str] = ('*',)) -> dict: ...
+    async def insert(self, _object: dict, *, returning: tuple[str] = (), typemap: dict | None = None) -> None: ...
+    async def update(self, _filter: dict, _object: dict, *, returning: tuple[str] = (), typemap: dict | None = None) -> None: ...
+    async def delete(self, _filter) -> None: ...
+    async def pop(self, _filter) -> dict: ...
+    async def drop(self, *, not_exists_ok: bool = False) -> None: ...
+    async def count(self, _filter: dict) -> int: ...
+    async def get_size(self) -> int: ...
+
+
+class ConnectionProtocol(Protocol):
+    async def __aenter__(self) -> ConnectionProtocol: ...
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None: ...
+    def __getattr__(self, key) -> CollectionProtocol: ...
+    def collection(self, key) -> CollectionProtocol: ...
+    async def commit(self) -> None: ...
+    async def rollback(self) -> None: ...
+    async def collections(self) -> tuple[CollectionProtocol]: ...
+    async def create(self, model: Model, *, exists_ok=False) -> None: ...
+    async def create_index(
+        self,
+        index_name: str,
+        collection_name: str,
+        fields: tuple[str],
+        *,
+        exists_ok: bool=False,
+        unique: bool=False
+    ) -> None: ...
+
+
+class PoolProtocol(Protocol):
+    async def acquire(self) -> ConnectionProtocol: ...
+    async def release(self, connection: ConnectionProtocol) -> None: ...
+    def on_acquire(self, coroutine: Coroutine[ConnectionProtocol]) -> None: ...
+
+
+def get_driver_name(dsn: str) -> str:
+    return DSN_PATTERN.findall(dsn)[0][0].lower()

slinn_orm-0.0.3/orm/attributed_dict.py

@@ -0,0 +1,9 @@
+class AttributedDict(dict):
+    def __init__(self, *args, **kwargs):
+        if args[0] is None:
+            self = None
+        else:
+            dict.__init__(self, *args, **kwargs)
+
+    def __getattr__(self, item):
+        return self[item]

slinn_orm-0.0.3/orm/models.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import Literal, Optional
+from datetime import timedelta, datetime
+from typing import NamedTuple
+
+
+class Model(ABC):
+    @staticmethod
+    @abstractmethod
+    def __collection_name__() -> str: ...
+
+    def _update_meta(self) -> None:
+        if not hasattr(self, '_meta_primary_keys'):
+            self._meta_primary_keys = ()
+
+        for field_name in self.__dict__.keys():
+            field = self.__dict__[field_name]
+            if field_name.startswith('_') or not isinstance(field, Field):
+                continue
+            if hasattr(field, 'primary') and field.primary:
+                if field_name not in self._meta_primary_keys:
+                    self._meta_primary_keys = (*self._meta_primary_keys, field_name)
+
+
+class Field(ABC):
+    class FieldReference(NamedTuple):
+        collection_name: str
+        field_name: str
+
+    def make_identity(self) -> Field:
+        self.identity = True
+        return self
+
+    def make_primary(self) -> Field:
+        self.primary = True
+        return self
+    
+    def make_unique(self) -> Field:
+        self.unique = True
+        return self
+    
+    def make_not_null(self) -> Field:
+        self.not_null = True
+        return self
+    
+    def set_reference(self, collection_name: str, field_name: str) -> Field:
+        self.reference = self.FieldReference(collection_name, field_name)
+        return self
+
+
+class BoolField(Field): ...
+
+
+class IntegerField(Field):
+    def __init__(self, *, size: Literal[2, 4, 8] = 4):
+        self.size = size
+
+
+class DecimalField(Field): ...
+
+
+class FloatField(Field):
+    def __init__(self, *, double: bool = False):
+        self.double = double
+
+
+class TextField(Field): ...
+
+
+class TimeField(Field):
+    def __init__(
+        self,
+        *,
+        zone: bool = True,
+        date: bool = True,
+        time: bool = True,
+        default: Optional[timedelta | datetime]
+    ):
+        self.zone = zone
+        self.date = date
+        self.time = time
+        self.default = default
+
+
+class TimeDeltaField(Field): ...
+
+
+class BinaryField(Field): ...
+
+
+class UIDField(Field):
+    def __init__(self):
+        self.make_identity()
+
+
+class UUIDField(Field): ...

slinn_orm-0.0.3/orm/order.py

@@ -0,0 +1,16 @@
+import enum
+
+
+class OrderType(enum.Enum):
+    ASC = 0
+    DESC = 1
+
+
+class Order:
+    @staticmethod
+    def ASC(field: str) -> tuple[OrderType, str]:
+        return (OrderType.ASC, field)
+
+    @staticmethod
+    def DESC(field: str) -> tuple[OrderType, str]:
+        return (OrderType.DESC, field)

slinn_orm-0.0.3/orm/postgres/__init__.py

@@ -0,0 +1,272 @@
+from __future__ import annotations
+from .. import CollectionProtocol, ConnectionProtocol, PoolProtocol
+from ..attributed_dict import AttributedDict
+from ..typemap import typemap as tm
+from ..order import OrderType
+from ..models import (Model, Field, BoolField, IntegerField, DecimalField, FloatField, TextField, TimeField, TimeDeltaField, 
+                      BinaryField, UIDField, UUIDField)
+from typing import Coroutine, Optional, Final
+from functools import partial
+from datetime import datetime, timedelta
+import asyncpg
+
+
+class PostgresCollection(CollectionProtocol):
+    def __init__(self, connection: PostgresConnection, name: str):
+        self.connection = connection
+        self.name = name
+
+    async def find(
+        self,
+        _filter: dict,
+        *,
+        fields: tuple[str] = ('*',),
+        order: tuple[tuple[OrderType, str]] = ()) -> list[dict]:
+        return [AttributedDict(record) for record in await self.connection._fetch(
+            f'SELECT {', '.join(fields)} '
+            f'FROM {self.name} '
+            f'{'WHERE ' if _filter else ''}{' AND '.join([f'{list(_filter.keys())[i]}=${i+1}' for i in range(0, len(_filter))])} '
+            f'{'ORDER BY ' if order else ''}{', '.join([(f'{o[1]} {'ASC' if o[0] is OrderType.ASC else 'DESC'}') for o in order])};',
+            *_filter.values())]
+
+    async def find_one(
+            self,
+            _filter: dict,
+            *,
+            fields: tuple[str] = ('*',)) -> dict:
+        result = await self.find(
+            _filter,
+            fields=fields
+        )
+        return result[0] if result else None
+
+    async def insert(
+        self,
+        _object: dict,
+        *,
+        returning: tuple[str] = (),
+        typemap: dict | None = None) -> None: 
+        if not _object:
+            return []
+        records = await self.connection._fetch(
+            f'INSERT INTO {self.name}({', '.join(_object.keys())}) '
+            f'VALUES({', '.join([f'${i+1}' for i in range(0, len(_object))])}) '
+            f'{'RETURNING' if returning else ''} {', '.join(returning)}',
+            *tm(_object, typemap).values())
+        return records[0] if records else None
+
+    async def update(
+        self,
+        _filter: dict,
+        _object: dict,
+        *,
+        returning: tuple[str] = (),
+        typemap: dict | None = None) -> None:
+        if not _object:
+            return []
+        return await self.connection._fetch(
+            f'UPDATE {self.name} '
+            f'SET {', '.join([f'{key}=${i+1}' for i, key in enumerate(_object)])} '
+            f'{'WHERE ' if _filter else ''}{' AND '.join([f'{list(_filter.keys())[i]}=${i+len(_object)+1}' for i in range(0, len(_filter))])} '
+            f'{'RETURNING' if returning else ''} {', '.join(returning)};',
+            *tm(_object, typemap).values(), *_filter.values())
+
+    async def delete(self, _filter: dict) -> None: 
+        await self.connection._fetch(f'''
+            DELETE FROM {self.name}
+            {'WHERE ' if _filter else ''}{' AND '.join([f'{list(_filter.keys())[i]}=${i+1}' for i in range(0, len(_filter))])};''',
+            *_filter.values())
+
+    async def pop(
+        self,
+        _filter: dict,
+        *,
+        returning: tuple[str] = ('*', )) -> dict: 
+        return await self.connection._fetch(
+            f'DELETE FROM {self.name} '
+            f'{'WHERE ' if _filter else ''}{' AND '.join([f'{list(_filter.keys())[i]}=${i+1}' for i in range(0, len(_filter))])} '
+            f'{'RETURNING' if returning else ''} {', '.join(returning)};',
+            *_filter.values())
+
+    async def count(self, _filter: dict) -> int: 
+        return (await self.connection._fetch(f'''
+            SELECT COUNT(*)
+            FROM {self.name}
+            {'WHERE ' if _filter else ''}{' AND '.join([f'{list(_filter.keys())[i]}=${i+1}' for i in range(0, len(_filter))])};''',
+            *_filter.values()))[0]['count']
+    async def get_size(self) -> int: ...
+    
+    async def drop(self, *, not_exists_ok: bool = False) -> None: 
+        await self.connection._fetch(f'DROP TABLE {'IF EXISTS ' if not_exists_ok else ''}{self.name};')
+
+
+class PostgresConnection(ConnectionProtocol):
+    FIELDS_MAP: Final[dict] = {
+        BoolField: lambda field: 'BOOLEAN',
+        IntegerField: lambda field: {
+            2: 'SMALLINT',
+            4: 'INTEGER',
+            8: 'BIGINT'
+        }[field.size],
+        DecimalField: lambda field: 'DECIMAL',
+        FloatField: lambda field: 'DOUBLE PRECISION' if field.double else 'REAL',
+        TextField: lambda field: 'TEXT',
+        TimeField: lambda field: {
+            (False, False, True): 'TIME',
+            (False, True, False): 'DATE',
+            (False, True, True): 'TIMESTAMP',
+            (True, False, True): 'TIMETZ',
+            (True, True, False): 'DATE',
+            (True, True, True): 'TIMESTAMPTZ'
+        }[field.zone, field.date, field.time] + (
+            '' if field.default is None else (' DEFAULT ' + {
+                datetime: lambda dt: f'to_timestamp({dt.timestamp()})',
+                timedelta: lambda td: f'NOW() + INTERVAL \'{td.total_seconds()} seconds\''
+            }[type(field.default)](field.default))
+        ),
+        TimeDeltaField: lambda field: 'INTERVAL',
+        BinaryField: lambda field: 'BYTEA',
+        UIDField: lambda field: 'BIGINT',
+        UUIDField: lambda field: 'UUID'
+    }
+
+    def __init__(self, pool, connection, transaction, autocommit=True):
+        self._pool = pool
+        self._connection = connection
+        self._transaction = transaction
+        self._autocommit = autocommit
+        self.collection = self.__getattr__
+    
+    def __getattr__(self, key) -> CollectionProtocol:
+        return PostgresCollection(self, key)
+    
+    async def rollback(self) -> None:
+        await self._transaction.rollback()
+    
+    async def commit(self) -> None:
+        await self._transaction.commit()
+    
+    async def collections(self) -> list:
+        return [collection[0] for collection in await self._fetch('''
+            SELECT table_name
+            FROM information_schema.tables
+            WHERE table_schema NOT IN ('pg_catalog', 'information_schema') AND table_type = 'BASE TABLE'
+            ORDER BY table_name;''')]
+
+    async def create(self, model: Model, *, exists_ok=False) -> None:
+        model._update_meta(model)
+        fields = []
+        for field_name in model.__dict__.keys():
+            field = getattr(model, field_name)
+            if field_name.startswith('_') or not isinstance(field, Field):
+                continue
+            fields.append(
+                f'''
+                    {field_name} {self.FIELDS_MAP[type(field)](field)}
+                    {'UNIQUE' if hasattr(field, 'unique') and field.unique else ''}
+                    {'NOT NULL' if hasattr(field, 'not_null') and field.not_null else ''}
+                    {'GENERATED ALWAYS AS IDENTITY' if hasattr(field, 'identity') and field.identity else ''}
+                    {f'REFERENCES {field.reference.collection_name}({field.reference.field_name})' 
+                     if hasattr(field, 'reference') and field.reference else ''}
+                '''.strip()
+            )
+        await self._fetch(f'''
+            CREATE TABLE {'IF NOT EXISTS ' if exists_ok else ''}{model.__collection_name__()}(
+                {','.join(fields)},
+                {f'PRIMARY KEY ({','.join(model._meta_primary_keys)})' if model._meta_primary_keys else ''}
+            );
+        '''.strip())
+    
+    async def create_index(
+        self,
+        index_name: str,
+        collection_name: str,
+        fields: tuple[str],
+        *,
+        exists_ok: bool=False,
+        unique: bool=False
+    ) -> None:
+        print(f"""
+            CREATE {'UNIQUE ' if unique else ''}INDEX {'IF NOT EXISTS ' if exists_ok else ''}{index_name} ON {collection_name}({','.join(fields)});
+        """)
+        await self._fetch(f'''
+            CREATE {'UNIQUE ' if unique else ''}INDEX {'IF NOT EXISTS ' if exists_ok else ''}{index_name} ON {collection_name}({','.join(fields)});
+        ''')
+    
+    async def __aenter__(self):
+        await self._transaction.start()
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        try:
+            if not exc_type and self._autocommit:
+                await self.commit()
+            else:
+                await self.rollback()
+        finally:
+            await self._pool.release(self)
+    
+    async def _fetch(self, query, *args, timeout: float | None = None, record_class=None) -> list:
+        query = ' '.join([line.strip() for line in query.split('\n')]).strip()
+        return await self._connection.fetch(
+            query,
+            *args,
+            timeout=timeout,
+            record_class=record_class
+        )
+
+class PostgresPool(PoolProtocol):
+    def __init__(self, pool_factory, autocommit=True):
+        self._pool_factory = pool_factory
+        self._autocommit = autocommit
+        self._pool = None
+        self._tasks = []    
+    
+    async def acquire(self) -> PostgresConnection:
+        if not self._pool:
+            self._pool = await self._pool_factory()
+        connection = await self._pool.acquire()
+        transaction = connection.transaction()
+        pg_conn = PostgresConnection(self, connection, transaction)
+        tasks, self._tasks = self._tasks, []
+        for task in tasks:
+            await task(pg_conn)
+        return pg_conn
+    
+    async def release(self, connection: PostgresConnection):
+        await self._pool.release(connection._connection)
+        del connection
+    
+    def on_acquire(self, coroutine: Coroutine[ConnectionProtocol]) -> None:
+        self._tasks.append(coroutine)
+    
+    async def close(self):
+        self._pool.close()
+
+
+def Postgres(
+        dsn: Optional[str] = None,
+        *,
+        host: Optional[str] = None,
+        port: Optional[int] = None,
+        user: Optional[str] = None,
+        password: Optional[str] = None,
+        database: Optional[str] = None,
+        server_settings: Optional[dict] = None,
+        autocommit: bool = True) -> PostgresPool:
+    return PostgresPool(
+        partial(
+            asyncpg.create_pool,
+            dsn,
+            server_settings=server_settings
+        ) if dsn else partial(
+            asyncpg.create_pool,
+            host=host,
+            port=port,
+            user=user,
+            password=password,
+            database=database,
+            server_settings=server_settings
+        ),
+        autocommit=autocommit
+    )

slinn_orm-0.0.3/orm/sqlite/__init__.py

@@ -0,0 +1,335 @@
+from __future__ import annotations
+from functools import partial
+from typing import Any, Coroutine, Optional, Final
+from .. import CollectionProtocol, ConnectionProtocol, PoolProtocol
+from ..attributed_dict import AttributedDict
+from ..typemap import typemap as tm
+from ..order import OrderType
+from ..models import (Model, Field, BoolField, IntegerField, DecimalField, FloatField, TextField, TimeField, TimeDeltaField, 
+                      BinaryField, UIDField, UUIDField)
+from datetime import datetime, timedelta
+import aiosqlite
+import asyncio
+
+
+class SQLiteCollection(CollectionProtocol):
+    def __init__(self, connection: SQLiteConnection, name: str):
+        self.connection = connection
+        self.name = name
+
+    async def find(
+        self,
+        _filter: dict,
+        *,
+        fields: tuple[str] = ("*",),
+        order: tuple[tuple[OrderType, str]] = (),
+    ) -> list[dict]:
+        where_clause = ""
+        params = []
+        if _filter:
+            conditions = [f"{key} = ?" for key in _filter.keys()]
+            where_clause = f"WHERE {' AND '.join(conditions)}"
+            params.extend(_filter.values())
+
+        order_clause = ""
+        if order:
+            order_parts = [
+                f"{col} {'ASC' if dir == OrderType.ASC else 'DESC'}"
+                for dir, col in order
+            ]
+            order_clause = f"ORDER BY {', '.join(order_parts)}"
+
+        query = f"SELECT {', '.join(fields)} FROM {self.name} {where_clause} {order_clause}"
+        rows = await self.connection._fetch(query, *params)
+        return [AttributedDict(row) for row in rows]
+
+    async def find_one(
+        self, _filter: dict, *, fields: tuple[str] = ("*",)
+    ) -> Optional[dict]:
+        result = await self.find(_filter, fields=fields)
+        return result[0] if result else None
+
+    async def insert(
+        self,
+        _object: dict,
+        *,
+        returning: tuple[str] = (),
+        typemap: Optional[dict] = None,
+    ) -> Optional[dict]:
+        if not _object:
+            return None
+
+        data = tm(_object, typemap)
+        columns = ", ".join(data.keys())
+        placeholders = ", ".join(["?"] * len(data))
+        returning_clause = ""
+        if returning:
+            returning_clause = f"RETURNING {', '.join(returning)}"
+
+        query = f"INSERT INTO {self.name}({columns}) VALUES({placeholders}) {returning_clause}"
+        rows = await self.connection._fetch(query, *data.values())
+        return rows[0] if rows else None
+
+    async def update(
+        self,
+        _filter: dict,
+        _object: dict,
+        *,
+        returning: tuple[str] = (),
+        typemap: Optional[dict] = None,
+    ) -> list[dict]:
+        if not _object:
+            return []
+
+        data = tm(_object, typemap)
+        set_clause = ", ".join([f"{key} = ?" for key in data.keys()])
+        params = list(data.values())
+
+        where_clause = ""
+        if _filter:
+            conditions = [f"{key} = ?" for key in _filter.keys()]
+            where_clause = f"WHERE {' AND '.join(conditions)}"
+            params.extend(_filter.values())
+
+        returning_clause = ""
+        if returning:
+            returning_clause = f"RETURNING {', '.join(returning)}"
+
+        query = f"UPDATE {self.name} SET {set_clause} {where_clause} {returning_clause}"
+        return await self.connection._fetch(query, *params)
+
+    async def delete(self, _filter: dict) -> None:
+        where_clause = ""
+        params = []
+        if _filter:
+            conditions = [f"{key} = ?" for key in _filter.keys()]
+            where_clause = f"WHERE {' AND '.join(conditions)}"
+            params.extend(_filter.values())
+
+        query = f"DELETE FROM {self.name} {where_clause}"
+        await self.connection._execute(query, *params)
+
+    async def pop(
+        self, _filter: dict, *, returning: tuple[str] = ("*",)
+    ) -> Optional[dict]:
+        where_clause = ""
+        params = []
+        if _filter:
+            conditions = [f"{key} = ?" for key in _filter.keys()]
+            where_clause = f"WHERE {' AND '.join(conditions)}"
+            params.extend(_filter.values())
+
+        returning_clause = f"RETURNING {', '.join(returning)}" if returning else ""
+        query = f"DELETE FROM {self.name} {where_clause} {returning_clause}"
+        rows = await self.connection._fetch(query, *params)
+        return rows[0] if rows else None
+
+    async def count(self, _filter: dict) -> int:
+        where_clause = ""
+        params = []
+        if _filter:
+            conditions = [f"{key} = ?" for key in _filter.keys()]
+            where_clause = f"WHERE {' AND '.join(conditions)}"
+            params.extend(_filter.values())
+
+        query = f"SELECT COUNT(*) FROM {self.name} {where_clause}"
+        rows = await self.connection._fetch(query, *params)
+        return rows[0][0] if rows else 0
+
+    async def get_size(self) -> int:
+        rows = await self.connection._fetch(
+            f'''
+                SELECT COUNT(*) * pgsize AS table_size_bytes
+                FROM sqlite_dbpage, (SELECT page_size AS pgsize FROM pragma_page_size())
+                WHERE schema = 'main' AND pgno IN (
+                    SELECT rootpage FROM sqlite_schema WHERE tbl_name = '{self.name}'
+                );
+            '''
+        )
+        return rows[0] if rows else 0
+
+    async def drop(self, *, not_exists_ok: bool = False) -> None: 
+        await self.connection._fetch(f'DROP TABLE {'IF EXISTS ' if not_exists_ok else ''}{self.name};')
+
+
+class SQLiteConnection(ConnectionProtocol):
+    FIELDS_MAP: Final[dict] = {
+        BoolField: lambda field: 'INTEGER',
+        IntegerField: lambda field: 'INTEGER',
+        DecimalField: lambda field: 'DECIMAL',
+        FloatField: lambda field: 'REAL',
+        TextField: lambda field: 'TEXT',
+        TimeField: lambda field: 'INTEGER' + (
+            '' if field.default is None else (' DEFAULT ' + {
+                datetime: lambda dt: f'{dt.timestamp()}',
+                timedelta: lambda td: f'(unixepoch() + {td.total_seconds()})'
+            }[type(field.default)](field.default))
+        ),
+        TimeDeltaField: lambda field: 'INTEGER',
+        BinaryField: lambda field: 'BLOB',
+        UIDField: lambda field: 'INTEGER',
+        UUIDField: lambda field: 'TEXT'
+    }
+
+    def __init__(self, pool: SQLitePool, connection: aiosqlite.Connection, autocommit: bool = True):
+        self._pool = pool
+        self._connection = connection
+        self._autocommit = autocommit
+        self._in_transaction = False
+        self.collection = self.__getattr__
+
+    def __getattr__(self, key) -> CollectionProtocol:
+        return SQLiteCollection(self, key)
+
+    async def rollback(self) -> None:
+        await self._connection.rollback()
+        self._in_transaction = False
+
+    async def commit(self) -> None:
+        await self._connection.commit()
+        self._in_transaction = False
+
+    async def collections(self) -> list[str]:
+        rows = await self._fetch(
+            "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name"
+        )
+        return [row[0] for row in rows]
+
+    async def create(self, model: Model, *, exists_ok=False) -> None:
+        model._update_meta(model)
+        fields = []
+        for field_name in model.__dict__.keys():
+            field = getattr(model, field_name)
+            if field_name.startswith('_') or not isinstance(field, Field):
+                continue
+            fields.append(
+                f'''
+                    {field_name} {self.FIELDS_MAP[type(field)](field)}
+                    {'PRIMARY KEY' if len(model._meta_primary_keys) == 1 and field_name in model._meta_primary_keys else ''}
+                    {'AUTOINCREMENT' if hasattr(field, 'identity') and field.identity else ''}
+                    {'UNIQUE' if hasattr(field, 'unique') and field.unique else ''}
+                    {'NOT NULL' if (hasattr(field, 'not_null') and field.not_null) or field_name not in model._meta_primary_keys else ''}
+                    {f'REFERENCES {field.reference.collection_name}({field.reference.field_name})' 
+                     if hasattr(field, 'reference') and field.reference else ''}
+                '''.strip()
+            )
+        await self._fetch(f'''
+            CREATE TABLE {'IF NOT EXISTS ' if exists_ok else ''}{model.__collection_name__()}(
+                {','.join(fields)}
+                {f',PRIMARY KEY ({','.join(model._meta_primary_keys)})' if len(model._meta_primary_keys) > 1 else ''}
+            );
+        '''.strip())
+    
+    async def create_index(
+        self,
+        index_name: str,
+        collection_name: str,
+        fields: tuple[str],
+        *,
+        exists_ok: bool=False,
+        unique: bool=False
+    ) -> None:
+        print(f"""
+            CREATE {'UNIQUE ' if unique else ''}INDEX {'IF NOT EXISTS ' if exists_ok else ''}{index_name} ON {collection_name}({','.join(fields)});
+        """)
+        await self._fetch(f'''
+            CREATE {'UNIQUE ' if unique else ''}INDEX {'IF NOT EXISTS ' if exists_ok else ''}{index_name} ON {collection_name}({','.join(fields)});
+        ''')
+
+    async def __aenter__(self):
+        await self._connection.execute("BEGIN")
+        self._in_transaction = True
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        try:
+            if not exc_type and self._autocommit:
+                await self.commit()
+            else:
+                await self.rollback()
+        finally:
+            await self._pool.release(self)
+
+    async def _fetch(self, query: str, *args, timeout: Optional[float] = None) -> list:
+        async with asyncio.timeout(timeout):
+            query = " ".join(line.strip() for line in query.split("\n")).strip()
+            async with self._connection.execute(query, args) as cursor:
+                return await cursor.fetchall()
+
+    async def _execute(self, query: str, *args) -> None:
+        query = " ".join(line.strip() for line in query.split("\n")).strip()
+        await self._connection.execute(query, args)
+
+
+class SQLitePool(PoolProtocol):
+    def __init__(self, database: str, autocommit: bool = True, **kwargs):
+        self._database = database
+        self._autocommit = autocommit
+        self._kwargs = kwargs  # additional aiosqlite.connect kwargs
+        self._pool: list[aiosqlite.Connection] = []
+        self._lock = asyncio.Lock()
+        self._tasks: list[Coroutine[Any, Any, Any]] = []
+        self._closed = False
+    
+    async def acquire(self) -> SQLiteConnection:
+        async with self._lock:
+            if self._closed:
+                raise RuntimeError("Pool is closed")
+            if self._pool:
+                conn = self._pool.pop()
+            else:
+                conn = await aiosqlite.connect(self._database, **self._kwargs)
+                await conn.execute("PRAGMA foreign_keys = ON")
+                # row_factory будет установлен ниже единообразно
+            # Устанавливаем row_factory для любой сессии из пула или новой
+            conn.row_factory = aiosqlite.Row
+
+        sqlite_conn = SQLiteConnection(self, conn, self._autocommit)
+        tasks, self._tasks = self._tasks, []
+        for task in tasks:
+            await task(sqlite_conn)
+        return sqlite_conn
+
+    async def release(self, connection: SQLiteConnection) -> None:
+        conn = connection._connection
+        if connection._in_transaction:
+            await conn.rollback()
+        # Сбрасываем row_factory на стандартный (кортежи), чтобы не влиять на другие возможные использования
+        conn.row_factory = None
+        async with self._lock:
+            if not self._closed:
+                self._pool.append(conn)
+            else:
+                await conn.close()
+        del connection
+
+    def on_acquire(self, coroutine: Coroutine[ConnectionProtocol, Any, Any]) -> None:
+        self._tasks.append(coroutine)
+
+    async def close(self) -> None:
+        async with self._lock:
+            self._closed = True
+            for conn in self._pool:
+                await conn.close()
+            self._pool.clear()
+        await asyncio.sleep(0)
+
+
+def SQLite(
+    dsn: Optional[str] = None,
+    *,
+    database: Optional[str] = None,
+    autocommit: bool = True,
+    **kwargs,
+) -> SQLitePool:
+    """
+    Create an asynchronous SQLite connection pool.
+
+    :param database: Path to the SQLite database file (use ":memory:" for in-memory)
+    :param autocommit: Whether to auto-commit after successful operations
+    :param kwargs: Additional arguments passed to aiosqlite.connect
+    :return: SQLitePool instance
+    """
+    if dsn:
+        return SQLitePool(dsn.split(':')[1], autocommit=autocommit, **kwargs)
+    return SQLitePool(database, autocommit=autocommit, **kwargs)

slinn_orm-0.0.3/orm/typemap.py

@@ -0,0 +1,9 @@
+def typemap(
+    _dict: dict,
+    _types: dict | None) -> dict:
+        if not _types:
+            return _dict.copy()
+        _dict = _dict.copy()
+        for _key, _type in _types.items():
+            _dict[_key] = _type(_dict[_key])
+        return _dict

slinn_orm-0.0.3/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "slinn-orm"
+version = "0.0.3"
+description = "ORM for Slinn"
+requires-python = ">=3.14"
+authors = [{ name = "Mark Radin", email = "openmiot@gmail.com" }]
+
+[project.optional-dependencies]
+postgres = ["asyncpg"]
+sqlite = ["aiosqlite"]
+full = ["slinn-orm[postgres]", "slinn-orm[sqlite]"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["orm*"]
+
+[tool.uv]
+managed = true
+workspace = { } 

slinn_orm-0.0.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

slinn_orm-0.0.3/slinn_orm.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: slinn-orm
+Version: 0.0.3
+Summary: ORM for Slinn
+Author-email: Mark Radin <openmiot@gmail.com>
+Requires-Python: >=3.14
+License-File: LICENSE
+Provides-Extra: postgres
+Requires-Dist: asyncpg; extra == "postgres"
+Provides-Extra: sqlite
+Requires-Dist: aiosqlite; extra == "sqlite"
+Provides-Extra: full
+Requires-Dist: slinn-orm[postgres]; extra == "full"
+Requires-Dist: slinn-orm[sqlite]; extra == "full"
+Dynamic: license-file

slinn_orm-0.0.3/slinn_orm.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+pyproject.toml
+orm/__init__.py
+orm/attributed_dict.py
+orm/models.py
+orm/order.py
+orm/typemap.py
+orm/postgres/__init__.py
+orm/sqlite/__init__.py
+slinn_orm.egg-info/PKG-INFO
+slinn_orm.egg-info/SOURCES.txt
+slinn_orm.egg-info/dependency_links.txt
+slinn_orm.egg-info/requires.txt
+slinn_orm.egg-info/top_level.txt

slinn_orm-0.0.3/slinn_orm.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

slinn_orm-0.0.3/slinn_orm.egg-info/requires.txt

@@ -0,0 +1,10 @@
+
+[full]
+slinn-orm[postgres]
+slinn-orm[sqlite]
+
+[postgres]
+asyncpg
+
+[sqlite]
+aiosqlite

slinn_orm-0.0.3/slinn_orm.egg-info/top_level.txt

@@ -0,0 +1 @@
+orm