pyopenapi-gen 2.7.2__py3-none-any.whl

pyopenapi_gen/core/parsing/keywords/any_of_parser.py

@@ -0,0 +1,84 @@
+"""
+Parser for 'anyOf' keyword in OpenAPI schemas.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable, List, Mapping
+
+from pyopenapi_gen import IRSchema  # Main IR model
+
+from ..context import ParsingContext  # Context object - MOVED
+
+if TYPE_CHECKING:
+    # from ..context import ParsingContext # No longer here
+    # No direct import of _parse_schema from schema_parser to avoid circularity
+    pass
+
+
+def _parse_any_of_schemas(
+    any_of_nodes: List[Mapping[str, Any]],
+    context: ParsingContext,
+    max_depth: int,
+    parse_fn: Callable[  # Accepts the main schema parsing function
+        [str | None, Mapping[str, Any] | None, ParsingContext, int], IRSchema
+    ],
+) -> tuple[List[IRSchema] | None, bool, str | None]:
+    """Parses 'anyOf' sub-schemas using a provided parsing function.
+
+    Contracts:
+        Pre-conditions:
+            - any_of_nodes is a list of schema node mappings.
+            - context is a valid ParsingContext instance.
+            - max_depth >= 0.
+            - parse_fn is a callable that can parse a schema node.
+        Post-conditions:
+            - Returns a tuple: (parsed_schemas, is_nullable, effective_schema_type)
+            - parsed_schemas: List of IRSchema for non-null sub-schemas, or None.
+            - is_nullable: True if a null type was present.
+            - effective_schema_type: Potential schema_type if list becomes empty/None (currently always None).
+    """
+    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
+    effective_schema_type: str | None = None
+
+    for sub_node in any_of_nodes:
+        if isinstance(sub_node, dict) and sub_node.get("type") == "null":
+            is_nullable_from_any_of = True
+            continue
+
+        parsed_schemas_list.append(parse_fn(None, sub_node, context, max_depth))
+
+    filtered_schemas = [
+        s
+        for s in parsed_schemas_list
+        if not (
+            s.type is None
+            and not s.properties
+            and not s.items
+            and not s.enum
+            and not s.any_of
+            and not s.one_of
+            and not s.all_of
+        )
+    ]
+
+    if not filtered_schemas:
+        effective_schema_type = None
+        return None, is_nullable_from_any_of, effective_schema_type
+
+    return filtered_schemas, is_nullable_from_any_of, effective_schema_type
+
+
+# ... existing code ...

pyopenapi_gen/core/parsing/keywords/array_items_parser.py

@@ -0,0 +1,72 @@
+"""
+Dedicated parser for handling 'items' within an array schema.
+Renamed from array_parser.py for clarity.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable, Mapping
+
+from pyopenapi_gen import IRSchema
+
+from ..context import ParsingContext
+
+if TYPE_CHECKING:
+    # from pyopenapi_gen import IRSchema # Already above or handled by context
+    # from ..context import ParsingContext # No longer here
+    pass
+
+
+def _parse_array_items_schema(
+    parent_schema_name: str | None,
+    items_node_data: Mapping[str, Any],
+    context: ParsingContext,
+    parse_fn: Callable[  # Accepts the main schema parsing function
+        [str | None, Mapping[str, Any] | None, ParsingContext, int], IRSchema
+    ],
+    max_depth: int,
+) -> IRSchema | None:
+    """Parses the 'items' sub-schema of an array.
+
+    Args:
+        parent_schema_name: The name of the parent array schema (if any).
+        items_node_data: The raw dictionary of the 'items' schema.
+        context: The parsing context.
+        parse_fn: The main schema parsing function to call recursively (_parse_schema from schema_parser.py).
+        max_depth: Maximum recursion depth.
+
+    Returns:
+        The parsed IRSchema for the items, or None if items_node_data is not suitable.
+
+    Contracts:
+        Pre-conditions:
+            - items_node_data is a mapping representing the items schema.
+            - context is a valid ParsingContext instance.
+            - parse_fn is a callable function.
+            - max_depth is a non-negative integer.
+        Post-conditions:
+            - Returns an IRSchema if items_node_data is a valid schema mapping.
+            - Returns None if items_node_data is not a mapping.
+            - Calls parse_fn with an appropriate name for the item schema.
+    """
+    # Pre-conditions
+    # items_node_data is checked later, as it can be non-Mapping to return None
+    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 (
+        isinstance(items_node_data, dict)
+        and "$ref" in items_node_data
+        and items_node_data["$ref"].startswith("#/components/schemas/")
+    ):
+        item_name_for_parse = items_node_data["$ref"].split("/")[-1]
+
+    if not isinstance(items_node_data, Mapping):
+        return None
+
+    return parse_fn(item_name_for_parse, items_node_data, context, max_depth)

pyopenapi_gen/core/parsing/keywords/one_of_parser.py

@@ -0,0 +1,77 @@
+"""
+Parser for 'oneOf' keyword in OpenAPI schemas.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable, List, Mapping
+
+from pyopenapi_gen import IRSchema
+
+from ..context import ParsingContext
+
+if TYPE_CHECKING:
+    # from ..context import ParsingContext # No longer here
+    pass
+
+
+def _parse_one_of_schemas(
+    one_of_nodes: List[Mapping[str, Any]],
+    context: ParsingContext,
+    max_depth: int,
+    parse_fn: Callable[[str | None, Mapping[str, Any] | None, ParsingContext, int], IRSchema],
+) -> tuple[List[IRSchema] | None, bool, str | None]:
+    """Parses 'oneOf' sub-schemas using a provided parsing function.
+
+    Contracts:
+        Pre-conditions:
+            - one_of_nodes is a list of schema node mappings.
+            - context is a valid ParsingContext instance.
+            - max_depth >= 0.
+            - parse_fn is a callable that can parse a schema node.
+        Post-conditions:
+            - Returns a tuple: (parsed_schemas, is_nullable, effective_schema_type)
+            - parsed_schemas: List of IRSchema for non-null sub-schemas, or None.
+            - is_nullable: True if a null type was present.
+            - effective_schema_type: Potential schema_type if list becomes empty/None (currently always None).
+    """
+    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
+    effective_schema_type: str | None = None
+
+    for sub_node in one_of_nodes:
+        if isinstance(sub_node, dict) and sub_node.get("type") == "null":
+            is_nullable_from_one_of = True
+            continue
+        parsed_schemas_list.append(parse_fn(None, sub_node, context, max_depth))
+
+    filtered_schemas = [
+        s
+        for s in parsed_schemas_list
+        if not (
+            s.type is None
+            and not s.properties
+            and not s.items
+            and not s.enum
+            and not s.any_of
+            and not s.one_of
+            and not s.all_of
+        )
+    ]
+
+    if not filtered_schemas:
+        effective_schema_type = None
+        return None, is_nullable_from_one_of, effective_schema_type
+
+    return filtered_schemas, is_nullable_from_one_of, effective_schema_type

pyopenapi_gen/core/parsing/keywords/properties_parser.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Callable, Mapping
+
+# Import NameSanitizer for use in name generation
+from pyopenapi_gen.core.utils import NameSanitizer
+
+# REVERTED: TEMPORARY DEBUG LOGGER REMOVED
+# properties_logger = logging.getLogger("pyopenapi_gen.core.parsing.keywords.properties_parser_DEBUG")
+# properties_logger.setLevel(logging.DEBUG)
+# # Ensure there's a handler if running in some environments
+# if not properties_logger.handlers:
+#    properties_logger.addHandler(logging.StreamHandler())
+from ..context import ParsingContext
+from ..transformers.inline_object_promoter import _attempt_promote_inline_object
+
+# Specific helpers needed by _parse_properties
+
+if TYPE_CHECKING:
+    from pyopenapi_gen import IRSchema  # Main IR model
+
+    # from ..context import ParsingContext  # No longer here
+    # No direct import of _parse_schema from schema_parser to avoid circularity
+    pass
+
+
+def _parse_properties(
+    properties_node: Mapping[str, Any],
+    parent_schema_name: str | None,
+    context: ParsingContext,
+    max_depth: int,
+    parse_fn: Callable[[str | None, Mapping[str, Any] | None, ParsingContext, int | None], IRSchema],
+    logger: logging.Logger,
+) -> dict[str, IRSchema]:
+    """Parse properties from a schema node.
+
+    Contracts:
+        Pre-conditions:
+            - properties_node is a valid Mapping
+            - context is a valid ParsingContext instance
+            - max_depth >= 0
+            - parse_fn is a callable for parsing schemas
+        Post-conditions:
+            - Returns a dictionary mapping property names to IRSchema instances
+            - Property references are properly maintained
+    """
+    properties_map: dict[str, IRSchema] = {}
+
+    for prop_key, prop_schema_node in properties_node.items():
+        # Skip invalid property names
+        if not prop_key or not isinstance(prop_key, str):
+            logger.warning(f"Skipping property with invalid name: {prop_key}")
+            continue
+
+        # Align with _parse_schema property naming logic:
+        # ParentNamePropName or just PropName if parent is anonymous.
+        sanitized_prop_key_for_name = NameSanitizer.sanitize_class_name(prop_key)
+        if parent_schema_name:
+            # Ensure parent_schema_name is also sanitized if it's part of the name
+            # This is implicitly handled if parent_schema_name comes from an IRSchema.name already.
+            # For direct use, ensure it's PascalCase for consistency,
+            # though _parse_schema currently doesn't re-sanitize it.
+            # Assuming parent_schema_name is already a valid schema name (e.g. "ParentSchema")
+            prop_schema_context_name = f"{parent_schema_name}{sanitized_prop_key_for_name}"
+        else:
+            prop_schema_context_name = sanitized_prop_key_for_name
+
+        # Parse the property schema
+        prop_schema_ir = parse_fn(prop_schema_context_name, prop_schema_node, context, max_depth)
+
+        # Handle $ref in property schema
+        if isinstance(prop_schema_node, Mapping) and "$ref" in prop_schema_node:
+            ref_value = prop_schema_node["$ref"]
+            ref_name = ref_value.split("/")[-1]
+            if ref_name in context.parsed_schemas:
+                prop_schema_ir._refers_to_schema = context.parsed_schemas[ref_name]
+
+        # Attempt to promote inline object
+        promoted_ir = _attempt_promote_inline_object(parent_schema_name, prop_key, prop_schema_ir, context, logger)
+        if promoted_ir is not None:
+            properties_map[prop_key] = promoted_ir
+            logger.debug(
+                f"Added promoted '{prop_key}' (name: {getattr(promoted_ir, 'name', 'N/A')}) "
+                f"to properties_map for '{parent_schema_name}'"
+            )
+        else:
+            properties_map[prop_key] = prop_schema_ir
+            logger.debug(
+                f"Added original '{prop_key}' (name: {getattr(prop_schema_ir, 'name', 'N/A')}, "
+                f"type: {getattr(prop_schema_ir, 'type', 'N/A')}, "
+                f"circular: {getattr(prop_schema_ir, '_is_circular_ref', 'N/A')}) "
+                f"to properties_map for '{parent_schema_name}'"
+            )
+
+    logger.debug(f"_parse_properties FINALLY returning for parent '{parent_schema_name}': {properties_map}")
+    # import pdb; pdb.set_trace() # For local debugging if needed
+    return properties_map

pyopenapi_gen/core/parsing/schema_finalizer.py

@@ -0,0 +1,169 @@
+"""
+Finalization an IRSchema object during OpenAPI parsing.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable, List, Mapping, Set, Union
+
+from pyopenapi_gen import IRSchema
+from pyopenapi_gen.core.utils import NameSanitizer
+
+from .context import ParsingContext
+
+# Specific helpers needed
+from .transformers.inline_enum_extractor import _process_standalone_inline_enum
+
+# Note: _parse_schema will be passed as parse_fn, not imported directly
+
+if TYPE_CHECKING:
+    pass
+
+
+def _finalize_schema_object(
+    name: str | None,
+    node: Mapping[str, Any],
+    context: ParsingContext,
+    schema_type: str | None,
+    is_nullable: bool,
+    any_of_schemas: List[IRSchema] | None,
+    one_of_schemas: List[IRSchema] | None,
+    parsed_all_of_components: List[IRSchema] | None,
+    final_properties_map: dict[str, IRSchema],
+    merged_required_set: Set[str],
+    final_items_schema: IRSchema | None,
+    additional_properties_node: Union[bool, Mapping[str, Any]] | None,
+    enum_node: List[Any] | None,
+    format_node: str | None,
+    description_node: str | None,
+    from_unresolved_ref_node: bool,
+    max_depth: int,
+    parse_fn: Callable[[str | None, Mapping[str, Any] | None, ParsingContext, int], IRSchema],
+    logger: Any,  # Changed to Any to support both real and mock loggers
+) -> IRSchema:
+    """Constructs the IRSchema object, performs final adjustments, and updates context.
+
+    Contracts:
+        Pre-conditions:
+            - All input arguments are appropriately populated.
+            - context is valid.
+            - parse_fn is a callable for parsing (e.g. additionalProperties).
+            - logger is a logging.Logger instance or a mock logger for testing.
+        Post-conditions:
+            - Returns a finalized IRSchema instance.
+            - If schema has a name and isn't a placeholder, it's in context.parsed_schemas.
+    """
+    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,
+    # return that placeholder immediately to preserve the cycle information.
+    if name and name in context.parsed_schemas:
+        existing_schema = context.parsed_schemas[name]
+        if getattr(existing_schema, "_is_circular_ref", False) or getattr(
+            existing_schema, "_from_unresolved_ref", False
+        ):
+            # Early return of cycle placeholder
+            return existing_schema
+
+    final_enum_values: List[Any] | None = enum_node if isinstance(enum_node, list) else None
+    final_required_fields_list: List[str] = sorted(list(merged_required_set))
+
+    final_additional_properties: Union[bool, IRSchema] | None = None
+    if isinstance(additional_properties_node, bool):
+        final_additional_properties = additional_properties_node
+    elif isinstance(additional_properties_node, dict):
+        final_additional_properties = parse_fn(None, additional_properties_node, context, max_depth)
+
+    final_schema_name_for_obj = NameSanitizer.sanitize_class_name(name) if name else None
+    current_schema_type = schema_type
+    if current_schema_type is None and final_properties_map:
+        current_schema_type = "object"
+
+    is_data_wrapper_flag = (
+        current_schema_type == "object"
+        and "data" in final_properties_map
+        and "data" in final_required_fields_list
+        and len(final_properties_map) == 1
+    )
+
+    schema_obj = IRSchema(
+        name=final_schema_name_for_obj,
+        type=current_schema_type,
+        format=format_node,
+        description=description_node,
+        required=final_required_fields_list,
+        properties=final_properties_map,
+        items=final_items_schema,
+        enum=final_enum_values,
+        additional_properties=final_additional_properties,
+        is_nullable=is_nullable,
+        any_of=any_of_schemas,
+        one_of=one_of_schemas,
+        all_of=parsed_all_of_components,
+        is_data_wrapper=is_data_wrapper_flag,
+        _from_unresolved_ref=from_unresolved_ref_node,
+    )
+
+    if (
+        schema_obj.name
+        and schema_obj.name in context.parsed_schemas
+        and context.parsed_schemas[schema_obj.name].type is None
+        and schema_obj.type is not None
+    ):
+        # Named schema in context has no type, adopting type
+        # schema_obj will be placed in context later, overwriting if necessary.
+        pass
+
+    if schema_obj.type is None and (
+        schema_obj.properties
+        or (
+            isinstance(node.get("_def"), dict)
+            and node["_def"].get("typeName") == "ZodObject"
+            and node["_def"].get("shape")
+        )
+    ):
+        # Schema has properties but no type; setting to 'object'
+        schema_obj.type = "object"
+
+    if name and "." in name:
+        is_explicitly_simple = node.get("type") in ["string", "integer", "number", "boolean", "array"]
+        is_explicitly_enum = "enum" in node
+        if schema_obj.type is None and not is_explicitly_simple and not is_explicitly_enum:
+            # Inline property lacks complex type, defaulting to 'object'
+            schema_obj.type = "object"
+
+    # Update the context with the finalized schema object
+    # This should only happen if we didn't return an existing placeholder above.
+    if name:
+        # Never overwrite a cycle placeholder!
+        if name in context.parsed_schemas and (
+            getattr(context.parsed_schemas[name], "_is_circular_ref", False)
+            or getattr(context.parsed_schemas[name], "_from_unresolved_ref", False)
+        ):
+            # Not overwriting cycle placeholder
+            pass  # Do not overwrite
+        elif name not in context.parsed_schemas:
+            context.parsed_schemas[name] = schema_obj
+        # If name is in context and is already a full schema, and schema_obj is also full,
+        # current one is considered fresher.
+        elif not (
+            getattr(context.parsed_schemas[name], "_is_circular_ref", False)
+            or getattr(context.parsed_schemas[name], "_from_unresolved_ref", False)
+        ):
+            context.parsed_schemas[name] = schema_obj  # Overwrite existing full with new full
+
+    if schema_obj:
+        schema_obj = _process_standalone_inline_enum(name, node, schema_obj, context, logger)
+
+    if schema_obj and schema_obj.name and context.parsed_schemas.get(schema_obj.name) is not schema_obj:
+        context.parsed_schemas[schema_obj.name] = schema_obj
+        # Ensured schema is in context post-standalone-enum processing
+
+    # Returning finalized schema object
+    return schema_obj