dclassql 0.4.0__tar.gz → 0.4.1__tar.gz

{dclassql-0.4.0 → dclassql-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dclassql
-Version: 0.4.0
+Version: 0.4.1
 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
@@ -62,11 +62,14 @@ class User:
 写出如下代码时: 
 
 ```python
-from dclassql import client
+from dclassql import Client
+
+client = Client()
 
 client.user.insert({
     "name": "Alice",
     "email": "test@example.com",
+    # 这里缺少 last_login 
 })
 ```
 

{dclassql-0.4.0 → dclassql-0.4.1}/README.md

@@ -41,11 +41,14 @@ class User:
 写出如下代码时: 
 
 ```python
-from dclassql import client
+from dclassql import Client
+
+client = Client()
 
 client.user.insert({
     "name": "Alice",
     "email": "test@example.com",
+    # 这里缺少 last_login 
 })
 ```
 

{dclassql-0.4.0 → dclassql-0.4.1}/pyproject.toml

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

{dclassql-0.4.0 → dclassql-0.4.1}/src/dclassql/cli.py

@@ -52,11 +52,17 @@ def load_module(module_path: Path) -> ModuleType:
         raise ImportError(f"Unable to load module from '{module_path}'")
     module = importlib.util.module_from_spec(spec)
     sys.modules[module_name] = module
-    sys.path.insert(0, str(module_path.parent))
+    original_sys_path = list(sys.path)
+    search_paths = [str(module_path.parent)]
+    cwd = str(Path.cwd())
+    if cwd not in search_paths:
+        search_paths.append(cwd)
+    for path in reversed(search_paths):
+        sys.path.insert(0, path)
     try:
         spec.loader.exec_module(module)
     finally:
-        sys.path.pop(0)
+        sys.path[:] = original_sys_path
     return module
 
 
@@ -87,18 +93,41 @@ def resolve_generated_package_dir(module_path: Path, target: GenerateTarget = "m
 def collect_models(module: ModuleType) -> list[type[Any]]:
     from dataclasses import is_dataclass
 
+    excluded_names = _collect_excluded_model_names(module)
     models: list[type[Any]] = []
     for value in vars(module).values():
-        if isinstance(value, type) and is_dataclass(value) and value.__module__ == module.__name__:
+        if (
+            isinstance(value, type)
+            and is_dataclass(value)
+            and value.__module__ == module.__name__
+            and value.__name__ not in excluded_names
+        ):
             models.append(value)
     if not models:
         raise ValueError("No dataclass models were found in the provided module")
     return models
 
 
+def _collect_excluded_model_names(module: ModuleType) -> set[str]:
+    raw = getattr(module, "__exclude__", ())
+    if raw is None:
+        return set()
+    if isinstance(raw, str):
+        return {raw}
+    names: set[str] = set()
+    for item in raw:
+        if isinstance(item, str):
+            names.add(item)
+            continue
+        if isinstance(item, type):
+            names.add(item.__name__)
+            continue
+        raise TypeError("__exclude__ entries must be dataclass classes or class names")
+    return names
+
+
 def _describe_schema_diff(info: ModelInfo, diff: SchemaDiff) -> str:
-    datasource_key = getattr(info.datasource, "key", None)
-    prefix = f"[{datasource_key}] " if datasource_key else ""
+    prefix = f"[{info.datasource.identity}] "
     parts: list[str] = [f"{prefix}模型 {info.model.__name__} 需要重建表"]
     if diff.added:
         added = ", ".join(f"+{column.name}:{column.type_sql}" for column in diff.added)
@@ -144,32 +173,24 @@ def push_database(
     confirm_mode: ConfirmRebuildMode | None = None,
 ) -> None:
     model_infos = inspect_models(models)
-    connections: dict[str, Any] = {}
-    opened: list[Any] = []
+    datasource_configs = {info.datasource for info in model_infos.values()}
+    if len(datasource_configs) != 1:
+        labels = ", ".join(sorted(config.identity for config in datasource_configs))
+        raise ValueError(f"push-db only supports one datasource, got: {labels}")
+    datasource = next(iter(datasource_configs))
+    if datasource.provider != "sqlite":
+        raise ValueError(f"Unsupported provider '{datasource.provider}'")
     confirm_callback = _build_confirm_callback(confirm_mode) if confirm_mode else None
+    connection = open_sqlite_connection(datasource.url)
     try:
-        for info in model_infos.values():
-            config = info.datasource
-            key = config.key
-            if key in connections:
-                continue
-            if config.provider != "sqlite":
-                raise ValueError(f"Unsupported provider '{config.provider}'")
-            connection = open_sqlite_connection(config.url)
-            connections[key] = connection
-            opened.append(connection)
         db_push(
             models,
-            connections,
+            connection,
             sync_indexes=sync_indexes,
             confirm_rebuild=confirm_callback,
         )
     finally:
-        for conn in opened:
-            try:
-                conn.close()
-            except Exception:
-                pass
+        connection.close()
 
 
 def command_generate(module_path: Path, *, target: GenerateTarget = "model-dir") -> None:

{dclassql-0.4.0 → dclassql-0.4.1}/src/dclassql/codegen.py

@@ -51,14 +51,34 @@ class WhereFieldSpec:
 @dataclass(slots=True)
 class ColumnSpecRender:
     name: str
+    '''数据库列名'''
+
     name_repr: str
+    '''列名的 Python 字符串字面量形式, 用于生成代码里的 dict key.'''
+
     optional: bool
+    '''插入/更新时是否允许 None 或缺省, 来自 Optional/default/factory 判断.'''
+
     auto_increment: bool
+    '''是否自增，给主键用的'''
+
     has_default: bool
+    '''原 dataclass 字段是否有 default'''
+
     has_default_factory: bool
+    '''原 dataclass 字段是否有 default_factory'''
+
+    returned_field: bool
+    '''是否会进入返回的原 dataclass 对象. 隐式 id 为 False.'''
+
     mapping_value_expr: str
+    '''Mapping payload 转数据库值的生成表达式. 例如 `data['open_order_id']`.'''
+
     insert_value_expr: str
+    '''Insert dataclass 或原模型实例转数据库值的生成表达式. 隐式 id 用 getattr 默认 None.'''
+
     is_enum: bool
+    '''是否是 Enum 列'''
 
 
 @dataclass(slots=True)
@@ -128,6 +148,7 @@ class ModelRenderContext:
     indexes_literal: str
     unique_indexes_literal: str
     primary_value_types: tuple[str, ...]
+    primary_key_on_model: bool
     row_assignments: tuple[RowAssignmentRender, ...]
     default_factories: tuple[DefaultFactoryRender, ...]
     model_info: ModelInfo
@@ -135,9 +156,6 @@ class ModelRenderContext:
 
 @dataclass(slots=True)
 class ClientDataSourceContext:
-    key: str
-    key_repr: str
-    provider_repr: str
     url_repr: str
     name_repr: str
 
@@ -237,10 +255,13 @@ def _build_model_context(
     upsert_where_dicts: list[UpsertWhereRender] = []
     dict_field_map: dict[str, str] = {}
     enum_type_map: dict[str, type[Enum] | None] = {}
-    column_lookup: dict[str, ColumnInfo] = {col.name: col for col in info.columns}
-    for col in info.columns:
+    model_column_names = {col.name for col in info.columns}
+    db_columns = _build_db_columns(info)
+    column_lookup: dict[str, ColumnInfo] = {col.name: col for col in db_columns}
+    primary_key_on_model = all(column_name in model_column_names for column_name in info.primary_key)
+    for col in db_columns:
         annotation = _format_insert_annotation(col, renderer)
-        default_fragment = _render_default_fragment(name, col)
+        default_fragment = _render_default_fragment(info.model, col)
         if default_fragment is not None:
             default_expr = default_fragment
         elif col.auto_increment:
@@ -267,8 +288,8 @@ def _build_model_context(
     if info.primary_key:
         pk_fields: list[TypedDictFieldSpec] = []
         for pk_col in info.primary_key:
-            col_info = column_lookup.get(pk_col)
-            annotation = renderer.render(col_info.python_type) if col_info else "object"
+            col_info = column_lookup[pk_col]
+            annotation = renderer.render(col_info.python_type)
             pk_fields.append(TypedDictFieldSpec(name=pk_col, annotation=annotation))
         upsert_where_dicts.append(UpsertWhereRender(name=f"{name}UpsertWherePK", fields=tuple(pk_fields)))
 
@@ -283,8 +304,11 @@ def _build_model_context(
                 UpsertWhereRender(name=f"{name}UpsertWhereUnique{idx}", fields=tuple(unique_fields))
             )
 
+    if not upsert_where_dicts:
+        renderer.require_typing("Never")
+
     where_fields: list[WhereFieldSpec] = []
-    for col in info.columns:
+    for col in db_columns:
         annotation = renderer.render(col.python_type)
         if "None" not in annotation:
             annotation = f"{annotation} | None"
@@ -329,11 +353,16 @@ def _build_model_context(
             auto_increment=column.auto_increment,
             has_default=column.has_default,
             has_default_factory=column.has_default_factory,
+            returned_field=column.name in model_column_names,
             mapping_value_expr=_format_mapping_value_expr(column, enum_type_map.get(column.name)),
-            insert_value_expr=_format_insert_value_expr(column, enum_type_map.get(column.name)),
+            insert_value_expr=_format_insert_value_expr(
+                column,
+                enum_type_map.get(column.name),
+                returned_field=column.name in model_column_names,
+            ),
             is_enum=enum_type_map.get(column.name) is not None,
         )
-        for column in info.columns
+        for column in db_columns
     ]
 
     foreign_keys = [
@@ -360,7 +389,7 @@ def _build_model_context(
 
     datasource_values = info.datasource
     datasource_expr = (
-        f"DataSourceConfig(provider={datasource_values.provider!r}, url={repr(datasource_values.url)}, name={repr(datasource_values.name)})"
+        f"DataSourceConfig(url={repr(datasource_values.url)}, name={repr(datasource_values.name)})"
     )
 
     indexes_literal = _tuple_literal(tuple(tuple(idx) for idx in info.indexes)) if info.indexes else "()"
@@ -368,13 +397,10 @@ def _build_model_context(
         _tuple_literal(tuple(tuple(idx) for idx in info.unique_indexes)) if info.unique_indexes else "()"
     )
 
-    row_assignments, default_factories = _build_row_assignment_context(info, enum_type_map)
+    row_assignments, default_factories = _build_row_assignment_context(info, enum_type_map, renderer)
     primary_value_types: list[str] = []
     for column_name in info.primary_key:
-        column = column_lookup.get(column_name)
-        if column is None:
-            primary_value_types.append("object")
-            continue
+        column = column_lookup[column_name]
         primary_value_types.append(renderer.render(column.python_type))
 
     relation_lookup = {relation.name: relation for relation in info.relations}
@@ -416,24 +442,39 @@ def _build_model_context(
         indexes_literal=indexes_literal,
         unique_indexes_literal=unique_indexes_literal,
         primary_value_types=tuple(primary_value_types),
+        primary_key_on_model=primary_key_on_model,
         row_assignments=tuple(row_assignments),
         default_factories=tuple(default_factories),
         model_info=info,
     )
 
 
+def _build_db_columns(info: ModelInfo) -> tuple[ColumnInfo, ...]:
+    if info.primary_key == ("id",) and all(column.name != "id" for column in info.columns):
+        implicit_id = ColumnInfo(
+            name="id",
+            python_type=int,
+            optional=False,
+            auto_increment=True,
+            storage_kind="scalar",
+            has_default=False,
+            default_value=None,
+            has_default_factory=False,
+            default_factory=None,
+        )
+        return (implicit_id, *info.columns)
+    return tuple(info.columns)
+
+
 def _build_client_context(model_infos: Mapping[str, ModelInfo], client_class_name: str) -> ClientContext:
     datasource_configs = {info.datasource for info in model_infos.values()}
     if len(datasource_configs) != 1:
         labels = ", ".join(
-            f"{ds.key}({ds.provider}, {ds.url!r})" for ds in sorted(datasource_configs, key=lambda item: item.key)
+            f"{ds.identity}({ds.url!r})" for ds in sorted(datasource_configs, key=lambda item: item.identity)
         )
         raise ValueError(f"Generated Client can only use one datasource, got: {labels}")
     datasource = next(iter(datasource_configs))
     datasource_item = ClientDataSourceContext(
-        key=datasource.key,
-        key_repr=repr(datasource.key),
-        provider_repr=repr(datasource.provider),
         url_repr=repr(datasource.url),
         name_repr=repr(datasource.name),
     )
@@ -520,7 +561,7 @@ def _build_relation_entries(info: ModelInfo, model_infos: Mapping[str, ModelInfo
         mapping: tuple[tuple[str, str], ...] | None = None
         if not relation.many:
             for fk in info.foreign_keys:
-                if fk.remote_model is target_model:
+                if fk.remote_model is target_model and fk.relation_attribute == relation.name:
                     mapping = tuple((local, remote) for local, remote in zip(fk.local_columns, fk.remote_columns))
                     break
             if mapping is None:
@@ -556,6 +597,7 @@ def _build_relation_entries(info: ModelInfo, model_infos: Mapping[str, ModelInfo
 def _build_row_assignment_context(
     info: ModelInfo,
     enum_type_map: Mapping[str, type[Enum] | None],
+    renderer: "_TypeRenderer",
 ) -> tuple[list[RowAssignmentRender], list[DefaultFactoryRender]]:
     dataclass_fields = fields(info.model)
     column_map = {column.name: column for column in info.columns}
@@ -571,6 +613,7 @@ def _build_row_assignment_context(
             column_map,
             enum_type_map,
             relation_defaults,
+            renderer,
         )
         assignments.append(RowAssignmentRender(field_name=field_obj.name, value_expr=assignment_expr))
         if default_factory is not None:
@@ -584,12 +627,13 @@ def _resolve_row_assignment(
     column_map: Mapping[str, ColumnInfo],
     enum_type_map: Mapping[str, type[Enum] | None],
     relation_defaults: Mapping[str, str],
+    renderer: "_TypeRenderer",
 ) -> tuple[str, DefaultFactoryRender | None]:
     name = field_obj.name
     column_info = column_map.get(name)
     if column_info is not None:
         enum_type = enum_type_map.get(name)
-        return _column_value_expression(column_info, enum_type), None
+        return _column_value_expression(column_info, enum_type, renderer), None
     if field_obj.default is not MISSING:
         return f"{model_cls.__name__}.__dataclass_fields__[{name!r}].default", None
     if field_obj.default_factory is not MISSING:
@@ -602,8 +646,14 @@ def _resolve_row_assignment(
     return _infer_field_fallback(field_obj.type), None
 
 
-def _column_value_expression(column: ColumnInfo, enum_type: type[Enum] | None) -> str:
+def _column_value_expression(
+    column: ColumnInfo,
+    enum_type: type[Enum] | None,
+    renderer: "_TypeRenderer",
+) -> str:
     base_expr = f"row[{column.name!r}]"
+    if column.storage_kind == "json":
+        return f"deserialize_json_value({base_expr}, {renderer.render(column.python_type)})"
     if enum_type is None:
         return base_expr
     converter = enum_type.__name__
@@ -613,6 +663,8 @@ def _column_value_expression(column: ColumnInfo, enum_type: type[Enum] | None) -
 
 
 def _format_mapping_value_expr(column: ColumnInfo, enum_type: type[Enum] | None) -> str:
+    if column.storage_kind == "json":
+        return f"serialize_json_value(data[{column.name!r}])"
     if enum_type is None:
         return f"data[{column.name!r}]"
     value_expr = f"data[{column.name!r}]"
@@ -621,7 +673,16 @@ def _format_mapping_value_expr(column: ColumnInfo, enum_type: type[Enum] | None)
     return f"{value_expr}.value"
 
 
-def _format_insert_value_expr(column: ColumnInfo, enum_type: type[Enum] | None) -> str:
+def _format_insert_value_expr(
+    column: ColumnInfo,
+    enum_type: type[Enum] | None,
+    *,
+    returned_field: bool = True,
+) -> str:
+    if not returned_field:
+        return f"getattr(data, {column.name!r}, None)"
+    if column.storage_kind == "json":
+        return f"serialize_json_value(data.{column.name})"
     if enum_type is None:
         return f"data.{column.name}"
     value_expr = f"data.{column.name}"
@@ -673,12 +734,12 @@ def _format_insert_annotation(col: ColumnInfo, renderer: "_TypeRenderer") -> str
     return annotation
 
 
-def _render_default_fragment(model_name: str, col: ColumnInfo) -> str | None:
+def _render_default_fragment(model_cls: type[Any], col: ColumnInfo) -> str | None:
     if col.has_default_factory and col.default_factory is not None:
-        factory_expr = f"{model_name}.__dataclass_fields__['{col.name}'].default_factory"
+        factory_expr = f"{model_cls.__name__}.__dataclass_fields__['{col.name}'].default_factory"
         return f"field(default_factory={factory_expr})"
     if col.has_default:
-        return repr(col.default_value)
+        return f"{model_cls.__name__}.__dataclass_fields__['{col.name}'].default"
     return None
 
 
@@ -907,6 +968,14 @@ class _TypeRenderer:
         self._typing_imports: set[str] = set()
 
     def render(self, tp: Any) -> str:
+        alias_value = getattr(tp, "__value__", None)
+        if alias_value is not None:
+            alias_name = getattr(tp, "__name__", None)
+            alias_module = getattr(tp, "__module__", None)
+            if isinstance(alias_name, str) and isinstance(alias_module, str):
+                self._module_imports[alias_module].add(alias_name)
+                return alias_name
+            return self.render(alias_value)
         if tp is Any:
             return "Any"
         if tp is type(None):

dclassql-0.4.1/src/dclassql/db_pool.py

@@ -0,0 +1,89 @@
+import functools
+import sqlite3
+import threading
+from typing import Any, Callable, Concatenate, Protocol
+
+
+class HasLocalClass(Protocol):
+    _local: threading.local
+
+
+def save_local[C: HasLocalClass, **P, T](
+    func: Callable[Concatenate[C, P], T] | None = None,
+    *,
+    key: Callable[[Any, Callable[..., object]], object] | None = None,
+) -> Callable[[Callable[Concatenate[C, P], T]], Callable[Concatenate[C, P], T]] | Callable[Concatenate[C, P], T]:
+    def decorator(func: Callable[Concatenate[C, P], T]) -> Callable[Concatenate[C, P], T]:
+        @functools.wraps(func)
+        def wrapper(self: C, *args: P.args, **kwargs: P.kwargs) -> T:
+            cache = getattr(self._local, "_dclassql_cache", None)
+            if cache is None:
+                cache = {}
+                self._local._dclassql_cache = cache
+
+            cache_key = key(self, func) if key is not None else func.__name__
+            if cache_key in cache:
+                return cache[cache_key]
+
+            value = func(self, *args, **kwargs)
+            cache[cache_key] = value
+            return value
+
+        return wrapper
+
+    if func is not None:
+        return decorator(func)
+    return decorator
+
+
+class BaseDBPool:
+    ''' Thread-level database pool base class. Methods decorated with `@save_local` are cached in `threading.local()`. Usage example:
+    ```python
+    class ExampleDBPool(BaseDBPool):
+        sqlite_db_path = 'data/news.db'
+        visitor_sqlite_db_path = 'data/visitors.db'
+
+        @save_local
+        def sqlite_conn(self) -> sqlite3.Connection:
+            conn = sqlite3.connect(self.sqlite_db_path, check_same_thread=False)
+            self._setup_sqlite_db(conn)
+            return conn
+
+        @save_local
+        def fastlite_conn(self):
+            from fastlite import database
+            fastlite_db = database(self.sqlite_db_path)
+            return fastlite_db
+
+        @save_local
+        def fastlite_conn_visitor(self):
+            from fastlite import database
+            fastlite_db_visitor = database(self.visitor_sqlite_db_path)
+            self._setup_sqlite_db(fastlite_db_visitor.conn)
+            return fastlite_db_visitor
+    ```
+    '''
+
+    _local = threading.local()
+
+    @classmethod
+    def close_all(cls, verbose: bool = False):
+        cache = getattr(cls._local, "_dclassql_cache", None)
+        if cache is None:
+            return
+        for key, obj in list(cache.items()):
+            label = repr(key)
+            if hasattr(obj, 'close') and callable(obj.close):
+                if verbose:
+                    print(f'Closing {label}')
+                obj.close()
+            del cache[key]
+
+    @classmethod
+    def _setup_sqlite_db(cls, conn: sqlite3.Connection):
+        conn.execute('PRAGMA journal_mode = WAL;')
+        conn.execute('PRAGMA synchronous = NORMAL;')
+        conn.execute('pragma temp_store = memory;')
+        conn.execute('pragma page_size = 32768;')
+        conn.execute("PRAGMA busy_timeout = 3000;")
+        conn.execute('PRAGMA journal_size_limit=104857600;')