dclassql 0.1.5__tar.gz → 0.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dclassql
-Version: 0.1.5
+Version: 0.2.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

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

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

@@ -1,9 +1,12 @@
-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 .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(
@@ -20,10 +23,12 @@ __all__ = [
     'Client',
     'db_push',
     'eager',
+    'asdict',
     'unwarp',
     'unwarp_or',
     'unwarp_or_raise',
     'BaseDBPool',
     'save_local',
     'DataSourceConfig',
+    'record_sql',
 ]

dclassql-0.2.0/src/dclassql/asdict.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+import dataclasses as _dataclasses
+from collections.abc import Mapping, Sequence
+from dataclasses import fields, is_dataclass
+from typing import Any, Literal, cast
+
+from .runtime.backends.lazy import (
+    LAZY_RELATION_STATE,
+    LazyInstance,
+    LazyRelationState,
+    resolve_lazy_relation,
+)
+
+RelationPolicy = Literal['skip', 'fetch', 'keep']
+RelationKey = tuple[type[Any] | None, tuple[tuple[str, Any], ...]]
+_SEQUENCE_SKIP_TYPES = (str, bytes, bytearray)
+
+
+def asdict(value: Any, *, relation_policy: RelationPolicy = 'keep') -> Any:
+    if value is None:
+        return None
+
+    memo: set[int] = set()
+    relation_guard: set[RelationKey] = set()
+    return _convert_value(value, relation_policy, memo, relation_guard)
+
+
+def _convert_value(
+    value: Any,
+    relation_policy: RelationPolicy,
+    memo: set[int],
+    relation_guard: set[RelationKey],
+) -> Any:
+    if value is None:
+        return None
+    if is_dataclass(value):
+        return _convert_dataclass(value, relation_policy, memo, relation_guard)
+    if isinstance(value, LazyInstance):
+        resolved = value._lazy_resolve()
+        return _convert_value(resolved, relation_policy, memo, relation_guard)
+    if isinstance(value, Mapping):
+        return {
+            key: _convert_value(item, relation_policy, memo, relation_guard)
+            for key, item in value.items()
+        }
+    if isinstance(value, list):
+        return [_convert_value(item, relation_policy, memo, relation_guard) for item in value]
+    if isinstance(value, tuple):
+        return tuple(_convert_value(item, relation_policy, memo, relation_guard) for item in value)
+    if isinstance(value, Sequence) and not isinstance(value, _SEQUENCE_SKIP_TYPES):
+        return [_convert_value(item, relation_policy, memo, relation_guard) for item in value]
+    return value
+
+
+def _convert_dataclass(
+    instance: Any,
+    relation_policy: RelationPolicy,
+    memo: set[int],
+    relation_guard: set[RelationKey],
+) -> dict[str, Any]:
+    instance_id = id(instance)
+    if instance_id in memo:
+        raise RecursionError('dclassql.asdict() detected a recursive dataclass reference')
+    memo.add(instance_id)
+    try:
+        state_map = LAZY_RELATION_STATE.get(instance)
+        result: dict[str, Any] = {}
+        for field_obj in fields(instance):
+            name = field_obj.name
+            state = _lookup_relation_state(state_map, name)
+            if state is not None:
+                result[name] = _convert_relation(instance, state, relation_policy, memo, relation_guard)
+                continue
+            value = getattr(instance, name)
+            result[name] = _convert_value(value, relation_policy, memo, relation_guard)
+        return result
+    finally:
+        memo.remove(instance_id)
+
+
+def _lookup_relation_state(state_map: dict[str, LazyRelationState] | None, name: str) -> LazyRelationState | None:
+    if state_map is None:
+        return None
+    return state_map.get(name)
+
+
+def _convert_relation(
+    owner: Any,
+    state: LazyRelationState,
+    relation_policy: RelationPolicy,
+    memo: set[int],
+    relation_guard: set[RelationKey],
+) -> Any:
+    relation_key = _relation_identity(owner, state)
+    if relation_key is not None and relation_key in relation_guard:
+        return [] if state.many else None
+
+    guard_added = False
+    if relation_key is not None:
+        relation_guard.add(relation_key)
+        guard_added = True
+
+    try:
+        if relation_policy == 'skip':
+            return [] if state.many else None
+
+        if relation_policy == 'fetch':
+            value = resolve_lazy_relation(owner, state)
+        elif state.loaded:
+            value = state.value
+        else:
+            if relation_policy == 'keep':
+                return [] if state.many else None
+            value = resolve_lazy_relation(owner, state)
+
+        if value is None:
+            return None if not state.many else []
+
+        if state.many:
+            result_list: list[Any] = []
+            for item in value:
+                if is_dataclass(item) and id(item) in memo:
+                    continue
+                result_list.append(_convert_value(item, relation_policy, memo, relation_guard))
+            return result_list
+
+        if is_dataclass(value) and id(value) in memo:
+            return None
+
+        return _convert_value(value, relation_policy, memo, relation_guard)
+    finally:
+        if guard_added and relation_key is not None:
+            relation_guard.discard(relation_key)
+
+
+def _relation_identity(owner: Any, state: LazyRelationState) -> RelationKey | None:
+    mapping = state.mapping
+    if not mapping:
+        return None
+    values: list[tuple[str, Any]] = []
+    for owner_column, target_column in mapping:
+        owner_value = getattr(owner, owner_column, None)
+        if owner_value is None:
+            return None
+        values.append((target_column, owner_value))
+    model_cls = getattr(state.table_cls, 'model', None)
+    return (model_cls, tuple(values))
+
+
+__all__ = ['RelationPolicy', 'asdict']
+
+
+def _apply_dict_factory(value: Any, dict_factory: Any) -> Any:
+    if isinstance(value, dict):
+        return dict_factory((key, _apply_dict_factory(val, dict_factory)) for key, val in value.items())
+    if isinstance(value, list):
+        return [_apply_dict_factory(item, dict_factory) for item in value]
+    if isinstance(value, tuple):
+        return tuple(_apply_dict_factory(item, dict_factory) for item in value)
+    if isinstance(value, set):
+        return {_apply_dict_factory(item, dict_factory) for item in value}
+    return value
+
+
+def _patch_dataclasses_asdict() -> None:
+    original = getattr(_dataclasses, '_dclassql_original_asdict_inner', None)
+    if original is not None:
+        return
+
+    original_inner = cast(Any, getattr(_dataclasses, '_asdict_inner'))
+
+    def _patched_inner(obj: Any, dict_factory: Any):
+        obj_in_state = False
+        try:
+            # some objects may raise exceptions on __hash__/__eq__
+            obj_in_state = obj in LAZY_RELATION_STATE
+        except Exception:
+            pass
+
+        if obj_in_state:
+            data = asdict(obj)
+            if dict_factory is dict:
+                return data
+            return _apply_dict_factory(data, dict_factory)
+        return original_inner(obj, dict_factory)
+
+    setattr(_dataclasses, '_asdict_inner', _patched_inner)
+    setattr(_dataclasses, '_dclassql_original_asdict_inner', original_inner)
+
+
+_patch_dataclasses_asdict()

dclassql-0.2.0/src/dclassql/asdict.pyi

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any, Literal, overload
+
+from .client import (
+    Address,
+    AddressDict,
+    BirthDay,
+    BirthDayDict,
+    Book,
+    BookDict,
+    User,
+    UserDict,
+    UserBook,
+    UserBookDict,
+)
+
+RelationPolicy = Literal['skip', 'fetch', 'keep']
+
+@overload
+def asdict(value: Address, *, relation_policy: RelationPolicy = 'keep') -> AddressDict: ...
+
+@overload
+def asdict(value: BirthDay, *, relation_policy: RelationPolicy = 'keep') -> BirthDayDict: ...
+
+@overload
+def asdict(value: Book, *, relation_policy: RelationPolicy = 'keep') -> BookDict: ...
+
+@overload
+def asdict(value: User, *, relation_policy: RelationPolicy = 'keep') -> UserDict: ...
+
+@overload
+def asdict(value: UserBook, *, relation_policy: RelationPolicy = 'keep') -> UserBookDict: ...
+
+@overload
+def asdict(value: Sequence[Address], *, relation_policy: RelationPolicy = 'keep') -> list[AddressDict]: ...
+
+@overload
+def asdict(value: Sequence[BirthDay], *, relation_policy: RelationPolicy = 'keep') -> list[BirthDayDict]: ...
+
+@overload
+def asdict(value: Sequence[Book], *, relation_policy: RelationPolicy = 'keep') -> list[BookDict]: ...
+
+@overload
+def asdict(value: Sequence[User], *, relation_policy: RelationPolicy = 'keep') -> list[UserDict]: ...
+
+@overload
+def asdict(value: Sequence[UserBook], *, relation_policy: RelationPolicy = 'keep') -> list[UserBookDict]: ...
+
+@overload
+def asdict(value: Sequence[Any], *, relation_policy: RelationPolicy = 'keep') -> list[Any]: ...
+
+@overload
+def asdict(value: None, *, relation_policy: RelationPolicy = 'keep') -> None: ...
+
+def asdict(value: object, *, relation_policy: RelationPolicy = 'keep') -> Any: ...

{dclassql-0.1.5 → dclassql-0.2.0}/src/dclassql/cli.py

@@ -28,11 +28,27 @@ ConfirmCallback = Callable[
 ]
 
 
+def _module_name_from_path(module_path: Path) -> str:
+    candidate = module_path.with_suffix("")
+    cwd = Path.cwd()
+    try:
+        rel = candidate.relative_to(cwd)
+        parts = rel.parts
+    except ValueError:
+        parts = candidate.parts
+    trimmed_parts = list(parts)
+
+    if not trimmed_parts:
+        trimmed_parts = [module_path.stem]
+
+    sanitized_parts = [re.sub(r"[^0-9a-zA-Z_]+", "_", part) or "_" for part in trimmed_parts]
+    return ".".join(sanitized_parts)
+
 def load_module(module_path: Path) -> ModuleType:
     module_path = module_path.resolve()
     if not module_path.exists():
         raise FileNotFoundError(f"Model file '{module_path}' does not exist")
-    module_name = module_path.stem
+    module_name = _module_name_from_path(module_path)
     spec = importlib.util.spec_from_file_location(module_name, module_path)
     if spec is None or spec.loader is None:
         raise ImportError(f"Unable to load module from '{module_path}'")
@@ -57,6 +73,10 @@ def resolve_generated_path() -> Path:
     return _find_package_directory() / GENERATED_CLIENT_FILENAME
 
 
+def resolve_asdict_stub_path() -> Path:
+    return _find_package_directory() / "asdict.pyi"
+
+
 def resolve_models_directory() -> Path:
     return _find_package_directory() / GENERATED_MODELS_DIRNAME
 
@@ -195,6 +215,8 @@ def command_generate(module_path: Path) -> None:
     output_path = resolve_generated_path()
     output_path.parent.mkdir(parents=True, exist_ok=True)
     output_path.write_text(generated.code, encoding="utf-8")
+    asdict_stub_path = resolve_asdict_stub_path()
+    asdict_stub_path.write_text(generated.asdict_stub, encoding="utf-8")
     sys.stdout.write(f"Client written to {output_path}\n")
 
 
@@ -256,8 +278,9 @@ def main(argv: Sequence[str] | None = None) -> int:
     try:
         handler(args)
         return 0
-    except Exception as exc:  # pragma: no cover - CLI error reporting
-        print(f"Error: {exc}", file=sys.stderr)
+    except Exception:  # pragma: no cover - CLI error reporting
+        import traceback
+        traceback.print_exc(file=sys.stderr)
         return 1