Improve CLI startup time with lazy imports (#2799)

* Improve CLI startup time with lazy imports

* Optimize startup time with lazy imports

* Fix pysnooper initialization race condition

* Add fast path for --version and lazy imports for yaml/argcomplete

* Add fast path for --help and move enums to separate module

* Add fast path for --generate-prompt

* Optimize CodeFormatter init and chain_as_tuple

* Add cache for get_dedup_key to reduce redundant computation

* Add fast path in imports to skip expensive field check for simple fields

* Use exclude_none=True in model_dump for constraints

* Add fast path in DataModelFieldBase.imports for simple cases

* Use global variable cache for is_pydantic_v2 functions

* Cache self_reference() result to reduce all_data_types iterations

* Fix CI errors and address review comments

- Fix Pydantic v1 compatibility by using __dict__ for self_reference cache
- Add noqa comments for PLW0603 in util.py
- Fix type error: wrap all_imports iterator in tuple()
- Rename _pysnooper_initialized to _pysnooper_default_state_set for clarity
- Add PydanticV2Dataclass to skip condition in conftest.py

* Add coverage pragma comments for untestable code paths

- Add # pragma: no cover for fast path CLI code (--version, --help,
  --generate-prompt) that runs at module import time
- Add # pragma: no cover for stdout output and ARGCOMPLETE paths
- Add # pragma: no branch for pydantic version caching checks

🤖 Generated with [Claude Code](https://claude.com/claude-code)

* Add pragma comments for optimization fast paths

- Add # pragma: no cover for chain_as_tuple n==0 and n==1 cases
- Add # pragma: no cover for deprecated YAML bool warning branch

🤖 Generated with [Claude Code](https://claude.com/claude-code)

* Remove unused code to fix coverage

Author: koxudaxi

src/datamodel_code_generator/__init__.py

@@ -11,25 +11,40 @@
 import sys
 from collections.abc import Callable, Iterator, Mapping, Sequence
 from datetime import datetime, timezone
-from enum import Enum
 from pathlib import Path
 from typing import (
     IO,
     TYPE_CHECKING,
     Any,
-    Final,
     TextIO,
     TypeAlias,
     TypeVar,
     cast,
 )
 from urllib.parse import ParseResult
 
-import yaml
-import yaml.parser
-from typing_extensions import TypeAliasType, TypedDict
-
-import datamodel_code_generator.pydantic_patch  # noqa: F401
+from typing_extensions import TypeAliasType
+
+from datamodel_code_generator.enums import (
+    DEFAULT_SHARED_MODULE_NAME,
+    MAX_VERSION,
+    MIN_VERSION,
+    AllExportsCollisionStrategy,
+    AllExportsScope,
+    AllOfMergeMode,
+    CollapseRootModelsNameStrategy,
+    DataclassArguments,
+    DataModelType,
+    FieldTypeCollisionStrategy,
+    GraphQLScope,
+    InputFileType,
+    ModuleSplitMode,
+    NamingStrategy,
+    OpenAPIScope,
+    ReadOnlyWriteOnlyModelType,
+    ReuseScope,
+    TargetPydanticVersion,
+)
 from datamodel_code_generator.format import (
     DEFAULT_FORMATTERS,
     CodeFormatter,
@@ -40,7 +55,6 @@
     PythonVersionMin,
 )
 from datamodel_code_generator.parser import DefaultPutDict, LiteralType
-from datamodel_code_generator.util import PYDANTIC_V2, SafeLoader
 
 if TYPE_CHECKING:
     from collections import defaultdict
@@ -52,55 +66,36 @@
     YamlScalar: TypeAlias = str | int | float | bool | None
     YamlValue = TypeAliasType("YamlValue", "dict[str, YamlValue] | list[YamlValue] | YamlScalar")
 
-MIN_VERSION: Final[int] = 10
-MAX_VERSION: Final[int] = 13
-DEFAULT_SHARED_MODULE_NAME: Final[str] = "shared"
-
 T = TypeVar("T")
 
+# Import is_pydantic_v2 here for module-level YamlValue type definition
+from datamodel_code_generator.util import is_pydantic_v2  # noqa: E402
 
-class DataclassArguments(TypedDict, total=False):
-    """Arguments for @dataclass decorator."""
-
-    init: bool
-    repr: bool
-    eq: bool
-    order: bool
-    unsafe_hash: bool
-    frozen: bool
-    match_args: bool
-    kw_only: bool
-    slots: bool
-    weakref_slot: bool
-
-
-if not TYPE_CHECKING:
+if not TYPE_CHECKING:  # pragma: no branch
     YamlScalar: TypeAlias = str | int | float | bool | None
-    if PYDANTIC_V2:
+    if is_pydantic_v2():
         YamlValue = TypeAliasType("YamlValue", "dict[str, YamlValue] | list[YamlValue] | YamlScalar")
     else:
         # Pydantic v1 cannot handle TypeAliasType, use Any for recursive parts
         YamlValue: TypeAlias = dict[str, Any] | list[Any] | YamlScalar
 
+
 GeneratedModules: TypeAlias = dict[tuple[str, ...], str]
 """Type alias for multiple generated modules.
 
 Maps module path tuples (e.g., ("models", "user.py")) to generated code strings.
 Returned by generate() when output=None and multiple modules are generated.
 """
 
-try:
-    import pysnooper
-
-    pysnooper.tracer.DISABLED = True
-except ImportError:  # pragma: no cover
-    pysnooper = None
-
 DEFAULT_BASE_CLASS: str = "pydantic.BaseModel"
 
 
 def load_yaml(stream: str | TextIO) -> YamlValue:
     """Load YAML content from a string or file-like object."""
+    import yaml  # noqa: PLC0415
+
+    from datamodel_code_generator.util import SafeLoader  # noqa: PLC0415
+
     return yaml.load(stream, Loader=SafeLoader)  # noqa: S506
 
 
@@ -130,22 +125,38 @@ def get_version() -> str:
 
 def enable_debug_message() -> None:  # pragma: no cover
     """Enable debug tracing with pysnooper."""
-    if not pysnooper:
-        msg = "Please run `$pip install 'datamodel-code-generator[debug]'` to use debug option"
-        raise Exception(msg)  # noqa: TRY002
+    global _pysnooper_default_state_set  # noqa: PLW0603
+    try:
+        import pysnooper  # noqa: PLC0415
 
-    pysnooper.tracer.DISABLED = False
+        pysnooper.tracer.DISABLED = False
+        _pysnooper_default_state_set = True
+    except ImportError as err:
+        msg = "Please run `$pip install 'datamodel-code-generator[debug]'` to use debug option"
+        raise Exception(msg) from err  # noqa: TRY002
 
 
 DEFAULT_MAX_VARIABLE_LENGTH: int = 100
 
 
+_pysnooper_default_state_set: bool = False
+
+
 def snooper_to_methods() -> Callable[..., Any]:
     """Class decorator to add pysnooper tracing to all methods."""
 
     def inner(cls: type[T]) -> type[T]:
-        if not pysnooper:
+        global _pysnooper_default_state_set  # noqa: PLW0603
+        try:
+            import pysnooper  # noqa: PLC0415
+        except ImportError:
             return cls
+
+        # Ensure tracing is disabled by default (only enabled via --debug flag)
+        if not _pysnooper_default_state_set:
+            pysnooper.tracer.DISABLED = True
+            _pysnooper_default_state_set = True
+
         import inspect  # noqa: PLC0415
 
         methods = inspect.getmembers(cls, predicate=inspect.isfunction)
@@ -201,19 +212,6 @@ def is_schema(data: dict) -> bool:
     return isinstance(data.get("properties"), dict)
 
 
-class InputFileType(Enum):
-    """Supported input file types for schema parsing."""
-
-    Auto = "auto"
-    OpenAPI = "openapi"
-    JsonSchema = "jsonschema"
-    Json = "json"
-    Yaml = "yaml"
-    Dict = "dict"
-    CSV = "csv"
-    GraphQL = "graphql"
-
-
 RAW_DATA_TYPES: list[InputFileType] = [
     InputFileType.Json,
     InputFileType.Yaml,
@@ -223,150 +221,6 @@ class InputFileType(Enum):
 ]
 
 
-class DataModelType(Enum):
-    """Supported output data model types."""
-
-    PydanticBaseModel = "pydantic.BaseModel"
-    PydanticV2BaseModel = "pydantic_v2.BaseModel"
-    PydanticV2Dataclass = "pydantic_v2.dataclass"
-    DataclassesDataclass = "dataclasses.dataclass"
-    TypingTypedDict = "typing.TypedDict"
-    MsgspecStruct = "msgspec.Struct"
-
-
-class ReuseScope(Enum):
-    """Scope for model reuse deduplication.
-
-    module: Deduplicate identical models within each module (default).
-    tree: Deduplicate identical models across all modules, placing shared models in shared.py.
-    """
-
-    Module = "module"
-    Tree = "tree"
-
-
-class OpenAPIScope(Enum):
-    """Scopes for OpenAPI model generation."""
-
-    Schemas = "schemas"
-    Paths = "paths"
-    Tags = "tags"
-    Parameters = "parameters"
-    Webhooks = "webhooks"
-    RequestBodies = "requestbodies"
-
-
-class AllExportsScope(Enum):
-    """Scope for __all__ exports in __init__.py.
-
-    children: Export models from direct child modules only.
-    recursive: Export models from all descendant modules recursively.
-    """
-
-    Children = "children"
-    Recursive = "recursive"
-
-
-class AllExportsCollisionStrategy(Enum):
-    """Strategy for handling name collisions in recursive exports.
-
-    error: Raise an error when name collision is detected.
-    minimal_prefix: Add module prefix only to colliding names.
-    full_prefix: Add full module path prefix to all colliding names.
-    """
-
-    Error = "error"
-    MinimalPrefix = "minimal-prefix"
-    FullPrefix = "full-prefix"
-
-
-class FieldTypeCollisionStrategy(Enum):
-    """Strategy for handling field name and type name collisions.
-
-    rename_field: Rename the field with a suffix and add alias (default).
-    rename_type: Rename the type class with a suffix to preserve field name.
-    """
-
-    RenameField = "rename-field"
-    RenameType = "rename-type"
-
-
-class NamingStrategy(Enum):
-    """Strategy for generating unique model names when duplicates occur.
-
-    numbered: Append numeric suffix (Address1, Address2) [default].
-    parent_prefixed: Prefix with parent model name (CustomerAddress, UserAddress).
-    full_path: Use full schema path for unique names (OrdersItemsAddress).
-    primary_first: Prioritize primary schema definitions, others get suffix.
-    """
-
-    Numbered = "numbered"
-    ParentPrefixed = "parent-prefixed"
-    FullPath = "full-path"
-    PrimaryFirst = "primary-first"
-
-
-class CollapseRootModelsNameStrategy(Enum):
-    """Strategy for naming when collapsing root models with object references.
-
-    child: Keep the inner (child) model's name, remove the wrapper.
-    parent: Rename inner model to wrapper's name, remove the wrapper.
-    """
-
-    Child = "child"
-    Parent = "parent"
-
-
-class AllOfMergeMode(Enum):
-    """Mode for field merging in allOf schemas.
-
-    constraints: Merge only constraint fields (minItems, maxItems, pattern, etc.) from parent.
-    all: Merge constraints plus annotation fields (default, examples) from parent.
-    none: Do not merge any fields from parent properties.
-    """
-
-    Constraints = "constraints"
-    All = "all"
-    NoMerge = "none"
-
-
-class GraphQLScope(Enum):
-    """Scopes for GraphQL model generation."""
-
-    Schema = "schema"
-
-
-class ReadOnlyWriteOnlyModelType(Enum):
-    """Model generation strategy for readOnly/writeOnly fields.
-
-    RequestResponse: Generate only Request/Response model variants (no base model).
-    All: Generate Base, Request, and Response models.
-    """
-
-    RequestResponse = "request-response"
-    All = "all"
-
-
-class ModuleSplitMode(Enum):
-    """Mode for splitting generated models into separate files.
-
-    Single: Generate one file per model class.
-    """
-
-    Single = "single"
-
-
-class TargetPydanticVersion(Enum):
-    """Target Pydantic version for generated code.
-
-    V2: Generate code compatible with Pydantic 2.0+ (uses populate_by_name).
-    V2_11: Generate code for Pydantic 2.11+ (uses validate_by_name).
-    """
-
-    V2 = "2"
-    V2_11 = "2.11"
-
-
 class Error(Exception):
     """Base exception for datamodel-code-generator errors."""
 
@@ -1061,6 +915,8 @@ def get_header_and_first_line(csv_file: IO[str]) -> dict[str, Any]:
 
 def infer_input_type(text: str) -> InputFileType:
     """Automatically detect the input file type from text content."""
+    import yaml.parser  # noqa: PLC0415
+
     try:
         data = load_yaml(text)
     except yaml.parser.ParserError: