pyopenapi-gen 2.7.2__py3-none-any.whl → 3.0.1__py3-none-any.whl

pyopenapi_gen/__init__.py

@@ -50,7 +50,7 @@ __all__ = [
 ]
 
 # Semantic version of the generator core – automatically managed by semantic-release.
-__version__: str = "2.7.2"
+__version__: str = "3.0.1"
 
 # ---------------------------------------------------------------------------
 # Lazy-loading and autocompletion support (This part remains)

pyopenapi_gen/core/cattrs_converter.py

@@ -307,17 +307,34 @@ converter.register_unstructure_hook(date, unstructure_date)
 
 def _is_union_type(t: Any) -> bool:
     """
-    Check if a type is a Union type.
+    Check if a type is a Union type (including Annotated[Union, ...]).
 
     Scenario:
-        Detect Union types including both typing.Union and Python 3.10+ X | Y syntax.
+        Detect Union types including both typing.Union and Python 3.10+ X | Y syntax,
+        as well as Annotated[Union, ...] for discriminated unions.
 
     Expected Outcome:
         Returns True for Union types, False otherwise.
     """
     origin = get_origin(t)
     # Handle both typing.Union and types.UnionType (Python 3.10+ X | Y syntax)
-    return origin is Union or (hasattr(types, "UnionType") and isinstance(t, types.UnionType))
+    if origin is Union or (hasattr(types, "UnionType") and isinstance(t, types.UnionType)):
+        return True
+
+    # Also handle Annotated[Union, ...] for discriminated unions
+    # Import Annotated here to avoid module-level import
+    try:
+        from typing import Annotated
+
+        if origin is Annotated:
+            # Check if the first arg is a Union
+            args = get_args(t)
+            if args and _is_union_type(args[0]):
+                return True
+    except ImportError:
+        pass
+
+    return False
 
 
 def _truncate_data_repr(data: Any, max_length: int = 200) -> str:
@@ -353,10 +370,11 @@ def _structure_union(data: Any, union_type: type) -> Any:
 
     Strategy:
         1. If data is None and NoneType is in the union, return None
-        2. If data is a dict, try each dataclass variant
-        3. Try structuring with other variants (generic types, registered hooks)
-        4. Fall back to dict[str, Any] if present
-        5. Raise error if no variant matches
+        2. Check for discriminator metadata for O(1) variant lookup
+        3. If data is a dict, try each dataclass variant
+        4. Try structuring with other variants (generic types, registered hooks)
+        5. Fall back to dict[str, Any] if present
+        6. Raise error if no variant matches
 
     Args:
         data: The raw data to structure
@@ -369,7 +387,24 @@ def _structure_union(data: Any, union_type: type) -> Any:
         TypeError: If data is None but NoneType not in union
         ValueError: If no Union variant matches the data
     """
-    args = get_args(union_type)
+    # If this is Annotated[Union[...], metadata], extract the Union and metadata
+    origin = get_origin(union_type)
+    try:
+        from typing import Annotated
+
+        if origin is Annotated:
+            # Extract Union type and metadata from Annotated
+            annotated_args = get_args(union_type)
+            if annotated_args:
+                # First arg is the actual Union, rest are metadata
+                actual_union = annotated_args[0]
+                args = get_args(actual_union)
+            else:
+                args = get_args(union_type)
+        else:
+            args = get_args(union_type)
+    except ImportError:
+        args = get_args(union_type)
 
     # Handle None explicitly
     if data is None:
@@ -377,6 +412,49 @@ def _structure_union(data: Any, union_type: type) -> Any:
             return None
         raise TypeError(f"None is not valid for {union_type}")
 
+    # Check for discriminator metadata (from Annotated[Union[...], discriminator])
+    # This enables O(1) lookup instead of O(n) sequential tries
+    if hasattr(union_type, "__metadata__"):
+        for metadata in union_type.__metadata__:
+            # Check if this is discriminator metadata (has property_name and get_mapping method)
+            if hasattr(metadata, "property_name") and hasattr(metadata, "get_mapping"):
+                if isinstance(data, dict) and metadata.property_name in data:
+                    discriminator_value = data[metadata.property_name]
+
+                    # Get the mapping using the get_mapping method
+                    mapping = metadata.get_mapping()
+
+                    if mapping and discriminator_value in mapping:
+                        variant = mapping[discriminator_value]
+
+                        # Handle forward reference strings
+                        if isinstance(variant, str):
+                            # Try to find the actual type from union args
+                            for arg in args:
+                                if hasattr(arg, "__name__") and arg.__name__ == variant:
+                                    variant = arg
+                                    break
+
+                        # Attempt to structure with the discriminated variant
+                        try:
+                            _register_structure_hooks_recursively(variant)
+                            return converter.structure(data, variant)
+                        except Exception as e:
+                            # Provide clear error message for discriminated variant failure
+                            raise ValueError(
+                                f"Failed to deserialize as {variant.__name__} "
+                                f"(discriminator {metadata.property_name}={discriminator_value!r}): {e}"
+                            ) from e
+                    elif mapping:
+                        # Unknown discriminator value
+                        valid_values = list(mapping.keys())
+                        raise ValueError(
+                            f"Unknown discriminator value {discriminator_value!r} "
+                            f"for field {metadata.property_name!r}. "
+                            f"Expected one of: {valid_values}"
+                        )
+                # If discriminator property not in data, fall through to sequential try
+
     # Separate variants by type category
     dataclass_variants: list[type[Any]] = []
     dict_any_fallback = False

pyopenapi_gen/core/loader/schemas/extractor.py

@@ -37,12 +37,16 @@ def build_schemas(raw_schemas: dict[str, Mapping[str, Any]], raw_components: Map
 
     # Build initial IR for all schemas found in components
     for n, nd in raw_schemas.items():
-        if n not in context.parsed_schemas:
+        # Check if schema is already registered (either by original name or sanitized name)
+        sanitized_n = NameSanitizer.sanitize_class_name(n)
+        if n not in context.parsed_schemas and sanitized_n not in context.parsed_schemas:
             _parse_schema(n, nd, context, allow_self_reference=True)
 
-    # Post-condition check
-    if not all(n in context.parsed_schemas for n in raw_schemas):
-        raise RuntimeError("Not all schemas were parsed")
+    # Post-condition check: each raw schema must be registered under either its original or sanitized name
+    for n in raw_schemas:
+        sanitized_n = NameSanitizer.sanitize_class_name(n)
+        if n not in context.parsed_schemas and sanitized_n not in context.parsed_schemas:
+            raise RuntimeError(f"Schema '{n}' (sanitized: '{sanitized_n}') was not parsed")
 
     return context
 
@@ -192,6 +196,13 @@ def extract_inline_enums(schemas: dict[str, IRSchema]) -> dict[str, IRSchema]:
 
         # Extract inline enums from properties
         for prop_name, prop_schema in list(schema.properties.items()):
+            # Debug: log property state
+            logger.debug(
+                f"Processing {schema_name}.{prop_name}: "
+                f"type={prop_schema.type}, enum={prop_schema.enum}, "
+                f"name={prop_schema.name}, generation_name={prop_schema.generation_name}"
+            )
+
             # Check if this property has an inline enum that needs extraction
             # An inline enum needs extraction if:
             # 1. It has enum values defined
@@ -204,6 +215,7 @@ def extract_inline_enums(schemas: dict[str, IRSchema]) -> dict[str, IRSchema]:
             # Check if the enum was already extracted or is a named reference
             # Case 1: generation_name exists in schemas dict (already extracted)
             # Case 2: property name itself is a schema reference (e.g., ExistingStatusEnum)
+            # Case 3: property.type is already an enum name (created during parsing)
             enum_already_extracted = (
                 (
                     prop_schema.generation_name
@@ -224,9 +236,28 @@ def extract_inline_enums(schemas: dict[str, IRSchema]) -> dict[str, IRSchema]:
                     and "_" not in prop_schema.name
                     and prop_schema.name != prop_name  # Name differs from property key
                 )
+                or (
+                    # Property.type is already an enum schema name (created during parsing)
+                    prop_schema.type
+                    and prop_schema.type in schemas
+                    and schemas[prop_schema.type].enum
+                )
             )
 
             if has_inline_enum and not enum_already_extracted:
+                # Check if this enum was already created during parsing
+                # If prop_schema.type is already an enum name (not a primitive type), reuse it
+                if prop_schema.type and prop_schema.type in schemas and schemas[prop_schema.type].enum:
+                    # Enum already exists - just ensure property references it correctly
+                    enum_name = prop_schema.type
+                    logger.debug(f"Reusing existing enum {enum_name} for {schema_name}.{prop_name}")
+                    # Don't create a new enum, just update property references
+                    prop_schema.name = enum_name
+                    prop_schema.generation_name = schemas[enum_name].generation_name or enum_name
+                    prop_schema.final_module_stem = schemas[enum_name].final_module_stem
+                    prop_schema.enum = None  # Clear inline enum
+                    continue  # Skip creating new enum
+
                 # Use property's existing generation_name if set, otherwise create a new name
                 # This keeps naming consistent with what the type resolver already assigned
                 if prop_schema.generation_name:

pyopenapi_gen/core/parsing/schema_parser.py

@@ -10,6 +10,7 @@ from typing import Any, Callable, List, Mapping, Set, Tuple
 
 from pyopenapi_gen import IRSchema
 from pyopenapi_gen.core.utils import NameSanitizer
+from pyopenapi_gen.ir import IRDiscriminator
 
 from .context import ParsingContext
 from .keywords.all_of_parser import _process_all_of
@@ -86,8 +87,16 @@ def _parse_composition_keywords(
     context: ParsingContext,
     max_depth: int,
     parse_fn: Callable[[str | None, Mapping[str, Any] | None, ParsingContext, int | None], IRSchema],
-) -> Tuple[List[IRSchema] | None, List[IRSchema] | None, List[IRSchema] | None, dict[str, IRSchema], Set[str], bool]:
-    """Parse composition keywords (anyOf, oneOf, allOf) from a schema node.
+) -> Tuple[
+    List[IRSchema] | None,
+    List[IRSchema] | None,
+    List[IRSchema] | None,
+    dict[str, IRSchema],
+    Set[str],
+    bool,
+    IRDiscriminator | None,
+]:
+    """Parse composition keywords (anyOf, oneOf, allOf) and discriminator from a schema node.
 
     Contracts:
         Pre-conditions:
@@ -97,7 +106,7 @@ def _parse_composition_keywords(
             - parse_fn is a callable for parsing schemas
         Post-conditions:
             - Returns a tuple of (any_of_schemas, one_of_schemas, all_of_components,
-              properties, required_fields, is_nullable)
+              properties, required_fields, is_nullable, discriminator)
     """
     any_of_schemas: List[IRSchema] | None = None
     one_of_schemas: List[IRSchema] | None = None
@@ -105,6 +114,7 @@ def _parse_composition_keywords(
     merged_properties: dict[str, IRSchema] = {}
     merged_required_set: Set[str] = set()
     is_nullable: bool = False
+    discriminator: IRDiscriminator | None = None
 
     if "anyOf" in node:
         parsed_sub_schemas, nullable_from_sub, _ = _parse_any_of_schemas(node["anyOf"], context, max_depth, parse_fn)
@@ -116,6 +126,18 @@ def _parse_composition_keywords(
         one_of_schemas = parsed_sub_schemas
         is_nullable = is_nullable or nullable_from_sub
 
+    # Extract discriminator if present (applies to oneOf or anyOf)
+    if "discriminator" in node and isinstance(node["discriminator"], Mapping):
+        disc_node = node["discriminator"]
+        property_name = disc_node.get("propertyName")
+        if property_name:
+            # Extract mapping if present
+            mapping = None
+            if "mapping" in disc_node and isinstance(disc_node["mapping"], Mapping):
+                mapping = dict(disc_node["mapping"])
+
+            discriminator = IRDiscriminator(property_name=property_name, mapping=mapping)
+
     if "allOf" in node:
         merged_properties, merged_required_set, parsed_all_of_components = _process_all_of(
             node, name, context, parse_fn, max_depth=max_depth
@@ -123,7 +145,15 @@ def _parse_composition_keywords(
     else:
         merged_required_set = set(node.get("required", []))
 
-    return any_of_schemas, one_of_schemas, parsed_all_of_components, merged_properties, merged_required_set, is_nullable
+    return (
+        any_of_schemas,
+        one_of_schemas,
+        parsed_all_of_components,
+        merged_properties,
+        merged_required_set,
+        is_nullable,
+        discriminator,
+    )
 
 
 def _parse_properties(
@@ -190,7 +220,21 @@ def _parse_properties(
                     and not promoted_ir_schema._max_depth_exceeded_marker
                     and not promoted_ir_schema._is_circular_ref
                 ):
-                    context.parsed_schemas[promoted_schema_name] = promoted_ir_schema
+                    # CRITICAL: Register using the schema's sanitized name to prevent duplicate keys
+                    registration_key = promoted_ir_schema.name if promoted_ir_schema.name else promoted_schema_name
+
+                    # Check for collision
+                    if registration_key in context.parsed_schemas:
+                        existing_schema = context.parsed_schemas[registration_key]
+                        if existing_schema is not promoted_ir_schema:
+                            # Collision - use original name
+                            registration_key = promoted_schema_name
+                            logger.debug(
+                                f"Promoted schema collision: {promoted_ir_schema.name!r} already registered. "
+                                f"Using original name {promoted_schema_name!r}."
+                            )
+
+                    context.parsed_schemas[registration_key] = promoted_ir_schema
             else:
                 # Directly parse other inline types (string, number, array of simple types, etc.)
                 # or objects that are not being promoted (e.g. if parent_schema_name is None)
@@ -248,8 +292,18 @@ def _parse_properties(
                     )
                 )
 
-                # Use a sanitized version of prop_name as context name for this sub-parse
-                prop_context_name = NameSanitizer.sanitize_class_name(prop_name)
+                # Use a sanitized version of prop_name combined with parent schema name for unique context
+                # This ensures properties with the same name in different schemas get unique enum names
+                if parent_schema_name:
+                    sanitized_prop_name = NameSanitizer.sanitize_class_name(prop_name)
+                    # Avoid redundant prefixing if the property name already starts with the parent schema name
+                    # e.g., Entry + entry_specific_role -> EntrySpecificRole (not EntryEntrySpecificRole)
+                    if sanitized_prop_name.lower().startswith(parent_schema_name.lower()):
+                        prop_context_name = sanitized_prop_name
+                    else:
+                        prop_context_name = f"{parent_schema_name}{sanitized_prop_name}"
+                else:
+                    prop_context_name = NameSanitizer.sanitize_class_name(prop_name)
 
                 # For simple primitives and simple arrays, avoid creating separate schemas
                 if (is_simple_primitive or is_simple_array) and prop_context_name in context.parsed_schemas:
@@ -301,7 +355,7 @@ def _parse_properties(
                         prop_is_nullable = True
 
                     property_holder_ir = IRSchema(
-                        name=prop_name,  # The actual property name
+                        name=None,  # Property name is the dict key, not stored in the schema object
                         # Type is the name of the (potentially registered) anonymous schema
                         type=parsed_prop_schema_ir.name,
                         description=prop_schema_node.get("description", parsed_prop_schema_ir.description),
@@ -317,27 +371,63 @@ def _parse_properties(
                 else:
                     # Simpler type, or error placeholder. Assign directly but ensure original prop_name is used.
                     # Also, try to respect original node's description, default, example, nullable if available.
-                    final_prop_ir = parsed_prop_schema_ir
-                    # Always assign the property name - this is the property's name in the parent object
-                    final_prop_ir.name = prop_name
-                    if isinstance(prop_schema_node, Mapping):
-                        final_prop_ir.description = prop_schema_node.get(
-                            "description", parsed_prop_schema_ir.description
-                        )
-                        final_prop_ir.default = prop_schema_node.get("default", parsed_prop_schema_ir.default)
-                        final_prop_ir.example = prop_schema_node.get("example", parsed_prop_schema_ir.example)
-                        current_prop_node_nullable = prop_schema_node.get("nullable", False)
-                        type_list_nullable = (
-                            isinstance(prop_schema_node.get("type"), list) and "null" in prop_schema_node["type"]
-                        )
-                        final_prop_ir.is_nullable = (
-                            final_prop_ir.is_nullable or current_prop_node_nullable or type_list_nullable
-                        )
-                        # If the sub-parse didn't pick up an enum (e.g. for simple types), take it from prop_schema_node
-                        if not final_prop_ir.enum and "enum" in prop_schema_node:
-                            final_prop_ir.enum = prop_schema_node["enum"]
 
-                    parsed_props[prop_name] = final_prop_ir
+                    # CRITICAL: If the schema was registered as a standalone schema (e.g., inline enum with parent context name),
+                    # we must NOT modify its name attribute. Instead, create a reference holder.
+                    schema_was_registered_standalone = (
+                        schema_name_for_parsing is not None
+                        and parsed_prop_schema_ir.name == schema_name_for_parsing
+                        and context.is_schema_parsed(schema_name_for_parsing)
+                    )
+
+                    if schema_was_registered_standalone:
+                        # Schema is registered - create a reference holder instead of modifying the schema
+                        # CRITICAL: Do NOT set 'name' field for property holders - the property name is the dict key.
+                        # Setting 'name' would cause __post_init__ to sanitize it, changing 'sender_role' to 'SenderRole'.
+                        prop_is_nullable = False
+                        if isinstance(prop_schema_node, Mapping):
+                            if "nullable" in prop_schema_node:
+                                prop_is_nullable = prop_schema_node["nullable"]
+                            elif isinstance(prop_schema_node.get("type"), list) and "null" in prop_schema_node["type"]:
+                                prop_is_nullable = True
+                        elif parsed_prop_schema_ir.is_nullable:
+                            prop_is_nullable = True
+
+                        property_holder_ir = IRSchema(
+                            name=None,  # Property name is the dict key, not stored in the schema object
+                            type=parsed_prop_schema_ir.name,  # Reference to the registered schema
+                            description=prop_schema_node.get("description", parsed_prop_schema_ir.description),
+                            is_nullable=prop_is_nullable,
+                            default=prop_schema_node.get("default"),
+                            example=prop_schema_node.get("example"),
+                            enum=prop_schema_node.get("enum") if not parsed_prop_schema_ir.enum else None,
+                            format=parsed_prop_schema_ir.format,
+                            _refers_to_schema=parsed_prop_schema_ir,
+                        )
+                        parsed_props[prop_name] = property_holder_ir
+                    else:
+                        # Schema was not registered - safe to modify its name
+                        final_prop_ir = parsed_prop_schema_ir
+                        # Always assign the property name - this is the property's name in the parent object
+                        final_prop_ir.name = prop_name
+                        if isinstance(prop_schema_node, Mapping):
+                            final_prop_ir.description = prop_schema_node.get(
+                                "description", parsed_prop_schema_ir.description
+                            )
+                            final_prop_ir.default = prop_schema_node.get("default", parsed_prop_schema_ir.default)
+                            final_prop_ir.example = prop_schema_node.get("example", parsed_prop_schema_ir.example)
+                            current_prop_node_nullable = prop_schema_node.get("nullable", False)
+                            type_list_nullable = (
+                                isinstance(prop_schema_node.get("type"), list) and "null" in prop_schema_node["type"]
+                            )
+                            final_prop_ir.is_nullable = (
+                                final_prop_ir.is_nullable or current_prop_node_nullable or type_list_nullable
+                            )
+                            # If the sub-parse didn't pick up an enum (e.g. for simple types), take it from prop_schema_node
+                            if not final_prop_ir.enum and "enum" in prop_schema_node:
+                                final_prop_ir.enum = prop_schema_node["enum"]
+
+                        parsed_props[prop_name] = final_prop_ir
     return parsed_props
 
 
@@ -400,11 +490,15 @@ def _parse_schema(
 
     # If we reach here, detection_result.action == CycleAction.CONTINUE_PARSING
 
+    # Sanitize schema name early for consistent use throughout parsing
+    # This ensures property enums get named correctly with the sanitized parent name
+    sanitized_schema_name = NameSanitizer.sanitize_class_name(schema_name) if schema_name else None
+
     try:  # Ensure exit_schema is called
         if schema_node is None:
             # Create empty schema for null schema nodes
             # Do NOT set generation_name - null schemas should resolve to Any inline, not generate separate files
-            return IRSchema(name=NameSanitizer.sanitize_class_name(schema_name) if schema_name else None)
+            return IRSchema(name=sanitized_schema_name)
 
         if not isinstance(schema_node, Mapping):
             raise TypeError(
@@ -473,14 +567,20 @@ def _parse_schema(
             elif is_nullable_from_type_field:
                 extracted_type = "null"
 
-        any_of_irs, one_of_irs, all_of_components_irs, props_from_comp, req_from_comp, nullable_from_comp = (
-            _parse_composition_keywords(
-                schema_node,
-                schema_name,
-                context,
-                ENV_MAX_DEPTH,
-                lambda n, sn, c, md: _parse_schema(n, sn, c, md, allow_self_reference),
-            )
+        (
+            any_of_irs,
+            one_of_irs,
+            all_of_components_irs,
+            props_from_comp,
+            req_from_comp,
+            nullable_from_comp,
+            discriminator_ir,
+        ) = _parse_composition_keywords(
+            schema_node,
+            schema_name,
+            context,
+            ENV_MAX_DEPTH,
+            lambda n, sn, c, md: _parse_schema(n, sn, c, md, allow_self_reference),
         )
 
         # Check for direct nullable field (OpenAPI 3.0 Swagger extension)
@@ -526,7 +626,7 @@ def _parse_schema(
             if "properties" in schema_node:
                 final_properties_for_ir = _parse_properties(
                     schema_node["properties"],
-                    schema_name,
+                    sanitized_schema_name,  # Use sanitized name for consistent enum naming
                     props_from_comp,  # these are from allOf merge
                     context,
                     max_depth_override,
@@ -641,7 +741,8 @@ def _parse_schema(
                 )
                 items_ir = IRSchema(type="object")
 
-        schema_ir_name_attr = NameSanitizer.sanitize_class_name(schema_name) if schema_name else None
+        # Use the already-sanitized schema name
+        schema_ir_name_attr = sanitized_schema_name
 
         # Parse additionalProperties field
         additional_properties_value: bool | IRSchema | None = None
@@ -666,6 +767,7 @@ def _parse_schema(
             any_of=any_of_irs,
             one_of=one_of_irs,
             all_of=all_of_components_irs,
+            discriminator=discriminator_ir,
             required=sorted(list(final_required_fields_set)),
             description=schema_node.get("description"),
             format=schema_node.get("format") if isinstance(schema_node.get("format"), str) else None,
@@ -762,7 +864,27 @@ def _parse_schema(
             and not is_synthetic_primitive
         )
         if should_register and schema_name:
-            context.parsed_schemas[schema_name] = schema_ir
+            # CRITICAL: Register using the schema's sanitized name (schema_ir.name) to prevent duplicate keys.
+            # The schema object's name attribute is already sanitized, so we use that as the key.
+            # This prevents the post-processor from registering the same schema again under a different key.
+            # However, if multiple raw schemas sanitize to the same name (e.g., "Foo-Bar" and "FooBar" both -> "FooBar"),
+            # we need to detect collisions and use the original raw schema name as a fallback.
+            registration_key = schema_ir.name if schema_ir.name else schema_name
+
+            # Check if this is a collision between different raw schemas
+            if registration_key in context.parsed_schemas:
+                existing_schema = context.parsed_schemas[registration_key]
+                # If it's the same schema object (e.g., from cycle detection returning existing), don't re-register
+                if existing_schema is not schema_ir:
+                    # Collision detected - use the original raw schema name as key to keep both schemas
+                    # This preserves backward compatibility with the collision handling in ModelsEmitter
+                    registration_key = schema_name
+                    logger.debug(
+                        f"Schema name collision detected: {schema_ir.name!r} already registered. "
+                        f"Using original raw name {schema_name!r} as key."
+                    )
+
+            context.parsed_schemas[registration_key] = schema_ir
 
         # Set generation_name and final_module_stem for schemas that will be generated as separate files
         # Skip for synthetic primitives (inline types) - they should remain without these attributes

pyopenapi_gen/core/utils.py

@@ -125,7 +125,8 @@ class NameSanitizer:
 
     @staticmethod
     def sanitize_module_name(name: str) -> str:
-        """Convert a raw name into a valid Python module name in snake_case, splitting camel case and PascalCase."""
+        """Convert a raw name into a valid Python module name in snake_case,
+        splitting camel case and PascalCase."""
         # # <<< Add Check for problematic input >>>
         # if '[' in name or ']' in name or ',' in name:
         #     logger.error(f"sanitize_module_name received potentially invalid input: '{name}'")
@@ -195,7 +196,8 @@ class NameSanitizer:
 
     @staticmethod
     def sanitize_method_name(name: str) -> str:
-        """Convert a raw name into a valid Python method name in snake_case, splitting camelCase and PascalCase."""
+        """Convert a raw name into a valid Python method name in snake_case,
+        splitting camelCase and PascalCase."""
         # Remove curly braces
         name = re.sub(r"[{}]", "", name)
         # Split camelCase and PascalCase to snake_case
@@ -261,7 +263,8 @@ class KwargsBuilder:
 
 
 class Formatter:
-    """Helper to format code using Black, falling back to unformatted content if Black is unavailable or errors."""
+    """Helper to format code using Black, falling back to unformatted content if
+    Black is unavailable or errors."""
 
     def __init__(self) -> None:
         from typing import Any, Callable
@@ -329,7 +332,8 @@ class DataclassSerializer:
             The serialized object with dataclasses converted to dictionaries.
 
         Handles:
-        - Dataclass instances with Meta.key_transform_with_dump: Applies field name mapping (snake_case → camelCase)
+        - Dataclass instances with Meta.key_transform_with_dump: Applies field
+          name mapping (snake_case → camelCase)
         - Legacy BaseSchema instances: Falls back to to_dict() if present (backward compatibility)
         - Regular dataclass instances: Converted to dictionaries using field names
         - Lists: Recursively serialize each item
@@ -389,7 +393,28 @@ class DataclassSerializer:
         if dataclasses.is_dataclass(obj) and not isinstance(obj, type):
             visited.add(obj_id)
             try:
-                # Build dict from dataclass fields without recursive unstructuring
+                # Check if there's a custom cattrs unstructure hook for this type
+                try:
+                    from pyopenapi_gen.core.cattrs_converter import converter
+
+                    obj_type = type(obj)
+                    # Get the unstructure hook for this type
+                    hook = converter.get_unstructure_hook(obj_type)
+
+                    # Check if it's a custom hook (not auto-generated by cattrs)
+                    # Auto-generated hooks have names like "unstructure_ClassName"
+                    expected_auto_gen_name = f"unstructure_{obj_type.__name__}"
+                    is_custom_hook = hook.__name__ != expected_auto_gen_name
+                    if is_custom_hook:
+                        # Custom unstructure hook exists - use it
+                        unstructured = converter.unstructure(obj)
+                        # Recursively serialize the result
+                        return DataclassSerializer._serialize_with_tracking(unstructured, visited)
+                except Exception:  # nosec B110
+                    # cattrs_converter not available or check failed - fall through to manual iteration
+                    pass
+
+                # Manual field iteration (for dataclasses without custom hooks or when cattrs fails)
                 data: dict[str, Any] = {}
                 for field in dataclasses.fields(obj):
                     value = getattr(obj, field.name)

pyopenapi_gen/core/writers/python_construct_renderer.py

@@ -31,12 +31,24 @@ class PythonConstructRenderer:
     - Generic classes (with bases, docstrings, and body)
     """
 
+    @staticmethod
+    def _to_module_name(class_name: str) -> str:
+        """Convert PascalCase class name to snake_case module name."""
+        import re
+
+        # Insert underscore before uppercase letters (except first)
+        s1 = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", class_name)
+        # Insert underscore before uppercase letters followed by lowercase
+        s2 = re.sub("([a-z0-9])([A-Z])", r"\1_\2", s1)
+        return s2.lower()
+
     def render_alias(
         self,
         alias_name: str,
         target_type: str,
         description: str | None,
         context: RenderContext,
+        discriminator: "IRDiscriminator | None" = None,  # type: ignore[name-defined]
     ) -> str:
         """
         Render a type alias assignment as Python code.
@@ -46,6 +58,7 @@ class PythonConstructRenderer:
             target_type: The target type expression
             description: Optional description for the docstring
             context: The rendering context for import registration
+            discriminator: Optional discriminator metadata for Union types
 
         Returns:
             Formatted Python code for the type alias
@@ -64,10 +77,70 @@ class PythonConstructRenderer:
         context.add_typing_imports_for_type(target_type)
 
         # Add __all__ export
-        writer.write_line(f'__all__ = ["{alias_name}"]')
+        exports = [alias_name]
+        if discriminator:
+            # Also export the discriminator metadata class
+            exports.append(f"{alias_name}Discriminator")
+        writer.write_line(f"__all__ = {exports!r}")
         writer.write_line("")  # Add a blank line for separation
 
-        writer.write_line(f"{alias_name}: TypeAlias = {target_type}")
+        # If there's a discriminator, generate the metadata class and use Annotated
+        if discriminator and target_type.startswith("Union["):
+            # Extract the union variants
+            context.add_import("typing", "Annotated")
+            context.add_import("dataclasses", "dataclass")
+            context.add_import("dataclasses", "field")
+
+            # Generate discriminator metadata class (frozen for hashability in Annotated)
+            writer.write_line("@dataclass(frozen=True)")
+            writer.write_line(f"class {alias_name}Discriminator:")
+            writer.write_line(f'    """Discriminator metadata for {alias_name} union."""')
+            writer.write_line("")
+            writer.write_line(f'    property_name: str = "{discriminator.property_name}"')
+            writer.write_line(f'    """The discriminator property name"""')
+            writer.write_line("")
+
+            # Store mapping as immutable tuple for frozen dataclass, convert to dict at runtime
+            if discriminator.mapping:
+                # Store discriminator mapping as tuple of tuples (immutable for frozen dataclass)
+                writer.write_line("    # Mapping stored as tuple for frozen dataclass compatibility")
+                writer.write_line("    _mapping_data: tuple[tuple[str, str], ...] = (")
+                for disc_value, schema_ref in discriminator.mapping.items():
+                    schema_name = schema_ref.split("/")[-1]
+                    writer.write_line(f'        ("{disc_value}", "{schema_name}"),')
+                writer.write_line("    )")
+                writer.write_line("")
+                writer.write_line("    def get_mapping(self) -> dict[str, type]:")
+                writer.write_line('        """Get discriminator mapping with actual type references."""')
+                # Import types locally
+                for disc_value, schema_ref in discriminator.mapping.items():
+                    schema_name = schema_ref.split("/")[-1]
+                    module_name = self._to_module_name(schema_name)
+                    writer.write_line(f"        from .{module_name} import {schema_name}")
+                writer.write_line("        return {")
+                for disc_value, schema_ref in discriminator.mapping.items():
+                    schema_name = schema_ref.split("/")[-1]
+                    writer.write_line(f'            "{disc_value}": {schema_name},')
+                writer.write_line("        }")
+            else:
+                writer.write_line("    _mapping_data: tuple[tuple[str, str], ...] | None = None")
+                writer.write_line("")
+                writer.write_line("    def get_mapping(self) -> dict[str, type] | None:")
+                writer.write_line('        """Get discriminator mapping."""')
+                writer.write_line("        return None")
+
+            writer.write_line("")
+            writer.write_line("")
+
+            # Use Annotated to attach discriminator metadata
+            writer.write_line(f"{alias_name}: TypeAlias = Annotated[")
+            writer.write_line(f"    {target_type},")
+            writer.write_line(f"    {alias_name}Discriminator()")
+            writer.write_line("]")
+        else:
+            # No discriminator, use plain type alias
+            writer.write_line(f"{alias_name}: TypeAlias = {target_type}")
+
         if description:
             # Sanitize description for use within a triple-double-quoted string for the actual docstring
             safe_desc_content = description.replace("\\", "\\\\")  # Escape backslashes first

pyopenapi_gen/emitters/models_emitter.py

@@ -278,15 +278,52 @@ class ModelsEmitter:
         # Update the main reference to use filtered schemas
         all_schemas_for_generation = filtered_schemas_for_generation
 
+        # Collect all nested schemas from oneOf/anyOf/allOf that need naming
+        def collect_nested_schemas(schema: IRSchema, collected: dict[int, IRSchema], visited_ids: Set[int]) -> None:
+            """Recursively collect all nested schemas that need generation_name."""
+            schema_id = id(schema)
+            if schema_id in visited_ids:
+                return  # Avoid infinite loops
+
+            visited_ids.add(schema_id)
+            if schema.name:  # Only collect schemas with names
+                collected[schema_id] = schema
+
+            # Process oneOf variants
+            if schema.one_of:
+                for variant in schema.one_of:
+                    if variant.name and id(variant) not in visited_ids:
+                        collect_nested_schemas(variant, collected, visited_ids)
+
+            # Process anyOf variants
+            if schema.any_of:
+                for variant in schema.any_of:
+                    if variant.name and id(variant) not in visited_ids:
+                        collect_nested_schemas(variant, collected, visited_ids)
+
+            # Process allOf components (though they typically merge, not union)
+            if schema.all_of:
+                for component in schema.all_of:
+                    if component.name and id(component) not in visited_ids:
+                        collect_nested_schemas(component, collected, visited_ids)
+
+        # Collect all schemas including nested ones
+        # Deduplicate schemas by ID first - same schema object may appear under multiple keys
+        unique_schemas_by_id = {id(s): s for s in all_schemas_for_generation.values()}
+        all_schemas_including_nested: dict[int, IRSchema] = {}
+        visited_schema_ids: Set[int] = set()
+        for schema in unique_schemas_by_id.values():
+            collect_nested_schemas(schema, all_schemas_including_nested, visited_schema_ids)
+
         schemas_to_name_decollision = sorted(
-            [s for s in all_schemas_for_generation.values()],
-            key=lambda s: s.name,  # type: ignore
+            list(all_schemas_including_nested.values()),
+            key=lambda s: s.name if s.name else "",
         )
 
-        # logger.debug(
-        #     f"ModelsEmitter: Schemas to actually de-collide (post-filter by s.name): "
-        #     f"{[s.name for s in schemas_to_name_decollision]}"
-        # )
+        logger.debug(
+            f"ModelsEmitter: Schemas to actually de-collide (post-filter by s.name): "
+            f"{[(s.name, id(s)) for s in schemas_to_name_decollision]}"
+        )
 
         for schema_for_naming in schemas_to_name_decollision:  # Use the comprehensive list
             original_schema_name = schema_for_naming.name

pyopenapi_gen/ir.py

@@ -14,6 +14,27 @@ from .http_types import HTTPMethod
 #     pass
 
 
+@dataclass
+class IRDiscriminator:
+    """
+    Discriminator metadata for oneOf/anyOf unions.
+
+    OpenAPI discriminator enables efficient runtime type resolution by specifying
+    which property identifies the variant and the mapping from property values to schema types.
+    """
+
+    property_name: str
+    """The name of the property used to discriminate between variants (e.g., 'type')"""
+
+    mapping: dict[str, str] | None = None
+    """Optional mapping from discriminator values to schema references.
+
+    Example: {'agent': '#/components/schemas/WorkflowAgentNode', 'end': '#/components/schemas/WorkflowEndNode'}
+
+    If None, the discriminator property value directly identifies the schema name.
+    """
+
+
 @dataclass
 class IRSchema:
     name: str | None = None
@@ -31,6 +52,7 @@ class IRSchema:
     any_of: List[IRSchema] | None = None
     one_of: List[IRSchema] | None = None
     all_of: List[IRSchema] | None = None  # Store the list of IRSchema objects from allOf
+    discriminator: IRDiscriminator | None = None  # Discriminator for oneOf/anyOf unions
     title: str | None = None  # Added title
     is_data_wrapper: bool = False  # True if schema is a simple {{ "data": OtherSchema }} wrapper
 
@@ -94,6 +116,10 @@ class IRSchema:
         if isinstance(self.additional_properties, dict):
             self.additional_properties = IRSchema(**self.additional_properties)
 
+        # Ensure discriminator is an IRDiscriminator instance
+        if isinstance(self.discriminator, dict):
+            self.discriminator = IRDiscriminator(**self.discriminator)
+
         for comp_list_attr in ["any_of", "one_of", "all_of"]:
             comp_list = getattr(self, comp_list_attr)
             if isinstance(comp_list, list):

pyopenapi_gen/visit/model/alias_generator.py

@@ -71,11 +71,15 @@ class AliasGenerator:
 
         # logger.debug(f"AliasGenerator: Rendering alias '{alias_name}' for target type '{target_type}'.")
 
+        # Pass discriminator metadata if this is a union type
+        discriminator = schema.discriminator if hasattr(schema, "discriminator") else None
+
         rendered_code = self.renderer.render_alias(
             alias_name=alias_name,
             target_type=target_type,
             description=schema.description,
             context=context,
+            discriminator=discriminator,
         )
 
         # Post-condition

pyopenapi_gen/visit/model/model_visitor.py

@@ -77,7 +77,16 @@ class ModelVisitor(Visitor[IRSchema, str]):
         # --- Model Type Detection Logic ---
         is_enum = bool(schema.name and schema.enum and schema.type in ("string", "integer"))
 
-        is_type_alias = bool(schema.name and not schema.properties and not is_enum and schema.type != "object")
+        # Check for discriminated union types (oneOf, anyOf) which should be Union type aliases
+        # Note: allOf is for schema composition/merging, not discriminated unions
+        is_union_type = bool(schema.name and (schema.one_of or schema.any_of))
+
+        is_type_alias = bool(
+            schema.name
+            and not schema.properties
+            and not is_enum
+            and (schema.type != "object" or is_union_type)  # Allow object types if they're union compositions
+        )
 
         if schema.type == "array" and schema.items and schema.items.type == "object" and schema.items.name is None:
             if is_type_alias:

{pyopenapi_gen-2.7.2.dist-info → pyopenapi_gen-3.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyopenapi-gen
-Version: 2.7.2
+Version: 3.0.1
 Summary: Modern, async-first Python client generator for OpenAPI specifications with advanced cycle detection and unified type resolution
 Project-URL: Homepage, https://github.com/your-org/pyopenapi-gen
 Project-URL: Documentation, https://github.com/your-org/pyopenapi-gen/blob/main/README.md

{pyopenapi_gen-2.7.2.dist-info → pyopenapi_gen-3.0.1.dist-info}/RECORD

@@ -1,8 +1,8 @@
-pyopenapi_gen/__init__.py,sha256=9Wv9-vW-L8neI6zgZEoBXOIglYJq8mKnvC3QCDqj0eA,7632
+pyopenapi_gen/__init__.py,sha256=Df2VrSmifyuu_8NbGBjzN9JRvXFoLv9FlqKk4x-_qnE,7632
 pyopenapi_gen/__main__.py,sha256=4-SCaCNhBd7rtyRK58uoDbdl93J0KhUeajP_b0CPpLE,110
 pyopenapi_gen/cli.py,sha256=TA3bpe8kmUuyA4lZqAHHx5YkWQvrNq81WuEDAtPO6JQ,2147
 pyopenapi_gen/http_types.py,sha256=EMMYZBt8PNVZKPFu77TQija-JI-nOKyXvpiQP9-VSWE,467
-pyopenapi_gen/ir.py,sha256=lGrn5VzU5gXHc_Tkjfte2AeMMsTyzAci4dy0bi5aG1E,7243
+pyopenapi_gen/ir.py,sha256=VDA7ZFCm5-EU5r_k4H0zkKKDNp-cljg44xPhywN0wBw,8229
 pyopenapi_gen/py.typed,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 pyopenapi_gen/context/CLAUDE.md,sha256=eUPvSY2ADQK21i52bWfzyBcDPVvvepErMiQrq6ndwlU,9004
 pyopenapi_gen/context/file_manager.py,sha256=vpbRByO5SH6COdjb6C-pXkdSIRu7QFqrXxi69VLKBnM,1691
@@ -10,7 +10,7 @@ pyopenapi_gen/context/import_collector.py,sha256=5WzQ5fXxARHJFZmYZ_GjPG5YjjzRLZT
 pyopenapi_gen/context/render_context.py,sha256=fAq0u3rDMZ0_OEHegrRUd98ySxs390XJbdypqQX8bwI,34894
 pyopenapi_gen/core/CLAUDE.md,sha256=bz48K-PSrhxCq5ScmiLiU9kfpVVzSWRKOA9RdKk_pbg,6482
 pyopenapi_gen/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyopenapi_gen/core/cattrs_converter.py,sha256=qaQz08_TTaM9xLfjZMcTJFO5ghSLp0yuThmGW-Xkdns,27796
+pyopenapi_gen/core/cattrs_converter.py,sha256=k-2rcUUKc6AnSbnTNhqvEQYMIeZRl89czlr52bPceBo,31460
 pyopenapi_gen/core/exceptions.py,sha256=HYFiYdmzsZUl46vB8M3B6Vpp6m8iqjUcKDWdL4yEKHo,498
 pyopenapi_gen/core/http_status_codes.py,sha256=nn8QdXmkv5BQA9C-HTn9wmAVWyEyB9bAHpHve6EZX4M,6249
 pyopenapi_gen/core/http_transport.py,sha256=JWTka-p8VUKS9vL7NciZUaiZqpjchBYxzx_MrdCyVYo,9836
@@ -19,7 +19,7 @@ pyopenapi_gen/core/postprocess_manager.py,sha256=Ia4H47lInhVxkHnDB46t4U-6BLpLXzh
 pyopenapi_gen/core/spec_fetcher.py,sha256=kAEj5XgYvV-IA0UHKn8_bglWxtscQwvJXZncC4hzmTM,4601
 pyopenapi_gen/core/streaming_helpers.py,sha256=5fkzH9xsgzZWOTKFrZpmje07S7n7CcOpjteb5dig7ds,2664
 pyopenapi_gen/core/telemetry.py,sha256=LNMrlrUNVcp591w9cX4uvzlFrPB6ZZoGRIuCOHlDCqA,2296
-pyopenapi_gen/core/utils.py,sha256=4733xWshc_pnj1mLrCWTTj0Pdv-H42fGbh5bcmawQBc,16409
+pyopenapi_gen/core/utils.py,sha256=oeZ3GIZGuODEQS5EIQ8uOZs88fDVOV-4mjo5HXxqCp0,17638
 pyopenapi_gen/core/warning_collector.py,sha256=DYl9D7eZYs04mDU84KeonS-5-d0aM7hNqraXTex31ss,2799
 pyopenapi_gen/core/auth/base.py,sha256=E2KUerA_mYv9D7xulUm-lenIxqZHqanjA4oRKpof2ZE,792
 pyopenapi_gen/core/auth/plugins.py,sha256=u4GZTykoxGwGaWAQyFeTdPKi-pSK7Dp0DCeg5RsrSw4,3446
@@ -34,12 +34,12 @@ pyopenapi_gen/core/loader/parameters/parser.py,sha256=TROPMq6iyL9Somh7K1ADjqyDGX
 pyopenapi_gen/core/loader/responses/__init__.py,sha256=6APWoH3IdNkgVmI0KsgZoZ6knDaG-S-pnUCa6gkzT8E,216
 pyopenapi_gen/core/loader/responses/parser.py,sha256=6dZ86WvyBxPq68UQjF_F8F2FtmGtMm5ZB8UjKXZTu9Y,4063
 pyopenapi_gen/core/loader/schemas/__init__.py,sha256=rlhujYfw_IzWgzhVhYMJ3eIhE6C5Vi1Ylba-BHEVqOg,296
-pyopenapi_gen/core/loader/schemas/extractor.py,sha256=VJtEM2QPuNSyrIdll43qD00StYIdmuUMcg49oTiyPqQ,13224
+pyopenapi_gen/core/loader/schemas/extractor.py,sha256=bx7EG0f4fDOT8H9E0tiZAjs-jtfJmY9cwHmdHgZrAfY,15249
 pyopenapi_gen/core/parsing/__init__.py,sha256=RJsIR6cHaNoI4tBcpMlAa0JsY64vsHb9sPxPg6rd8FQ,486
 pyopenapi_gen/core/parsing/context.py,sha256=oahabtftjYiyeKNHwc3fWjSGrIoCeNnKN-KhWofiOmk,7968
 pyopenapi_gen/core/parsing/cycle_helpers.py,sha256=HyVQBWU78PbypyppHq34yxr6BG4W5Bt4ev5kkGUyvkg,5969
 pyopenapi_gen/core/parsing/schema_finalizer.py,sha256=BMx7nlg5tECbKDfv6XEwumNNPkzkL5qRPdYrRI8qrxo,6856
-pyopenapi_gen/core/parsing/schema_parser.py,sha256=DlC5dyLMCB8O-EBU5oxPgh4AQKU8wj_nD8C5xhoQqWc,41912
+pyopenapi_gen/core/parsing/schema_parser.py,sha256=3XlzkDOdv-DVJhHy_34bJt4SLkrxb7LaSbwipQny08M,48838
 pyopenapi_gen/core/parsing/unified_cycle_detection.py,sha256=MXghh1Ip6P1etfjuzPiRiDHBdFdQUb9nFUQqhexcvfc,10836
 pyopenapi_gen/core/parsing/common/__init__.py,sha256=U3sHMO-l6S3Cm04CVOYmBCpqLEZvCylUI7yQfcTwxYU,27
 pyopenapi_gen/core/parsing/common/type_parser.py,sha256=h9pg0KWFezjNYvo-A1Dx_ADA7dp4THeMb_JKmZRJk1Q,2542
@@ -65,7 +65,7 @@ pyopenapi_gen/core/parsing/transformers/inline_object_promoter.py,sha256=d9DZ1CV
 pyopenapi_gen/core/writers/code_writer.py,sha256=5rWMPRdj5dWu3NRER6do4NEJEIa9qL68Hc7zhJ8jSdg,4763
 pyopenapi_gen/core/writers/documentation_writer.py,sha256=ZnXJsRc9y9bUMsQR7g0qoBJZbBo2MCxHH_5KgxrPtyA,8645
 pyopenapi_gen/core/writers/line_writer.py,sha256=-K2FaMtQa6hdzGZLcjQrT2ItEmfE-kquTCrn6R3I_QA,7743
-pyopenapi_gen/core/writers/python_construct_renderer.py,sha256=IDAlk2yQkDntjLk3Uc3kKIONpaiWzggcNItVP8dbfk8,12356
+pyopenapi_gen/core/writers/python_construct_renderer.py,sha256=ILR7wdCgjk8VWZn_WYCzMolSJhTrwyqByfvOjq3cZ48,16406
 pyopenapi_gen/core_package_template/README.md,sha256=8YP-MS0KxphRbCGBf7kV3dYIFLU9piOJ3IMm3K_0hcI,1488
 pyopenapi_gen/emit/models_emitter.py,sha256=MBRq71UjtlZHrpf9QhDN0wXk_X-oGeGd6TAq3RKG7ko,7180
 pyopenapi_gen/emitters/CLAUDE.md,sha256=iZYEZq1a1h033rxuh97cMpsKUElv72ysvTm3-QQUvrs,9323
@@ -75,7 +75,7 @@ pyopenapi_gen/emitters/docs_emitter.py,sha256=aouKqhRdtVvYfGVsye_uqM80nONRy0SqN0
 pyopenapi_gen/emitters/endpoints_emitter.py,sha256=m4Kts3-hxflNyCXcKtakyeHLELKLqVjcKLl4_F_1rhQ,10716
 pyopenapi_gen/emitters/exceptions_emitter.py,sha256=PfbDQX7dfgg2htvxEh40t7FR7b3BrK8jeRd5INu_kjk,7547
 pyopenapi_gen/emitters/mocks_emitter.py,sha256=D8fjD8KbgG-yFiqCEEAe2rKE2B439pW6bRLvoqQ6SdI,7431
-pyopenapi_gen/emitters/models_emitter.py,sha256=wJwtvCGEmhy5yhojfoUW2CXNOQytGlN4J8-GcwoYIMY,22221
+pyopenapi_gen/emitters/models_emitter.py,sha256=OU8UNg18QdYop1lUZ2aAi4Co-hm_71ZRT6PKnG4oEYw,24107
 pyopenapi_gen/generator/CLAUDE.md,sha256=BS9KkmLvk2WD-Io-_apoWjGNeMU4q4LKy4UOxYF9WxM,10870
 pyopenapi_gen/generator/client_generator.py,sha256=ZtMTNXBbsLkqsVdFPepMhB2jsmV4poNKAR7pM-Wyvpo,29229
 pyopenapi_gen/generator/exceptions.py,sha256=6mgO_3pk1U61AVyRpv00UTPY5UYMUzY3MmfgmMv-4mM,168
@@ -126,12 +126,12 @@ pyopenapi_gen/visit/endpoint/processors/__init__.py,sha256=_6RqpOdDuDheArqDBi3yk
 pyopenapi_gen/visit/endpoint/processors/import_analyzer.py,sha256=ou5pl3S6PXvHrhKeBQraRfK9MTOQE1WUGLeieAVUXRM,3364
 pyopenapi_gen/visit/endpoint/processors/parameter_processor.py,sha256=E0VoygkhU8iCsvH0U-tA6ZZg2Nm3rfr4e17vxqQLH7c,7666
 pyopenapi_gen/visit/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyopenapi_gen/visit/model/alias_generator.py,sha256=wEMHipPA1_CFxvQ6CS9j4qgXK93seI1bI_tFJvIrb70,3563
+pyopenapi_gen/visit/model/alias_generator.py,sha256=NPFEMWzhrSHFCOdYpT_G-9QJTuyq7bxvIfT3a-fVggg,3758
 pyopenapi_gen/visit/model/dataclass_generator.py,sha256=NVQY3PNptVJn31zJv3pysPT8skLLoPObcQ906NvJ6gs,21869
 pyopenapi_gen/visit/model/enum_generator.py,sha256=AXqKUFuWUUjUF_6_HqBKY8vB5GYu35Pb2C2WPFrOw1k,10061
-pyopenapi_gen/visit/model/model_visitor.py,sha256=TC6pbxpQiy5FWhmQpfllLuXA3ImTYNMcrazkOFZCIyo,9470
-pyopenapi_gen-2.7.2.dist-info/METADATA,sha256=eOVgSGGvpd0bywp8X_HLCUsybzRhzDG29GZvc9WRgMQ,39057
-pyopenapi_gen-2.7.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-pyopenapi_gen-2.7.2.dist-info/entry_points.txt,sha256=gxSlNiwom50T3OEZnlocA6qRjGdV0bn6hN_Xr-Ub5wA,56
-pyopenapi_gen-2.7.2.dist-info/licenses/LICENSE,sha256=UFAyTWKa4w10-QerlJaHJeep7G2gcwpf-JmvI2dS2Gc,1088
-pyopenapi_gen-2.7.2.dist-info/RECORD,,
+pyopenapi_gen/visit/model/model_visitor.py,sha256=Xrlk0Re5PN7XhaO3R3q2G4Qf0p8kkZeWlBkyCuaLS98,9857
+pyopenapi_gen-3.0.1.dist-info/METADATA,sha256=pNnWkFqEHuNgW5PYiKRgEDKkAsEA4wamleh4wsJ8pYM,39057
+pyopenapi_gen-3.0.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pyopenapi_gen-3.0.1.dist-info/entry_points.txt,sha256=gxSlNiwom50T3OEZnlocA6qRjGdV0bn6hN_Xr-Ub5wA,56
+pyopenapi_gen-3.0.1.dist-info/licenses/LICENSE,sha256=UFAyTWKa4w10-QerlJaHJeep7G2gcwpf-JmvI2dS2Gc,1088
+pyopenapi_gen-3.0.1.dist-info/RECORD,,