dclassql 0.2.0__tar.gz → 0.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dclassql
-Version: 0.2.0
+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.2.0 → dclassql-0.3.0}/README.md

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "dclassql"
-version = "0.2.0"
+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.2.0 → dclassql-0.3.0}/src/dclassql/__init__.py

@@ -10,12 +10,12 @@ 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]
 
 

{dclassql-0.2.0 → 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.2.0 → dclassql-0.3.0}/src/dclassql/codegen.py

@@ -181,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 = [
@@ -897,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:
@@ -941,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

{dclassql-0.2.0 → dclassql-0.3.0}/src/dclassql/runtime/backends/base.py

@@ -25,6 +25,7 @@ class BackendBase(BackendProtocol, ABC):
     query_cls: type[Query] = Query
     table_cls: type[Table] = Table
     parameter_cls: type[Parameter] = Parameter
+    like_escape_char: str | None = "\\"
 
     def __init__(self, *, echo_sql: bool = False) -> None:
         self._identity_map: dict[tuple[type[Any], tuple[Any, ...]], list[ReferenceType[object]]] = {}
@@ -33,7 +34,7 @@ class BackendBase(BackendProtocol, ABC):
     def insert(
         self,
         table: TableProtocol[ModelT, InsertT, WhereT, IncludeT, OrderByT],
-        data: InsertT | Mapping[str, object],
+        data: InsertT | ModelT | Mapping[str, object],
     ) -> ModelT:
         payload = table.serialize_insert(data)
         if not payload:
@@ -61,7 +62,7 @@ class BackendBase(BackendProtocol, ABC):
     def insert_many(
         self,
         table: TableProtocol[ModelT, InsertT, WhereT, IncludeT, OrderByT],
-        data: Sequence[InsertT | Mapping[str, object]],
+        data: Sequence[InsertT | ModelT | Mapping[str, object]],
         *,
         batch_size: int | None = None,
     ) -> list[ModelT]:
@@ -115,7 +116,7 @@ class BackendBase(BackendProtocol, ABC):
         *,
         where: UpsertWhereT,
         update: Mapping[str, object],
-        insert: InsertT | Mapping[str, object],
+        insert: InsertT | ModelT | Mapping[str, object],
         include: Mapping[str, bool] | None = None,
     ) -> ModelT:
         where_payload = dict(where)
@@ -273,7 +274,7 @@ class BackendBase(BackendProtocol, ABC):
         delete_query: QueryBuilder = self.query_cls.from_(sql_table).delete()
         criterion, params = self._compile_where(table, sql_table, where)
         if criterion is None:
-            raise ValueError("delete() requires a where clause")
+            raise ValueError("delete() requires a where clause, if you want to delete more rows use delete_many()")
         delete_query = delete_query.where(criterion)
         sql = self._render_query(delete_query)
         returning_columns = [spec.name for spec in table.column_specs]

{dclassql-0.2.0 → dclassql-0.3.0}/src/dclassql/runtime/backends/protocols.py

@@ -25,7 +25,7 @@ class TableProtocol[ModelT, InsertT, WhereT, IncludeT, OrderByT](Protocol):
     column_specs_by_name: Mapping[str, ColumnSpec]
 
     @classmethod
-    def serialize_insert(cls, data: InsertT | Mapping[str, object]) -> dict[str, object]: ...
+    def serialize_insert(cls, data: InsertT | ModelT | Mapping[str, object]) -> dict[str, object]: ...
     @classmethod
     def serialize_update(cls, data: Mapping[str, object]) -> dict[str, object]: ...
 
@@ -46,11 +46,12 @@ class BackendProtocol(Protocol):
     query_cls: type[Query]
     table_cls: type[Table]
     parameter_cls: type[Parameter]
+    like_escape_char: str | None
 
     def insert(
         self,
         table: TableProtocol[ModelT, InsertT, WhereT, IncludeT, OrderByT],
-        data: InsertT | Mapping[str, object],
+        data: InsertT | ModelT | Mapping[str, object],
     ) -> ModelT: ...
     def update(
         self,
@@ -66,14 +67,14 @@ class BackendProtocol(Protocol):
         *,
         where: UpsertWhereT,
         update: Mapping[str, object],
-        insert: InsertT | Mapping[str, object],
+        insert: InsertT | ModelT | Mapping[str, object],
         include: IncludeT | None = None,
     ) -> ModelT: ...
 
     def insert_many(
         self,
         table: TableProtocol[ModelT, InsertT, WhereT, IncludeT, OrderByT],
-        data: Sequence[InsertT | Mapping[str, object]],
+        data: Sequence[InsertT | ModelT | Mapping[str, object]],
         *,
         batch_size: int | None = None,
     ) -> list[ModelT]: ...

{dclassql-0.2.0 → dclassql-0.3.0}/src/dclassql/runtime/backends/where_compiler.py

@@ -34,6 +34,23 @@ def combine_or(criteria: Sequence[Criterion | None]) -> Criterion | None:
     return result
 
 
+class EscapeLikeCriterion(Criterion):
+    def __init__(self, field: Field, parameter: Parameter, *, escape: str, negated: bool = False) -> None:
+        self._field = field
+        self._parameter = parameter
+        self._escape = escape
+        self._negated = negated
+
+    def negate(self) -> Criterion:
+        return EscapeLikeCriterion(self._field, self._parameter, escape=self._escape, negated=not self._negated)
+
+    def get_sql(self, **kwargs: object) -> str:  # type: ignore[override]
+        field_sql = self._field.get_sql(**kwargs)
+        param_sql = self._parameter.get_sql(**kwargs)
+        operator = "NOT LIKE" if self._negated else "LIKE"
+        return f"{field_sql} {operator} {param_sql} ESCAPE '{self._escape}'"
+
+
 class WhereCompiler:
     def __init__(
         self,
@@ -157,13 +174,13 @@ class WhereCompiler:
             return field >= self._bind_value(operand)
         if operator == "CONTAINS":
             text = ensure_string(operand, operator=operator)
-            return self._apply_like(field, f"%{text}%")
+            return self._apply_like(field, f"%{self._escape_like(text)}%")
         if operator == "STARTS_WITH":
             text = ensure_string(operand, operator=operator)
-            return self._apply_like(field, f"{text}%")
+            return self._apply_like(field, f"{self._escape_like(text)}%")
         if operator == "ENDS_WITH":
             text = ensure_string(operand, operator=operator)
-            return self._apply_like(field, f"%{text}")
+            return self._apply_like(field, f"%{self._escape_like(text)}")
         if operator == "NOT":
             if isinstance(operand, ABCMapping):
                 compiled = self._compile_filter(field, operand)
@@ -176,9 +193,22 @@ class WhereCompiler:
 
     def _apply_like(self, field: Field, pattern: str) -> Criterion:
         parameter = self._bind_value(pattern)
+        escape = self._backend.like_escape_char
+        if escape:
+            return EscapeLikeCriterion(field, parameter, escape=escape)
         # pypika 的 Field.like 允许 Term 参数, 但类型标注仅接受 str
         return field.like(parameter)  # type: ignore[arg-type]
 
+    def _escape_like(self, text: str) -> str:
+        escape = self._backend.like_escape_char
+        if not escape:
+            return text
+        return (
+            text.replace(escape, escape + escape)
+            .replace("%", escape + "%")
+            .replace("_", escape + "_")
+        )
+
     def _bind_value(self, value: object) -> Parameter:
         parameter = self._backend.new_parameter()
         self.params.append(value)

{dclassql-0.2.0 → dclassql-0.3.0}/src/dclassql/runtime/sqlite_adapters.py

@@ -13,8 +13,6 @@ def _adapt_date_iso(value: _dt.date) -> str:
 
 
 def _adapt_datetime_iso(value: _dt.datetime) -> str:
-    if value.tzinfo is not None:
-        value = value.astimezone(_dt.timezone.utc).replace(tzinfo=None)
     return value.isoformat(sep="T")
 
 
@@ -40,4 +38,3 @@ def register_sqlite_adapters() -> None:
     sqlite3.register_converter("datetime", _convert_datetime_iso)
 
     _REGISTERED["done"] = True
-

{dclassql-0.2.0 → dclassql-0.3.0}/src/dclassql/templates/partials/model_section.jinja

@@ -106,7 +106,7 @@ class {{ table_class }}(TableProtocol):
         )
 
     @classmethod
-    def serialize_insert(cls, data: {{ insert_class }} | Mapping[str, object]) -> dict[str, object]:
+    def serialize_insert(cls, data: {{ insert_class }} | {{ name }} | Mapping[str, object]) -> dict[str, object]:
         if isinstance(data, Mapping):
             result: dict[str, object] = {}
 {% for column in model.column_specs %}
@@ -114,7 +114,7 @@ class {{ table_class }}(TableProtocol):
                 result[{{ column.name_repr }}] = {{ column.mapping_value_expr }}{{ '  # type: ignore[attr-defined]' if column.is_enum else '' }}
 {% endfor %}
             return result
-        if isinstance(data, {{ insert_class }}):
+        if isinstance(data, ({{ insert_class }}, {{ name }})):
             return {
 {% for column in model.column_specs %}                {{ column.name_repr }}: {{ column.insert_value_expr }},{{ '  # type: ignore[attr-defined]' if column.is_enum else '' }}
 {% endfor %}            }
@@ -138,10 +138,10 @@ class {{ table_class }}(TableProtocol):
     def __str__(self) -> str:
         return self._backend.escape_identifier(self.table_name)
 
-    def insert(self, data: {{ insert_class }} | {{ insert_dict_class }}) -> {{ name }}:
+    def insert(self, data: {{ insert_class }} | {{ name }} | {{ insert_dict_class }}) -> {{ name }}:
         return self._backend.insert(self, data)
 
-    def insert_many(self, data: Sequence[{{ insert_class }} | {{ insert_dict_class }}], *, batch_size: int | None = None) -> list[{{ name }}]:
+    def insert_many(self, data: Sequence[{{ insert_class }} | {{ name }} | {{ insert_dict_class }}], *, batch_size: int | None = None) -> list[{{ name }}]:
         return self._backend.insert_many(self, data, batch_size=batch_size)
 
     def update(self, *, data: {{ update_dict_class }}, where: {{ where_dict_class }}, include: {{ include_dict_class }} | None = None) -> {{ name }}:
@@ -159,7 +159,7 @@ class {{ table_class }}(TableProtocol):
         *,
         where: {{ upsert_where_alias }},
         update: {{ upsert_update_class }},
-        insert: {{ upsert_insert_class }} | {{ upsert_insert_dict_class }},
+        insert: {{ upsert_insert_class }} | {{ name }} | {{ upsert_insert_dict_class }},
         include: {{ include_dict_class }} | None = None,
     ) -> {{ name }}:
         return self._backend.upsert(self, where=where, update=update, insert=insert, include=include)