dclassql 0.1.2__tar.gz → 0.1.3__tar.gz

{dclassql-0.1.2 → dclassql-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dclassql
-Version: 0.1.2
+Version: 0.1.3
 Summary: A type-safe ORM generator for Python, creating fully type-hinted database clients from plain dataclass definitions.
 Keywords: orm,codegen,sqlite,dataclass,typed
 Author: myuanz

{dclassql-0.1.2 → dclassql-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dclassql"
-version = "0.1.2"
+version = "0.1.3"
 description = "A type-safe ORM generator for Python, creating fully type-hinted database clients from plain dataclass definitions."
 readme = "README.md"
 authors = [

{dclassql-0.1.2 → dclassql-0.1.3}/src/dclassql/__init__.py

@@ -1,3 +1,4 @@
+from .model_inspector import DataSourceConfig
 from .db_pool import BaseDBPool, save_local
 from .push import db_push
 from .runtime.backends.lazy import eager
@@ -24,4 +25,5 @@ __all__ = [
     'unwarp_or_raise',
     'BaseDBPool',
     'save_local',
+    'DataSourceConfig',
 ]

{dclassql-0.1.2 → dclassql-0.1.3}/src/dclassql/client.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from types import MappingProxyType
 from typing import Any, Literal, Mapping, Sequence, NotRequired
 from typing_extensions import TypedDict
 
+from dclassql import DataSourceConfig
 from dclassql.db_pool import BaseDBPool, save_local
 from dclassql.runtime.backends import BackendProtocol, ColumnSpec, ForeignKeySpec, RelationSpec
 from dclassql.runtime.datasource import open_sqlite_connection
@@ -12,18 +13,6 @@ from dclassql.runtime.datasource import open_sqlite_connection
 from datetime import datetime
 from dclassql.generated_models.test_models import Address, BirthDay, Book, User, UserBook
 
-@dataclass(slots=True)
-class DataSourceConfig:
-    provider: str
-    url: str | None
-    name: str | None = None
-
-    @property
-    def key(self) -> str:
-        return self.name or self.provider
-
-
-
 TAddressIncludeCol = Literal['user']
 TAddressSortableCol = Literal['id', 'location', 'user_id']
 
@@ -57,6 +46,7 @@ class AddressOrderByDict(TypedDict, total=False, closed=True):
 class AddressTable:
     model = Address
     insert_model = AddressInsert
+    table_name: str = 'Address'
     datasource = DataSourceConfig(provider='sqlite', url='sqlite:///test.db', name=None)
     column_specs: tuple[ColumnSpec, ...] = (
         ColumnSpec(name='id', optional=False, auto_increment=True, has_default=False, has_default_factory=False),
@@ -84,6 +74,9 @@ class AddressTable:
     def __init__(self, backend: BackendProtocol) -> None:
         self._backend = backend
 
+    def __str__(self) -> str:
+        return self._backend.escape_identifier(self.table_name)
+
     def insert(self, data: AddressInsert | AddressInsertDict) -> Address:
         return self._backend.insert(self, data)
 
@@ -133,6 +126,7 @@ class BirthDayOrderByDict(TypedDict, total=False, closed=True):
 class BirthDayTable:
     model = BirthDay
     insert_model = BirthDayInsert
+    table_name: str = 'BirthDay'
     datasource = DataSourceConfig(provider='sqlite', url='sqlite:///test.db', name=None)
     column_specs: tuple[ColumnSpec, ...] = (
         ColumnSpec(name='user_id', optional=False, auto_increment=False, has_default=False, has_default_factory=False),
@@ -159,6 +153,9 @@ class BirthDayTable:
     def __init__(self, backend: BackendProtocol) -> None:
         self._backend = backend
 
+    def __str__(self) -> str:
+        return self._backend.escape_identifier(self.table_name)
+
     def insert(self, data: BirthDayInsert | BirthDayInsertDict) -> BirthDay:
         return self._backend.insert(self, data)
 
@@ -208,6 +205,7 @@ class BookOrderByDict(TypedDict, total=False, closed=True):
 class BookTable:
     model = Book
     insert_model = BookInsert
+    table_name: str = 'Book'
     datasource = DataSourceConfig(provider='sqlite', url='sqlite:///test.db', name=None)
     column_specs: tuple[ColumnSpec, ...] = (
         ColumnSpec(name='id', optional=False, auto_increment=True, has_default=False, has_default_factory=False),
@@ -227,6 +225,9 @@ class BookTable:
     def __init__(self, backend: BackendProtocol) -> None:
         self._backend = backend
 
+    def __str__(self) -> str:
+        return self._backend.escape_identifier(self.table_name)
+
     def insert(self, data: BookInsert | BookInsertDict) -> Book:
         return self._backend.insert(self, data)
 
@@ -286,6 +287,7 @@ class UserOrderByDict(TypedDict, total=False, closed=True):
 class UserTable:
     model = User
     insert_model = UserInsert
+    table_name: str = 'User'
     datasource = DataSourceConfig(provider='sqlite', url='sqlite:///test.db', name=None)
     column_specs: tuple[ColumnSpec, ...] = (
         ColumnSpec(name='id', optional=False, auto_increment=True, has_default=False, has_default_factory=False),
@@ -309,6 +311,9 @@ class UserTable:
     def __init__(self, backend: BackendProtocol) -> None:
         self._backend = backend
 
+    def __str__(self) -> str:
+        return self._backend.escape_identifier(self.table_name)
+
     def insert(self, data: UserInsert | UserInsertDict) -> User:
         return self._backend.insert(self, data)
 
@@ -363,6 +368,7 @@ class UserBookOrderByDict(TypedDict, total=False, closed=True):
 class UserBookTable:
     model = UserBook
     insert_model = UserBookInsert
+    table_name: str = 'UserBook'
     datasource = DataSourceConfig(provider='sqlite', url='sqlite:///test.db', name=None)
     column_specs: tuple[ColumnSpec, ...] = (
         ColumnSpec(name='user_id', optional=False, auto_increment=False, has_default=False, has_default_factory=False),
@@ -397,6 +403,9 @@ class UserBookTable:
     def __init__(self, backend: BackendProtocol) -> None:
         self._backend = backend
 
+    def __str__(self) -> str:
+        return self._backend.escape_identifier(self.table_name)
+
     def insert(self, data: UserBookInsert | UserBookInsertDict) -> UserBook:
         return self._backend.insert(self, data)
 

{dclassql-0.1.2 → dclassql-0.1.3}/src/dclassql/codegen.py

@@ -73,6 +73,7 @@ class RelationRender:
 class ModelRenderContext:
     name: str
     datasource_expr: str
+    table_name_literal: str
     insert_fields: tuple[InsertFieldSpec, ...]
     typed_dict_fields: tuple[TypedDictFieldSpec, ...]
     where_fields: tuple[WhereFieldSpec, ...]
@@ -253,6 +254,7 @@ def _build_model_context(
     return ModelRenderContext(
         name=name,
         datasource_expr=datasource_expr,
+        table_name_literal=repr(name),
         insert_fields=tuple(insert_fields),
         typed_dict_fields=tuple(typed_dict_fields),
         where_fields=tuple(where_fields),

{dclassql-0.1.2 → dclassql-0.1.3}/src/dclassql/runtime/backends/base.py

@@ -49,17 +49,9 @@ class BackendBase(BackendProtocol, ABC):
         sql = self._render_query(insert_query)
         returning_columns = [spec.name for spec in table.column_specs]
         sql_with_returning = self._append_returning(sql, returning_columns)
-        cursor = self._execute(sql_with_returning, params, auto_commit=False)
-        connection = getattr(cursor, "connection", None)
-        row: Any | None = None
-        try:
-            row = cursor.fetchone()
-            if row is None:
-                raise RuntimeError("Inserted row not returned by backend")
-            if connection is not None:
-                connection.commit()
-        finally:
-            cursor.close()
+
+        row = self.query_raw(sql_with_returning, params, auto_commit=True)[0]
+
         result = self._row_to_model(table, row, include_map={})
         self._invalidate_backrefs(table, result)
         return result
@@ -116,7 +108,7 @@ class BackendBase(BackendProtocol, ABC):
             select_query = select_query.limit(take)
 
         sql = self._render_query(select_query)
-        rows = self._fetch_all(sql, params)
+        rows = self.query_raw(sql, params)
         include_map = include or {}
         return [self._row_to_model(table, row, include_map) for row in rows]
 
@@ -205,6 +197,17 @@ class BackendBase(BackendProtocol, ABC):
             raise RuntimeError("Inserted row could not be reloaded")
         return results[0]
 
+    def query_raw(self, sql: str, params: Sequence[object] | None = None, auto_commit: bool = False) -> Sequence[object]:
+        raise NotImplementedError
+
+    def execute_raw(self, sql: str, params: Sequence[object] | None = None, auto_commit: bool = True) -> int:
+        raise NotImplementedError
+
+    def escape_identifier(self, name: str) -> str:
+        if self.quote_char:
+            return format_quotes(name, self.quote_char)
+        raise ValueError("Backend does not support identifier quoting without a quote character set")
+
     def _invalidate_backrefs(
         self,
         table: TableProtocol[ModelT, InsertT, WhereT, IncludeT, OrderByT],
@@ -313,11 +316,3 @@ class BackendBase(BackendProtocol, ABC):
         else:
             column_sql = ", ".join(columns)
         return f"{trimmed} RETURNING {column_sql};"
-
-    @abstractmethod
-    def _fetch_all(self, sql: str, params: Sequence[Any]) -> Sequence[Any]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def _execute(self, sql: str, params: Sequence[Any], *, auto_commit: bool = True) -> Any:
-        raise NotImplementedError

{dclassql-0.1.2 → dclassql-0.1.3}/src/dclassql/runtime/backends/protocols.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import sqlite3
 from typing import Callable, Literal, Mapping, Protocol, Sequence, runtime_checkable
 
+from dclassql.model_inspector import DataSourceConfig
 from dclassql.typing import IncludeT, InsertT, ModelT, OrderByT, WhereT
 
 from .metadata import ColumnSpec, ForeignKeySpec, RelationSpec
@@ -21,9 +22,13 @@ class TableProtocol[
 
     model: type[ModelT]
     insert_model: type[InsertT]
+    table_name: str
+    datasource: DataSourceConfig
     column_specs: tuple[ColumnSpec, ...]
     column_specs_by_name: Mapping[str, ColumnSpec]
     primary_key: tuple[str, ...]
+    indexes: tuple[tuple[str, ...], ...]
+    unique_indexes: tuple[tuple[str, ...], ...]
     foreign_keys: tuple[ForeignKeySpec, ...]
     relations: tuple[RelationSpec[BackendProtocol], ...]
 
@@ -64,3 +69,9 @@ class BackendProtocol(Protocol):
         order_by: OrderByT | None = None,
         skip: int | None = None,
     ) -> ModelT | None: ...
+
+    def query_raw(self, sql: str, params: Sequence[object] | None = None, auto_commit: bool = False) -> Sequence[object]: ...
+
+    def execute_raw(self, sql: str, params: Sequence[object] | None = None, auto_commit: bool = True) -> int: ...
+
+    def escape_identifier(self, name: str) -> str: ...

{dclassql-0.1.2 → dclassql-0.1.3}/src/dclassql/runtime/backends/sqlite.py

@@ -83,16 +83,6 @@ class SQLiteBackend(BackendBase):
                 results.append(instance)
             start = end
         return results
-    def _fetch_all(self, sql: str, params: Sequence[Any]) -> list[sqlite3.Row]:
-        cursor = self._execute(sql, params)
-        return cursor.fetchall()
-
-    def _execute(self, sql: str, params: Sequence[Any], *, auto_commit: bool = True) -> sqlite3.Cursor:
-        connection = self._acquire_connection()
-        cursor = connection.execute(sql, tuple(params))
-        if auto_commit:
-            connection.commit()
-        return cursor
 
     def _acquire_connection(self) -> sqlite3.Connection:
         if self._factory is None:
@@ -126,3 +116,27 @@ class SQLiteBackend(BackendBase):
             connection.close()
             delattr(self._local, "connection")
         self._clear_identity_map()
+
+    def query_raw(self, sql: str, params: Sequence[object] | None = None, auto_commit: bool = False) -> Sequence[object]:
+        connection = self._acquire_connection()
+        cursor = connection.execute(sql, params or ())
+
+        try:
+            rows = cursor.fetchall()
+
+            if auto_commit:
+                connection.commit()
+        finally:
+            cursor.close()
+        return rows
+
+    def execute_raw(self, sql: str, params: Sequence[object] | None = None, auto_commit: bool = True) -> int:
+        connection = self._acquire_connection()
+        cursor = connection.execute(sql, params or ())
+        try:
+            affected = cursor.rowcount
+            if auto_commit:
+                connection.commit()
+        finally:
+            cursor.close()
+        return affected

{dclassql-0.1.2 → dclassql-0.1.3}/src/dclassql/templates/client_module.py.jinja

@@ -1,8 +1,6 @@
 {% import 'partials/macros.jinja' as macros %}
 {% include 'partials/imports.jinja' %}
 
-{% include 'partials/datasource_config.jinja' %}
-
 {% for model in models %}
 {% include 'partials/model_section.jinja' %}
 {% endfor %}

{dclassql-0.1.2 → dclassql-0.1.3}/src/dclassql/templates/partials/imports.jinja

@@ -5,6 +5,7 @@ from types import MappingProxyType
 from typing import Any, Literal, Mapping, Sequence, NotRequired
 from typing_extensions import TypedDict
 
+from dclassql import DataSourceConfig
 from dclassql.db_pool import BaseDBPool, save_local
 from dclassql.runtime.backends import BackendProtocol, ColumnSpec, ForeignKeySpec, RelationSpec
 from dclassql.runtime.datasource import open_sqlite_connection

{dclassql-0.1.2 → dclassql-0.1.3}/src/dclassql/templates/partials/model_section.jinja

@@ -51,6 +51,7 @@ class {{ order_by_dict_class }}(TypedDict, total=False, closed=True):
 class {{ table_class }}:
     model = {{ name }}
     insert_model = {{ insert_class }}
+    table_name: str = {{ model.table_name_literal }}
     datasource = {{ model.datasource_expr }}
 {{ macros.column_specs(model.column_specs)|indent(4, True) }}
     column_specs_by_name: Mapping[str, ColumnSpec] = MappingProxyType({spec.name: spec for spec in column_specs})
@@ -63,6 +64,9 @@ class {{ table_class }}:
     def __init__(self, backend: {{ backend_signature }}) -> None:
         self._backend = backend
 
+    def __str__(self) -> str:
+        return self._backend.escape_identifier(self.table_name)
+
     def insert(self, data: {{ insert_class }} | {{ insert_dict_class }}) -> {{ name }}:
         return self._backend.insert(self, data)
 
@@ -82,4 +86,3 @@ class {{ table_class }}:
             where=where, include=include, order_by=order_by, 
             skip=skip
         )
-

dclassql-0.1.2/src/dclassql/templates/partials/datasource_config.jinja

@@ -1,11 +0,0 @@
-@dataclass(slots=True)
-class DataSourceConfig:
-    provider: str
-    url: str | None
-    name: str | None = None
-
-    @property
-    def key(self) -> str:
-        return self.name or self.provider
-
-