pyopenapi-gen 0.11.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

pyopenapi_gen/core/loader/loader.py

@@ -148,8 +148,10 @@ class SpecLoader:
         )
 
         # Post-condition check
-        assert ir_spec.schemas == schemas_dict, "Schemas mismatch in IRSpec"
-        assert ir_spec.operations == operations, "Operations mismatch in IRSpec"
+        if ir_spec.schemas != schemas_dict:
+            raise RuntimeError("Schemas mismatch in IRSpec")
+        if ir_spec.operations != operations:
+            raise RuntimeError("Operations mismatch in IRSpec")
 
         return ir_spec
 

pyopenapi_gen/core/loader/operations/parser.py

@@ -39,11 +39,16 @@ def parse_operations(
             - All operations have correct path, method, parameters, responses, etc.
             - All referenced schemas are properly stored in context
     """
-    assert isinstance(paths, Mapping), "paths must be a Mapping"
-    assert isinstance(raw_parameters, Mapping), "raw_parameters must be a Mapping"
-    assert isinstance(raw_responses, Mapping), "raw_responses must be a Mapping"
-    assert isinstance(raw_request_bodies, Mapping), "raw_request_bodies must be a Mapping"
-    assert isinstance(context, ParsingContext), "context must be a ParsingContext"
+    if not isinstance(paths, Mapping):
+        raise TypeError("paths must be a Mapping")
+    if not isinstance(raw_parameters, Mapping):
+        raise TypeError("raw_parameters must be a Mapping")
+    if not isinstance(raw_responses, Mapping):
+        raise TypeError("raw_responses must be a Mapping")
+    if not isinstance(raw_request_bodies, Mapping):
+        raise TypeError("raw_request_bodies must be a Mapping")
+    if not isinstance(context, ParsingContext):
+        raise TypeError("context must be a ParsingContext")
 
     ops: List[IROperation] = []
 
@@ -150,6 +155,7 @@ def parse_operations(
                 ops.append(op)
 
     # Post-condition check
-    assert all(isinstance(op, IROperation) for op in ops), "All items must be IROperation objects"
+    if not all(isinstance(op, IROperation) for op in ops):
+        raise TypeError("All items must be IROperation objects")
 
     return ops

pyopenapi_gen/core/loader/operations/post_processor.py

@@ -24,8 +24,10 @@ def post_process_operation(op: IROperation, context: ParsingContext) -> None:
         Postconditions:
             - All request body and response schemas are properly named and registered
     """
-    assert isinstance(op, IROperation), "op must be an IROperation"
-    assert isinstance(context, ParsingContext), "context must be a ParsingContext"
+    if not isinstance(op, IROperation):
+        raise TypeError("op must be an IROperation")
+    if not isinstance(context, ParsingContext):
+        raise TypeError("context must be a ParsingContext")
 
     # Handle request body schemas
     if op.request_body:

pyopenapi_gen/core/loader/operations/request_body.py

@@ -33,10 +33,14 @@ def parse_request_body(
             - Returns a properly populated IRRequestBody or None if invalid
             - All content media types are properly mapped to schemas
     """
-    assert isinstance(rb_node, Mapping), "rb_node must be a Mapping"
-    assert isinstance(raw_request_bodies, Mapping), "raw_request_bodies must be a Mapping"
-    assert isinstance(context, ParsingContext), "context must be a ParsingContext"
-    assert operation_id, "operation_id must be provided"
+    if not isinstance(rb_node, Mapping):
+        raise TypeError("rb_node must be a Mapping")
+    if not isinstance(raw_request_bodies, Mapping):
+        raise TypeError("raw_request_bodies must be a Mapping")
+    if not isinstance(context, ParsingContext):
+        raise TypeError("context must be a ParsingContext")
+    if not operation_id:
+        raise ValueError("operation_id must be provided")
 
     # Handle $ref in request body
     if (
@@ -80,6 +84,7 @@ def parse_request_body(
     request_body = IRRequestBody(required=required_flag, content=content_map, description=desc)
 
     # Post-condition check
-    assert request_body.content == content_map, "Request body content mismatch"
+    if request_body.content != content_map:
+        raise RuntimeError("Request body content mismatch")
 
     return request_body

pyopenapi_gen/core/loader/parameters/parser.py

@@ -27,8 +27,10 @@ def resolve_parameter_node_if_ref(param_node_data: Mapping[str, Any], context: P
             - Returns the resolved parameter node or the original if not a ref
             - If a reference, the parameter is looked up in components
     """
-    assert isinstance(param_node_data, Mapping), "param_node_data must be a Mapping"
-    assert isinstance(context, ParsingContext), "context must be a ParsingContext"
+    if not isinstance(param_node_data, Mapping):
+        raise TypeError("param_node_data must be a Mapping")
+    if not isinstance(context, ParsingContext):
+        raise TypeError("context must be a ParsingContext")
 
     if "$ref" in param_node_data and isinstance(param_node_data.get("$ref"), str):
         ref_path = param_node_data["$ref"]
@@ -62,9 +64,12 @@ def parse_parameter(
             - Returns a properly populated IRParameter
             - Complex parameter schemas are given appropriate names
     """
-    assert isinstance(node, Mapping), "node must be a Mapping"
-    assert "name" in node, "Parameter node must have a name"
-    assert isinstance(context, ParsingContext), "context must be a ParsingContext"
+    if not isinstance(node, Mapping):
+        raise TypeError("node must be a Mapping")
+    if "name" not in node:
+        raise ValueError("Parameter node must have a name")
+    if not isinstance(context, ParsingContext):
+        raise TypeError("context must be a ParsingContext")
 
     sch = node.get("schema")
     param_name = node["name"]
@@ -114,12 +119,38 @@ def parse_parameter(
         and "enum" in sch["items"]
         and "$ref" not in sch["items"]
     ):
-        # This is an array of string enums - for parameters, we can treat this as List[str]
-        # rather than creating complex named schemas
+        # This is an array of string enums - create a proper enum schema for the items
+        # Give it a name based on the parameter and operation
+        enum_name = None
+        if operation_id_for_promo and param_name:
+            # Create a name for this inline enum when we have operation context
+            enum_name = f"{operation_id_for_promo}Param{NameSanitizer.sanitize_class_name(param_name)}Item"
+        elif param_name:
+            # For component parameters without operation context, use just the parameter name
+            enum_name = f"{NameSanitizer.sanitize_class_name(param_name)}Item"
+
+        if enum_name:
+            items_schema = IRSchema(
+                name=enum_name,
+                type="string",
+                enum=sch["items"]["enum"],
+                generation_name=enum_name,  # Mark it as promoted
+            )
+            logger.debug(
+                f"Created enum schema '{enum_name}' for array parameter '{param_name}' with values {sch['items']['enum'][:3]}..."
+            )
+        else:
+            # Fallback if we don't have enough info to create a good name
+            items_schema = IRSchema(name=None, type="string", enum=sch["items"]["enum"])
+            logger.warning(
+                f"Could not create proper enum name for parameter array items with values {sch['items']['enum'][:3]}... "
+                f"This will generate a warning during type resolution."
+            )
+
         schema_ir = IRSchema(
             name=None,
             type="array",
-            items=IRSchema(name=None, type="string", enum=sch["items"]["enum"]),
+            items=items_schema,
             description=sch.get("description"),
         )
     else:
@@ -138,7 +169,9 @@ def parse_parameter(
     )
 
     # Post-condition check
-    assert param.name == node["name"], "Parameter name mismatch"
-    assert param.schema is not None, "Parameter schema must be created"
+    if param.name != node["name"]:
+        raise RuntimeError("Parameter name mismatch")
+    if param.schema is None:
+        raise RuntimeError("Parameter schema must be created")
 
     return param

pyopenapi_gen/core/loader/responses/parser.py

@@ -34,10 +34,14 @@ def parse_response(
             - All content media types are properly mapped to schemas
             - Stream flags are correctly set based on media types
     """
-    assert isinstance(code, str), "code must be a string"
-    assert isinstance(node, Mapping), "node must be a Mapping"
-    assert isinstance(context, ParsingContext), "context must be a ParsingContext"
-    assert operation_id_for_promo, "operation_id_for_promo must be provided"
+    if not isinstance(code, str):
+        raise TypeError("code must be a string")
+    if not isinstance(node, Mapping):
+        raise TypeError("node must be a Mapping")
+    if not isinstance(context, ParsingContext):
+        raise TypeError("context must be a ParsingContext")
+    if not operation_id_for_promo:
+        raise ValueError("operation_id_for_promo must be provided")
 
     content: Dict[str, IRSchema] = {}
     STREAM_FORMATS = {
@@ -97,8 +101,11 @@ def parse_response(
     )
 
     # Post-condition checks
-    assert response.status_code == code, "Response status code mismatch"
-    assert response.content == content, "Response content mismatch"
-    assert response.stream == stream_flag, "Response stream flag mismatch"
+    if response.status_code != code:
+        raise RuntimeError("Response status code mismatch")
+    if response.content != content:
+        raise RuntimeError("Response content mismatch")
+    if response.stream != stream_flag:
+        raise RuntimeError("Response stream flag mismatch")
 
     return response

pyopenapi_gen/core/loader/schemas/extractor.py

@@ -28,8 +28,10 @@ def build_schemas(raw_schemas: Dict[str, Mapping[str, Any]], raw_components: Map
             - A ParsingContext is returned with all schemas parsed
             - All schemas in raw_schemas are populated in context.parsed_schemas
     """
-    assert isinstance(raw_schemas, dict), "raw_schemas must be a dict"
-    assert isinstance(raw_components, Mapping), "raw_components must be a Mapping"
+    if not isinstance(raw_schemas, dict):
+        raise TypeError("raw_schemas must be a dict")
+    if not isinstance(raw_components, Mapping):
+        raise TypeError("raw_components must be a Mapping")
 
     context = ParsingContext(raw_spec_schemas=raw_schemas, raw_spec_components=raw_components)
 
@@ -39,7 +41,8 @@ def build_schemas(raw_schemas: Dict[str, Mapping[str, Any]], raw_components: Map
             _parse_schema(n, nd, context, allow_self_reference=True)
 
     # Post-condition check
-    assert all(n in context.parsed_schemas for n in raw_schemas), "Not all schemas were parsed"
+    if not all(n in context.parsed_schemas for n in raw_schemas):
+        raise RuntimeError("Not all schemas were parsed")
 
     return context
 
@@ -55,8 +58,10 @@ def extract_inline_array_items(schemas: Dict[str, IRSchema]) -> Dict[str, IRSche
             - All array item schemas have proper names
             - No duplicate schema names are created
     """
-    assert isinstance(schemas, dict), "schemas must be a dict"
-    assert all(isinstance(s, IRSchema) for s in schemas.values()), "all values must be IRSchema objects"
+    if not isinstance(schemas, dict):
+        raise TypeError("schemas must be a dict")
+    if not all(isinstance(s, IRSchema) for s in schemas.values()):
+        raise TypeError("all values must be IRSchema objects")
 
     # Store original schema count for post-condition validation
     original_schema_count = len(schemas)
@@ -119,8 +124,10 @@ def extract_inline_array_items(schemas: Dict[str, IRSchema]) -> Dict[str, IRSche
     schemas.update(new_item_schemas)
 
     # Post-condition checks
-    assert len(schemas) >= original_schema_count, "Schemas count should not decrease"
-    assert original_schemas.issubset(set(schemas.keys())), "Original schemas should still be present"
+    if len(schemas) < original_schema_count:
+        raise RuntimeError("Schemas count should not decrease")
+    if not original_schemas.issubset(set(schemas.keys())):
+        raise RuntimeError("Original schemas should still be present")
 
     return schemas
 
@@ -140,8 +147,10 @@ def extract_inline_enums(schemas: Dict[str, IRSchema]) -> Dict[str, IRSchema]:
             - No duplicate schema names are created
             - Top-level enum schemas have generation_name set
     """
-    assert isinstance(schemas, dict), "schemas must be a dict"
-    assert all(isinstance(s, IRSchema) for s in schemas.values()), "all values must be IRSchema objects"
+    if not isinstance(schemas, dict):
+        raise TypeError("schemas must be a dict")
+    if not all(isinstance(s, IRSchema) for s in schemas.values()):
+        raise TypeError("all values must be IRSchema objects")
 
     # Store original schema count for post-condition validation
     original_schema_count = len(schemas)
@@ -160,6 +169,9 @@ def extract_inline_enums(schemas: Dict[str, IRSchema]) -> Dict[str, IRSchema]:
             # but we can set it here to avoid the warning)
             if not hasattr(schema, "generation_name") or not schema.generation_name:
                 schema.generation_name = schema.name
+                logger.info(
+                    f"Set generation_name for top-level enum schema: {schema_name} with values {schema.enum[:3]}..."
+                )
             # Mark this as a properly processed enum by ensuring generation_name is set
             # This serves as the marker that this enum was properly processed
             logger.debug(f"Marked top-level enum schema: {schema_name}")
@@ -195,7 +207,9 @@ def extract_inline_enums(schemas: Dict[str, IRSchema]) -> Dict[str, IRSchema]:
     schemas.update(new_enums)
 
     # Post-condition checks
-    assert len(schemas) >= original_schema_count, "Schemas count should not decrease"
-    assert original_schemas.issubset(set(schemas.keys())), "Original schemas should still be present"
+    if len(schemas) < original_schema_count:
+        raise RuntimeError("Schemas count should not decrease")
+    if not original_schemas.issubset(set(schemas.keys())):
+        raise RuntimeError("Original schemas should still be present")
 
     return schemas

pyopenapi_gen/core/parsing/context.py

@@ -169,7 +169,8 @@ class ParsingContext:
             Postconditions:
                 - Returns True if the schema exists in parsed_schemas, False otherwise
         """
-        assert isinstance(schema_name, str), "schema_name must be a string"
+        if not isinstance(schema_name, str):
+            raise TypeError("schema_name must be a string")
         return schema_name in self.parsed_schemas
 
     def get_parsed_schema(self, schema_name: str) -> Optional["IRSchema"]:
@@ -181,5 +182,6 @@ class ParsingContext:
             Postconditions:
                 - Returns the IRSchema if it exists, None otherwise
         """
-        assert isinstance(schema_name, str), "schema_name must be a string"
+        if not isinstance(schema_name, str):
+            raise TypeError("schema_name must be a string")
         return self.parsed_schemas.get(schema_name)

pyopenapi_gen/core/parsing/keywords/all_of_parser.py

@@ -43,10 +43,14 @@ def _process_all_of(
                 - parsed_all_of_components: List of IRSchema for each item in 'allOf' (empty if 'allOf' not present).
     """
     # Pre-conditions
-    assert isinstance(node, Mapping) and node, "node must be a non-empty Mapping"
-    assert isinstance(context, ParsingContext), "context must be a ParsingContext instance"
-    assert callable(_parse_schema_func), "_parse_schema_func must be callable"
-    assert isinstance(max_depth, int) and max_depth >= 0, "max_depth must be a non-negative integer"
+    if not (isinstance(node, Mapping) and node):
+        raise TypeError("node must be a non-empty Mapping")
+    if not isinstance(context, ParsingContext):
+        raise TypeError("context must be a ParsingContext instance")
+    if not callable(_parse_schema_func):
+        raise TypeError("_parse_schema_func must be callable")
+    if not (isinstance(max_depth, int) and max_depth >= 0):
+        raise ValueError("max_depth must be a non-negative integer")
 
     parsed_all_of_components: List[IRSchema] = []
     merged_required: Set[str] = set(node.get("required", []))

pyopenapi_gen/core/parsing/keywords/any_of_parser.py

@@ -38,11 +38,16 @@ def _parse_any_of_schemas(
             - is_nullable: True if a null type was present.
             - effective_schema_type: Potential schema_type if list becomes empty/None (currently always None).
     """
-    assert isinstance(any_of_nodes, list), "any_of_nodes must be a list"
-    assert all(isinstance(n, Mapping) for n in any_of_nodes), "all items in any_of_nodes must be Mappings"
-    assert isinstance(context, ParsingContext), "context must be a ParsingContext instance"
-    assert max_depth >= 0, "max_depth must be non-negative"
-    assert callable(parse_fn), "parse_fn must be a callable"
+    if not isinstance(any_of_nodes, list):
+        raise TypeError("any_of_nodes must be a list")
+    if not all(isinstance(n, Mapping) for n in any_of_nodes):
+        raise TypeError("all items in any_of_nodes must be Mappings")
+    if not isinstance(context, ParsingContext):
+        raise TypeError("context must be a ParsingContext instance")
+    if not max_depth >= 0:
+        raise ValueError("max_depth must be non-negative")
+    if not callable(parse_fn):
+        raise TypeError("parse_fn must be a callable")
 
     parsed_schemas_list: List[IRSchema] = []  # Renamed to avoid confusion with module name
     is_nullable_from_any_of = False

pyopenapi_gen/core/parsing/keywords/array_items_parser.py

@@ -51,9 +51,12 @@ def _parse_array_items_schema(
     """
     # Pre-conditions
     # items_node_data is checked later, as it can be non-Mapping to return None
-    assert isinstance(context, ParsingContext), "context must be a ParsingContext instance"
-    assert callable(parse_fn), "parse_fn must be callable"
-    assert isinstance(max_depth, int) and max_depth >= 0, "max_depth must be a non-negative integer"
+    if not isinstance(context, ParsingContext):
+        raise TypeError("context must be a ParsingContext instance")
+    if not callable(parse_fn):
+        raise TypeError("parse_fn must be callable")
+    if not (isinstance(max_depth, int) and max_depth >= 0):
+        raise ValueError("max_depth must be a non-negative integer")
 
     item_name_for_parse = f"{parent_schema_name}Item" if parent_schema_name else None
     if (

pyopenapi_gen/core/parsing/keywords/one_of_parser.py

@@ -35,11 +35,16 @@ def _parse_one_of_schemas(
             - is_nullable: True if a null type was present.
             - effective_schema_type: Potential schema_type if list becomes empty/None (currently always None).
     """
-    assert isinstance(one_of_nodes, list), "one_of_nodes must be a list"
-    assert all(isinstance(n, Mapping) for n in one_of_nodes), "all items in one_of_nodes must be Mappings"
-    assert isinstance(context, ParsingContext), "context must be a ParsingContext instance"
-    assert max_depth >= 0, "max_depth must be non-negative"
-    assert callable(parse_fn), "parse_fn must be a callable"
+    if not isinstance(one_of_nodes, list):
+        raise TypeError("one_of_nodes must be a list")
+    if not all(isinstance(n, Mapping) for n in one_of_nodes):
+        raise TypeError("all items in one_of_nodes must be Mappings")
+    if not isinstance(context, ParsingContext):
+        raise TypeError("context must be a ParsingContext instance")
+    if not max_depth >= 0:
+        raise ValueError("max_depth must be non-negative")
+    if not callable(parse_fn):
+        raise TypeError("parse_fn must be a callable")
 
     parsed_schemas_list: List[IRSchema] = []
     is_nullable_from_one_of = False

pyopenapi_gen/core/parsing/schema_finalizer.py

@@ -53,9 +53,12 @@ def _finalize_schema_object(
             - Returns a finalized IRSchema instance.
             - If schema has a name and isn't a placeholder, it's in context.parsed_schemas.
     """
-    assert isinstance(node, Mapping), "node must be a Mapping"
-    assert isinstance(context, ParsingContext), "context must be a ParsingContext instance"
-    assert callable(parse_fn), "parse_fn must be callable"
+    if not isinstance(node, Mapping):
+        raise TypeError("node must be a Mapping")
+    if not isinstance(context, ParsingContext):
+        raise TypeError("context must be a ParsingContext instance")
+    if not callable(parse_fn):
+        raise TypeError("parse_fn must be callable")
     # Remove logger type check to support mock loggers in tests
 
     # If a placeholder for this schema name already exists due to a cycle detected deeper,

pyopenapi_gen/core/parsing/schema_parser.py

@@ -326,7 +326,8 @@ def _parse_schema(
     Parse a schema node and return an IRSchema object.
     """
     # Pre-conditions
-    assert context is not None, "Context cannot be None for _parse_schema"
+    if context is None:
+        raise ValueError("Context cannot be None for _parse_schema")
 
     # Set allow_self_reference flag on unified context
     context.unified_cycle_context.allow_self_reference = allow_self_reference
@@ -377,9 +378,10 @@ def _parse_schema(
         if schema_node is None:
             return IRSchema(name=NameSanitizer.sanitize_class_name(schema_name) if schema_name else None)
 
-        assert isinstance(
-            schema_node, Mapping
-        ), f"Schema node for '{schema_name or 'anonymous'}' must be a Mapping (e.g., dict), got {type(schema_node)}"
+        if not isinstance(schema_node, Mapping):
+            raise TypeError(
+                f"Schema node for '{schema_name or 'anonymous'}' must be a Mapping (e.g., dict), got {type(schema_node)}"
+            )
 
         # If the current schema_node itself is a $ref, resolve it.
         if "$ref" in schema_node:

pyopenapi_gen/emitters/endpoints_emitter.py

@@ -197,7 +197,8 @@ class EndpointsEmitter:
             self._deduplicate_operation_ids(ops_for_tag)
 
             # EndpointVisitor must exist here due to check above
-            assert self.visitor is not None, "EndpointVisitor not initialized"
+            if self.visitor is None:
+                raise RuntimeError("EndpointVisitor not initialized")
             methods = [self.visitor.visit(op, self.context) for op in ops_for_tag]
             class_content = self.visitor.emit_endpoint_client_class(canonical_tag_name, methods, self.context)
 

pyopenapi_gen/emitters/models_emitter.py

@@ -42,12 +42,10 @@ class ModelsEmitter:
         # )
 
         # Assert that de-collided names have been set by the emit() method's preprocessing.
-        assert (
-            schema_ir.generation_name is not None
-        ), f"Schema '{schema_ir.name}' must have generation_name set before file generation."
-        assert (
-            schema_ir.final_module_stem is not None
-        ), f"Schema '{schema_ir.name}' must have final_module_stem set before file generation."
+        if schema_ir.generation_name is None:
+            raise RuntimeError(f"Schema '{schema_ir.name}' must have generation_name set before file generation.")
+        if schema_ir.final_module_stem is None:
+            raise RuntimeError(f"Schema '{schema_ir.name}' must have final_module_stem set before file generation.")
 
         file_path = models_dir / f"{schema_ir.final_module_stem}.py"
 
@@ -138,12 +136,10 @@ class ModelsEmitter:
 
         for s_schema in sorted_schemas_for_init:
             # These should have been set in the emit() preprocessing step.
-            assert (
-                s_schema.generation_name is not None
-            ), f"Schema '{s_schema.name}' missing generation_name in __init__ generation."
-            assert (
-                s_schema.final_module_stem is not None
-            ), f"Schema '{s_schema.name}' missing final_module_stem in __init__ generation."
+            if s_schema.generation_name is None:
+                raise RuntimeError(f"Schema '{s_schema.name}' missing generation_name in __init__ generation.")
+            if s_schema.final_module_stem is None:
+                raise RuntimeError(f"Schema '{s_schema.name}' missing final_module_stem in __init__ generation.")
 
             if s_schema._from_unresolved_ref:  # Check this flag if it's relevant
                 # logger.debug(
@@ -184,8 +180,10 @@ class ModelsEmitter:
                 - All models are properly formatted and type-annotated
                 - Returns a list of file paths generated
         """
-        assert isinstance(spec, IRSpec), "spec must be an IRSpec"
-        assert output_root, "output_root must be a non-empty string"
+        if not isinstance(spec, IRSpec):
+            raise TypeError("spec must be an IRSpec")
+        if not output_root:
+            raise ValueError("output_root must be a non-empty string")
 
         output_dir = Path(output_root.rstrip("/"))
         models_dir = output_dir / "models"

pyopenapi_gen/helpers/type_resolution/named_resolver.py

@@ -75,15 +75,14 @@ class NamedTypeResolver:
         if schema.name and schema.name in self.all_schemas:
             # This schema is a REFERENCE to a globally defined schema (e.g., in components/schemas)
             ref_schema = self.all_schemas[schema.name]  # Get the actual definition
-            assert ref_schema.name is not None, f"Schema '{schema.name}' resolved to ref_schema with None name."
+            if ref_schema.name is None:
+                raise RuntimeError(f"Schema '{schema.name}' resolved to ref_schema with None name.")
 
             # NEW: Use generation_name and final_module_stem from the referenced schema
-            assert (
-                ref_schema.generation_name is not None
-            ), f"Referenced schema '{ref_schema.name}' must have generation_name set."
-            assert (
-                ref_schema.final_module_stem is not None
-            ), f"Referenced schema '{ref_schema.name}' must have final_module_stem set."
+            if ref_schema.generation_name is None:
+                raise RuntimeError(f"Referenced schema '{ref_schema.name}' must have generation_name set.")
+            if ref_schema.final_module_stem is None:
+                raise RuntimeError(f"Referenced schema '{ref_schema.name}' must have final_module_stem set.")
 
             class_name_for_ref = ref_schema.generation_name
             module_name_for_ref = ref_schema.final_module_stem

pyopenapi_gen/helpers/type_resolution/object_resolver.py

@@ -113,12 +113,14 @@ class ObjectTypeResolver:
                     # If this named object is a component schema, ensure it's imported.
                     if schema.name and schema.name in self.all_schemas:
                         actual_schema_def = self.all_schemas[schema.name]
-                        assert (
-                            actual_schema_def.generation_name is not None
-                        ), f"Actual schema '{actual_schema_def.name}' for '{schema.name}' must have generation_name."
-                        assert (
-                            actual_schema_def.final_module_stem is not None
-                        ), f"Actual schema '{actual_schema_def.name}' for '{schema.name}' must have final_module_stem."
+                        if actual_schema_def.generation_name is None:
+                            raise RuntimeError(
+                                f"Actual schema '{actual_schema_def.name}' for '{schema.name}' must have generation_name."
+                            )
+                        if actual_schema_def.final_module_stem is None:
+                            raise RuntimeError(
+                                f"Actual schema '{actual_schema_def.name}' for '{schema.name}' must have final_module_stem."
+                            )
 
                         class_name_to_use = actual_schema_def.generation_name
                         module_stem_to_use = actual_schema_def.final_module_stem
@@ -162,14 +164,16 @@ class ObjectTypeResolver:
                     schema.name and schema.name in self.all_schemas
                 ):  # Named object, no properties, AND it's a known component
                     actual_schema_def = self.all_schemas[schema.name]
-                    assert actual_schema_def.generation_name is not None, (
-                        f"Actual schema (no props) '{actual_schema_def.name}' "
-                        f"for '{schema.name}' must have generation_name."
-                    )
-                    assert actual_schema_def.final_module_stem is not None, (
-                        f"Actual schema (no props) '{actual_schema_def.name}' "
-                        f"for '{schema.name}' must have final_module_stem."
-                    )
+                    if actual_schema_def.generation_name is None:
+                        raise RuntimeError(
+                            f"Actual schema (no props) '{actual_schema_def.name}' "
+                            f"for '{schema.name}' must have generation_name."
+                        )
+                    if actual_schema_def.final_module_stem is None:
+                        raise RuntimeError(
+                            f"Actual schema (no props) '{actual_schema_def.name}' "
+                            f"for '{schema.name}' must have final_module_stem."
+                        )
 
                     class_name_to_use = actual_schema_def.generation_name
                     module_stem_to_use = actual_schema_def.final_module_stem

pyopenapi_gen/types/resolvers/schema_resolver.py

@@ -181,8 +181,15 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
                 # Return the enum type name
                 return ResolvedType(python_type=schema.generation_name, is_optional=not required)
             else:
-                # This is an unprocessed inline enum - log warning but continue
-                logger.warning(f"Found inline enum in string schema that wasn't promoted: {schema.name or 'unnamed'}")
+                # This is an unprocessed inline enum - log warning with details
+                enum_values = schema.enum[:5] if len(schema.enum) > 5 else schema.enum
+                more = f" (and {len(schema.enum) - 5} more)" if len(schema.enum) > 5 else ""
+                context_info = f"name='{schema.name}'" if schema.name else "unnamed"
+                logger.warning(
+                    f"Found inline enum in string schema that wasn't promoted: "
+                    f"{context_info}, type={schema.type}, enum_values={enum_values}{more}. "
+                    f"This will be treated as plain 'str' instead of a proper Enum type."
+                )
                 return ResolvedType(python_type="str", is_optional=not required)
 
         # Handle string formats

pyopenapi_gen/visit/endpoint/generators/response_handler_generator.py

@@ -388,7 +388,7 @@ class EndpointResponseHandlerGenerator:
         # All code paths should be covered by the match statement above
         writer.write_line("# All paths above should return or raise - this should never execute")
         context.add_import("typing", "NoReturn")
-        writer.write_line("assert False, 'Unexpected code path'  # pragma: no cover")
+        writer.write_line("raise RuntimeError('Unexpected code path')  # pragma: no cover")
         writer.write_line("")  # Add a blank line for readability
 
     def _write_strategy_based_return(

pyopenapi_gen/visit/model/alias_generator.py

@@ -24,7 +24,8 @@ class AliasGenerator:
         all_schemas: Optional[Dict[str, IRSchema]],
     ):
         # Pre-condition
-        assert renderer is not None, "PythonConstructRenderer cannot be None"
+        if renderer is None:
+            raise ValueError("PythonConstructRenderer cannot be None")
         self.renderer = renderer
         self.all_schemas = all_schemas if all_schemas is not None else {}
         self.type_service = UnifiedTypeService(self.all_schemas)
@@ -58,10 +59,14 @@ class AliasGenerator:
                 - ``TypeAlias`` is imported in the context if not already present.
         """
         # Pre-conditions
-        assert schema is not None, "Schema cannot be None for alias generation."
-        assert schema.name is not None, "Schema name must be present for alias generation."
-        assert base_name, "Base name cannot be empty for alias generation."
-        assert context is not None, "RenderContext cannot be None."
+        if schema is None:
+            raise ValueError("Schema cannot be None for alias generation.")
+        if schema.name is None:
+            raise ValueError("Schema name must be present for alias generation.")
+        if not base_name:
+            raise ValueError("Base name cannot be empty for alias generation.")
+        if context is None:
+            raise ValueError("RenderContext cannot be None.")
 
         alias_name = NameSanitizer.sanitize_class_name(base_name)
         target_type = self.type_service.resolve_schema_type(schema, context, required=True, resolve_underlying=True)
@@ -77,13 +82,15 @@ class AliasGenerator:
         )
 
         # Post-condition
-        assert rendered_code.strip(), "Generated alias code cannot be empty."
+        if not rendered_code.strip():
+            raise RuntimeError("Generated alias code cannot be empty.")
         # PythonConstructRenderer is responsible for adding TypeAlias import
         # We can check if it was added to context if 'TypeAlias' is in the rendered code
         if "TypeAlias" in rendered_code:
-            assert (
+            if not (
                 "typing" in context.import_collector.imports
                 and "TypeAlias" in context.import_collector.imports["typing"]
-            ), "TypeAlias import was not added to context by renderer."
+            ):
+                raise RuntimeError("TypeAlias import was not added to context by renderer.")
 
         return rendered_code

pyopenapi_gen/visit/model/dataclass_generator.py

@@ -31,7 +31,8 @@ class DataclassGenerator:
             Pre-conditions:
                 - ``renderer`` is not None.
         """
-        assert renderer is not None, "PythonConstructRenderer cannot be None."
+        if renderer is None:
+            raise ValueError("PythonConstructRenderer cannot be None.")
         self.renderer = renderer
         self.all_schemas = all_schemas if all_schemas is not None else {}
         self.type_service = UnifiedTypeService(self.all_schemas)
@@ -56,8 +57,10 @@ class DataclassGenerator:
                 - Returns a valid Python default value string
                   (e.g., "None", "field(default_factory=list)", "\"abc\"") or None.
         """
-        assert ps is not None, "Property schema (ps) cannot be None."
-        assert context is not None, "RenderContext cannot be None."
+        if ps is None:
+            raise ValueError("Property schema (ps) cannot be None.")
+        if context is None:
+            raise ValueError("RenderContext cannot be None.")
 
         if ps.type == "array":
             context.add_import("dataclasses", "field")
@@ -124,10 +127,14 @@ class DataclassGenerator:
                 - Returns a non-empty string containing valid Python code for a dataclass.
                 - ``@dataclass`` decorator is present, implying ``dataclasses.dataclass`` is imported.
         """
-        assert schema is not None, "Schema cannot be None for dataclass generation."
-        assert schema.name is not None, "Schema name must be present for dataclass generation."
-        assert base_name, "Base name cannot be empty for dataclass generation."
-        assert context is not None, "RenderContext cannot be None."
+        if schema is None:
+            raise ValueError("Schema cannot be None for dataclass generation.")
+        if schema.name is None:
+            raise ValueError("Schema name must be present for dataclass generation.")
+        if not base_name:
+            raise ValueError("Base name cannot be empty for dataclass generation.")
+        if context is None:
+            raise ValueError("RenderContext cannot be None.")
         # Additional check for schema type might be too strict here, as ModelVisitor decides eligibility.
 
         class_name = base_name
@@ -136,7 +143,8 @@ class DataclassGenerator:
 
         if schema.type == "array" and schema.items:
             field_name_for_array_content = "items"
-            assert schema.items is not None, "Schema items must be present for array type dataclass field."
+            if schema.items is None:
+                raise ValueError("Schema items must be present for array type dataclass field.")
 
             list_item_py_type = self.type_service.resolve_schema_type(schema.items, context, required=True)
             list_item_py_type = TypeFinalizer(context)._clean_type(list_item_py_type)
@@ -213,16 +221,18 @@ class DataclassGenerator:
             field_mappings=field_mappings if field_mappings else None,
         )
 
-        assert rendered_code.strip(), "Generated dataclass code cannot be empty."
+        if not rendered_code.strip():
+            raise RuntimeError("Generated dataclass code cannot be empty.")
         # PythonConstructRenderer adds the @dataclass decorator and import
-        assert "@dataclass" in rendered_code, "Dataclass code missing @dataclass decorator."
-        assert (
+        if "@dataclass" not in rendered_code:
+            raise RuntimeError("Dataclass code missing @dataclass decorator.")
+        if not (
             "dataclasses" in context.import_collector.imports
             and "dataclass" in context.import_collector.imports["dataclasses"]
-        ), "dataclass import was not added to context by renderer."
+        ):
+            raise RuntimeError("dataclass import was not added to context by renderer.")
         if "default_factory" in rendered_code:  # Check for field import if factory is used
-            assert "field" in context.import_collector.imports.get(
-                "dataclasses", set()
-            ), "'field' import from dataclasses missing when default_factory is used."
+            if "field" not in context.import_collector.imports.get("dataclasses", set()):
+                raise RuntimeError("'field' import from dataclasses missing when default_factory is used.")
 
         return rendered_code

pyopenapi_gen/visit/model/enum_generator.py

@@ -19,7 +19,8 @@ class EnumGenerator:
 
     def __init__(self, renderer: PythonConstructRenderer):
         # Pre-condition
-        assert renderer is not None, "PythonConstructRenderer cannot be None"
+        if renderer is None:
+            raise ValueError("PythonConstructRenderer cannot be None")
         self.renderer = renderer
 
     def _generate_member_name_for_string_enum(self, value: str) -> str:
@@ -32,7 +33,8 @@ class EnumGenerator:
             Post-conditions:
                 - Returns a non-empty string that is a valid Python identifier, typically uppercase.
         """
-        assert isinstance(value, str), "Input value must be a string."
+        if not isinstance(value, str):
+            raise TypeError("Input value must be a string.")
         base_member_name = str(value).upper().replace("-", "_").replace(" ", "_")
         sanitized_member_name = re.sub(r"[^A-Z0-9_]", "", base_member_name)
 
@@ -58,10 +60,11 @@ class EnumGenerator:
         if not re.match(r"^[A-Z_]", sanitized_member_name.upper()):
             sanitized_member_name = f"MEMBER_{sanitized_member_name}"
 
-        assert sanitized_member_name and re.match(r"^[A-Z_][A-Z0-9_]*$", sanitized_member_name.upper()), (
-            f"Generated string enum member name '{sanitized_member_name}' "
-            f"is not a valid Python identifier from value '{value}'."
-        )
+        if not (sanitized_member_name and re.match(r"^[A-Z_][A-Z0-9_]*$", sanitized_member_name.upper())):
+            raise ValueError(
+                f"Generated string enum member name '{sanitized_member_name}' "
+                f"is not a valid Python identifier from value '{value}'."
+            )
         return sanitized_member_name
 
     def _generate_member_name_for_integer_enum(self, value: str | int, int_value_for_fallback: int) -> str:
@@ -75,8 +78,10 @@ class EnumGenerator:
             Post-conditions:
                 - Returns a non-empty string that is a valid Python identifier, typically uppercase.
         """
-        assert isinstance(value, (str, int)), "Input value for integer enum naming must be str or int."
-        assert isinstance(int_value_for_fallback, int), "Fallback integer value must be an int."
+        if not isinstance(value, (str, int)):
+            raise TypeError("Input value for integer enum naming must be str or int.")
+        if not isinstance(int_value_for_fallback, int):
+            raise TypeError("Fallback integer value must be an int.")
 
         name_basis = str(value)  # Use string representation as basis for name
         base_member_name = name_basis.upper().replace("-", "_").replace(" ", "_").replace(".", "_DOT_")
@@ -105,10 +110,11 @@ class EnumGenerator:
             if not sanitized_member_name:  # Should be impossible
                 sanitized_member_name = f"ENUM_MEMBER_UNKNOWN_{abs(int_value_for_fallback)}"
 
-        assert sanitized_member_name and re.match(r"^[A-Z_][A-Z0-9_]*$", sanitized_member_name.upper()), (
-            f"Generated integer enum member name '{sanitized_member_name}' "
-            f"is not a valid Python identifier from value '{value}'."
-        )
+        if not (sanitized_member_name and re.match(r"^[A-Z_][A-Z0-9_]*$", sanitized_member_name.upper())):
+            raise ValueError(
+                f"Generated integer enum member name '{sanitized_member_name}' "
+                f"is not a valid Python identifier from value '{value}'."
+            )
         return sanitized_member_name
 
     def generate(
@@ -138,12 +144,18 @@ class EnumGenerator:
                 - Returns a non-empty string containing valid Python code for an enum.
                 - ``Enum`` from the ``enum`` module is imported in the context.
         """
-        assert schema is not None, "Schema cannot be None for enum generation."
-        assert schema.name is not None, "Schema name must be present for enum generation."
-        assert base_name, "Base name cannot be empty for enum generation."
-        assert context is not None, "RenderContext cannot be None."
-        assert schema.enum, "Schema must have enum values for enum generation."
-        assert schema.type in ("string", "integer"), "Enum schema type must be 'string' or 'integer'."
+        if schema is None:
+            raise ValueError("Schema cannot be None for enum generation.")
+        if schema.name is None:
+            raise ValueError("Schema name must be present for enum generation.")
+        if not base_name:
+            raise ValueError("Base name cannot be empty for enum generation.")
+        if context is None:
+            raise ValueError("RenderContext cannot be None.")
+        if not schema.enum:
+            raise ValueError("Schema must have enum values for enum generation.")
+        if schema.type not in ("string", "integer"):
+            raise ValueError("Enum schema type must be 'string' or 'integer'.")
 
         enum_class_name = base_name  # PythonConstructRenderer will sanitize this class name
         base_type = "str" if schema.type == "string" else "int"
@@ -192,9 +204,9 @@ class EnumGenerator:
             context=context,
         )
 
-        assert rendered_code.strip(), "Generated enum code cannot be empty."
-        assert (
-            "enum" in context.import_collector.imports and "Enum" in context.import_collector.imports["enum"]
-        ), "Enum import was not added to context by renderer."
+        if not rendered_code.strip():
+            raise RuntimeError("Generated enum code cannot be empty.")
+        if not ("enum" in context.import_collector.imports and "Enum" in context.import_collector.imports["enum"]):
+            raise RuntimeError("Enum import was not added to context by renderer.")
 
         return rendered_code

pyopenapi_gen/visit/model/model_visitor.py

@@ -114,7 +114,7 @@ class ModelVisitor(Visitor[IRSchema, str]):
             logger.error(
                 f"ModelVisitor: Schema has no usable name (name or generation_name) for model generation: {schema}"
             )
-            assert False, "Schema must have a name or generation_name for model code generation at this point."
+            raise RuntimeError("Schema must have a name or generation_name for model code generation at this point.")
             # return "" # Should not reach here if assertions are active
 
         # --- Import Registration ---
@@ -144,13 +144,15 @@ class ModelVisitor(Visitor[IRSchema, str]):
             #     "alias, enum, or dataclass. No standalone model generated by ModelVisitor."
             # )
             # Post-condition: returns empty string if no specific generator called
-            assert not rendered_code, "Rendered code should be empty if no generator was matched."
+            if rendered_code:
+                raise RuntimeError("Rendered code should be empty if no generator was matched.")
             return ""
 
         # Post-condition: ensure some code was generated if a generator was called
-        assert rendered_code.strip() or not (
-            is_type_alias or is_enum or is_dataclass
-        ), f"Code generation resulted in an empty string for schema '{schema.name}' which was matched as a model type."
+        if not rendered_code.strip() and (is_type_alias or is_enum or is_dataclass):
+            raise RuntimeError(
+                f"Code generation resulted in an empty string for schema '{schema.name}' which was matched as a model type."
+            )
 
         return self.formatter.format(rendered_code)
 

{pyopenapi_gen-0.11.0.dist-info → pyopenapi_gen-0.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyopenapi-gen
-Version: 0.11.0
+Version: 0.12.0
 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
@@ -32,13 +32,13 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Networking
 Classifier: Typing :: Typed
 Requires-Python: <4.0.0,>=3.12
-Requires-Dist: click<9.0.0,>=8.0.0
+Requires-Dist: click>=8.0.0
 Requires-Dist: dataclass-wizard>=0.22.0
 Requires-Dist: httpx>=0.24.0
 Requires-Dist: openapi-core>=0.19
 Requires-Dist: openapi-spec-validator>=0.7
 Requires-Dist: pyyaml>=6.0
-Requires-Dist: typer<0.14.0,>=0.12.0
+Requires-Dist: typer>=0.14.0
 Provides-Extra: dev
 Requires-Dist: bandit[toml]>=1.7.0; extra == 'dev'
 Requires-Dist: black>=23.0; extra == 'dev'

{pyopenapi_gen-0.11.0.dist-info → pyopenapi_gen-0.12.0.dist-info}/RECORD

@@ -22,22 +22,22 @@ pyopenapi_gen/core/warning_collector.py,sha256=DYl9D7eZYs04mDU84KeonS-5-d0aM7hNq
 pyopenapi_gen/core/auth/base.py,sha256=E2KUerA_mYv9D7xulUm-lenIxqZHqanjA4oRKpof2ZE,792
 pyopenapi_gen/core/auth/plugins.py,sha256=bDWx4MTRFsCKp1i__BsQtZEvQPGU-NKI137-zoxmrgs,3465
 pyopenapi_gen/core/loader/__init__.py,sha256=bt-MQ35fbq-f1YnCcopPg53TuXCI9_7wcMzQZoWVpjU,391
-pyopenapi_gen/core/loader/loader.py,sha256=aehmWhOwWzv2af4Q0XxuOwP9AoAozG36o4-yMVMO0hE,6318
+pyopenapi_gen/core/loader/loader.py,sha256=fjRw6ZrG6hRS2RBWJY5IOv9e1ULc6tnxVGagqXhMmpk,6374
 pyopenapi_gen/core/loader/operations/__init__.py,sha256=7se21D-BOy7Qw6C9auJ9v6D3NCuRiDpRlhqxGq11fJs,366
-pyopenapi_gen/core/loader/operations/parser.py,sha256=ai5iZZA2nicouC77iEvo8jKGXbHKbX_NcTy44lkwOVQ,6896
-pyopenapi_gen/core/loader/operations/post_processor.py,sha256=3FZ5o59J2bSpZP-tNIec0A2hw095cC27GKqkhGrgHZA,2437
-pyopenapi_gen/core/loader/operations/request_body.py,sha256=qz-wh014ejb1SGTuVRNODSXc95_iOLAjw05aDRhbXoo,3099
+pyopenapi_gen/core/loader/operations/parser.py,sha256=QHg3o8TRaReYofEEcBwuDuNxGDxZjkWXRDqOxKFiRtk,7046
+pyopenapi_gen/core/loader/operations/post_processor.py,sha256=Rzb3GSiLyJk-0hTBZ6s6iWAj4KqE4Rfo3w-q2wm_R7w,2487
+pyopenapi_gen/core/loader/operations/request_body.py,sha256=r-jscZEfOmqFA-E4i1Uj3S66rNEf1gDTlBiGUiA0P9k,3224
 pyopenapi_gen/core/loader/parameters/__init__.py,sha256=p13oSibCRC5RCfsP6w7yD9MYs5TXcdI4WwPv7oGUYKk,284
-pyopenapi_gen/core/loader/parameters/parser.py,sha256=ohyi0Ay7vterM8ho_kscWzzNXuwKISDGjgpArByeFSw,6089
+pyopenapi_gen/core/loader/parameters/parser.py,sha256=rOZWbykHQy7MH1gTHI61460mFG1nPKdU9A4hOsYAiIc,7505
 pyopenapi_gen/core/loader/responses/__init__.py,sha256=6APWoH3IdNkgVmI0KsgZoZ6knDaG-S-pnUCa6gkzT8E,216
-pyopenapi_gen/core/loader/responses/parser.py,sha256=T0QXH_3c-Y6_S6DvveKHPfV_tID7qhBoX0nFtdLCa0A,3896
+pyopenapi_gen/core/loader/responses/parser.py,sha256=F9otAn6ncQiY3C25Fq4mEJ5UFNgN83eujcX20Vd_nPU,4069
 pyopenapi_gen/core/loader/schemas/__init__.py,sha256=rlhujYfw_IzWgzhVhYMJ3eIhE6C5Vi1Ylba-BHEVqOg,296
-pyopenapi_gen/core/loader/schemas/extractor.py,sha256=TlLflugYrkQg-Fe7p-C4ppT8rRC9OKvK4nubEUR58tY,9445
+pyopenapi_gen/core/loader/schemas/extractor.py,sha256=n2jF_g8ZjA4GQiSKEWGAt35Hw7Ek93cnxFaS4Ld21Sc,9889
 pyopenapi_gen/core/parsing/__init__.py,sha256=RJsIR6cHaNoI4tBcpMlAa0JsY64vsHb9sPxPg6rd8FQ,486
-pyopenapi_gen/core/parsing/context.py,sha256=crn5oTkzEvnSzYdPuHBA_s72kmq0RKzXpyaqNh67k68,7947
+pyopenapi_gen/core/parsing/context.py,sha256=8cM8mPItvDvJr8ZiukvdHBumlQl9hK1gUZL4BDpHaBk,8005
 pyopenapi_gen/core/parsing/cycle_helpers.py,sha256=nG5ysNavL_6lpnHWFUZR9qraBxqOzuNfI6NgSEa8a5M,5939
-pyopenapi_gen/core/parsing/schema_finalizer.py,sha256=fsyuOenLJA3TndzYVETqKkSlo2Qz3TsD1YDtlbyOATQ,6839
-pyopenapi_gen/core/parsing/schema_parser.py,sha256=qFdan2djgdRBtzVCLiDBooVqXgcuWy_JbzDGLTJpPeE,30502
+pyopenapi_gen/core/parsing/schema_finalizer.py,sha256=qRTHUoVBQTgGmdfLuBuWxtWdj_SG71STGC3rn-tJvnA,6914
+pyopenapi_gen/core/parsing/schema_parser.py,sha256=W0kCV0ucq6Wybr7x1wZl-nMSRXVWAqI4T57ASSabZsM,30557
 pyopenapi_gen/core/parsing/unified_cycle_detection.py,sha256=3nplaCVh2dFwBPbmDc2kiU0SzTPXXktdQ5Rc0Q9Uu9s,10873
 pyopenapi_gen/core/parsing/common/__init__.py,sha256=U3sHMO-l6S3Cm04CVOYmBCpqLEZvCylUI7yQfcTwxYU,27
 pyopenapi_gen/core/parsing/common/type_parser.py,sha256=cK7xtxhoD43K2WjLP9TGip3As3akYeYW7L2XztXCecg,2562
@@ -52,10 +52,10 @@ pyopenapi_gen/core/parsing/common/ref_resolution/helpers/missing_ref.py,sha256=B
 pyopenapi_gen/core/parsing/common/ref_resolution/helpers/new_schema.py,sha256=MTaxiyqoPEaNFqF7tQHii3IH41M05wPKt6lBQi1SCDU,1625
 pyopenapi_gen/core/parsing/common/ref_resolution/helpers/stripped_suffix.py,sha256=ukKU64ozHINPiVlHE9YBDz1Nq2i6Xh64jhoWSEqbK5c,1774
 pyopenapi_gen/core/parsing/keywords/__init__.py,sha256=enTLacWXGXLIOjSJ3j7KNUDzU27Kq3Ww79sFElz02cM,27
-pyopenapi_gen/core/parsing/keywords/all_of_parser.py,sha256=s0aav49R4LYAwfEimWa0ZuFwbNWkYpRAJmcmSVDsO-s,3594
-pyopenapi_gen/core/parsing/keywords/any_of_parser.py,sha256=r9_0opPM75p0rPgdcRTBmae7Td3jPkJouuL_ksuFWtM,2856
-pyopenapi_gen/core/parsing/keywords/array_items_parser.py,sha256=dIb3_VsEkqsR9W4rwXoTT9IW313TnH66sQzJL4K7EQQ,2645
-pyopenapi_gen/core/parsing/keywords/one_of_parser.py,sha256=82SUPd0hk0QF4-hMr0QJmRSFa9nnJL8ncYmvgkIKKXs,2601
+pyopenapi_gen/core/parsing/keywords/all_of_parser.py,sha256=ZH8rkxdDjldd226UGw5tv853ONXKaoqvWj5FfbgSoRY,3699
+pyopenapi_gen/core/parsing/keywords/any_of_parser.py,sha256=HQ4iBBPgox48KIPPhM6VVZTXHIUVqpMoHkCbqcebXOw,2982
+pyopenapi_gen/core/parsing/keywords/array_items_parser.py,sha256=nk9AFbx5ANLdDeGsxSTeYHhd8MqqrQwDRMzJ8FJmJxY,2723
+pyopenapi_gen/core/parsing/keywords/one_of_parser.py,sha256=TUiT1dH1r8GEPExzlR3zdgnYpGxilH8yvnSWOvQmKmY,2727
 pyopenapi_gen/core/parsing/keywords/properties_parser.py,sha256=bm248ApsNskFPQF4fXq7mT5oJf6FF9yAcdVLmK6el3E,4426
 pyopenapi_gen/core/parsing/transformers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyopenapi_gen/core/parsing/transformers/inline_enum_extractor.py,sha256=hXuht-t0Syi5vPO8qn9GcjEpyDcZnfFVHVIlwfMa8L0,13461
@@ -70,9 +70,9 @@ pyopenapi_gen/emitters/CLAUDE.md,sha256=iZYEZq1a1h033rxuh97cMpsKUElv72ysvTm3-QQU
 pyopenapi_gen/emitters/client_emitter.py,sha256=kmMVnG-wAOJm7TUm0xOQ5YnSJfYxz1SwtpiyoUCbcCA,1939
 pyopenapi_gen/emitters/core_emitter.py,sha256=RcBsAYQ3ZKcWwtkzQmyHkL7VtDQjbIObFLXD9M_GdpI,8020
 pyopenapi_gen/emitters/docs_emitter.py,sha256=aouKqhRdtVvYfGVsye_uqM80nONRy0SqN06cr1l3OgA,1137
-pyopenapi_gen/emitters/endpoints_emitter.py,sha256=2VuJJF0hpzyN-TqY9XVLQtTJ-QgedZe5Vj8ITBGsJYE,9558
+pyopenapi_gen/emitters/endpoints_emitter.py,sha256=tzSLUzlZle2Lih_aZc4cJ-Y1ItjN5H_rABEWcDwECXA,9586
 pyopenapi_gen/emitters/exceptions_emitter.py,sha256=qPTIPXDyqSUtpmBIp-V4ap1uMHUPmYziCSN62t7qcAE,1918
-pyopenapi_gen/emitters/models_emitter.py,sha256=I3IKwtKVocD3UVrI7cINXI8NjLwUZqHuGgvS3hjWUJ8,22192
+pyopenapi_gen/emitters/models_emitter.py,sha256=Gd0z2Xoze1XkVnajkOptW90ti7197wQ15I7vIITnULM,22243
 pyopenapi_gen/generator/CLAUDE.md,sha256=BS9KkmLvk2WD-Io-_apoWjGNeMU4q4LKy4UOxYF9WxM,10870
 pyopenapi_gen/generator/client_generator.py,sha256=MULKJY9SdRuYjt_R4XCXh3vJSW-92rsxOu-MVpIklho,29333
 pyopenapi_gen/helpers/CLAUDE.md,sha256=GyIJ0grp4SkD3plAUzyycW4nTUZf9ewtvvsdAGkmIZw,10609
@@ -85,8 +85,8 @@ pyopenapi_gen/helpers/type_resolution/__init__.py,sha256=TbaQZp7jvBiYgmuzuG8Wp56
 pyopenapi_gen/helpers/type_resolution/array_resolver.py,sha256=dFppBtA6CxmiWAMR6rwGnQPv4AibL3nxtzw1LbeXVn4,2023
 pyopenapi_gen/helpers/type_resolution/composition_resolver.py,sha256=wq6CRGxGgOKK470ln5Tpk9SzHtMuwB22TXHsRLtUFyw,3015
 pyopenapi_gen/helpers/type_resolution/finalizer.py,sha256=_BcOBmOvadhBTUAvIc0Ak8FNxFw1uYL4rkKWtU68_m4,4332
-pyopenapi_gen/helpers/type_resolution/named_resolver.py,sha256=akHVthcD7cp9lHI-TCeABMacwQ2Z1gGp8zMGNsI_b5A,9403
-pyopenapi_gen/helpers/type_resolution/object_resolver.py,sha256=jayEjBr4evzIVMMAPc7g_gKb6BShFbAXG1oHMgskOcI,12373
+pyopenapi_gen/helpers/type_resolution/named_resolver.py,sha256=hXu6Gao92EVV0jyHRqf9cIhoAFn3suuEw5ye9nRTFks,9423
+pyopenapi_gen/helpers/type_resolution/object_resolver.py,sha256=Jm4m5QgzWU-4joPqfUSC0Y-za3Yx0ROdJjyv5J8VNk0,12557
 pyopenapi_gen/helpers/type_resolution/primitive_resolver.py,sha256=qTshZaye5ohibVfcJYCzh4v3CAshguMGWPt2FgvQeNM,1960
 pyopenapi_gen/helpers/type_resolution/resolver.py,sha256=qQY6wAitBluA-tofiyJ67Gxx8ol1W528zDWd9izYN5s,1982
 pyopenapi_gen/types/CLAUDE.md,sha256=xRYlHdLhw3QGIfIlWqPt9pewRs736H1YCzwmslKtzZc,4255
@@ -97,7 +97,7 @@ pyopenapi_gen/types/contracts/types.py,sha256=-Qvbx3N_14AaN-1BeyocrvsjiwXPn_eWQh
 pyopenapi_gen/types/resolvers/__init__.py,sha256=_5kA49RvyOTyXgt0GbbOfHJcdQw2zHxvU9af8GGyNWc,295
 pyopenapi_gen/types/resolvers/reference_resolver.py,sha256=qnaZeLmtyh4_NBMcKib58s6o5ycUJaattYt8F38_qIo,2053
 pyopenapi_gen/types/resolvers/response_resolver.py,sha256=Kb1a2803lyoukoZy06ztPBlUw-A1lHiZ6NlJmsixxA8,6500
-pyopenapi_gen/types/resolvers/schema_resolver.py,sha256=6cgJPgRsEyMNrEnaR_ONExvMNWjWWBuWa69D7gKTsSY,17528
+pyopenapi_gen/types/resolvers/schema_resolver.py,sha256=PsSF-DE8-GDXmvbAJz-tHlTCR-1UATGhT4dHf6kUDQQ,17988
 pyopenapi_gen/types/services/__init__.py,sha256=inSUKmY_Vnuym6tC-AhvjCTj16GbkfxCGLESRr_uQPE,123
 pyopenapi_gen/types/services/type_service.py,sha256=-LQj7oSx1mxb10Zi6DpawS8uyoUrUbnYhmUA0GuKZTc,4402
 pyopenapi_gen/types/strategies/__init__.py,sha256=bju8_KEPNIow1-woMO-zJCgK_E0M6JnFq0NFsK1R4Ss,171
@@ -113,19 +113,19 @@ pyopenapi_gen/visit/endpoint/generators/__init__.py,sha256=-X-GYnJZ9twiEBr_U0obW
 pyopenapi_gen/visit/endpoint/generators/docstring_generator.py,sha256=U02qvuYtFElQNEtOHuTNXFl2NxUriIiuZMkmUsapOg4,5913
 pyopenapi_gen/visit/endpoint/generators/endpoint_method_generator.py,sha256=wUJ4_gaA1gRrFCHYFCObBIankxGQu0MNqiOSoZOZmoA,4352
 pyopenapi_gen/visit/endpoint/generators/request_generator.py,sha256=OnkrkRk39_BrK9ZDvyWqJYLz1mocD2zY7j70yIpS0J4,5374
-pyopenapi_gen/visit/endpoint/generators/response_handler_generator.py,sha256=VuyYpUUQ3hIOwM0X_hrMk9qmQTC0P6xRQdC2HTTIyQw,22828
+pyopenapi_gen/visit/endpoint/generators/response_handler_generator.py,sha256=xbh4GQcA-fA98mOZxVSylLbZADse-7RLcLIbjnVAmlE,22834
 pyopenapi_gen/visit/endpoint/generators/signature_generator.py,sha256=CYtfsPMlTZN95g2WxrdnTloGx2RmqeNQRiyP9fOkUEQ,3892
 pyopenapi_gen/visit/endpoint/generators/url_args_generator.py,sha256=EsmNuVSkGfUqrmV7-1GiLPzdN86V5UqLfs1SVY0jsf0,9590
 pyopenapi_gen/visit/endpoint/processors/__init__.py,sha256=_6RqpOdDuDheArqDBi3ykhsaetACny88WUuuAJvr_ME,29
 pyopenapi_gen/visit/endpoint/processors/import_analyzer.py,sha256=tNmhgWwt-CjLE774TC8sPVH1-yaTKKm6JmfgBT2-iRk,3386
 pyopenapi_gen/visit/endpoint/processors/parameter_processor.py,sha256=BygP8yzSTrxfvNpEQIHERjd2NpEXDiwpCtmMseJKRq0,7700
 pyopenapi_gen/visit/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyopenapi_gen/visit/model/alias_generator.py,sha256=3iPFDjCXU0Vm59Hfp64jTDfHoUL8ouXTTfoEwiOVm4Q,3558
-pyopenapi_gen/visit/model/dataclass_generator.py,sha256=WtcQNx6l2sxVyTlH1MdQ-UFYWVMsxQk5nyJr1Mk02iM,9999
-pyopenapi_gen/visit/model/enum_generator.py,sha256=QWsD-IAxGOxKQuC6LLNUvbT8Ot3NWrLFsaYT0DI16DU,9670
-pyopenapi_gen/visit/model/model_visitor.py,sha256=PZeQd7-dlxZf5gY10BW-DhswmAGF903NccV6L56mjoE,9439
-pyopenapi_gen-0.11.0.dist-info/METADATA,sha256=gv2QjmQpa6Oj87vq7sE14_6MqXO3YEmQsZS6-4NQsNQ,14040
-pyopenapi_gen-0.11.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pyopenapi_gen-0.11.0.dist-info/entry_points.txt,sha256=gxSlNiwom50T3OEZnlocA6qRjGdV0bn6hN_Xr-Ub5wA,56
-pyopenapi_gen-0.11.0.dist-info/licenses/LICENSE,sha256=UFAyTWKa4w10-QerlJaHJeep7G2gcwpf-JmvI2dS2Gc,1088
-pyopenapi_gen-0.11.0.dist-info/RECORD,,
+pyopenapi_gen/visit/model/alias_generator.py,sha256=TGL3AMq_PkBWFWeeXbNnA8hgO9hvp0flwBA00Gr6S3o,3744
+pyopenapi_gen/visit/model/dataclass_generator.py,sha256=nyTvBph6rtbJlCwTiDW_Y2UJmLLiA6D2QJUpA2xE0m8,10289
+pyopenapi_gen/visit/model/enum_generator.py,sha256=AXqKUFuWUUjUF_6_HqBKY8vB5GYu35Pb2C2WPFrOw1k,10061
+pyopenapi_gen/visit/model/model_visitor.py,sha256=4kAQSWsI4XumVYB3aAE7Ts_31hGfDlbytRalxyMFV3g,9510
+pyopenapi_gen-0.12.0.dist-info/METADATA,sha256=do9Qt8fZ_bOvewCqxXYsCYbNE0qs7BtvC5Xe-AhBnBQ,14025
+pyopenapi_gen-0.12.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pyopenapi_gen-0.12.0.dist-info/entry_points.txt,sha256=gxSlNiwom50T3OEZnlocA6qRjGdV0bn6hN_Xr-Ub5wA,56
+pyopenapi_gen-0.12.0.dist-info/licenses/LICENSE,sha256=UFAyTWKa4w10-QerlJaHJeep7G2gcwpf-JmvI2dS2Gc,1088
+pyopenapi_gen-0.12.0.dist-info/RECORD,,