dclassql 0.1.6__tar.gz → 0.3.0__tar.gz

{dclassql-0.1.6 → dclassql-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dclassql
-Version: 0.1.6
+Version: 0.3.0
 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
@@ -86,7 +86,7 @@ uv add dclassql
 
 ## 当前状态
 
-DataclassQL 仍在早期开发阶段, 已完成代码生成和 SQLite 支持, 后续将扩展更多数据库与查询功能. 
+DataclassQL 仍在早期开发阶段, 但不是无根浮萍, 我已经在另外两个项目里大量使用, 目前基于其他项目的反馈来更新. 
 
 ## 一份更长的例子
 

{dclassql-0.1.6 → dclassql-0.3.0}/README.md

@@ -65,7 +65,7 @@ uv add dclassql
 
 ## 当前状态
 
-DataclassQL 仍在早期开发阶段, 已完成代码生成和 SQLite 支持, 后续将扩展更多数据库与查询功能. 
+DataclassQL 仍在早期开发阶段, 但不是无根浮萍, 我已经在另外两个项目里大量使用, 目前基于其他项目的反馈来更新. 
 
 ## 一份更长的例子
 

{dclassql-0.1.6 → dclassql-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dclassql"
-version = "0.1.6"
+version = "0.3.0"
 description = "A type-safe ORM generator for Python, creating fully type-hinted database clients from plain dataclass definitions."
 readme = "README.md"
 authors = [
@@ -26,10 +26,10 @@ dependencies = [
 ]
 
 [project.scripts]
-"dql" = "dclassql.cli:main"
+"dclassql" = "dclassql.cli:main"
 
 [build-system]
-requires = ["uv_build>=0.8.22,<0.9.0"]
+requires = ["uv_build>=0.11.6,<0.12.0"]
 build-backend = "uv_build"
 
 [dependency-groups]

{dclassql-0.1.6 → dclassql-0.3.0}/src/dclassql/__init__.py

@@ -1,19 +1,21 @@
-from .model_inspector import DataSourceConfig
+from .asdict import asdict
 from .db_pool import BaseDBPool, save_local
+from .model_inspector import DataSourceConfig
 from .push import db_push
 from .runtime.backends.lazy import eager
-from .asdict import asdict
+from .runtime.sql_recorder import record_sql
 from .unwarp import unwarp, unwarp_or, unwarp_or_raise
 
+
 class _MissingClient:
     def __init__(self, *args: object, **kwargs: object) -> None:
         raise RuntimeError(
-            "dclassql.Client 尚未生成。请先运行 `dql -m <model.py> generate` 生成客户端后再导入。"
+            "dclassql.Client 尚未生成。请先运行 `dclassql -m <model.py> generate` 生成客户端后再导入。"
         )
 
 try:  # pragma: no cover - exercised in integration tests
     from .client import Client  # type: ignore
-except ModuleNotFoundError:  # pragma: no cover - fallback when未生成
+except (ModuleNotFoundError, ImportError):  # pragma: no cover - fallback when未生成
     Client = _MissingClient  # type: ignore[assignment]
 
 
@@ -28,4 +30,5 @@ __all__ = [
     'BaseDBPool',
     'save_local',
     'DataSourceConfig',
+    'record_sql',
 ]

{dclassql-0.1.6 → dclassql-0.3.0}/src/dclassql/cli.py

@@ -3,9 +3,7 @@ from __future__ import annotations
 import argparse
 import importlib.util
 import re
-import shutil
 import sys
-import warnings
 from pathlib import Path
 from types import ModuleType
 from typing import Any, Callable, Literal, Sequence
@@ -19,7 +17,6 @@ from .runtime.datasource import open_sqlite_connection
 
 DEFAULT_MODEL_FILE = "model.py"
 GENERATED_CLIENT_FILENAME = "client.py"
-GENERATED_MODELS_DIRNAME = "generated_models"
 
 ConfirmRebuildMode = Literal["auto", "prompt"]
 ConfirmCallback = Callable[
@@ -77,43 +74,6 @@ def resolve_asdict_stub_path() -> Path:
     return _find_package_directory() / "asdict.pyi"
 
 
-def resolve_models_directory() -> Path:
-    return _find_package_directory() / GENERATED_MODELS_DIRNAME
-
-
-def _sanitize_name(name: str) -> str:
-    sanitized = re.sub(r"[^0-9a-zA-Z_]+", "_", name).strip("_")
-    return sanitized.lower() or "models"
-
-
-def compute_model_target(module_path: Path) -> tuple[Path, str]:
-    base_dir = resolve_models_directory()
-    base_dir.mkdir(parents=True, exist_ok=True)
-    (base_dir / "__init__.py").touch()
-
-    module_name = _sanitize_name(module_path.stem)
-
-    target_path = base_dir / f"{module_name}.py"
-    import_path = f"dclassql.{GENERATED_MODELS_DIRNAME}.{module_name}"
-    return target_path, import_path
-
-
-def materialize_model_module(module_path: Path) -> str:
-    target_path, import_path = compute_model_target(module_path)
-    if target_path.exists() or target_path.is_symlink():
-        target_path.unlink()
-    try:
-        target_path.symlink_to(module_path.resolve())
-    except OSError as exc:
-        warnings.warn(
-            f"Unable to create symlink for model '{module_path}'; falling back to copy. ({exc})",
-            RuntimeWarning,
-            stacklevel=2,
-        )
-        shutil.copy2(module_path, target_path)
-    return import_path
-
-
 def collect_models(module: ModuleType) -> list[type[Any]]:
     from dataclasses import is_dataclass
 
@@ -205,13 +165,7 @@ def push_database(
 def command_generate(module_path: Path) -> None:
     module = load_module(module_path)
     models = collect_models(module)
-    generated_models_module = materialize_model_module(module_path)
-    original_modules = {model: model.__module__ for model in models}
-    for model in models:
-        model.__module__ = generated_models_module
     generated = generate_client(models)
-    for model, original in original_modules.items():
-        model.__module__ = original
     output_path = resolve_generated_path()
     output_path.parent.mkdir(parents=True, exist_ok=True)
     output_path.write_text(generated.code, encoding="utf-8")

{dclassql-0.1.6 → dclassql-0.3.0}/src/dclassql/codegen.py

@@ -100,6 +100,12 @@ class ScalarFilterRender:
     fields: tuple[TypedDictFieldSpec, ...]
 
 
+@dataclass(slots=True)
+class UpsertWhereRender:
+    name: str
+    fields: tuple[TypedDictFieldSpec, ...]
+
+
 @dataclass(slots=True)
 class ModelRenderContext:
     name: str
@@ -107,6 +113,8 @@ class ModelRenderContext:
     table_name_literal: str
     insert_fields: tuple[InsertFieldSpec, ...]
     typed_dict_fields: tuple[TypedDictFieldSpec, ...]
+    update_fields: tuple[TypedDictFieldSpec, ...]
+    upsert_where_dicts: tuple["UpsertWhereRender", ...]
     dict_fields: tuple[TypedDictFieldSpec, ...]
     where_fields: tuple[WhereFieldSpec, ...]
     relation_filters: tuple[RelationFilterRender, ...]
@@ -116,6 +124,7 @@ class ModelRenderContext:
     primary_key_literal: str
     indexes_literal: str
     unique_indexes_literal: str
+    primary_value_types: tuple[str, ...]
     row_assignments: tuple[RowAssignmentRender, ...]
     default_factories: tuple[DefaultFactoryRender, ...]
     model_info: ModelInfo
@@ -172,21 +181,19 @@ def generate_client(models: Sequence[type[Any]]) -> GeneratedModule:
     renderer = _TypeRenderer({info.model: name for name, info in model_infos.items()})
     filter_registry = _ScalarFilterRegistry(renderer)
 
-    model_imports: dict[str, set[str]] = defaultdict(set)
+    model_imports: defaultdict[str, set[str]] = defaultdict(set)
     for info in model_infos.values():
-        module = info.model.__module__
-        model_imports.setdefault(module, set()).add(info.model.__name__)
+        model_imports[info.model.__module__].add(info.model.__name__)
 
     model_contexts = [
         _build_model_context(model_infos[name], renderer, model_infos, filter_registry)
         for name in sorted(model_infos.keys())
     ]
 
-    module_imports = renderer.build_imports()
-    combined_imports: dict[str, set[str]] = defaultdict(set)
+    combined_imports: defaultdict[str, set[str]] = defaultdict(set)
     for module, names in model_imports.items():
         combined_imports[module].update(names)
-    for module, names in module_imports.items():
+    for module, names in renderer.module_imports.items():
         combined_imports[module].update(names)
 
     import_blocks = [
@@ -222,8 +229,11 @@ def _build_model_context(
 
     insert_fields: list[InsertFieldSpec] = []
     typed_dict_fields: list[TypedDictFieldSpec] = []
+    update_fields: list[TypedDictFieldSpec] = []
+    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:
         annotation = _format_insert_annotation(col, renderer)
         default_fragment = _render_default_fragment(name, col)
@@ -248,6 +258,27 @@ def _build_model_context(
         enum_type = _resolve_enum_class(col.python_type)
         enum_type_map[col.name] = enum_type
 
+        update_fields.append(TypedDictFieldSpec(name=col.name, annotation=renderer.render(col.python_type)))
+
+    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"
+            pk_fields.append(TypedDictFieldSpec(name=pk_col, annotation=annotation))
+        upsert_where_dicts.append(UpsertWhereRender(name=f"{name}UpsertWherePK", fields=tuple(pk_fields)))
+
+    if info.unique_indexes:
+        for idx, unique_cols in enumerate(info.unique_indexes, start=1):
+            unique_fields: list[TypedDictFieldSpec] = []
+            for col_name in unique_cols:
+                col_info = column_lookup.get(col_name)
+                annotation = renderer.render(col_info.python_type) if col_info else "object"
+                unique_fields.append(TypedDictFieldSpec(name=col_name, annotation=annotation))
+            upsert_where_dicts.append(
+                UpsertWhereRender(name=f"{name}UpsertWhereUnique{idx}", fields=tuple(unique_fields))
+            )
+
     where_fields: list[WhereFieldSpec] = []
     for col in info.columns:
         annotation = renderer.render(col.python_type)
@@ -334,6 +365,13 @@ def _build_model_context(
     )
 
     row_assignments, default_factories = _build_row_assignment_context(info, enum_type_map)
+    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
+        primary_value_types.append(renderer.render(column.python_type))
 
     relation_lookup = {relation.name: relation for relation in info.relations}
     dataclass_fields = fields(info.model)
@@ -362,6 +400,8 @@ def _build_model_context(
         table_name_literal=repr(name),
         insert_fields=tuple(insert_fields),
         typed_dict_fields=tuple(typed_dict_fields),
+        update_fields=tuple(update_fields),
+        upsert_where_dicts=tuple(upsert_where_dicts),
         dict_fields=tuple(dict_fields),
         where_fields=tuple(where_fields),
         relation_filters=tuple(relation_filters),
@@ -371,6 +411,7 @@ def _build_model_context(
         primary_key_literal=_tuple_literal(info.primary_key),
         indexes_literal=indexes_literal,
         unique_indexes_literal=unique_indexes_literal,
+        primary_value_types=tuple(primary_value_types),
         row_assignments=tuple(row_assignments),
         default_factories=tuple(default_factories),
         model_info=info,
@@ -436,6 +477,8 @@ def _collect_exports(model_contexts: Sequence[ModelRenderContext]) -> list[str]:
                 f"{name}Dict",
                 f"{name}Insert",
                 f"{name}InsertDict",
+                f"{name}UpdateDict",
+                f"{name}UpsertWhereDict",
                 f"{name}WhereDict",
                 f"{name}Table",
             ]
@@ -852,7 +895,7 @@ class _ScalarFilterRegistry:
 class _TypeRenderer:
     def __init__(self, model_map: Mapping[type[Any], str]) -> None:
         self._model_map = dict(model_map)
-        self._module_imports: dict[str, set[str]] = defaultdict(set)
+        self._module_imports: defaultdict[str, set[str]] = defaultdict(set) # {module: set of names}
         self._typing_imports: set[str] = set()
 
     def render(self, tp: Any) -> str:
@@ -896,13 +939,14 @@ class _TypeRenderer:
             if tp.__module__ == "builtins":
                 return tp.__name__
             if tp.__module__ == "datetime":
-                self._module_imports.setdefault("datetime", set()).add(tp.__name__)
+                self._module_imports["datetime"].add(tp.__name__)
                 return tp.__name__
-            self._module_imports.setdefault(tp.__module__, set()).add(tp.__qualname__.split(".")[0])
+            self._module_imports[tp.__module__].add(tp.__qualname__.split(".")[0])
             return tp.__qualname__
         return repr(tp)
 
-    def build_imports(self) -> Mapping[str, set[str]]:
+    @property
+    def module_imports(self) -> defaultdict[str, set[str]]:
         return self._module_imports
 
     @property