django-cfg 1.4.10__py3-none-any.whl → 1.4.13__py3-none-any.whl

django_cfg/modules/django_client/core/generator/python/models_generator.py

@@ -0,0 +1,318 @@
+"""
+Models Generator - Generates Pydantic models and enums.
+
+Handles:
+- Pydantic 2 model classes (Request/Response/Patch)
+- Enum classes (StrEnum, IntEnum)
+- Field validation and constraints
+"""
+
+from __future__ import annotations
+
+from jinja2 import Environment
+
+from ..base import GeneratedFile
+from ...ir import IRSchemaObject
+
+
+class ModelsGenerator:
+    """Generates Pydantic models and enum classes."""
+
+    def __init__(self, jinja_env: Environment, context, base_generator):
+        """
+        Initialize models generator.
+
+        Args:
+            jinja_env: Jinja2 environment for templates
+            context: Generation context with schemas
+            base_generator: Reference to base generator for utility methods
+        """
+        self.jinja_env = jinja_env
+        self.context = context
+        self.base = base_generator
+
+    def generate_models_file(self) -> GeneratedFile:
+        """Generate models.py with all Pydantic models."""
+        # Generate all schemas
+        schema_codes = []
+
+        # Response models first
+        for name, schema in self.base.get_response_schemas().items():
+            schema_codes.append(self.generate_schema(schema))
+
+        # Request models
+        for name, schema in self.base.get_request_schemas().items():
+            schema_codes.append(self.generate_schema(schema))
+
+        # Patch models
+        for name, schema in self.base.get_patch_schemas().items():
+            schema_codes.append(self.generate_schema(schema))
+
+        template = self.jinja_env.get_template('models/models.py.jinja')
+        content = template.render(
+            has_enums=bool(self.base.get_enum_schemas()),
+            schemas=schema_codes
+        )
+
+        return GeneratedFile(
+            path="models.py",
+            content=content,
+            description="Pydantic 2 models (Request/Response/Patch)",
+        )
+
+    def generate_enums_file(self) -> GeneratedFile:
+        """Generate enums.py with all Enum classes (flat structure)."""
+        # Generate all enums
+        enum_codes = []
+        for name, schema in self.base.get_enum_schemas().items():
+            enum_codes.append(self.generate_enum(schema))
+
+        template = self.jinja_env.get_template('models/enums.py.jinja')
+        content = template.render(enums=enum_codes)
+
+        return GeneratedFile(
+            path="enums.py",
+            content=content,
+            description="Enum classes from x-enum-varnames",
+        )
+
+    def generate_shared_enums_file(self, enums: dict[str, IRSchemaObject]) -> GeneratedFile:
+        """Generate shared enums.py for namespaced structure (Variant 2)."""
+        # Generate all enums
+        enum_codes = []
+        for name, schema in enums.items():
+            enum_codes.append(self.generate_enum(schema))
+
+        template = self.jinja_env.get_template('models/enums.py.jinja')
+        content = template.render(enums=enum_codes)
+
+        return GeneratedFile(
+            path="enums.py",
+            content=content,
+            description="Shared enum classes from x-enum-varnames",
+        )
+
+    def generate_schema(self, schema: IRSchemaObject) -> str:
+        """Generate Pydantic model for schema."""
+        if schema.type != "object":
+            # For primitive types, skip (they'll be inlined)
+            return ""
+
+        # Class docstring
+        docstring_lines = []
+        if schema.description:
+            docstring_lines.extend(self.base.wrap_comment(schema.description, 76))
+
+        # Add metadata about model type
+        if schema.is_request_model:
+            docstring_lines.append("")
+            docstring_lines.append("Request model (no read-only fields).")
+        elif schema.is_patch_model:
+            docstring_lines.append("")
+            docstring_lines.append("PATCH model (all fields optional).")
+        elif schema.is_response_model:
+            docstring_lines.append("")
+            docstring_lines.append("Response model (includes read-only fields).")
+
+        docstring = "\n".join(docstring_lines) if docstring_lines else None
+
+        # Fields
+        field_lines = []
+        for prop_name, prop_schema in schema.properties.items():
+            field_lines.append(self._generate_field(prop_name, prop_schema, schema.required))
+
+        template = self.jinja_env.get_template('models/schema_class.py.jinja')
+        return template.render(
+            name=schema.name,
+            docstring=docstring,
+            fields=field_lines
+        )
+
+    def _generate_field(
+        self,
+        name: str,
+        schema: IRSchemaObject,
+        required_fields: list[str],
+    ) -> str:
+        """
+        Generate Pydantic field definition.
+
+        Examples:
+            id: int
+            username: str
+            email: str | None = None
+            age: int = Field(..., ge=0, le=150)
+            status: StatusEnum
+        """
+        # Check if this field is an enum
+        if schema.enum and schema.name:
+            # Use enum type from shared enums (sanitized to PascalCase)
+            python_type = self.base.sanitize_enum_name(schema.name)
+            if schema.nullable:
+                python_type = f"{python_type} | None"
+        # Check if this field is a reference to an enum (via $ref)
+        elif schema.ref and schema.ref in self.context.schemas:
+            ref_schema = self.context.schemas[schema.ref]
+            if ref_schema.enum:
+                # This is a reference to an enum component (sanitized to PascalCase)
+                python_type = self.base.sanitize_enum_name(schema.ref)
+                if schema.nullable:
+                    python_type = f"{python_type} | None"
+            else:
+                # Regular reference
+                python_type = schema.python_type
+        else:
+            # Get Python type
+            python_type = schema.python_type
+
+        # Check if required
+        is_required = name in required_fields
+
+        # Build Field() kwargs
+        field_kwargs = []
+
+        if schema.description:
+            field_kwargs.append(f"description={schema.description!r}")
+
+        # Validation constraints
+        if schema.min_length is not None:
+            field_kwargs.append(f"min_length={schema.min_length}")
+        if schema.max_length is not None:
+            field_kwargs.append(f"max_length={schema.max_length}")
+        if schema.pattern:
+            field_kwargs.append(f"pattern={schema.pattern!r}")
+        if schema.minimum is not None:
+            field_kwargs.append(f"ge={schema.minimum}")
+        if schema.maximum is not None:
+            field_kwargs.append(f"le={schema.maximum}")
+
+        # Example
+        if schema.example:
+            field_kwargs.append(f"examples=[{schema.example!r}]")
+
+        # Default value
+        if is_required:
+            if field_kwargs:
+                default = f"Field({', '.join(field_kwargs)})"
+            else:
+                default = "..."
+        else:
+            if field_kwargs:
+                default = f"Field(None, {', '.join(field_kwargs)})"
+            else:
+                default = "None"
+
+        return f"{name}: {python_type} = {default}"
+
+    def generate_enum(self, schema: IRSchemaObject) -> str:
+        """Generate Enum class from x-enum-varnames."""
+        # Determine enum base class
+        if schema.type == "integer":
+            base_class = "IntEnum"
+        else:
+            base_class = "StrEnum"
+
+        # Sanitize enum class name (convert to PascalCase)
+        # "OrderDetail.status" → "OrderDetailStatus"
+        # "Currency.currency_type" → "CurrencyCurrencyType"
+        enum_name = self.base.sanitize_enum_name(schema.name)
+
+        # Class docstring
+        docstring = None
+        if schema.description:
+            # Format enum description to split bullet points
+            docstring = self.base.format_enum_description(schema.description)
+
+        # Enum members
+        member_lines = []
+        for var_name, value in zip(schema.enum_var_names, schema.enum):
+            # Skip empty values (from blank=True in Django)
+            if not var_name or (isinstance(value, str) and value == ''):
+                continue
+
+            if isinstance(value, str):
+                member_lines.append(f'{var_name} = "{value}"')
+            else:
+                member_lines.append(f"{var_name} = {value}")
+
+        template = self.jinja_env.get_template('models/enum_class.py.jinja')
+        return template.render(
+            name=enum_name,
+            base_class=base_class,
+            docstring=docstring,
+            members=member_lines
+        )
+
+    def generate_app_models_file(
+        self,
+        tag: str,
+        schemas: dict[str, IRSchemaObject],
+        operations: list
+    ) -> GeneratedFile:
+        """Generate models.py for a specific app (namespaced structure)."""
+        schema_codes = []
+
+        # Collect enum names used in these schemas
+        enum_names = set()
+
+        # Track seen schema names to avoid duplicates
+        seen_schemas = set()
+
+        # Response models
+        for name, schema in schemas.items():
+            if schema.is_response_model and name not in seen_schemas:
+                schema_codes.append(self.generate_schema(schema))
+                seen_schemas.add(name)
+                # Collect enums from properties
+                if schema.properties:
+                    for prop in schema.properties.values():
+                        if prop.enum and prop.name:
+                            enum_names.add(prop.name.replace(".", ""))
+                        elif prop.ref and prop.ref in self.context.schemas:
+                            ref_schema = self.context.schemas[prop.ref]
+                            if ref_schema.enum:
+                                enum_names.add(prop.ref.replace(".", ""))
+
+        # Request models
+        for name, schema in schemas.items():
+            if schema.is_request_model and name not in seen_schemas:
+                schema_codes.append(self.generate_schema(schema))
+                seen_schemas.add(name)
+                # Collect enums from properties
+                if schema.properties:
+                    for prop in schema.properties.values():
+                        if prop.enum and prop.name:
+                            enum_names.add(prop.name.replace(".", ""))
+                        elif prop.ref and prop.ref in self.context.schemas:
+                            ref_schema = self.context.schemas[prop.ref]
+                            if ref_schema.enum:
+                                enum_names.add(prop.ref.replace(".", ""))
+
+        # Patch models
+        for name, schema in schemas.items():
+            if schema.is_patch_model and name not in seen_schemas:
+                schema_codes.append(self.generate_schema(schema))
+                seen_schemas.add(name)
+                # Collect enums from properties
+                if schema.properties:
+                    for prop in schema.properties.values():
+                        if prop.enum and prop.name:
+                            enum_names.add(prop.name.replace(".", ""))
+                        elif prop.ref and prop.ref in self.context.schemas:
+                            ref_schema = self.context.schemas[prop.ref]
+                            if ref_schema.enum:
+                                enum_names.add(prop.ref.replace(".", ""))
+
+        template = self.jinja_env.get_template('models/app_models.py.jinja')
+        content = template.render(
+            has_enums=len(enum_names) > 0,
+            enum_names=sorted(enum_names),  # Sort for consistent output
+            schemas=schema_codes
+        )
+
+        folder_name = self.base.tag_and_app_to_folder_name(tag, operations)
+        return GeneratedFile(
+            path=f"{folder_name}/models.py",
+            content=content,
+            description=f"Models for {tag}",
+        )

django_cfg/modules/django_client/core/generator/python/operations_generator.py

@@ -0,0 +1,278 @@
+"""
+Operations Generator - Generates operation methods for async and sync clients.
+
+Handles:
+- Async operation methods (async def with await)
+- Sync operation methods (def without await)
+- Path parameters, query parameters, request bodies
+- Response parsing and validation
+"""
+
+from __future__ import annotations
+
+from jinja2 import Environment
+
+from ...ir import IROperationObject
+
+
+class OperationsGenerator:
+    """Generates operation methods for Python clients."""
+
+    def __init__(self, jinja_env: Environment, base_generator):
+        """
+        Initialize operations generator.
+
+        Args:
+            jinja_env: Jinja2 environment for templates
+            base_generator: Reference to base generator for utility methods
+        """
+        self.jinja_env = jinja_env
+        self.base = base_generator
+
+    def generate_async_operation(self, operation: IROperationObject, remove_tag_prefix: bool = False) -> str:
+        """Generate async method for operation."""
+        # Get method name
+        method_name = operation.operation_id
+        if remove_tag_prefix and operation.tags:
+            # Remove tag prefix using base class method
+            tag = operation.tags[0]
+            method_name = self.base.remove_tag_prefix(method_name, tag)
+
+        # Method signature
+        params = ["self"]
+
+        # Add path parameters
+        for param in operation.path_parameters:
+            param_type = self._map_param_type(param.schema_type)
+            params.append(f"{param.name}: {param_type}")
+
+        # Add request body parameter
+        if operation.request_body:
+            params.append(f"data: {operation.request_body.schema_name}")
+        elif operation.patch_request_body:
+            params.append(f"data: {operation.patch_request_body.schema_name} | None = None")
+
+        # Add query parameters
+        for param in operation.query_parameters:
+            param_type = self._map_param_type(param.schema_type)
+            if not param.required:
+                param_type = f"{param_type} | None = None"
+            params.append(f"{param.name}: {param_type}")
+
+        # Return type
+        primary_response = operation.primary_success_response
+        if primary_response and primary_response.schema_name:
+            if operation.is_list_operation:
+                return_type = f"list[{primary_response.schema_name}]"
+            else:
+                return_type = primary_response.schema_name
+        else:
+            return_type = "None"
+
+        signature = f"async def {method_name}({', '.join(params)}) -> {return_type}:"
+
+        # Docstring
+        docstring_lines = []
+        if operation.summary:
+            docstring_lines.append(operation.summary)
+        if operation.description:
+            if docstring_lines:
+                docstring_lines.append("")
+            docstring_lines.extend(self.base.wrap_comment(operation.description, 72))
+
+        docstring = "\n".join(docstring_lines) if docstring_lines else None
+
+        # Method body
+        body_lines = []
+
+        # Build URL
+        url_expr = f'"{operation.path}"'
+        if operation.path_parameters:
+            # Replace {id} with f-string {id}
+            url_expr = f'f"{operation.path}"'
+
+        body_lines.append(f"url = {url_expr}")
+
+        # Build request
+        request_kwargs = []
+
+        # Query params
+        if operation.query_parameters:
+            query_items = []
+            for param in operation.query_parameters:
+                if param.required:
+                    query_items.append(f'"{param.name}": {param.name}')
+                else:
+                    query_items.append(f'"{param.name}": {param.name} if {param.name} is not None else None')
+
+            query_dict = "{" + ", ".join(query_items) + "}"
+            request_kwargs.append(f"params={query_dict}")
+
+        # JSON body
+        if operation.request_body:
+            # Required body
+            request_kwargs.append("json=data.model_dump()")
+        elif operation.patch_request_body:
+            # Optional PATCH body - check for None
+            request_kwargs.append("json=data.model_dump() if data is not None else None")
+
+        # Make request
+        method_lower = operation.http_method.lower()
+        request_line = f"response = await self._client.{method_lower}(url"
+        if request_kwargs:
+            request_line += ", " + ", ".join(request_kwargs)
+        request_line += ")"
+
+        body_lines.append(request_line)
+
+        # Handle response
+        body_lines.append("response.raise_for_status()")
+
+        if return_type != "None":
+            if operation.is_list_operation:
+                # Paginated list response - extract results
+                body_lines.append(f"data = response.json()")
+                body_lines.append(f'return [{primary_response.schema_name}.model_validate(item) for item in data.get("results", [])]')
+            else:
+                body_lines.append(f"return {primary_response.schema_name}.model_validate(response.json())")
+        else:
+            body_lines.append("return None")
+
+        template = self.jinja_env.get_template('client/operation_method.py.jinja')
+        return template.render(
+            method_name=method_name,
+            params=params,
+            return_type=return_type,
+            docstring=docstring,
+            body_lines=body_lines
+        )
+
+    def generate_sync_operation(self, operation: IROperationObject, remove_tag_prefix: bool = False) -> str:
+        """Generate sync method for operation (mirrors async generate_operation)."""
+        # Get method name
+        method_name = operation.operation_id
+        if remove_tag_prefix and operation.tags:
+            # Remove tag prefix using base class method
+            tag = operation.tags[0]
+            method_name = self.base.remove_tag_prefix(method_name, tag)
+
+        # Method signature
+        params = ["self"]
+
+        # Add path parameters
+        for param in operation.path_parameters:
+            param_type = self._map_param_type(param.schema_type)
+            params.append(f"{param.name}: {param_type}")
+
+        # Add request body parameter
+        if operation.request_body:
+            params.append(f"data: {operation.request_body.schema_name}")
+        elif operation.patch_request_body:
+            params.append(f"data: {operation.patch_request_body.schema_name} | None = None")
+
+        # Add query parameters
+        for param in operation.query_parameters:
+            param_type = self._map_param_type(param.schema_type)
+            if not param.required:
+                param_type = f"{param_type} | None = None"
+            params.append(f"{param.name}: {param_type}")
+
+        # Return type
+        primary_response = operation.primary_success_response
+        if primary_response and primary_response.schema_name:
+            if operation.is_list_operation:
+                return_type = f"list[{primary_response.schema_name}]"
+            else:
+                return_type = primary_response.schema_name
+        else:
+            return_type = "None"
+
+        # Docstring
+        docstring_lines = []
+        if operation.summary:
+            docstring_lines.append(operation.summary)
+        if operation.description:
+            if docstring_lines:
+                docstring_lines.append("")
+            docstring_lines.extend(self.base.wrap_comment(operation.description, 72))
+
+        docstring = "\n".join(docstring_lines) if docstring_lines else None
+
+        # Method body
+        body_lines = []
+
+        # Build URL
+        url_expr = f'"{operation.path}"'
+        if operation.path_parameters:
+            # Replace {id} with f-string {id}
+            url_expr = f'f"{operation.path}"'
+
+        body_lines.append(f"url = {url_expr}")
+
+        # Build request
+        request_kwargs = []
+
+        # Query params
+        if operation.query_parameters:
+            query_items = []
+            for param in operation.query_parameters:
+                if param.required:
+                    query_items.append(f'"{param.name}": {param.name}')
+                else:
+                    query_items.append(f'"{param.name}": {param.name} if {param.name} is not None else None')
+
+            query_dict = "{" + ", ".join(query_items) + "}"
+            request_kwargs.append(f"params={query_dict}")
+
+        # JSON body
+        if operation.request_body:
+            # Required body
+            request_kwargs.append("json=data.model_dump(exclude_unset=True)")
+        elif operation.patch_request_body:
+            # Optional PATCH body - check for None
+            request_kwargs.append("json=data.model_dump(exclude_unset=True) if data is not None else None")
+
+        # HTTP method
+        method_lower = operation.http_method.lower()
+
+        # Build request call (sync version - no await)
+        if request_kwargs:
+            request_call = f'self._client.{method_lower}(url, {", ".join(request_kwargs)})'
+        else:
+            request_call = f'self._client.{method_lower}(url)'
+
+        body_lines.append(f"response = {request_call}")
+        body_lines.append("response.raise_for_status()")
+
+        # Parse response
+        if return_type != "None":
+            if operation.is_list_operation:
+                # List response - validate each item (paginated)
+                primary_schema = primary_response.schema_name
+                body_lines.append(f"data = response.json()")
+                body_lines.append(f'return [{primary_schema}.model_validate(item) for item in data.get("results", [])]')
+            else:
+                # Single object response
+                body_lines.append(f"return {return_type}.model_validate(response.json())")
+
+        # Render template
+        template = self.jinja_env.get_template('client/sync_operation_method.py.jinja')
+        return template.render(
+            method_name=method_name,
+            params=params,
+            return_type=return_type,
+            body_lines=body_lines,
+            docstring=docstring
+        )
+
+    def _map_param_type(self, schema_type: str) -> str:
+        """Map parameter schema type to Python type."""
+        type_map = {
+            "string": "str",
+            "integer": "int",
+            "number": "float",
+            "boolean": "bool",
+            "array": "list",
+            "object": "dict",
+        }
+        return type_map.get(schema_type, "str")

django_cfg/modules/django_client/core/generator/python/sync_client_gen.py

@@ -0,0 +1,102 @@
+"""
+Sync Client Generator - Generates sync Python clients.
+
+Handles:
+- Main SyncAPIClient class (httpx.Client)
+- Sync sub-client classes (per tag/app)
+- Mirrors async client structure without async/await
+"""
+
+from __future__ import annotations
+
+from jinja2 import Environment
+
+from ..base import GeneratedFile
+from ...ir import IROperationObject
+
+
+class SyncClientGenerator:
+    """Generates sync Python client files."""
+
+    def __init__(self, jinja_env: Environment, base_generator, operations_gen):
+        """
+        Initialize sync client generator.
+
+        Args:
+            jinja_env: Jinja2 environment for templates
+            base_generator: Reference to base generator
+            operations_gen: Operations generator instance
+        """
+        self.jinja_env = jinja_env
+        self.base = base_generator
+        self.operations_gen = operations_gen
+
+    def generate_app_sync_client_file(self, tag: str, operations: list[IROperationObject]) -> GeneratedFile:
+        """Generate sync_client.py for a specific app."""
+        class_name = self.base.tag_to_class_name(tag)
+
+        # Generate sync methods
+        method_codes = []
+        for operation in operations:
+            method_codes.append(self.operations_gen.generate_sync_operation(operation, remove_tag_prefix=True))
+
+        template = self.jinja_env.get_template('client/sync_sub_client.py.jinja')
+        content = template.render(
+            tag=self.base.tag_to_display_name(tag),
+            class_name=class_name,
+            operations=method_codes
+        )
+
+        folder_name = self.base.tag_and_app_to_folder_name(tag, operations)
+        return GeneratedFile(
+            path=f"{folder_name}/sync_client.py",
+            content=content,
+            description=f"Sync API client for {tag}",
+        )
+
+    def generate_sync_main_client_file(self, ops_by_tag: dict) -> GeneratedFile:
+        """Generate sync_client.py with SyncAPIClient."""
+        tags = sorted(ops_by_tag.keys())
+
+        # Prepare tags data for template (with Sync prefix for imports)
+        tags_data = [
+            {
+                "class_name": f"Sync{self.base.tag_to_class_name(tag)}",  # Add Sync prefix
+                "slug": f"{self.base.tag_and_app_to_folder_name(tag, ops_by_tag[tag])}.sync_client",  # Import from sync_client module
+            }
+            for tag in tags
+        ]
+
+        # Generate sync APIClient class
+        sync_client_code = self._generate_sync_main_client_class(ops_by_tag)
+
+        template = self.jinja_env.get_template('client/main_client_file.py.jinja')
+        content = template.render(
+            tags=tags_data,
+            client_code=sync_client_code
+        )
+
+        return GeneratedFile(
+            path="sync_client.py",
+            content=content,
+            description="Main sync API client",
+        )
+
+    def _generate_sync_main_client_class(self, ops_by_tag: dict) -> str:
+        """Generate main SyncAPIClient with sync sub-clients."""
+        tags = sorted(ops_by_tag.keys())
+
+        # Prepare tags data for template
+        tags_data = [
+            {
+                "class_name": self.base.tag_to_class_name(tag),
+                "property": self.base.tag_to_property_name(tag),
+            }
+            for tag in tags
+        ]
+
+        template = self.jinja_env.get_template('client/sync_main_client.py.jinja')
+        return template.render(
+            api_title=self.base.context.openapi_info.title,
+            tags=tags_data
+        )