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

pyopenapi_gen/core/loader/parameters/parser.py

@@ -135,7 +135,16 @@ def parse_parameter(
                 type="string",
                 enum=sch["items"]["enum"],
                 generation_name=enum_name,  # Mark it as promoted
+                final_module_stem=NameSanitizer.sanitize_module_name(enum_name),  # Set module stem for imports
             )
+
+            # Register this inline enum schema so it gets generated as a model file
+            if isinstance(context, ParsingContext) and enum_name not in context.parsed_schemas:
+                context.parsed_schemas[enum_name] = items_schema
+                logger.debug(
+                    f"Registered enum schema '{enum_name}' for array parameter '{param_name}' with values {sch['items']['enum'][:3]}..."
+                )
+
             logger.debug(
                 f"Created enum schema '{enum_name}' for array parameter '{param_name}' with values {sch['items']['enum'][:3]}..."
             )

pyopenapi_gen/core/parsing/schema_parser.py

@@ -17,6 +17,8 @@ from .keywords.any_of_parser import _parse_any_of_schemas
 from .keywords.one_of_parser import _parse_one_of_schemas
 from .unified_cycle_detection import CycleAction
 
+logger = logging.getLogger(__name__)
+
 # Environment variables for configurable limits, with defaults
 try:
     MAX_CYCLES = int(os.environ.get("PYOPENAPI_MAX_CYCLES", "0"))  # Default 0 means no explicit cycle count limit
@@ -27,8 +29,6 @@ try:
 except ValueError:
     ENV_MAX_DEPTH = 150  # Fallback to 150 if env var is invalid
 
-logger = logging.getLogger(__name__)
-
 
 def _resolve_ref(
     ref_path_str: str,
@@ -417,7 +417,23 @@ def _parse_schema(
         raw_type_field = schema_node.get("type")
 
         if isinstance(raw_type_field, str):
-            extracted_type = raw_type_field
+            # Handle non-standard type values that might appear
+            if raw_type_field in ["Any", "any"]:
+                # Convert 'Any' to None - will be handled as object later
+                extracted_type = None
+                logger.warning(
+                    f"Schema{f' {schema_name}' if schema_name else ''} uses non-standard type 'Any'. "
+                    "Converting to 'object'. Use standard OpenAPI types: string, number, integer, boolean, array, object."
+                )
+            elif raw_type_field == "None":
+                # Convert 'None' string to null handling
+                extracted_type = "null"
+                logger.warning(
+                    f"Schema{f' {schema_name}' if schema_name else ''} uses type 'None'. "
+                    'Converting to nullable object. Use \'type: ["object", "null"]\' for nullable types.'
+                )
+            else:
+                extracted_type = raw_type_field
         elif isinstance(raw_type_field, list):
             if "null" in raw_type_field:
                 is_nullable_from_type_field = True
@@ -446,10 +462,33 @@ def _parse_schema(
             if props_from_comp or "allOf" in schema_node or "properties" in schema_node:
                 current_final_type = "object"
             elif any_of_irs or one_of_irs:
+                # Keep None for composition types - they'll be handled by resolver
                 current_final_type = None
+            elif "enum" in schema_node:
+                # Enum without explicit type - infer from enum values
+                enum_values = schema_node.get("enum", [])
+                if enum_values:
+                    first_val = enum_values[0]
+                    if isinstance(first_val, str):
+                        current_final_type = "string"
+                    elif isinstance(first_val, (int, float)):
+                        current_final_type = "number"
+                    elif isinstance(first_val, bool):
+                        current_final_type = "boolean"
+                    else:
+                        # Fallback to object for complex enum values
+                        current_final_type = "object"
+                else:
+                    current_final_type = "string"  # Default for empty enums
+            else:
+                # No type specified and no clear indicators - default to object
+                # This is safer than 'Any' and matches OpenAPI spec defaults
+                current_final_type = "object"
 
         if current_final_type == "null":
-            current_final_type = None
+            # Explicit null type - mark as nullable but use object type
+            is_nullable_overall = True
+            current_final_type = "object"
 
         if current_final_type == "object":
             # Properties from allOf have already been handled by _parse_composition_keywords
@@ -511,7 +550,13 @@ def _parse_schema(
                 else:
                     items_ir = actual_item_ir
             else:
-                items_ir = IRSchema(type="Any")
+                # Array without items specification - use object as safer default
+                # Log warning to help developers fix their specs
+                logger.warning(
+                    f"Array type without 'items' specification found{f' in {schema_name}' if schema_name else ''}. "
+                    "Using 'object' as item type. Consider adding 'items' to your OpenAPI spec for better type safety."
+                )
+                items_ir = IRSchema(type="object")
 
         schema_ir_name_attr = NameSanitizer.sanitize_class_name(schema_name) if schema_name else None
 

pyopenapi_gen/types/resolvers/schema_resolver.py

@@ -53,11 +53,12 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
 
         # Handle composition types (any_of, all_of, one_of)
         # These are processed for inline compositions or when generating the alias for a named composition
-        if hasattr(schema, "any_of") and schema.any_of:
+        # Check for the attribute existence, not just truthiness, to handle empty lists
+        if hasattr(schema, "any_of") and schema.any_of is not None:
             return self._resolve_any_of(schema, context, required, resolve_underlying)
-        elif hasattr(schema, "all_of") and schema.all_of:
+        elif hasattr(schema, "all_of") and schema.all_of is not None:
             return self._resolve_all_of(schema, context, required, resolve_underlying)
-        elif hasattr(schema, "one_of") and schema.one_of:
+        elif hasattr(schema, "one_of") and schema.one_of is not None:
             return self._resolve_one_of(schema, context, required, resolve_underlying)
 
         # Handle named schemas without generation_name (fallback for references)
@@ -96,7 +97,52 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
         elif schema_type == "null":
             return self._resolve_null(context, required)
         else:
-            logger.warning(f"Unknown schema type: {schema_type}")
+            # Gather detailed information about the problematic schema
+            schema_details = {
+                "type": schema_type,
+                "name": getattr(schema, "name", None),
+                "ref": getattr(schema, "ref", None),
+                "properties": list(getattr(schema, "properties", {}).keys()) if hasattr(schema, "properties") else None,
+                "enum": getattr(schema, "enum", None),
+                "description": getattr(schema, "description", None),
+                "generation_name": getattr(schema, "generation_name", None),
+                "is_nullable": getattr(schema, "is_nullable", None),
+                "any_of": len(getattr(schema, "any_of", []) or []) if hasattr(schema, "any_of") else 0,
+                "all_of": len(getattr(schema, "all_of", []) or []) if hasattr(schema, "all_of") else 0,
+                "one_of": len(getattr(schema, "one_of", []) or []) if hasattr(schema, "one_of") else 0,
+            }
+
+            # Remove None values for cleaner output
+            schema_details = {k: v for k, v in schema_details.items() if v is not None}
+
+            # Create detailed error message
+            error_msg = f"Unknown schema type '{schema_type}' encountered."
+            if schema_details.get("name"):
+                error_msg += f" Schema name: '{schema_details['name']}'."
+            if schema_details.get("ref"):
+                error_msg += f" Reference: '{schema_details['ref']}'."
+
+            # Log full details with actionable advice
+            logger.warning(f"{error_msg} Full details: {schema_details}")
+
+            # Provide specific guidance based on the unknown type
+            if schema_type == "Any":
+                logger.info(
+                    "Schema type 'Any' will be mapped to typing.Any. Consider using a more specific type in your OpenAPI spec."
+                )
+            elif schema_type == "None" or schema_type is None:
+                logger.info(
+                    "Schema type 'None' detected - likely an optional field or null type. This will be mapped to Optional[Any]."
+                )
+                return self._resolve_null(context, required)
+            elif schema_type and isinstance(schema_type, str):
+                # Unknown string type - provide helpful suggestions
+                logger.info(f"Unknown type '{schema_type}' - common issues:")
+                logger.info("  1. Typo in type name (should be: string, integer, number, boolean, array, object)")
+                logger.info("  2. Using a schema name as type (should use $ref instead)")
+                logger.info("  3. Custom type not supported by OpenAPI (consider using allOf/oneOf/anyOf)")
+                logger.info(f"  Location: Check your OpenAPI spec for schemas with type='{schema_type}'")
+
             return self._resolve_any(context)
 
     def _resolve_reference(
@@ -115,7 +161,12 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
         module_stem = getattr(schema, "final_module_stem", None)
 
         if not module_stem:
-            logger.warning(f"Named schema {schema.name} missing final_module_stem")
+            logger.warning(f"Named schema '{schema.name}' missing final_module_stem attribute.")
+            logger.info(f"  This usually means the schema wasn't properly processed during parsing.")
+            logger.info(
+                f"  Check if '{schema.name}' is defined in components/schemas or if it's an inline schema that should be promoted."
+            )
+            logger.info(f"  The schema will be treated as 'Any' type for now.")
             return ResolvedType(python_type=class_name or "Any", is_optional=not required)
 
         # Check if we're trying to import from the same module (self-import)
@@ -237,6 +288,10 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
 
     def _resolve_null(self, context: TypeContext, required: bool) -> ResolvedType:
         """Resolve null type."""
+        # For null types in schemas, we need to import Any for the Optional[Any] pattern
+        # But the type itself is None for union composition
+        if not required:
+            context.add_import("typing", "Any")
         return ResolvedType(python_type="None", is_optional=not required)
 
     def _resolve_array(
@@ -245,7 +300,11 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
         """Resolve array type."""
         items_schema = getattr(schema, "items", None)
         if not items_schema:
-            logger.warning("Array schema missing items")
+            schema_name = getattr(schema, "name", "unnamed")
+            logger.warning(f"Array schema '{schema_name}' missing 'items' definition.")
+            logger.info("  Arrays in OpenAPI must define the type of items they contain.")
+            logger.info('  Example: { "type": "array", "items": { "type": "string" } }')
+            logger.info("  This will be mapped to List[Any] - consider fixing the OpenAPI spec.")
             context.add_import("typing", "List")
             context.add_import("typing", "Any")
             return ResolvedType(python_type="List[Any]", is_optional=not required)
@@ -340,10 +399,8 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
             if hasattr(sub_schema, "type") and sub_schema.type:
                 return self.resolve_schema(sub_schema, context, required, resolve_underlying)
 
-        # Fallback to first schema
-        if schema.all_of:
-            return self.resolve_schema(schema.all_of[0], context, required, resolve_underlying)
-
+        # Fallback - if no schema has a concrete type, return Any
+        # Don't recurse into schemas with no type as that causes warnings
         return self._resolve_any(context)
 
     def _resolve_one_of(

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyopenapi-gen
-Version: 0.12.0
+Version: 0.13.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

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

@@ -28,7 +28,7 @@ pyopenapi_gen/core/loader/operations/parser.py,sha256=QHg3o8TRaReYofEEcBwuDuNxGD
 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=rOZWbykHQy7MH1gTHI61460mFG1nPKdU9A4hOsYAiIc,7505
+pyopenapi_gen/core/loader/parameters/parser.py,sha256=tMAAxcPnAQQtdVFP7-NY6XSfxvc2HkG5rPXd1wwyE8I,8049
 pyopenapi_gen/core/loader/responses/__init__.py,sha256=6APWoH3IdNkgVmI0KsgZoZ6knDaG-S-pnUCa6gkzT8E,216
 pyopenapi_gen/core/loader/responses/parser.py,sha256=F9otAn6ncQiY3C25Fq4mEJ5UFNgN83eujcX20Vd_nPU,4069
 pyopenapi_gen/core/loader/schemas/__init__.py,sha256=rlhujYfw_IzWgzhVhYMJ3eIhE6C5Vi1Ylba-BHEVqOg,296
@@ -37,7 +37,7 @@ pyopenapi_gen/core/parsing/__init__.py,sha256=RJsIR6cHaNoI4tBcpMlAa0JsY64vsHb9sP
 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=qRTHUoVBQTgGmdfLuBuWxtWdj_SG71STGC3rn-tJvnA,6914
-pyopenapi_gen/core/parsing/schema_parser.py,sha256=W0kCV0ucq6Wybr7x1wZl-nMSRXVWAqI4T57ASSabZsM,30557
+pyopenapi_gen/core/parsing/schema_parser.py,sha256=2hOj1Xz8a2f2PF3oAAG-DwQse9WHt9DzvR6nhQ5dHJU,33148
 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
@@ -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=PsSF-DE8-GDXmvbAJz-tHlTCR-1UATGhT4dHf6kUDQQ,17988
+pyopenapi_gen/types/resolvers/schema_resolver.py,sha256=n8pI9kUJo-vLjZAOPSvwpVmRoM7AzTa7cOMlidYJVXo,21779
 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
@@ -124,8 +124,8 @@ pyopenapi_gen/visit/model/alias_generator.py,sha256=TGL3AMq_PkBWFWeeXbNnA8hgO9hv
 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,,
+pyopenapi_gen-0.13.0.dist-info/METADATA,sha256=mGXIXN6P2PxDBwf8glZdGr7Ak_Wx2f9HfpzZfl1GVa4,14025
+pyopenapi_gen-0.13.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pyopenapi_gen-0.13.0.dist-info/entry_points.txt,sha256=gxSlNiwom50T3OEZnlocA6qRjGdV0bn6hN_Xr-Ub5wA,56
+pyopenapi_gen-0.13.0.dist-info/licenses/LICENSE,sha256=UFAyTWKa4w10-QerlJaHJeep7G2gcwpf-JmvI2dS2Gc,1088
+pyopenapi_gen-0.13.0.dist-info/RECORD,,