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

pyopenapi_gen/__init__.py

@@ -43,7 +43,7 @@ __all__ = [
 ]
 
 # Semantic version of the generator core – automatically managed by semantic-release.
-__version__: str = "0.9.0"
+__version__: str = "0.10.2"
 
 
 # ---------------------------------------------------------------------------

pyopenapi_gen/core/exceptions.py

@@ -1,12 +1,7 @@
-from typing import Optional
-
-import httpx
-
-
 class HTTPError(Exception):
     """Base HTTP error with status code and message."""
 
-    def __init__(self, status_code: int, message: str, response: Optional[httpx.Response] = None) -> None:
+    def __init__(self, status_code: int, message: str, response: object | None = None) -> None:
         super().__init__(f"{status_code}: {message}")
         self.status_code = status_code
         self.message = message

pyopenapi_gen/core/loader/loader.py

@@ -87,8 +87,22 @@ class SpecLoader:
                 validate_spec(cast(Mapping[Hashable, Any], self.spec))
             except Exception as e:
                 warning_msg = f"OpenAPI spec validation error: {e}"
+                # Always collect the message
                 warnings_list.append(warning_msg)
-                warnings.warn(warning_msg, UserWarning)
+
+                # Heuristic: if this error originates from jsonschema or
+                # openapi_spec_validator, prefer logging over global warnings
+                # to avoid noisy test output while still surfacing the issue.
+                origin_module = getattr(e.__class__, "__module__", "")
+                if (
+                    isinstance(e, RecursionError)
+                    or origin_module.startswith("jsonschema")
+                    or origin_module.startswith("openapi_spec_validator")
+                ):
+                    logger.warning(warning_msg)
+                else:
+                    # Preserve explicit warning behavior for unexpected failures
+                    warnings.warn(warning_msg, UserWarning)
 
         return warnings_list
 
@@ -134,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"]
@@ -79,6 +84,29 @@ def parse_parameter(
         base_param_promo_name = f"{operation_id_for_promo}Param" if operation_id_for_promo else ""
         name_for_inline_param_schema = f"{base_param_promo_name}{NameSanitizer.sanitize_class_name(param_name)}"
 
+    # General rule: if a parameter is defined inline but a components parameter exists with the
+    # same name and location, prefer the components schema (often richer: arrays/enums/refs).
+    try:
+        if isinstance(context, ParsingContext):
+            components_params = context.raw_spec_components.get("parameters", {})
+            if isinstance(components_params, Mapping):
+                for comp_key, comp_param in components_params.items():
+                    if not isinstance(comp_param, Mapping):
+                        continue
+                    if comp_param.get("name") == param_name and comp_param.get("in") == node.get("in"):
+                        comp_schema = comp_param.get("schema")
+                        if isinstance(comp_schema, Mapping):
+                            # Prefer component schema if inline is missing or clearly less specific
+                            inline_is_specific = isinstance(sch, Mapping) and (
+                                sch.get("type") in {"array", "object"} or "$ref" in sch or "enum" in sch
+                            )
+                            if not inline_is_specific:
+                                sch = comp_schema
+                        break
+    except Exception:
+        # Be conservative on any unexpected structure
+        pass
+
     # For parameters, we want to avoid creating complex schemas for simple enum arrays
     # Check if this is a simple enum array and handle it specially
     if (
@@ -91,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:
@@ -115,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
 
@@ -128,6 +135,8 @@ def extract_inline_array_items(schemas: Dict[str, IRSchema]) -> Dict[str, IRSche
 def extract_inline_enums(schemas: Dict[str, IRSchema]) -> Dict[str, IRSchema]:
     """Extract inline property enums as unique schemas and update property references.
 
+    Also ensures top-level enum schemas are properly marked for generation.
+
     Contracts:
         Preconditions:
             - schemas is a dict of IRSchema objects
@@ -136,9 +145,12 @@ def extract_inline_enums(schemas: Dict[str, IRSchema]) -> Dict[str, IRSchema]:
             - All property schemas with enums have proper names
             - All array item schemas have proper names
             - 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)
@@ -149,6 +161,22 @@ def extract_inline_enums(schemas: Dict[str, IRSchema]) -> Dict[str, IRSchema]:
 
     new_enums = {}
     for schema_name, schema in list(schemas.items()):
+        # Handle top-level enum schemas (those defined directly in components/schemas)
+        # These are already enums but need generation_name set
+        if schema.enum and schema.type in ["string", "integer", "number"]:
+            # This is a top-level enum schema
+            # Ensure it has generation_name set (will be properly set by emitter later,
+            # 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}")
+
+        # Extract inline enums from properties
         for prop_name, prop_schema in list(schema.properties.items()):
             if prop_schema.enum and not prop_schema.name:
                 enum_name = (
@@ -167,6 +195,7 @@ def extract_inline_enums(schemas: Dict[str, IRSchema]) -> Dict[str, IRSchema]:
                     enum=copy.deepcopy(prop_schema.enum),
                     description=prop_schema.description or f"Enum for {schema_name}.{prop_name}",
                 )
+                enum_schema.generation_name = enum_name  # Set generation_name for extracted enums
                 new_enums[enum_name] = enum_schema
 
                 # Update the original property to reference the extracted enum
@@ -178,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"