clientele 2.2.2__tar.gz → 2.3.0__tar.gz

{clientele-2.2.2 → clientele-2.3.0}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Change log
 
+## 2.3.0
+
+- Add `clientele.api.Query(alias=...)` for annotating a query parameter with its wire-format name via `typing.Annotated`, so a Python-friendly (snake_case) parameter name can be used without breaking the actual HTTP request. Clients generated from an OpenAPI spec now apply this automatically whenever a query parameter's name isn't already valid snake_case (e.g. `orderBy` → `order_by`).
+- Fix generated/decorated functions sending query parameters under their sanitized Python name instead of the original API name whenever that name required sanitization (e.g. a spec's `yourInput` query parameter was sent as `?your_input=...` instead of `?yourInput=...`).
+- Major refactoring of the project structure including removing of redundant code paths (mostly left over from the old generator logic).
+- Reorganisation of the tests and their files to mirror the codebase more.
+
 ## 2.2.2
 
 - Fix `HttpxHTTPBackend.close()`/`aclose()` not resetting the client reference — a closed-but-non-None client was returned on subsequent requests, causing `RuntimeError: Cannot send a request, as the client has been closed`.

{clientele-2.2.2 → clientele-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clientele
-Version: 2.2.2
+Version: 2.3.0
 Summary: Clientele is a different way to build Python API Clients
 Project-URL: Homepage, https://clientele.dev
 Project-URL: Changelog, https://docs.clientele.dev/CHANGELOG/

{clientele-2.2.2 → clientele-2.3.0}/SECURITY.md

@@ -4,8 +4,8 @@
 
 | Version       | Supported          |
 | --------------| ------------------ |
-| 2.2.2         | :white_check_mark: |
-| 2.2.1 or less | :x:                |
+| 2.3.0         | :white_check_mark: |
+| 2.2.2 or less | :x:                |
 
 ## Reporting a Vulnerability
 

{clientele-2.2.2 → clientele-2.3.0}/clientele/api/__init__.py

@@ -1,6 +1,7 @@
 from clientele.api.client import APIClient
 from clientele.api.config import BaseConfig, get_default_config
 from clientele.api.exceptions import APIException
+from clientele.api.params import Query
 from clientele.http.status_codes import codes
 
-__all__ = ["APIException", "APIClient", "BaseConfig", "codes", "get_default_config"]
+__all__ = ["APIException", "APIClient", "BaseConfig", "Query", "codes", "get_default_config"]

{clientele-2.2.2 → clientele-2.3.0}/clientele/api/client.py

@@ -11,7 +11,7 @@ import pydantic
 
 from clientele.api import config as api_config
 from clientele.api import exceptions as api_exceptions
-from clientele.api import requests, type_utils
+from clientele.api import request_context, type_utils
 from clientele.http import httpx_backend
 from clientele.http import response as http_response
 
@@ -281,7 +281,7 @@ class APIClient:
         streaming_response: bool = False,
     ) -> typing.Callable[[typing.Any], typing.Any]:
         def decorator(func: typing.Any) -> typing.Any:
-            context = requests.build_request_context(
+            context = request_context.build_request_context(
                 method,
                 path,
                 func,
@@ -319,8 +319,8 @@ class APIClient:
         return decorator
 
     def _prepare_call(
-        self, context: requests.RequestContext, args: tuple[typing.Any, ...], kwargs: dict[str, typing.Any]
-    ) -> requests.PreparedCall:
+        self, context: request_context.RequestContext, args: tuple[typing.Any, ...], kwargs: dict[str, typing.Any]
+    ) -> request_context.PreparedCall:
         """
         Parse function arguments into an HTTP request specification.
 
@@ -373,6 +373,8 @@ class APIClient:
         else:
             query_params = {k: v for k, v in request_arguments.items() if k != "data"}
             query_params.update(extra_kwargs)
+            if context.query_alias_map:
+                query_params = {context.query_alias_map.get(k, k): v for k, v in query_params.items()}
 
         # Filter out None values from query params to avoid adding empty parameters to the URL
         if query_params:
@@ -400,7 +402,7 @@ class APIClient:
         url_path = self._substitute_path(context.path_template, path_params)
         result_annotation = context.type_hints.get("result", inspect._empty)
 
-        return requests.PreparedCall(
+        return request_context.PreparedCall(
             context=context,
             bound_arguments=bound_arguments,
             call_arguments=call_arguments,
@@ -412,7 +414,7 @@ class APIClient:
         )
 
     def _execute_sync(
-        self, context: requests.RequestContext, args: tuple[typing.Any, ...], kwargs: dict[str, typing.Any]
+        self, context: request_context.RequestContext, args: tuple[typing.Any, ...], kwargs: dict[str, typing.Any]
     ) -> typing.Any:
         prepared = self._prepare_call(context, args, kwargs)
         response = self._send_request(
@@ -427,7 +429,7 @@ class APIClient:
         return result
 
     async def _execute_async(
-        self, context: requests.RequestContext, args: tuple[typing.Any, ...], kwargs: dict[str, typing.Any]
+        self, context: request_context.RequestContext, args: tuple[typing.Any, ...], kwargs: dict[str, typing.Any]
     ) -> typing.Any:
         prepared = self._prepare_call(context, args, kwargs)
         response = await self._send_request_async(
@@ -442,7 +444,7 @@ class APIClient:
         return await result
 
     async def _execute_async_stream(
-        self, context: requests.RequestContext, args: tuple[typing.Any, ...], kwargs: dict[str, typing.Any]
+        self, context: request_context.RequestContext, args: tuple[typing.Any, ...], kwargs: dict[str, typing.Any]
     ) -> typing.Any:
         """
         Execute an async streaming request.
@@ -495,7 +497,7 @@ class APIClient:
         return result
 
     def _execute_sync_stream(
-        self, context: requests.RequestContext, args: tuple[typing.Any, ...], kwargs: dict[str, typing.Any]
+        self, context: request_context.RequestContext, args: tuple[typing.Any, ...], kwargs: dict[str, typing.Any]
     ) -> typing.Any:
         """
         Execute a sync streaming request.
@@ -658,7 +660,7 @@ class APIClient:
 
     def _finalise_call(
         self,
-        prepared: requests.PreparedCall,
+        prepared: request_context.PreparedCall,
         response: http_response.Response,
     ) -> typing.Any:
         parsed_result = self._parse_response(

clientele-2.3.0/clientele/api/params.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+
+class Query:
+    """Marks a decorated function parameter as an HTTP query parameter with a wire-format alias.
+
+    Use via ``typing.Annotated`` when the Python parameter name (e.g. to satisfy naming
+    conventions such as ruff's N803) differs from the query parameter name expected by the API.
+
+    Example:
+    ```python
+    from typing import Annotated
+
+    from clientele import api
+
+    client = api.APIClient(base_url="https://pokeapi.co/api/v2/")
+
+
+    @client.get("/pokemon/")
+    def get_pokemon_page(result: dict, order_by: Annotated[str, api.Query(alias="orderBy")]) -> dict:
+        return result
+    ```
+    """
+
+    __slots__ = ("alias",)
+
+    def __init__(self, *, alias: str) -> None:
+        self.alias = alias
+
+    def __repr__(self) -> str:
+        return f"Query(alias={self.alias!r})"
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, Query) and self.alias == other.alias
+
+    def __hash__(self) -> int:
+        return hash(("clientele.api.Query", self.alias))

clientele-2.2.2/clientele/api/requests.py → clientele-2.3.0/clientele/api/request_context.py

@@ -7,6 +7,7 @@ import typing
 import pydantic
 
 from clientele.api import type_utils
+from clientele.api.params import Query
 from clientele.http import response as http_response
 from clientele.http import status_codes
 
@@ -52,6 +53,7 @@ class RequestContext(pydantic.BaseModel):
         typing.Callable[[http_response.Response], typing.Any] | typing.Callable[[str], typing.Any] | None
     ) = None
     streaming: bool = False
+    query_alias_map: dict[str, str] = {}
 
 
 def validate_result_parameter(
@@ -124,6 +126,23 @@ def validate_result_parameter(
             )
 
 
+def _extract_query_alias_map(type_hints: dict[str, typing.Any]) -> dict[str, str]:
+    """
+    Scans resolved type hints for `Annotated[X, Query(alias=...)]` metadata.
+
+    Returns a mapping from the Python parameter name to the wire-format query
+    parameter name declared via `Query(alias=...)`.
+    """
+    alias_map: dict[str, str] = {}
+    for name, annotation in type_hints.items():
+        if typing.get_origin(annotation) is not typing.Annotated:
+            continue
+        for meta in getattr(annotation, "__metadata__", ()):
+            if isinstance(meta, Query):
+                alias_map[name] = meta.alias
+    return alias_map
+
+
 def build_request_context(
     method: str,
     path: str,
@@ -175,6 +194,7 @@ def build_request_context(
         response_map=response_map,
         response_parser=response_parser,
         streaming=streaming,
+        query_alias_map=_extract_query_alias_map(type_hints),
     )
 
 

clientele-2.3.0/clientele/generators/api/__init__.py

@@ -0,0 +1 @@
+# API generator for decorator-based clients

clientele-2.2.2/clientele/generators/base_clients.py → clientele-2.3.0/clientele/generators/api/clients.py

@@ -1,4 +1,4 @@
-"""Base class for client generators shared by api and basic generators."""
+"""Generates the client.py file for the api generator."""
 
 import collections
 import typing
@@ -8,10 +8,20 @@ from cicerone.spec import openapi_spec as cicerone_openapi_spec
 from rich import console as rich_console
 
 from clientele.generators import cicerone_compat
-from clientele.generators.shared import utils
+from clientele.generators.api import writer
+from clientele.generators.shared import schemas, utils
 
 console = rich_console.Console()
 
+# Template used for each HTTP method when rendering client functions
+METHOD_TEMPLATE_MAP = {
+    "get": "api_get_method.jinja2",
+    "delete": "api_get_method.jinja2",
+    "post": "api_post_method.jinja2",
+    "put": "api_post_method.jinja2",
+    "patch": "api_post_method.jinja2",
+}
+
 
 class ParametersResponse(pydantic.BaseModel):
     # Parameters that need to be passed in the URL query
@@ -22,88 +32,50 @@ class ParametersResponse(pydantic.BaseModel):
     headers_args: dict[str, str]
     # Mapping from sanitized Python name to original API parameter name
     param_name_map: dict[str, str] = {}
-
-    def get_path_args_as_string(self) -> str:
-        # Get all the path arguments, and the query arguments and make a big string out of them.
-        args = list(self.path_args.items()) + list(self.query_args.items())
-        # Separate required and optional parameters
-        # Python requires all required parameters (no default) before optional ones (with default)
-        required_args = []
-        optional_args = []
-        for k, v in args:
-            if v.startswith("typing.Optional["):
-                optional_args.append(f"{k}: {v} = None")
-            else:
-                required_args.append(f"{k}: {v}")
-        # Return required parameters first, then optional ones
-        return ", ".join(required_args + optional_args)
+    # Keys (from path_args/query_args) that are optional. Tracked explicitly rather than
+    # sniffed from the type string, since aliased query args wrap their type in
+    # `typing.Annotated[...]`, which would otherwise hide a `typing.Optional[` prefix.
+    optional_keys: set[str] = set()
 
     def get_required_args_as_string(self) -> str:
-        """Get only required parameters (those without Optional wrapper)."""
+        """Get only required parameters (those not in optional_keys)."""
         args = list(self.path_args.items()) + list(self.query_args.items())
-        required_args = []
-        for k, v in args:
-            if not v.startswith("typing.Optional["):
-                required_args.append(f"{k}: {v}")
+        required_args = [f"{k}: {v}" for k, v in args if k not in self.optional_keys]
         return ", ".join(required_args) if required_args else ""
 
     def get_optional_args_as_string(self) -> str:
-        """Get only optional parameters (those with Optional wrapper)."""
+        """Get only optional parameters (those in optional_keys)."""
         args = list(self.path_args.items()) + list(self.query_args.items())
-        optional_args = []
-        for k, v in args:
-            if v.startswith("typing.Optional["):
-                optional_args.append(f"{k}: {v} = None")
+        optional_args = [f"{k}: {v} = None" for k, v in args if k in self.optional_keys]
         return ", ".join(optional_args) if optional_args else ""
 
-    def get_required_path_args_as_string(self) -> str:
-        """Get only required path parameters (for clientele-api generator)."""
-        required_args = []
-        for k, v in self.path_args.items():
-            if not v.startswith("typing.Optional["):
-                required_args.append(f"{k}: {v}")
-        return ", ".join(required_args) if required_args else ""
-
-    def has_query_args(self) -> bool:
-        """Check if there are any query parameters."""
-        return len(self.query_args) > 0
-
 
-class BaseClientsGenerator:
+class ClientsGenerator:
     """
-    Base class for generating client code from OpenAPI specifications.
-    Provides common functionality for client generators.
+    Handles all the content generated in the client.py file for the api generator.
+    This generates decorator-based client functions instead of traditional functions.
     """
 
-    method_template_map: dict[str, str]
     results: dict[str, int]
     spec: cicerone_openapi_spec.OpenAPISpec
     output_dir: str
-    schemas_generator: typing.Any  # Type will be specific in subclasses
-    http_generator: typing.Any  # Type will be specific in subclasses
-    writer: typing.Any  # Must be set by subclass
+    schemas_generator: schemas.SchemasGenerator
+    # Status codes per generated function, used to build response_map arguments
+    function_and_status_codes_bundle: dict[str, dict[str, str]]
 
     def __init__(
         self,
         spec: cicerone_openapi_spec.OpenAPISpec,
         output_dir: str,
-        schemas_generator: typing.Any,
-        http_generator: typing.Any,
+        schemas_generator: schemas.SchemasGenerator,
         asyncio: bool,
     ) -> None:
         self.spec = spec
         self.output_dir = output_dir
         self.results = collections.defaultdict(int)
         self.schemas_generator = schemas_generator
-        self.http_generator = http_generator
         self.asyncio = asyncio
-        self.method_template_map = dict(
-            get="get_method.jinja2",
-            delete="get_method.jinja2",
-            post="post_method.jinja2",
-            put="post_method.jinja2",
-            patch="post_method.jinja2",
-        )
+        self.function_and_status_codes_bundle = {}
 
     def generate_paths(self) -> None:
         # Check if the spec has paths
@@ -127,6 +99,7 @@ class BaseClientsGenerator:
         path_args = {}
         headers_args = {}
         param_name_map = {}  # Maps sanitized name to original name
+        optional_keys: set[str] = set()
         all_parameters = parameters + additional_parameters
         for param in all_parameters:
             if param.get("$ref"):
@@ -144,11 +117,15 @@ class BaseClientsGenerator:
             if in_ == "query":
                 # URL query string values
                 param_type = utils.resolve_forward_refs_for_client(utils.get_type(param["schema"]))
-                if required:
-                    query_args[clean_key] = param_type
-                else:
-                    param_type = utils.strip_none_from_type(param_type)
-                    query_args[clean_key] = f"typing.Optional[{param_type}]"
+                if not required:
+                    param_type = f"typing.Optional[{utils.strip_none_from_type(param_type)}]"
+                    optional_keys.add(clean_key)
+                if clean_key != original_name:
+                    # The sanitized Python name differs from the name the API expects, so
+                    # record it via Query(alias=...) to keep the request sent with the correct
+                    # wire-format name (see clientele.api.request_context.query_alias_map).
+                    param_type = f'typing.Annotated[{param_type}, clientele_api.Query(alias="{original_name}")]'
+                query_args[clean_key] = param_type
             elif in_ == "path":
                 # Function arguments
                 param_type = utils.resolve_forward_refs_for_client(utils.get_type(param["schema"]))
@@ -157,6 +134,7 @@ class BaseClientsGenerator:
                 else:
                     param_type = utils.strip_none_from_type(param_type)
                     path_args[clean_key] = f"typing.Optional[{param_type}]"
+                    optional_keys.add(clean_key)
             elif in_ == "header":
                 # Header object arguments
                 headers_args[param["name"]] = utils.get_type(param["schema"])
@@ -166,6 +144,7 @@ class BaseClientsGenerator:
             path_args=path_args,
             headers_args=headers_args,
             param_name_map=param_name_map,
+            optional_keys=optional_keys,
         )
 
     def get_response_class_names(self, responses: dict, func_name: str) -> list[str]:
@@ -221,7 +200,7 @@ class BaseClientsGenerator:
                     )
                 status_code_map[status_code] = class_name
                 response_classes.append(class_name)
-        self.http_generator.add_status_codes_to_bundle(func_name=func_name, status_code_map=status_code_map)
+        self.function_and_status_codes_bundle[func_name] = status_code_map
         # Use set to deduplicate, then sorted for consistent ordering
         return sorted(set(response_classes))
 
@@ -267,6 +246,31 @@ class BaseClientsGenerator:
         else:
             return f"schemas.{input_class_names[0]}"
 
+    def get_response_map(self, func_name: str) -> typing.Optional[str]:
+        """
+        Generate response_map for decorator if there are multiple response types.
+        Returns a string representation of the response_map dict or None.
+        """
+        status_codes = self.function_and_status_codes_bundle.get(func_name, {})
+
+        # If there's only one response code, we don't need response_map
+        if len(status_codes) <= 1:
+            return None
+
+        # Filter out None responses (no content responses)
+        valid_responses = {code: schema for code, schema in status_codes.items() if schema != "None"}
+
+        if len(valid_responses) <= 1:
+            return None
+
+        # Build response_map dict with schemas. prefix
+        response_map_parts = []
+        for status_code, schema_name in sorted(valid_responses.items()):
+            # Add schemas. prefix to match the response types
+            response_map_parts.append(f"{status_code}: schemas.{schema_name}")
+
+        return "{" + ", ".join(response_map_parts) + "}"
+
     def generate_function(
         self,
         operation: dict,
@@ -289,13 +293,10 @@ class BaseClientsGenerator:
             parameters=operation.get("parameters", []),
             additional_parameters=additional_parameters,
         )
-        # Replace path parameters in URL with sanitized names
+        # Replace path parameters in URL with sanitized names but DON'T add query args
+        # In the clientele api, query args are passed as function parameters, not in the URL
         api_url = utils.replace_path_parameters(url, function_arguments.param_name_map)
-        if query_args := function_arguments.query_args:
-            # Use original parameter names in URL, but sanitized names for Python variables
-            api_url = api_url + utils.create_query_args_with_mapping(
-                list(query_args.keys()), function_arguments.param_name_map
-            )
+
         if method in ["post", "put", "patch"] and not operation.get("requestBody"):
             data_class_name = None
         elif method in ["post", "put", "patch"]:
@@ -303,7 +304,7 @@ class BaseClientsGenerator:
         else:
             data_class_name = None
         self.results[method] += 1
-        template = self.writer.templates.get_template(self.method_template_map[method])
+        template = writer.templates.get_template(METHOD_TEMPLATE_MAP[method])
         if headers := function_arguments.headers_args:
             header_class_name = self.schemas_generator.generate_headers_class(
                 properties=headers,
@@ -311,10 +312,14 @@ class BaseClientsGenerator:
             )
         else:
             header_class_name = None
+
+        # Get response_map for clientele api decorator
+        response_map = self.get_response_map(func_name)
+
         content = template.render(
             asyncio=self.asyncio,
             func_name=func_name,
-            function_arguments=function_arguments,  # Pass the object, not the string
+            function_arguments=function_arguments,
             response_types=response_types,
             data_class_name=data_class_name,
             header_class_name=header_class_name,
@@ -323,13 +328,14 @@ class BaseClientsGenerator:
             summary=operation.get("summary", summary),
             description=operation.get("description"),
             deprecated=operation.get("deprecated", False),
+            response_map=response_map,
         )
-        self.writer.write_to_client(content=content, output_dir=self.output_dir)
+        writer.write_to_client(content=content, output_dir=self.output_dir)
 
     def write_path_to_client(self, path: tuple[str, dict]) -> None:
         url, operations = path
         for method, operation in operations.items():
-            if method.lower() in self.method_template_map.keys():
+            if method.lower() in METHOD_TEMPLATE_MAP:
                 self.generate_function(
                     operation=operation,
                     method=method,

{clientele-2.2.2 → clientele-2.3.0}/clientele/generators/api/generator.py

@@ -7,18 +7,18 @@ from os import path
 from cicerone.spec import openapi_spec as cicerone_openapi_spec
 from rich import console as rich_console
 
-from clientele import generators, settings, utils
-from clientele.generators.api import writer
-from clientele.generators.api.generators import clients, schemas
+from clientele import generators, settings
+from clientele.generators.api import clients, writer
+from clientele.generators.shared import schemas, utils
 
 console = rich_console.Console()
 
 
 class APIGenerator(generators.Generator):
     """
-    The framework Clientele generator.
+    The API Clientele generator.
 
-    Produces a decorator-based Python HTTP Client library using the clientele framework.
+    Produces a decorator-based Python HTTP Client library using the clientele runtime.
     """
 
     spec: cicerone_openapi_spec.OpenAPISpec
@@ -52,7 +52,7 @@ class APIGenerator(generators.Generator):
         self.output_dir = output_dir
         self.file = file
         self.url = url
-        # Framework generator only needs client, config, and schemas (no http.py)
+        # The api generator only needs client, config, and schemas (no http.py)
         self.file_name_writer_tuple = (
             ("config.py", "config_py.jinja2", writer.write_to_config),
             ("client.py", "client_py.jinja2", writer.write_to_client),
@@ -60,7 +60,6 @@ class APIGenerator(generators.Generator):
         )
 
     def generate_templates_files(self) -> None:
-        new_unions = settings.PY_VERSION[1] > 10
         client_project_directory_path = utils.get_client_project_directory_path(output_dir=self.output_dir)
 
         # Extract base_url from OpenAPI spec servers
@@ -83,7 +82,6 @@ class APIGenerator(generators.Generator):
             template = writer.templates.get_template(client_template_file)
             content = template.render(
                 client_project_directory_path=client_project_directory_path,
-                new_unions=new_unions,
                 base_url=base_url,
             )
             write_func(content, output_dir=self.output_dir)

{clientele-2.2.2 → clientele-2.3.0}/clientele/generators/basic/generator.py

@@ -1,8 +1,9 @@
 import os
 import pathlib
 
-from clientele import generators, settings, utils
+from clientele import generators, settings
 from clientele.generators.basic import writer
+from clientele.generators.shared import utils
 
 
 class BasicGenerator(generators.Generator):

{clientele-2.2.2/clientele/generators/shared/generators → clientele-2.3.0/clientele/generators/shared}/schemas.py

@@ -3,12 +3,49 @@ import typing
 from cicerone.spec import openapi_spec as cicerone_openapi_spec
 from rich import console as rich_console
 
-from clientele.generators import cicerone_compat, schema_utils
+from clientele.generators import cicerone_compat
 from clientele.generators.shared import utils
 
 console = rich_console.Console()
 
 
+def build_union_type_string(
+    schema_options: list[typing.Dict[str, typing.Any]],
+    discriminator: typing.Optional[str] = None,
+) -> str:
+    """
+    Build a union type string from a list of schema options (for oneOf or anyOf).
+
+    Args:
+        schema_options: List of schema option dictionaries from oneOf or anyOf
+        discriminator: Optional discriminator property name for discriminated unions
+
+    Returns:
+        A union type string (e.g., "Cat | Dog" or "typing.Union[Cat, Dog]")
+        When discriminator is provided, returns:
+        "typing.Annotated[Cat | Dog, pydantic.Field(discriminator='type')]"
+    """
+    union_types = []
+    for schema_option in schema_options:
+        if ref := schema_option.get("$ref"):
+            ref_name = utils.class_name_titled(utils.schema_ref(ref))
+            # Use direct reference without quotes for type aliases
+            union_types.append(ref_name)
+        else:
+            # Inline schema - convert to type and remove forward ref quotes
+            type_str = utils.get_type(schema_option)
+            type_str = utils.remove_forward_ref_quotes(type_str)
+            union_types.append(type_str)
+
+    union_str = utils.union_for_py_ver(union_types)
+
+    # Wrap with Annotated + Field(discriminator=...) if discriminator is present
+    if discriminator:
+        return f'typing.Annotated[{union_str}, pydantic.Field(discriminator="{discriminator}")]'
+
+    return union_str
+
+
 class SchemasGenerator:
     """
     Handles all the content generated in the schemas.py file.
@@ -26,8 +63,6 @@ class SchemasGenerator:
         self.output_dir = output_dir
         self.writer = writer
 
-    generated_response_class_names: list[str] = []
-
     def generate_enum_properties(self, properties: dict) -> str:
         lines = [
             f"    {utils.snake_case_prop(arg.upper())} = {utils.get_type(arg_details)}\n"
@@ -112,7 +147,7 @@ class SchemasGenerator:
         schema_options: list[dict],
         discriminator: typing.Optional[str] = None,
     ) -> None:
-        union_type = schema_utils.build_union_type_string(schema_options, discriminator=discriminator)
+        union_type = build_union_type_string(schema_options, discriminator=discriminator)
         template = self.writer.templates.get_template("schema_type_alias.jinja2")
         content = template.render(class_name=schema_key, union_type=union_type)
         self.writer.write_to_schemas(content, output_dir=self.output_dir)