openapi-python-client 0.28.4__py3-none-any.whl → 0.29.1__py3-none-any.whl

openapi_python_client/schema/openapi_schema_pydantic/open_api.py

@@ -1,5 +1,6 @@
 from pydantic import BaseModel, ConfigDict, field_validator
 
+from ..untrusted_string import UntrustedString
 from .components import Components
 from .external_documentation import ExternalDocumentation
 from .info import Info
@@ -26,7 +27,7 @@ class OpenAPI(BaseModel):
     security: list[SecurityRequirement] | None = None
     tags: list[Tag] | None = None
     externalDocs: ExternalDocumentation | None = None
-    openapi: str
+    openapi: UntrustedString
     model_config = ConfigDict(
         # `Components` is not build yet, will rebuild in `__init__.py`:
         defer_build=True,
@@ -35,8 +36,9 @@ class OpenAPI(BaseModel):
 
     @field_validator("openapi")
     @classmethod
-    def check_openapi_version(cls, value: str) -> str:
+    def check_openapi_version(cls, untrusted: UntrustedString) -> UntrustedString:
         """Validates that the declared OpenAPI version is a supported one"""
+        value = untrusted.get_untrusted_value()
         parts = value.split(".")
         if len(parts) != NUM_SEMVER_PARTS:
             raise ValueError(f"Invalid OpenAPI version {value}")
@@ -44,4 +46,4 @@ class OpenAPI(BaseModel):
             raise ValueError(f"Only OpenAPI versions 3.* are supported, got {value}")
         if int(parts[1]) > 1:
             raise ValueError(f"Only OpenAPI versions 3.1.* are supported, got {value}")
-        return value
+        return untrusted

openapi_python_client/schema/openapi_schema_pydantic/operation.py

@@ -1,5 +1,6 @@
 from pydantic import BaseModel, ConfigDict, Field
 
+from ..untrusted_string import UntrustedString
 from .callback import Callback
 from .external_documentation import ExternalDocumentation
 from .parameter import Parameter
@@ -18,15 +19,15 @@ class Operation(BaseModel):
         - https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#operationObject
     """
 
-    tags: list[str] | None = None
-    summary: str | None = None
-    description: str | None = None
+    tags: list[UntrustedString] | None = None
+    summary: UntrustedString | None = None
+    description: UntrustedString | None = None
     externalDocs: ExternalDocumentation | None = None
-    operationId: str | None = None
+    operationId: UntrustedString | None = None
     parameters: list[ReferenceOr[Parameter]] | None = None
     request_body: ReferenceOr[RequestBody] | None = Field(None, alias="requestBody")
     responses: Responses
-    callbacks: dict[str, Callback] | None = None
+    callbacks: dict[UntrustedString, Callback] | None = None
 
     deprecated: bool = False
     security: list[SecurityRequirement] | None = None

openapi_python_client/schema/openapi_schema_pydantic/parameter.py

@@ -3,6 +3,7 @@ from typing import Any
 from pydantic import BaseModel, ConfigDict, Field
 
 from ..parameter_location import ParameterLocation
+from ..untrusted_string import UntrustedString
 from .example import Example
 from .media_type import MediaType
 from .reference import ReferenceOr
@@ -21,19 +22,19 @@ class Parameter(BaseModel):
         - https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#parameterObject
     """
 
-    name: str
+    name: UntrustedString
     param_in: ParameterLocation = Field(alias="in")
-    description: str | None = None
+    description: UntrustedString | None = None
     required: bool = False
     deprecated: bool = False
     allowEmptyValue: bool = False
-    style: str | None = None
+    style: UntrustedString | None = None
     explode: bool = False
     allowReserved: bool = False
     param_schema: ReferenceOr[Schema] | None = Field(default=None, alias="schema")
     example: Any | None = None
-    examples: dict[str, ReferenceOr[Example]] | None = None
-    content: dict[str, MediaType] | None = None
+    examples: dict[UntrustedString, ReferenceOr[Example]] | None = None
+    content: dict[UntrustedString, MediaType] | None = None
     model_config = ConfigDict(
         # `MediaType` is not build yet, will rebuild in `__init__.py`:
         defer_build=True,

openapi_python_client/schema/openapi_schema_pydantic/path_item.py

@@ -2,6 +2,8 @@ from typing import TYPE_CHECKING
 
 from pydantic import BaseModel, ConfigDict, Field
 
+from ..ref import Ref
+from ..untrusted_string import UntrustedString
 from .parameter import Parameter
 from .reference import ReferenceOr
 from .server import Server
@@ -22,9 +24,9 @@ class PathItem(BaseModel):
         - https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#pathItemObject
     """
 
-    ref: str | None = Field(default=None, alias="$ref")
-    summary: str | None = None
-    description: str | None = None
+    ref: Ref | None = Field(default=None, alias="$ref")
+    summary: UntrustedString | None = None
+    description: UntrustedString | None = None
     get: "Operation | None" = None
     put: "Operation | None" = None
     post: "Operation | None" = None

openapi_python_client/schema/openapi_schema_pydantic/paths.py

@@ -1,6 +1,7 @@
+from ..untrusted_string import UntrustedString
 from .path_item import PathItem
 
-Paths = dict[str, PathItem]
+Paths = dict[UntrustedString, PathItem]
 """
 Holds the relative paths to the individual endpoints and their operations.
 The path is appended to the URL from the [`Server Object`](#serverObject) in order to construct the full URL.

openapi_python_client/schema/openapi_schema_pydantic/reference.py

@@ -2,6 +2,8 @@ from typing import Annotated, Any, Literal, TypeAlias, TypeVar
 
 from pydantic import BaseModel, ConfigDict, Discriminator, Field, Tag
 
+from openapi_python_client.schema.ref import Ref
+
 
 class Reference(BaseModel):
     """
@@ -18,7 +20,7 @@ class Reference(BaseModel):
         - https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#referenceObject
     """
 
-    ref: str = Field(alias="$ref")
+    ref: Ref = Field(alias="$ref")
     model_config = ConfigDict(
         extra="allow",
         populate_by_name=True,

openapi_python_client/schema/openapi_schema_pydantic/request_body.py

@@ -1,5 +1,6 @@
 from pydantic import BaseModel, ConfigDict
 
+from ..untrusted_string import UntrustedString
 from .media_type import MediaType
 
 
@@ -11,8 +12,8 @@ class RequestBody(BaseModel):
         - https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#requestBodyObject
     """
 
-    description: str | None = None
-    content: dict[str, MediaType]
+    description: UntrustedString | None = None
+    content: dict[UntrustedString, MediaType]
     required: bool = False
     model_config = ConfigDict(
         # `MediaType` is not build yet, will rebuild in `__init__.py`:

openapi_python_client/schema/openapi_schema_pydantic/response.py

@@ -1,5 +1,6 @@
 from pydantic import BaseModel, ConfigDict
 
+from ..untrusted_string import UntrustedString
 from .header import Header
 from .link import Link
 from .media_type import MediaType
@@ -16,10 +17,10 @@ class Response(BaseModel):
         - https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#responseObject
     """
 
-    description: str
-    headers: dict[str, ReferenceOr[Header]] | None = None
-    content: dict[str, MediaType] | None = None
-    links: dict[str, ReferenceOr[Link]] | None = None
+    description: UntrustedString
+    headers: dict[UntrustedString, ReferenceOr[Header]] | None = None
+    content: dict[UntrustedString, MediaType] | None = None
+    links: dict[UntrustedString, ReferenceOr[Link]] | None = None
     model_config = ConfigDict(
         # `MediaType` is not build yet, will rebuild in `__init__.py`:
         defer_build=True,

openapi_python_client/schema/openapi_schema_pydantic/responses.py

@@ -1,7 +1,8 @@
+from ..untrusted_string import UntrustedString
 from .reference import ReferenceOr
 from .response import Response
 
-Responses = dict[str, ReferenceOr[Response]]
+Responses = dict[UntrustedString, ReferenceOr[Response]]
 """
 A container for the expected responses of an operation.
 The container maps a HTTP response code to the expected response.

openapi_python_client/schema/openapi_schema_pydantic/schema.py

@@ -3,6 +3,7 @@ from typing import Any
 from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictFloat, StrictInt, StrictStr, model_validator
 
 from ..data_type import DataType
+from ..untrusted_string import UntrustedString
 from .discriminator import Discriminator
 from .external_documentation import ExternalDocumentation
 from .reference import ReferenceOr
@@ -20,7 +21,7 @@ class Schema(BaseModel):
         - https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#schemaObject
     """
 
-    title: str | None = None
+    title: UntrustedString | None = None
     multipleOf: float | None = Field(default=None, gt=0.0)
     maximum: float | None = None
     exclusiveMaximum: bool | float | None = None
@@ -28,13 +29,13 @@ class Schema(BaseModel):
     exclusiveMinimum: bool | float | None = None
     maxLength: int | None = Field(default=None, ge=0)
     minLength: int | None = Field(default=None, ge=0)
-    pattern: str | None = None
+    pattern: UntrustedString | None = None
     maxItems: int | None = Field(default=None, ge=0)
     minItems: int | None = Field(default=None, ge=0)
     uniqueItems: bool | None = None
     maxProperties: int | None = Field(default=None, ge=0)
     minProperties: int | None = Field(default=None, ge=0)
-    required: list[str] | None = Field(default=None)
+    required: list[UntrustedString] | None = Field(default=None)
     enum: None | list[Any] = Field(default=None, min_length=1)
     const: None | StrictStr | StrictInt | StrictFloat | StrictBool = None
     type: DataType | list[DataType] | None = Field(default=None)
@@ -44,10 +45,10 @@ class Schema(BaseModel):
     schema_not: ReferenceOr["Schema"] | None = Field(default=None, alias="not")
     items: ReferenceOr["Schema"] | None = None
     prefixItems: list[ReferenceOr["Schema"]] = Field(default_factory=list)
-    properties: dict[str, ReferenceOr["Schema"]] | None = None
+    properties: dict[UntrustedString, ReferenceOr["Schema"]] | None = None
     additionalProperties: bool | ReferenceOr["Schema"] | None = None
-    description: str | None = None
-    schema_format: str | None = Field(default=None, alias="format")
+    description: UntrustedString | None = None
+    schema_format: UntrustedString | None = Field(default=None, alias="format")
     default: Any | None = None
     nullable: bool = Field(default=False)
     discriminator: Discriminator | None = None

openapi_python_client/schema/openapi_schema_pydantic/security_requirement.py

@@ -1,4 +1,6 @@
-SecurityRequirement = dict[str, list[str]]
+from ..untrusted_string import UntrustedString
+
+SecurityRequirement = dict[UntrustedString, list[UntrustedString]]
 """
 Lists the required security schemes to execute this operation.
 The name used for each property MUST correspond to a security scheme declared in the

openapi_python_client/schema/openapi_schema_pydantic/security_scheme.py

@@ -1,5 +1,6 @@
 from pydantic import BaseModel, ConfigDict, Field
 
+from ..untrusted_string import UntrustedString
 from .oauth_flows import OAuthFlows
 
 
@@ -17,14 +18,14 @@ class SecurityScheme(BaseModel):
         - https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#componentsObject
     """
 
-    type: str
-    description: str | None = None
-    name: str | None = None
-    security_scheme_in: str | None = Field(default=None, alias="in")
-    scheme: str | None = None
-    bearerFormat: str | None = None
+    type: UntrustedString
+    description: UntrustedString | None = None
+    name: UntrustedString | None = None
+    security_scheme_in: UntrustedString | None = Field(default=None, alias="in")
+    scheme: UntrustedString | None = None
+    bearerFormat: UntrustedString | None = None
     flows: OAuthFlows | None = None
-    openIdConnectUrl: str | None = None
+    openIdConnectUrl: UntrustedString | None = None
     model_config = ConfigDict(
         extra="allow",
         populate_by_name=True,

openapi_python_client/schema/openapi_schema_pydantic/server.py

@@ -1,5 +1,6 @@
 from pydantic import BaseModel, ConfigDict
 
+from ..untrusted_string import UntrustedString
 from .server_variable import ServerVariable
 
 
@@ -11,9 +12,9 @@ class Server(BaseModel):
         - https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#serverObject
     """
 
-    url: str
-    description: str | None = None
-    variables: dict[str, ServerVariable] | None = None
+    url: UntrustedString
+    description: UntrustedString | None = None
+    variables: dict[UntrustedString, ServerVariable] | None = None
     model_config = ConfigDict(
         extra="allow",
         json_schema_extra={

openapi_python_client/schema/openapi_schema_pydantic/server_variable.py

@@ -1,5 +1,7 @@
 from pydantic import BaseModel, ConfigDict
 
+from ..untrusted_string import UntrustedString
+
 
 class ServerVariable(BaseModel):
     """An object representing a Server Variable for server URL template substitution.
@@ -9,7 +11,7 @@ class ServerVariable(BaseModel):
         - https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#serverVariableObject
     """
 
-    enum: list[str] | None = None
-    default: str
-    description: str | None = None
+    enum: list[UntrustedString] | None = None
+    default: UntrustedString
+    description: UntrustedString | None = None
     model_config = ConfigDict(extra="allow")

openapi_python_client/schema/openapi_schema_pydantic/tag.py

@@ -1,5 +1,6 @@
 from pydantic import BaseModel, ConfigDict
 
+from ..untrusted_string import UntrustedString
 from .external_documentation import ExternalDocumentation
 
 
@@ -13,8 +14,8 @@ class Tag(BaseModel):
         - https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#tagObject
     """
 
-    name: str
-    description: str | None = None
+    name: UntrustedString
+    description: UntrustedString | None = None
     externalDocs: ExternalDocumentation | None = None
     model_config = ConfigDict(
         extra="allow", json_schema_extra={"examples": [{"name": "pet", "description": "Pets operations"}]}

openapi_python_client/schema/openapi_schema_pydantic/xml.py

@@ -1,5 +1,7 @@
 from pydantic import BaseModel, ConfigDict
 
+from ..untrusted_string import UntrustedString
+
 
 class XML(BaseModel):
     """
@@ -14,9 +16,9 @@ class XML(BaseModel):
         - https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#xmlObject
     """
 
-    name: str | None = None
-    namespace: str | None = None
-    prefix: str | None = None
+    name: UntrustedString | None = None
+    namespace: UntrustedString | None = None
+    prefix: UntrustedString | None = None
     attribute: bool = False
     wrapped: bool = False
     model_config = ConfigDict(

openapi_python_client/schema/parameter_location.py

@@ -1,25 +1,10 @@
-# Python 3.11 has StrEnum but breaks the old `str, Enum` hack.
-# Unless this gets fixed, we need to have two implementations :(
-import sys
+from enum import StrEnum
 
-if sys.version_info >= (3, 11):
-    from enum import StrEnum
 
-    class ParameterLocation(StrEnum):
-        """The places Parameters can be put when calling an Endpoint"""
+class ParameterLocation(StrEnum):
+    """The places Parameters can be put when calling an Endpoint"""
 
-        QUERY = "query"
-        PATH = "path"
-        HEADER = "header"
-        COOKIE = "cookie"
-
-else:
-    from enum import Enum
-
-    class ParameterLocation(str, Enum):
-        """The places Parameters can be put when calling an Endpoint"""
-
-        QUERY = "query"
-        PATH = "path"
-        HEADER = "header"
-        COOKIE = "cookie"
+    QUERY = "query"
+    PATH = "path"
+    HEADER = "header"
+    COOKIE = "cookie"

openapi_python_client/schema/ref.py

@@ -0,0 +1,52 @@
+from typing import Any
+
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import core_schema
+
+from .untrusted_string import UntrustedString
+
+
+class Ref:
+    """A $ref in the schema, the raw value is protected to make sure we don't accidentally place it in the generated code."""
+
+    def __init__(self, value: str | UntrustedString) -> None:
+        if isinstance(value, UntrustedString):
+            value = value.get_untrusted_value()
+        self._value = value
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source_type: Any, _handler: GetCoreSchemaHandler) -> core_schema.CoreSchema:
+        return core_schema.no_info_after_validator_function(
+            cls,
+            core_schema.str_schema(),
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                cls._serialize, info_arg=True, return_schema=core_schema.any_schema()
+            ),
+        )
+
+    @staticmethod
+    def _serialize(value: "Ref", info: core_schema.SerializationInfo) -> Any:
+        # Only unwrap in JSON mode (used for error messages); Python mode keeps the wrapper so it
+        # can't leak into generated code. Returning the wrapper also avoids serializer warnings.
+        if info.mode == "json":
+            return value.get_untrusted_value()
+        return value
+
+    def get_untrusted_value(self) -> str:
+        """
+        Get the raw $ref value.
+
+        DO NOT place this in generated code.
+        """
+        return self._value
+
+    def endswith(self, suffix: str) -> bool:
+        return self._value.endswith(suffix)
+
+    def __hash__(self) -> int:
+        return hash(self._value)
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, Ref):
+            return self._value == other._value
+        return False  # pragma: no cover

openapi_python_client/schema/untrusted_string.py

@@ -0,0 +1,56 @@
+from typing import Any, TypeVar
+
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import CoreSchema, core_schema
+
+T = TypeVar("T")
+
+
+class UntrustedString:
+    """A raw string in the OpenAPI document which should not be directly placed in the generated code."""
+
+    def __init__(self, value: str) -> None:
+        self._value = value
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source_type: Any, _handler: GetCoreSchemaHandler) -> CoreSchema:
+        return core_schema.no_info_after_validator_function(
+            cls,
+            core_schema.str_schema(),
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                cls._serialize, info_arg=True, return_schema=core_schema.any_schema()
+            ),
+        )
+
+    @staticmethod
+    def _serialize(value: "UntrustedString", info: core_schema.SerializationInfo) -> Any:
+        # Only unwrap in JSON mode (used for error messages); Python mode keeps the wrapper so it
+        # can't leak into generated code. Returning the wrapper also avoids serializer warnings.
+        if info.mode == "json":
+            return value.get_untrusted_value()
+        return value
+
+    def get_untrusted_value(self) -> str:
+        """
+        Return the raw string with no transformations.
+
+        DO NOT use this for generating code directly. It can result in arbitrary code generation.
+        """
+        return self._value
+
+    def startswith(self, prefix: str) -> bool:
+        return self._value.startswith(prefix)
+
+    def __bool__(self) -> bool:
+        """Whether the raw value is non-empty. Emptiness is not sensitive, so this is safe to expose."""
+        return bool(self._value)
+
+    def __hash__(self) -> int:
+        return hash(self._value)
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, UntrustedString):
+            return self._value == other._value
+        if isinstance(other, str):
+            return self._value == other
+        return False