dclassql 0.3.1__tar.gz → 0.4.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dclassql
-Version: 0.3.1
+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.3.1 → 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.3.1 → dclassql-0.4.1}/pyproject.toml

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

@@ -0,0 +1,21 @@
+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
+
+
+__all__ = [
+    'db_push',
+    'eager',
+    'asdict',
+    'unwarp',
+    'unwarp_or',
+    'unwarp_or_raise',
+    'BaseDBPool',
+    'save_local',
+    'DataSourceConfig',
+    'record_sql',
+]

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

@@ -18,6 +18,7 @@ from .runtime.datasource import open_sqlite_connection
 DEFAULT_MODEL_FILE = "model.py"
 GENERATED_CLIENT_FILENAME = "client.py"
 
+GenerateTarget = Literal["model-dir", "package"]
 ConfirmRebuildMode = Literal["auto", "prompt"]
 ConfirmCallback = Callable[
     [ModelInfo, SchemaPlan, tuple[ExistingColumn, ...] | None, SchemaDiff],
@@ -51,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
 
 
@@ -66,29 +73,61 @@ def _find_package_directory() -> Path:
     return Path(next(iter(spec.submodule_search_locations))).resolve()
 
 
-def resolve_generated_path() -> Path:
-    return _find_package_directory() / GENERATED_CLIENT_FILENAME
+def resolve_client_package_name(module_path: Path) -> str:
+    stem = re.sub(r"[^0-9a-zA-Z_]+", "_", module_path.stem) or "_"
+    return f"{stem}_client"
 
 
-def resolve_asdict_stub_path() -> Path:
-    return _find_package_directory() / "asdict.pyi"
+def resolve_client_class_name(module_path: Path) -> str:
+    package_name = resolve_client_package_name(module_path)
+    return "".join(part.capitalize() for part in package_name.split("_") if part)
+
+
+def resolve_generated_package_dir(module_path: Path, target: GenerateTarget = "model-dir") -> Path:
+    package_name = resolve_client_package_name(module_path)
+    if target == "model-dir":
+        return module_path.resolve().parent / package_name
+    return _find_package_directory() / package_name
 
 
 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)
@@ -134,44 +173,38 @@ 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) -> None:
+def command_generate(module_path: Path, *, target: GenerateTarget = "model-dir") -> None:
     module = load_module(module_path)
     models = collect_models(module)
-    generated = generate_client(models)
-    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")
+    client_class_name = resolve_client_class_name(module_path)
+    generated = generate_client(models, client_class_name=client_class_name)
+    output_dir = resolve_generated_package_dir(module_path, target)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    (output_dir / "__init__.py").write_text(generated.init_code, encoding="utf-8")
+    (output_dir / "__init__.pyi").write_text(generated.init_stub, encoding="utf-8")
+    (output_dir / GENERATED_CLIENT_FILENAME).write_text(generated.code, encoding="utf-8")
+    (output_dir / "asdict.pyi").write_text(generated.asdict_stub, encoding="utf-8")
+    sys.stdout.write(f"Client package written to {output_dir}\n")
 
 
 def command_push_db(
@@ -197,7 +230,13 @@ def build_parser() -> argparse.ArgumentParser:
     subparsers = parser.add_subparsers(dest="command", required=True)
 
     generate_parser = subparsers.add_parser("generate", help="Generate client code for given models")
-    generate_parser.set_defaults(handler=lambda args: command_generate(args.module))
+    generate_parser.add_argument(
+        "--target",
+        choices=("model-dir", "package"),
+        default="model-dir",
+        help="生成 client 的位置: model-dir 写到模型文件同目录; package 写到 dclassql 包内",
+    )
+    generate_parser.set_defaults(handler=lambda args: command_generate(args.module, target=args.target))
 
     push_parser = subparsers.add_parser("push-db", help="Apply schema and indexes to configured databases")
     push_parser.add_argument(

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

@@ -17,7 +17,10 @@ from .model_inspector import ColumnInfo, ModelInfo, inspect_models, DataSourceCo
 class GeneratedModule:
     code: str
     asdict_stub: str
+    init_code: str
+    init_stub: str
     model_names: tuple[str, ...]
+    client_class_name: str
 
 
 @dataclass(slots=True)
@@ -48,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)
@@ -125,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
@@ -132,9 +156,6 @@ class ModelRenderContext:
 
 @dataclass(slots=True)
 class ClientDataSourceContext:
-    key: str
-    key_repr: str
-    provider_repr: str
     url_repr: str
     name_repr: str
 
@@ -147,6 +168,7 @@ class ClientModelBindingContext:
 
 @dataclass(slots=True)
 class ClientContext:
+    class_name: str
     datasource: ClientDataSourceContext
     model_bindings: tuple[ClientModelBindingContext, ...]
 
@@ -167,7 +189,7 @@ def _get_environment() -> Environment:
     return _ENVIRONMENT
 
 
-def generate_client(models: Sequence[type[Any]]) -> GeneratedModule:
+def generate_client(models: Sequence[type[Any]], *, client_class_name: str = "GeneratedClient") -> GeneratedModule:
     model_infos = inspect_models(models)
     renderer = _TypeRenderer({info.model: name for name, info in model_infos.items()})
     filter_registry = _ScalarFilterRegistry(renderer)
@@ -192,8 +214,8 @@ def generate_client(models: Sequence[type[Any]]) -> GeneratedModule:
         for module, names in sorted(combined_imports.items())
     ]
 
-    client_context = _build_client_context(model_infos)
-    exports = _collect_exports(model_contexts)
+    client_context = _build_client_context(model_infos, client_class_name)
+    exports = _collect_exports(model_contexts, client_class_name)
     scalar_filters = filter_registry.render_definitions()
 
     template = _get_environment().get_template(_TEMPLATE_NAME)
@@ -207,7 +229,16 @@ def generate_client(models: Sequence[type[Any]]) -> GeneratedModule:
     if not code.endswith("\n"):
         code += "\n"
     asdict_stub = _render_asdict_stub(model_contexts)
-    return GeneratedModule(code=code, asdict_stub=asdict_stub, model_names=tuple(sorted(model_infos.keys())))
+    init_code = _render_init_code(client_class_name)
+    init_stub = _render_init_stub(client_class_name)
+    return GeneratedModule(
+        code=code,
+        asdict_stub=asdict_stub,
+        init_code=init_code,
+        init_stub=init_stub,
+        model_names=tuple(sorted(model_infos.keys())),
+        client_class_name=client_class_name,
+    )
 
 
 def _build_model_context(
@@ -224,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:
@@ -254,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)))
 
@@ -270,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"
@@ -316,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 = [
@@ -347,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 "()"
@@ -355,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}
@@ -403,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_client_context(model_infos: Mapping[str, ModelInfo]) -> ClientContext:
+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),
     )
@@ -434,13 +488,14 @@ def _build_client_context(model_infos: Mapping[str, ModelInfo]) -> ClientContext
     ]
 
     return ClientContext(
+        class_name=client_class_name,
         datasource=datasource_item,
         model_bindings=tuple(model_bindings),
     )
 
 
-def _collect_exports(model_contexts: Sequence[ModelRenderContext]) -> list[str]:
-    exports: list[str] = ["DataSourceConfig", "ForeignKeySpec", "Client"]
+def _collect_exports(model_contexts: Sequence[ModelRenderContext], client_class_name: str) -> list[str]:
+    exports: list[str] = ["DataSourceConfig", "ForeignKeySpec", client_class_name]
     for context in model_contexts:
         name = context.name
         exports.extend(
@@ -472,6 +527,24 @@ def _render_asdict_stub(model_contexts: Sequence[ModelRenderContext]) -> str:
     return code
 
 
+def _render_init_code(client_class_name: str) -> str:
+    code = (
+        "from dclassql.asdict import asdict as asdict\n"
+        f"from .client import {client_class_name} as {client_class_name}\n\n"
+        f"__all__ = ['{client_class_name}', 'asdict']\n"
+    )
+    return code
+
+
+def _render_init_stub(client_class_name: str) -> str:
+    code = (
+        "from .asdict import asdict as asdict\n"
+        f"from .client import {client_class_name} as {client_class_name}\n\n"
+        "__all__: list[str]\n"
+    )
+    return code
+
+
 def _build_relation_entries(info: ModelInfo, model_infos: Mapping[str, ModelInfo]) -> list[dict[str, Any]]:
     entries: list[dict[str, Any]] = []
     if not info.relations:
@@ -488,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:
@@ -524,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}
@@ -539,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:
@@ -552,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:
@@ -570,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__
@@ -581,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}]"
@@ -589,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}"
@@ -641,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
 
 
@@ -875,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):