ab-openapi-python-generator 2.2.5__tar.gz → 2.2.7__tar.gz

{ab_openapi_python_generator-2.2.5 → ab_openapi_python_generator-2.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ab-openapi-python-generator
-Version: 2.2.5
+Version: 2.2.7
 Summary: Openapi Python Generator
 Project-URL: Homepage, https://github.com/auth-broker/openapi-python-generator
 Project-URL: Repository, https://github.com/auth-broker/openapi-python-generator

{ab_openapi_python_generator-2.2.5 → ab_openapi_python_generator-2.2.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ab-openapi-python-generator"
-version = "2.2.5"
+version = "2.2.7"
 description = "Openapi Python Generator"
 authors = [
     { name = "Marco Müllner", email = "muellnermarco@gmail.com" },

{ab_openapi_python_generator-2.2.5 → ab_openapi_python_generator-2.2.7}/src/ab_openapi_python_generator/language_converters/python/client_generator.py

@@ -144,38 +144,46 @@ HTTP_OPERATIONS = ["get", "post", "put", "delete", "options", "head", "patch", "
 def generate_body_param(operation: Operation) -> Union[str, None]:
     if operation.requestBody is None:
         return None
-    else:
-        if isinstance(operation.requestBody, Reference30) or isinstance(operation.requestBody, Reference31):
-            return "data.dict()"
-
-        if operation.requestBody.content is None:
-            return None  # pragma: no cover
-
-        if operation.requestBody.content.get("application/json") is None:
-            return None  # pragma: no cover
-
-        media_type = operation.requestBody.content.get("application/json")
-
-        if media_type is None:
-            return None  # pragma: no cover
-
-        if isinstance(media_type.media_type_schema, (Reference, Reference30, Reference31)):
-            return "data.dict()"
-        elif hasattr(media_type.media_type_schema, "ref"):
-            # Handle Reference objects from different OpenAPI versions
-            return "data.dict()"
-        elif isinstance(media_type.media_type_schema, (Schema, Schema30, Schema31)):
-            schema = media_type.media_type_schema
-            if schema.type == "array":
-                return "[i.dict() for i in data]"
-            elif schema.type == "object":
-                return "data"
-            else:
-                raise Exception(f"Unsupported schema type for request body: {schema.type}")  # pragma: no cover
-        else:
-            raise Exception(
-                f"Unsupported schema type for request body: {type(media_type.media_type_schema)}"
-            )  # pragma: no cover
+
+    # If requestBody is a $ref, it will be a Pydantic model instance in the client.
+    if isinstance(operation.requestBody, (Reference30, Reference31)):
+        return "data.model_dump(by_alias=True, exclude_none=True)"
+
+    rb_content = getattr(operation.requestBody, "content", None)
+    if rb_content is None:
+        return None  # pragma: no cover
+
+    if rb_content.get("application/json") is None:
+        return None  # pragma: no cover
+
+    media_type = rb_content.get("application/json")
+    if media_type is None:
+        return None  # pragma: no cover
+
+    mts = getattr(media_type, "media_type_schema", None)
+    if mts is None:
+        return None  # pragma: no cover
+
+    # $ref schema -> model
+    if isinstance(mts, (Reference, Reference30, Reference31)) or hasattr(mts, "ref"):
+        return "data.model_dump(by_alias=True, exclude_none=True)"
+
+    # Concrete schema
+    if isinstance(mts, (Schema, Schema30, Schema31)):
+        schema = mts
+
+        if schema.type == "array":
+            # List of models or primitives
+            return "[i.model_dump(by_alias=True, exclude_none=True) if hasattr(i, 'model_dump') else i for i in data]"
+
+        if schema.type == "object":
+            # Model or dict-like
+            return "data.model_dump(by_alias=True, exclude_none=True) if hasattr(data, 'model_dump') else data"
+
+        # Primitive (string/int/etc.)
+        return "data"
+
+    raise Exception(f"Unsupported schema type for request body: {type(mts)}")  # pragma: no cover
 
 
 def generate_params(operation: Operation) -> str:

{ab_openapi_python_generator-2.2.5 → ab_openapi_python_generator-2.2.7}/src/ab_openapi_python_generator/language_converters/python/generator.py

@@ -13,6 +13,7 @@ from ab_openapi_python_generator.language_converters.python.exception_generator
 )
 from ab_openapi_python_generator.language_converters.python.model_generator import (
     generate_models,
+    generate_response_union_alias_models,
 )
 from ab_openapi_python_generator.models import ConversionResult, LibraryConfig
 
@@ -40,6 +41,14 @@ def generator(
     else:
         models = []
 
+    # Generate response union alias models (e.g. AuthorizeResponse) from paths
+    # so client return types that reference those aliases have corresponding
+    # model modules available in the output.
+    if data.paths is not None:
+        resp_alias_models = generate_response_union_alias_models(data.paths, pydantic_version)
+        if resp_alias_models:
+            models.extend(resp_alias_models)
+
     if data.paths is not None:
         clients = generate_clients(data, data.paths, library_config, env_token_name, pydantic_version)
     else:

{ab_openapi_python_generator-2.2.5 → ab_openapi_python_generator-2.2.7}/src/ab_openapi_python_generator/language_converters/python/model_generator.py

@@ -757,16 +757,21 @@ def _generate_property_from_schema(
     """
     required = parent_schema is not None and parent_schema.required is not None and name in parent_schema.required
 
-    import_type = None
+    # Pick up OpenAPI default (if present)
+    default_val = getattr(schema, "default", None)
+
     if required:
-        import_type = [] if name == model_name else [name]
+        rendered_default = None
+    else:
+        # If OpenAPI provides a default, use it. Otherwise fall back to None.
+        rendered_default = repr(default_val) if default_val is not None else "None"
 
     return Property(
         name=name,
         type=type_converter(schema, required, model_name),
         required=required,
-        default=None if required else "None",
-        import_type=import_type,
+        default=rendered_default,
+        import_type=None if not required else ([] if name == model_name else [name]),
     )
 
 

{ab_openapi_python_generator-2.2.5 → ab_openapi_python_generator-2.2.7}/src/ab_openapi_python_generator/language_converters/python/templates/async_client_httpx_pydantic_2.jinja2

@@ -57,15 +57,20 @@ AsyncGenerator[str | dict[str, Any], None]
         path = f"{{ op.path_name }}"
 
         headers = {
+{% if op.body_param %}
             "Content-Type": "application/json",
+{% endif %}
 {% if op.is_sse %}
             "Accept": "text/event-stream",
 {% else %}
             "Accept": "application/json",
 {% endif %}
-            "Authorization": f"Bearer { await self.get_access_token() }",
         }
 
+        _token = await self.get_access_token()
+        if _token:
+            headers["Authorization"] = f"Bearer {_token}"
+
         query_params: Dict[str, Any] = {
 {% for qp in op.query_params %}
             {{ qp }},

{ab_openapi_python_generator-2.2.5 → ab_openapi_python_generator-2.2.7}/src/ab_openapi_python_generator/language_converters/python/templates/sync_client_httpx_pydantic_2.jinja2

@@ -57,15 +57,20 @@ Generator[str | dict[str, Any], None, None]
         path = f"{{ op.path_name }}"
 
         headers = {
+{% if op.body_param %}
             "Content-Type": "application/json",
+{% endif %}
 {% if op.is_sse %}
             "Accept": "text/event-stream",
 {% else %}
             "Accept": "application/json",
 {% endif %}
-            "Authorization": f"Bearer { self.get_access_token() }",
         }
 
+        _token = self.get_access_token()
+        if _token:
+            headers["Authorization"] = f"Bearer {_token}"
+
         query_params: Dict[str, Any] = {
 {% for qp in op.query_params %}
             {{ qp }},