datamodel-code-generator 0.11.12__py3-none-any.whl → 0.45.0__py3-none-any.whl

datamodel_code_generator/model/types.py

@@ -0,0 +1,106 @@
+"""Base type manager for model modules.
+
+Provides DataTypeManager implementation with type mapping factory.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from datamodel_code_generator import DatetimeClassType, PythonVersion, PythonVersionMin
+from datamodel_code_generator.imports import (
+    IMPORT_ANY,
+    IMPORT_DECIMAL,
+    IMPORT_TIMEDELTA,
+)
+from datamodel_code_generator.types import DataType, StrictTypes, Types
+from datamodel_code_generator.types import DataTypeManager as _DataTypeManager
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+def type_map_factory(data_type: type[DataType]) -> dict[Types, DataType]:
+    """Create type mapping for common schema types to Python types."""
+    data_type_int = data_type(type="int")
+    data_type_float = data_type(type="float")
+    data_type_str = data_type(type="str")
+    return {
+        # TODO: Should we support a special type such UUID?
+        Types.integer: data_type_int,
+        Types.int32: data_type_int,
+        Types.int64: data_type_int,
+        Types.number: data_type_float,
+        Types.float: data_type_float,
+        Types.double: data_type_float,
+        Types.decimal: data_type.from_import(IMPORT_DECIMAL),
+        Types.time: data_type_str,
+        Types.string: data_type_str,
+        Types.byte: data_type_str,  # base64 encoded string
+        Types.binary: data_type(type="bytes"),
+        Types.date: data_type_str,
+        Types.date_time: data_type_str,
+        Types.timedelta: data_type.from_import(IMPORT_TIMEDELTA),
+        Types.password: data_type_str,
+        Types.email: data_type_str,
+        Types.uuid: data_type_str,
+        Types.uuid1: data_type_str,
+        Types.uuid2: data_type_str,
+        Types.uuid3: data_type_str,
+        Types.uuid4: data_type_str,
+        Types.uuid5: data_type_str,
+        Types.uri: data_type_str,
+        Types.hostname: data_type_str,
+        Types.ipv4: data_type_str,
+        Types.ipv6: data_type_str,
+        Types.ipv4_network: data_type_str,
+        Types.ipv6_network: data_type_str,
+        Types.boolean: data_type(type="bool"),
+        Types.object: data_type.from_import(IMPORT_ANY, is_dict=True),
+        Types.null: data_type(type="None"),
+        Types.array: data_type.from_import(IMPORT_ANY, is_list=True),
+        Types.any: data_type.from_import(IMPORT_ANY),
+    }
+
+
+class DataTypeManager(_DataTypeManager):
+    """Base type manager for model modules."""
+
+    def __init__(  # noqa: PLR0913, PLR0917
+        self,
+        python_version: PythonVersion = PythonVersionMin,
+        use_standard_collections: bool = False,  # noqa: FBT001, FBT002
+        use_generic_container_types: bool = False,  # noqa: FBT001, FBT002
+        strict_types: Sequence[StrictTypes] | None = None,
+        use_non_positive_negative_number_constrained_types: bool = False,  # noqa: FBT001, FBT002
+        use_decimal_for_multiple_of: bool = False,  # noqa: FBT001, FBT002
+        use_union_operator: bool = False,  # noqa: FBT001, FBT002
+        use_pendulum: bool = False,  # noqa: FBT001, FBT002
+        target_datetime_class: DatetimeClassType | None = None,
+        treat_dot_as_module: bool = False,  # noqa: FBT001, FBT002
+        use_serialize_as_any: bool = False,  # noqa: FBT001, FBT002
+    ) -> None:
+        """Initialize type manager with basic type mapping."""
+        super().__init__(
+            python_version,
+            use_standard_collections,
+            use_generic_container_types,
+            strict_types,
+            use_non_positive_negative_number_constrained_types,
+            use_decimal_for_multiple_of,
+            use_union_operator,
+            use_pendulum,
+            target_datetime_class,
+            treat_dot_as_module,
+            use_serialize_as_any,
+        )
+
+        self.type_map: dict[Types, DataType] = type_map_factory(self.data_type)
+
+    def get_data_type(
+        self,
+        types: Types,
+        **_: Any,
+    ) -> DataType:
+        """Get data type for schema type."""
+        return self.type_map[types]

datamodel_code_generator/model/union.py

@@ -0,0 +1,105 @@
+"""Union type model generators.
+
+Provides classes for generating union type aliases for GraphQL union types.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from datamodel_code_generator.imports import (
+    IMPORT_TYPE_ALIAS,
+    IMPORT_TYPE_ALIAS_BACKPORT,
+    IMPORT_TYPE_ALIAS_TYPE,
+    IMPORT_UNION,
+    Import,
+)
+from datamodel_code_generator.model import DataModel, DataModelFieldBase
+from datamodel_code_generator.model.base import UNDEFINED
+
+if TYPE_CHECKING:
+    from collections import defaultdict
+    from pathlib import Path
+
+    from datamodel_code_generator.reference import Reference
+
+
+class _DataTypeUnionBase(DataModel):
+    """Base class for GraphQL union types with shared __init__ logic."""
+
+    def __init__(  # noqa: PLR0913
+        self,
+        *,
+        reference: Reference,
+        fields: list[DataModelFieldBase],
+        decorators: list[str] | None = None,
+        base_classes: list[Reference] | None = None,
+        custom_base_class: str | None = None,
+        custom_template_dir: Path | None = None,
+        extra_template_data: defaultdict[str, dict[str, Any]] | None = None,
+        methods: list[str] | None = None,
+        path: Path | None = None,
+        description: str | None = None,
+        default: Any = UNDEFINED,
+        nullable: bool = False,
+        keyword_only: bool = False,
+        treat_dot_as_module: bool = False,
+    ) -> None:
+        """Initialize GraphQL union type."""
+        super().__init__(
+            reference=reference,
+            fields=fields,
+            decorators=decorators,
+            base_classes=base_classes,
+            custom_base_class=custom_base_class,
+            custom_template_dir=custom_template_dir,
+            extra_template_data=extra_template_data,
+            methods=methods,
+            path=path,
+            description=description,
+            default=default,
+            nullable=nullable,
+            keyword_only=keyword_only,
+            treat_dot_as_module=treat_dot_as_module,
+        )
+
+
+class DataTypeUnion(_DataTypeUnionBase):
+    """GraphQL union using TypeAlias annotation for Python 3.10+ (Name: TypeAlias = Union[...])."""
+
+    TEMPLATE_FILE_PATH: ClassVar[str] = "UnionTypeAliasAnnotation.jinja2"
+    BASE_CLASS: ClassVar[str] = ""
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (
+        IMPORT_TYPE_ALIAS,
+        IMPORT_UNION,
+    )
+
+
+class DataTypeUnionBackport(_DataTypeUnionBase):
+    """GraphQL union using TypeAlias annotation for Python 3.9 (Name: TypeAlias = Union[...])."""
+
+    TEMPLATE_FILE_PATH: ClassVar[str] = "UnionTypeAliasAnnotation.jinja2"
+    BASE_CLASS: ClassVar[str] = ""
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (
+        IMPORT_TYPE_ALIAS_BACKPORT,
+        IMPORT_UNION,
+    )
+
+
+class DataTypeUnionTypeBackport(_DataTypeUnionBase):
+    """GraphQL union using TypeAliasType for Python 3.9-3.11 (Name = TypeAliasType("Name", Union[...]))."""
+
+    TEMPLATE_FILE_PATH: ClassVar[str] = "UnionTypeAliasType.jinja2"
+    BASE_CLASS: ClassVar[str] = ""
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (
+        IMPORT_TYPE_ALIAS_TYPE,
+        IMPORT_UNION,
+    )
+
+
+class DataTypeUnionTypeStatement(_DataTypeUnionBase):
+    """GraphQL union using type statement for Python 3.12+ (type Name = Union[...])."""
+
+    TEMPLATE_FILE_PATH: ClassVar[str] = "UnionTypeStatement.jinja2"
+    BASE_CLASS: ClassVar[str] = ""
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (IMPORT_UNION,)

datamodel_code_generator/parser/__init__.py

@@ -1,31 +1,49 @@
+"""Parser utilities and base types for schema parsing.
+
+Provides LiteralType enum for literal parsing options and DefaultPutDict
+for caching remote schema content.
+"""
+
+from __future__ import annotations
+
+from collections import UserDict
 from enum import Enum
-from typing import Callable, Dict, Optional, TypeVar
+from typing import Callable, TypeVar
 
-TK = TypeVar('TK')
-TV = TypeVar('TV')
+TK = TypeVar("TK")
+TV = TypeVar("TV")
 
 
 class LiteralType(Enum):
-    All = 'all'
-    One = 'one'
+    """Options for handling enum fields as literals."""
+
+    All = "all"
+    One = "one"
+
 
+class DefaultPutDict(UserDict[TK, TV]):
+    """Dict that can lazily compute and cache missing values."""
 
-class DefaultPutDict(Dict[TK, TV]):
     def get_or_put(
         self,
         key: TK,
-        default: Optional[TV] = None,
-        default_factory: Optional[Callable[[TK], TV]] = None,
+        default: TV | None = None,
+        default_factory: Callable[[TK], TV] | None = None,
     ) -> TV:
+        """Get value for key, or compute and store it if missing."""
         if key in self:
             return self[key]
-        elif default:  # pragma: no cover
+        if default:  # pragma: no cover
             value = self[key] = default
             return value
-        elif default_factory:
+        if default_factory:
             value = self[key] = default_factory(key)
             return value
-        raise ValueError('Not found default and default_factory')  # pragma: no cover
+        msg = "Not found default and default_factory"  # pragma: no cover
+        raise ValueError(msg)  # pragma: no cover
 
 
-__all__ = ['LiteralType']
+__all__ = [
+    "DefaultPutDict",
+    "LiteralType",
+]

datamodel_code_generator/parser/_graph.py

@@ -0,0 +1,67 @@
+"""Graph utilities used by parsers.
+
+This module intentionally contains only generic graph algorithms (no DataModel
+or schema-specific logic), so it can be reused across parsers without creating
+dependency cycles.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Hashable
+from heapq import heappop, heappush
+from typing import TypeVar
+
+TNode = TypeVar("TNode", bound=Hashable)
+
+
+def stable_toposort(
+    nodes: list[TNode],
+    edges: dict[TNode, set[TNode]],
+    *,
+    key: Callable[[TNode], int],
+) -> list[TNode]:
+    """Stable topological sort; breaks ties by `key`.
+
+    The `edges` mapping is an adjacency list where `edges[u]` contains all `v`
+    such that `u -> v` (i.e., `u` must come before `v`).
+
+    If a cycle is detected, any remaining nodes are appended in `key` order for
+    determinism.
+    """
+    node_set = set(nodes)
+    order_index = {node: index for index, node in enumerate(nodes)}
+    indegree: dict[TNode, int] = dict.fromkeys(nodes, 0)
+    outgoing: dict[TNode, set[TNode]] = {n: set() for n in nodes}
+
+    for source in node_set & edges.keys():
+        destinations = edges[source]
+        new_destinations = destinations & node_set - outgoing[source]
+        outgoing[source].update(new_destinations)
+        for destination in new_destinations:
+            indegree[destination] += 1
+
+    outgoing_sorted = {
+        node: sorted(neighbors, key=lambda neighbor: (key(neighbor), order_index[neighbor]))
+        for node, neighbors in outgoing.items()
+    }
+
+    ready: list[tuple[int, int, TNode]] = []
+    for node in nodes:
+        if indegree[node] == 0:
+            heappush(ready, (key(node), order_index[node], node))
+
+    result: list[TNode] = []
+    while ready:
+        _, _, node = heappop(ready)
+        result.append(node)
+        for neighbor in outgoing_sorted[node]:
+            indegree[neighbor] -= 1
+            if indegree[neighbor] == 0:
+                heappush(ready, (key(neighbor), order_index[neighbor], neighbor))
+
+    remaining = sorted(
+        [node for node in nodes if node not in result],
+        key=lambda node: (key(node), order_index[node]),
+    )
+    result.extend(remaining)
+    return result

datamodel_code_generator/parser/_scc.py

@@ -0,0 +1,171 @@
+"""Strongly Connected Components detection using Tarjan's algorithm.
+
+Provides SCC detection for module dependency graphs to identify
+circular import patterns in generated code.
+"""
+
+from __future__ import annotations
+
+from enum import IntEnum
+from typing import NamedTuple
+
+from typing_extensions import TypeAlias
+
+ModulePath: TypeAlias = tuple[str, ...]
+ModuleGraph: TypeAlias = dict[ModulePath, set[ModulePath]]
+SCC: TypeAlias = set[ModulePath]
+SCCList: TypeAlias = list[SCC]
+
+_EMPTY_SET: frozenset[ModulePath] = frozenset()
+
+
+class _Phase(IntEnum):
+    """DFS traversal phase for iterative Tarjan's algorithm."""
+
+    VISIT = 0
+    POSTVISIT = 1
+
+
+class _Frame(NamedTuple):
+    """Call stack frame for iterative DFS."""
+
+    node: ModulePath
+    neighbor_idx: int
+    phase: _Phase
+
+
+class _TarjanState:
+    """Mutable state for Tarjan's SCC algorithm."""
+
+    __slots__ = ("graph", "index", "index_counter", "lowlinks", "on_stack", "result", "sorted_cache", "stack")
+
+    def __init__(self, graph: ModuleGraph) -> None:
+        self.graph = graph
+        self.index_counter: int = 0
+        self.stack: list[ModulePath] = []
+        self.lowlinks: dict[ModulePath, int] = {}
+        self.index: dict[ModulePath, int] = {}
+        self.on_stack: set[ModulePath] = set()
+        self.result: SCCList = []
+        self.sorted_cache: dict[ModulePath, list[ModulePath]] = {}
+
+    def get_sorted_neighbors(self, node: ModulePath) -> list[ModulePath]:
+        """Get sorted neighbors with lazy memoization."""
+        cached: list[ModulePath] | None = self.sorted_cache.get(node)
+        if cached is None:
+            cached = sorted(self.graph.get(node, _EMPTY_SET))
+            self.sorted_cache[node] = cached
+        return cached
+
+    def extract_scc(self, root: ModulePath) -> None:
+        """Pop nodes from stack to form an SCC rooted at the given node."""
+        scc: SCC = set()
+        while True:
+            w: ModulePath = self.stack.pop()
+            self.on_stack.remove(w)
+            scc.add(w)
+            if w == root:  # pragma: no branch
+                break
+        self.result.append(scc)
+
+    def initialize_node(self, node: ModulePath) -> None:
+        """Initialize a node for DFS traversal."""
+        self.index[node] = self.lowlinks[node] = self.index_counter
+        self.index_counter += 1
+        self.stack.append(node)
+        self.on_stack.add(node)
+
+
+def _strongconnect(state: _TarjanState, start: ModulePath) -> None:
+    """Execute Tarjan's strongconnect algorithm iteratively."""
+    state.initialize_node(start)
+    call_stack: list[_Frame] = [_Frame(start, 0, _Phase.VISIT)]
+
+    while call_stack:
+        frame: _Frame = call_stack.pop()
+        node: ModulePath = frame.node
+        neighbors: list[ModulePath] = state.get_sorted_neighbors(node)
+        neighbor_idx: int = frame.neighbor_idx
+
+        # Handle post-visit: update lowlink from child
+        if frame.phase == _Phase.POSTVISIT:
+            child: ModulePath = neighbors[neighbor_idx]
+            state.lowlinks[node] = min(state.lowlinks[node], state.lowlinks[child])
+            neighbor_idx += 1
+
+        # Process remaining neighbors
+        while neighbor_idx < len(neighbors):
+            w: ModulePath = neighbors[neighbor_idx]
+
+            if w not in state.index:
+                # Save state for post-visit
+                call_stack.append(_Frame(node, neighbor_idx, _Phase.POSTVISIT))
+                # Initialize and push unvisited neighbor
+                state.initialize_node(w)
+                call_stack.append(_Frame(w, 0, _Phase.VISIT))
+                break
+            if w in state.on_stack:
+                state.lowlinks[node] = min(state.lowlinks[node], state.index[w])
+
+            neighbor_idx += 1
+        else:
+            # All neighbors processed: check if node is SCC root
+            if state.lowlinks[node] == state.index[node]:
+                state.extract_scc(node)
+
+
+def strongly_connected_components(graph: ModuleGraph) -> SCCList:
+    """Find all strongly connected components using Tarjan's algorithm.
+
+    Uses an iterative approach to avoid Python recursion limits on large graphs.
+    Neighbors are lazily sorted and memoized for determinism with O(E log V) cost.
+
+    Args:
+        graph: Adjacency list mapping module tuple to set of dependency module tuples.
+               Each node is a tuple like ("pkg", "__init__.py") or ("pkg", "module.py").
+
+    Returns:
+        List of all SCCs, each being a set of module tuples.
+        SCCs are returned in reverse topological order (leaves first).
+        Includes all SCCs, including singleton nodes without self-loops.
+    """
+    # Collect all nodes (including those only referenced as edges)
+    all_nodes: set[ModulePath] = set(graph.keys())
+    for neighbors in graph.values():
+        all_nodes.update(neighbors)
+
+    state = _TarjanState(graph)
+
+    # Run algorithm on all unvisited nodes (sorted for determinism)
+    for node in sorted(all_nodes):
+        if node not in state.index:
+            _strongconnect(state, node)
+
+    return state.result
+
+
+def find_circular_sccs(graph: ModuleGraph) -> SCCList:
+    """Find SCCs that represent circular dependencies.
+
+    A circular SCC is one with:
+    - More than one node, OR
+    - Exactly one node with a self-loop (edge to itself)
+
+    Args:
+        graph: Module dependency graph
+
+    Returns:
+        List of circular SCCs, sorted by their minimum element for determinism
+    """
+    all_sccs: SCCList = strongly_connected_components(graph)
+    circular: SCCList = []
+
+    for scc in all_sccs:
+        if len(scc) > 1:
+            circular.append(scc)
+        elif len(scc) == 1:  # pragma: no branch
+            node: ModulePath = next(iter(scc))
+            if node in graph and node in graph[node]:
+                circular.append(scc)
+
+    return sorted(circular, key=min)