openapi-python-client 0.29.0__tar.gz → 0.29.1__tar.gz

{openapi_python_client-0.29.0 → openapi_python_client-0.29.1}/.gitignore

@@ -34,7 +34,5 @@ test-reports/
 htmlcov/
 
 # Generated end to end test data
-my-test-api-client/
-custom-e2e/
-3-1-features-client
-tests/tmp
+tests/tmp
+end_to_end_tests/tmp/*

{openapi_python_client-0.29.0 → openapi_python_client-0.29.1}/PKG-INFO

@@ -1,15 +1,14 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: openapi-python-client
-Version: 0.29.0
+Version: 0.29.1
 Summary: Generate modern Python clients from OpenAPI
 Project-URL: repository, https://github.com/openapi-generators/openapi-python-client
 Author-email: Dylan Anthony <contact@dylananthony.com>
-License: MIT
+License-Expression: MIT
 License-File: LICENSE
 Keywords: Client,Generator,OpenAPI
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -26,7 +25,7 @@ Requires-Dist: pydantic<3.0.0,>=2.10
 Requires-Dist: ruamel-yaml<0.20.0,>=0.18.6
 Requires-Dist: ruff>=0.2
 Requires-Dist: shellingham<2.0.0,>=1.3.2
-Requires-Dist: typer<0.27,>0.16
+Requires-Dist: typer<0.28,>0.16
 Description-Content-Type: text/markdown
 
 ![Run Checks](https://github.com/openapi-generators/openapi-python-client/workflows/Run%20Checks/badge.svg)

{openapi_python_client-0.29.0 → openapi_python_client-0.29.1}/openapi_python_client/__init__.py

@@ -4,7 +4,7 @@ import json
 import mimetypes
 import shutil
 import subprocess
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from importlib.metadata import version
 from pathlib import Path
 from subprocess import CalledProcessError
@@ -16,7 +16,7 @@ from jinja2 import BaseLoader, ChoiceLoader, Environment, FileSystemLoader, Pack
 from ruamel.yaml import YAML
 from ruamel.yaml.error import YAMLError
 
-from openapi_python_client import utils
+from openapi_python_client import strings
 
 from .config import Config, MetaType
 from .parser import GeneratorData, import_string_from_class
@@ -25,11 +25,16 @@ from .parser.properties import LiteralEnumProperty
 
 __version__ = version(__package__)
 
+from .schema.untrusted_string import UntrustedString
 
-TEMPLATE_FILTERS = {
-    "snakecase": utils.snake_case,
-    "kebabcase": utils.kebab_case,
-    "pascalcase": utils.pascal_case,
+TEMPLATE_FILTERS: dict[str, Callable[..., object]] = {
+    "snakecase": strings.snake_case,
+    "kebabcase": strings.kebab_case,
+    "pascalcase": strings.pascal_case,
+    "safe_for_docstring": strings.safe_for_docstring,
+    "in_double_quote_literal": strings.in_double_quote_literal,
+    "in_f_string_literal": strings.in_f_string_literal,
+    "as_unembedded_code": strings.PythonCode.as_unembedded_code,
     "any": any,
 }
 
@@ -66,14 +71,14 @@ class Project:
             keep_trailing_newline=True,
         )
 
-        self.project_name: str = config.project_name_override or f"{utils.kebab_case(openapi.title).lower()}-client"
+        self.project_name: str = config.project_name_override or f"{strings.kebab_case(openapi.title).lower()}-client"
         self.package_name: str = config.package_name_override or self.project_name.replace("-", "_")
         self.project_dir: Path  # Where the generated code will be placed
         self.package_dir: Path  # Where the generated Python module will be placed (same as project_dir if no meta)
 
         if config.output_path is not None:
             self.project_dir = config.output_path
-        elif config.meta_type == MetaType.NONE:
+        elif config.meta_type == MetaType.NONE:  # pragma: no cover
             self.project_dir = Path.cwd() / self.package_name
         else:
             self.project_dir = Path.cwd() / self.project_name
@@ -83,17 +88,20 @@ class Project:
         else:
             self.package_dir = self.project_dir / self.package_name
 
-        self.package_description: str = utils.remove_string_escapes(
-            f"A client library for accessing {self.openapi.title}"
+        self.package_description = UntrustedString(
+            f"A client library for accessing {self.openapi.title.get_untrusted_value()}"
+        )
+        self.version: UntrustedString = (
+            UntrustedString(config.package_version_override) if config.package_version_override else openapi.version
         )
-        self.version: str = config.package_version_override or openapi.version
 
         self.env.filters.update(TEMPLATE_FILTERS)
         self.env.globals.update(
             config=config,
-            utils=utils,
-            python_identifier=lambda x: utils.PythonIdentifier(x, config.field_prefix),
-            class_name=lambda x: utils.ClassName(x, config.field_prefix),
+            strings=strings,
+            PythonCode=strings.PythonCode,
+            python_identifier=lambda x: strings.PythonIdentifier(x, config.field_prefix),
+            class_name=lambda x: strings.ClassName(x, config.field_prefix),
             package_name=self.package_name,
             package_dir=self.package_dir,
             package_description=self.package_description,
@@ -110,7 +118,7 @@ class Project:
 
         print(f"Generating {self.project_dir}")
         try:
-            self.project_dir.mkdir()
+            self.project_dir.mkdir(parents=True)
         except FileExistsError:
             if not self.config.overwrite:
                 return [GeneratorError(detail="Directory already exists. Delete it or use the --overwrite option.")]
@@ -267,7 +275,8 @@ class Project:
 
         endpoint_collections_by_tag = self.openapi.endpoint_collections_by_tag
         endpoint_template = self.env.get_template(
-            "endpoint_module.py.jinja", globals={"isbool": lambda obj: obj.get_base_type_string() == "bool"}
+            "endpoint_module.py.jinja",
+            globals={"isbool": lambda obj: obj.get_base_type_string() == strings.PythonCode("bool")},
         )
         for tag, collection in endpoint_collections_by_tag.items():
             tag_dir = api_dir / tag
@@ -281,7 +290,7 @@ class Project:
             )
 
             for endpoint in collection.endpoints:
-                module_path = tag_dir / f"{utils.PythonIdentifier(endpoint.name, self.config.field_prefix)}.py"
+                module_path = tag_dir / f"{strings.PythonIdentifier(endpoint.name, self.config.field_prefix)}.py"
                 module_path.write_text(
                     endpoint_template.render(
                         endpoint=endpoint,

{openapi_python_client-0.29.0 → openapi_python_client-0.29.1}/openapi_python_client/cli.py

@@ -1,7 +1,6 @@
 import codecs
 from collections.abc import Sequence
 from pathlib import Path
-from pprint import pformat
 
 import typer
 
@@ -75,7 +74,7 @@ def _print_parser_error(err: GeneratorError, color: str) -> None:
         typer.echo(err=True)
 
     if isinstance(err, ParseError) and err.data is not None:
-        formatted_data = pformat(err.data)
+        formatted_data = err.data.model_dump_json(indent=2, exclude_unset=True, by_alias=True)
         typer.secho(formatted_data, fg=color, err=True)
 
     typer.echo(err=True)

{openapi_python_client-0.29.0 → openapi_python_client-0.29.1}/openapi_python_client/config.py

@@ -7,6 +7,8 @@ from attr import define
 from pydantic import BaseModel
 from ruamel.yaml import YAML
 
+from openapi_python_client.schema.untrusted_string import UntrustedString
+
 
 class ClassOverride(BaseModel):
     """An override of a single generated class.
@@ -14,7 +16,7 @@ class ClassOverride(BaseModel):
     See https://github.com/openapi-generators/openapi-python-client#class_overrides
     """
 
-    class_name: str | None = None
+    class_name: UntrustedString | None = None
     module_name: str | None = None
 
 

{openapi_python_client-0.29.0 → openapi_python_client-0.29.1}/openapi_python_client/parser/bodies.py

@@ -12,7 +12,8 @@ from openapi_python_client.parser.properties.schemas import get_reference_simple
 
 from .. import schema as oai
 from ..config import Config
-from ..utils import get_content_type
+from ..schema.untrusted_string import UntrustedString
+from ..strings import get_content_type
 from .errors import ErrorLevel, ParseError
 
 
@@ -25,7 +26,7 @@ class BodyType(StrEnum):
 
 @attr.define
 class Body:
-    content_type: str
+    content_type: UntrustedString
     prop: Property
     body_type: BodyType
 
@@ -34,7 +35,7 @@ def body_from_data(
     *,
     data: oai.Operation,
     schemas: Schemas,
-    request_bodies: dict[str, oai.RequestBody | oai.Reference],
+    request_bodies: dict[UntrustedString, oai.RequestBody | oai.Reference],
     config: Config,
     endpoint_name: str,
 ) -> tuple[list[Body | ParseError], Schemas]:
@@ -50,7 +51,7 @@ def body_from_data(
     prefix_type_names = len(body_content) > 1
 
     for content_type, media_type in body_content.items():
-        simplified_content_type = get_content_type(content_type, config)
+        simplified_content_type = get_content_type(content_type.get_untrusted_value(), config)
         if simplified_content_type is None:
             bodies.append(
                 ParseError(
@@ -88,7 +89,7 @@ def body_from_data(
             )
             continue
         prop, schemas = property_from_data(
-            name="body",
+            name=UntrustedString("body"),
             required=body.required,
             data=media_type_schema,
             schemas=schemas,
@@ -121,7 +122,7 @@ def body_from_data(
 
 
 def _resolve_reference(
-    body: oai.RequestBody | oai.Reference | None, request_bodies: dict[str, oai.RequestBody | oai.Reference]
+    body: oai.RequestBody | oai.Reference | None, request_bodies: dict[UntrustedString, oai.RequestBody | oai.Reference]
 ) -> oai.RequestBody | ParseError | None:
     if body is None:
         return None
@@ -132,5 +133,5 @@ def _resolve_reference(
     if isinstance(body, oai.Reference):
         return ParseError(detail="Circular $ref in request body", data=body)
     if body is None and references_seen:
-        return ParseError(detail=f"Could not resolve $ref {references_seen[-1]} in request body")
+        return ParseError(detail=f"Could not resolve $ref {references_seen[-1].get_untrusted_value()} in request body")
     return body

{openapi_python_client-0.29.0 → openapi_python_client-0.29.1}/openapi_python_client/parser/openapi.py

@@ -7,9 +7,10 @@ from typing import Any, Protocol
 from pydantic import ValidationError
 
 from .. import schema as oai
-from .. import utils
+from .. import strings
 from ..config import Config
-from ..utils import PythonIdentifier
+from ..schema.untrusted_string import UntrustedString
+from ..strings import PythonIdentifier
 from .bodies import Body, body_from_data
 from .errors import GeneratorError, ParseError, PropertyError
 from .properties import (
@@ -46,15 +47,15 @@ class EndpointCollection:
     @staticmethod
     def from_data(
         *,
-        data: dict[str, oai.PathItem],
+        data: dict[UntrustedString, oai.PathItem],
         schemas: Schemas,
         parameters: Parameters,
-        request_bodies: dict[str, oai.RequestBody | oai.Reference],
-        responses: dict[str, oai.Response | oai.Reference],
+        request_bodies: dict[UntrustedString, oai.RequestBody | oai.Reference],
+        responses: dict[UntrustedString, oai.Response | oai.Reference],
         config: Config,
-    ) -> tuple[dict[utils.PythonIdentifier, "EndpointCollection"], Schemas, Parameters]:
+    ) -> tuple[dict[strings.PythonIdentifier, "EndpointCollection"], Schemas, Parameters]:
         """Parse the openapi paths data to get EndpointCollections by tag"""
-        endpoints_by_tag: dict[utils.PythonIdentifier, EndpointCollection] = {}
+        endpoints_by_tag: dict[strings.PythonIdentifier, EndpointCollection] = {}
 
         methods = ["get", "put", "post", "delete", "options", "head", "patch", "trace"]
 
@@ -64,7 +65,10 @@ class EndpointCollection:
                 if operation is None:
                     continue
 
-                tags = [utils.PythonIdentifier(value=tag, prefix="tag") for tag in operation.tags or ["default"]]
+                tags = [
+                    strings.PythonIdentifier(value=tag, prefix="tag")
+                    for tag in operation.tags or [UntrustedString("default")]
+                ]
                 if not config.generate_all_tags:
                     tags = tags[:1]
 
@@ -93,12 +97,14 @@ class EndpointCollection:
                 if not isinstance(endpoint, ParseError):
                     endpoint = Endpoint.sort_parameters(endpoint=endpoint)
                 if isinstance(endpoint, ParseError):
-                    endpoint.header = f"WARNING parsing {method.upper()} {path} within {'/'.join(tags)}. Endpoint will not be generated."
+                    endpoint.header = f"WARNING parsing {method.upper()} {path.get_untrusted_value()} within {'/'.join(tags)}. Endpoint will not be generated."
                     for collection in collections:
                         collection.parse_errors.append(endpoint)
                     continue
                 for error in endpoint.errors:
-                    error.header = f"WARNING parsing {method.upper()} {path} within {'/'.join(tags)}."
+                    error.header = (
+                        f"WARNING parsing {method.upper()} {path.get_untrusted_value()} within {'/'.join(tags)}."
+                    )
                     for collection in collections:
                         collection.parse_errors.append(error)
                 for collection in collections:
@@ -107,14 +113,14 @@ class EndpointCollection:
         return endpoints_by_tag, schemas, parameters
 
 
-def generate_operation_id(*, path: str, method: str) -> str:
+def generate_operation_id(*, path: UntrustedString, method: str, prefix: str) -> PythonIdentifier:
     """Generate an operationId from a path"""
-    clean_path = path.replace("{", "").replace("}", "").replace("/", "_")
-    if clean_path.startswith("_"):
-        clean_path = clean_path[1:]
-    if clean_path.endswith("_"):
-        clean_path = clean_path[:-1]
-    return f"{method}_{clean_path}"
+    unsafe_id = path.get_untrusted_value().replace("{", "").replace("}", "").replace("/", "_")
+    if unsafe_id.startswith("_"):
+        unsafe_id = unsafe_id[1:]
+    if unsafe_id.endswith("_"):  # pragma: no cover
+        unsafe_id = unsafe_id[:-1]
+    return PythonIdentifier(f"{method}_{unsafe_id}", prefix=prefix)
 
 
 models_relative_prefix: str = "..."
@@ -134,13 +140,13 @@ class Endpoint:
     Describes a single endpoint on the server
     """
 
-    path: str
+    path: UntrustedString
     method: str
-    description: str | None
-    name: str
+    description: UntrustedString
+    name: PythonIdentifier
     requires_security: bool
     tags: list[PythonIdentifier]
-    summary: str | None = ""
+    summary: UntrustedString
     relative_imports: set[str] = field(default_factory=set)
     query_parameters: list[Property] = field(default_factory=list)
     path_parameters: list[Property] = field(default_factory=list)
@@ -156,7 +162,7 @@ class Endpoint:
         endpoint: "Endpoint",
         data: oai.Responses,
         schemas: Schemas,
-        responses: dict[str, oai.Response | oai.Reference],
+        responses: dict[UntrustedString, oai.Response | oai.Reference],
         config: Config,
     ) -> tuple["Endpoint", Schemas]:
         endpoint = deepcopy(endpoint)
@@ -234,7 +240,7 @@ class Endpoint:
 
         endpoint = deepcopy(endpoint)
 
-        unique_parameters: set[tuple[str, oai.ParameterLocation]] = set()
+        unique_parameters: set[tuple[UntrustedString, oai.ParameterLocation]] = set()
         parameters_by_location: dict[str, list[Property]] = {
             oai.ParameterLocation.QUERY: endpoint.query_parameters,
             oai.ParameterLocation.PATH: endpoint.path_parameters,
@@ -260,7 +266,7 @@ class Endpoint:
                         detail=(
                             "Parameters MUST NOT contain duplicates. "
                             "A unique parameter is defined by a combination of a name and location. "
-                            f"Duplicated parameters named `{param.name}` detected in `{param.param_in}`."
+                            f"Duplicated parameters named `{param.name.get_untrusted_value()}` detected in `{param.param_in}`."
                         ),
                     ),
                     schemas,
@@ -312,7 +318,7 @@ class Endpoint:
         self,
         *,
         config: Config,
-        previously_modified_params: set[tuple[oai.ParameterLocation, str]] | None = None,
+        previously_modified_params: set[tuple[oai.ParameterLocation, UntrustedString]] | None = None,
     ) -> "Endpoint | ParseError":
         """Check for conflicting parameters
 
@@ -330,7 +336,7 @@ class Endpoint:
             location, prop = parameter
 
             if prop.python_name in reserved_names:
-                prop.set_python_name(new_name=f"{prop.python_name}_{location}", config=config)
+                prop.set_python_name(new_name=UntrustedString(f"{prop.python_name}_{location}"), config=config)
                 modified_params.add((location, prop.name))
                 continue
 
@@ -349,9 +355,9 @@ class Endpoint:
 
             if location != conflicting_location:
                 conflicting_prop.set_python_name(
-                    new_name=f"{conflicting_prop.python_name}_{conflicting_location}", config=config
+                    new_name=UntrustedString(f"{conflicting_prop.python_name}_{conflicting_location}"), config=config
                 )
-                prop.set_python_name(new_name=f"{prop.python_name}_{location}", config=config)
+                prop.set_python_name(new_name=UntrustedString(f"{prop.python_name}_{location}"), config=config)
             elif conflicting_prop.name != prop.name:  # Use the name to differentiate
                 conflicting_prop.set_python_name(new_name=conflicting_prop.name, config=config, skip_snake_case=True)
                 prop.set_python_name(new_name=prop.name, config=config, skip_snake_case=True)
@@ -378,7 +384,7 @@ class Endpoint:
                 the path parameters and they could not be sorted.
         """
         endpoint = deepcopy(endpoint)
-        parameters_from_path = re.findall(_PATH_PARAM_REGEX, endpoint.path)
+        parameters_from_path = re.findall(_PATH_PARAM_REGEX, endpoint.path.get_untrusted_value())
         try:
             endpoint.path_parameters.sort(
                 key=lambda param: parameters_from_path.index(param.name),
@@ -388,37 +394,41 @@ class Endpoint:
 
         if parameters_from_path != [param.name for param in endpoint.path_parameters]:
             return ParseError(
-                detail=f"Incorrect path templating for {endpoint.path} (Path parameters do not match with path)",
+                detail=f"Incorrect path templating for {endpoint.path.get_untrusted_value()} (Path parameters do not match with path)",
             )
         for parameter in endpoint.path_parameters:
-            endpoint.path = endpoint.path.replace(f"{{{parameter.name}}}", f"{{{parameter.python_name}}}")
+            endpoint.path = UntrustedString(
+                endpoint.path.get_untrusted_value().replace(
+                    f"{{{parameter.name.get_untrusted_value()}}}", f"{{{parameter.python_name}}}"
+                )
+            )
         return endpoint
 
     @staticmethod
     def from_data(
         *,
         data: oai.Operation,
-        path: str,
+        path: UntrustedString,
         method: str,
         tags: list[PythonIdentifier],
         schemas: Schemas,
         parameters: Parameters,
-        request_bodies: dict[str, oai.RequestBody | oai.Reference],
-        responses: dict[str, oai.Response | oai.Reference],
+        request_bodies: dict[UntrustedString, oai.RequestBody | oai.Reference],
+        responses: dict[UntrustedString, oai.Response | oai.Reference],
         config: Config,
     ) -> tuple["Endpoint | ParseError", Schemas, Parameters]:
         """Construct an endpoint from the OpenAPI data"""
 
         if data.operationId is None:
-            name = generate_operation_id(path=path, method=method)
+            name = generate_operation_id(path=path, method=method, prefix=config.field_prefix)
         else:
-            name = data.operationId
+            name = PythonIdentifier(data.operationId, prefix=config.field_prefix)
 
         endpoint = Endpoint(
             path=path,
             method=method,
-            summary=utils.remove_string_escapes(data.summary) if data.summary else "",
-            description=utils.remove_string_escapes(data.description) if data.description else "",
+            summary=data.summary if data.summary else UntrustedString(""),
+            description=data.description if data.description else UntrustedString(""),
             name=name,
             requires_security=bool(data.security),
             tags=tags,
@@ -440,7 +450,7 @@ class Endpoint:
             responses=responses,
             config=config,
         )
-        if isinstance(result, ParseError):
+        if isinstance(result, ParseError):  # pragma: no cover
             return result, schemas, parameters
         bodies, schemas = body_from_data(
             data=data, schemas=schemas, config=config, endpoint_name=result.name, request_bodies=request_bodies
@@ -467,14 +477,14 @@ class Endpoint:
 
         return result, schemas, parameters
 
-    def response_type(self) -> str:
+    def response_type(self) -> strings.PythonCode:
         """Get the Python type of any response from this endpoint"""
-        types = sorted({response.prop.get_type_string() for response in self.responses})
+        types = sorted({response.prop.get_type_string().as_unembedded_code() for response in self.responses})
         if len(types) == 0:
-            return "Any"
+            return strings.PythonCode("Any")
         if len(types) == 1:
-            return types[0]
-        return " | ".join(types)
+            return strings.PythonCode(types[0])
+        return strings.PythonCode(" | ".join(types))
 
     def iter_all_parameters(self) -> Iterator[tuple[oai.ParameterLocation, Property]]:
         """Iterate through all the parameters of this endpoint"""
@@ -498,12 +508,12 @@ class Endpoint:
 class GeneratorData:
     """All the data needed to generate a client"""
 
-    title: str
-    description: str | None
-    version: str
+    title: UntrustedString
+    description: UntrustedString | None
+    version: UntrustedString
     models: list[ModelProperty]
     errors: list[ParseError]
-    endpoint_collections_by_tag: dict[utils.PythonIdentifier, EndpointCollection]
+    endpoint_collections_by_tag: dict[strings.PythonIdentifier, EndpointCollection]
     enums: list[EnumProperty | LiteralEnumProperty]
 
     @staticmethod