python-openapi 0.1.10__py3-none-any.whl → 0.3.0__py3-none-any.whl

pyopenapi/operations.py

@@ -1,17 +1,26 @@
+"""
+Generate an OpenAPI specification from a Python class definition
+
+Copyright 2021-2026, Levente Hunyadi
+
+:see: https://github.com/hunyadi/pyopenapi
+"""
+
 import collections.abc
 import enum
 import inspect
 import typing
 import uuid
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, Iterable, Iterator, List, Optional, Tuple, Union
+from types import NoneType
+from typing import Any, Callable, Iterable, Iterator
 
 from strong_typing.inspection import get_signature, is_type_enum, is_type_optional, unwrap_optional_type
 
 from .metadata import WebMethod
 
 
-def split_prefix(s: str, sep: str, prefix: Union[str, Iterable[str]]) -> Tuple[Optional[str], str]:
+def split_prefix(s: str, sep: str, prefix: str | Iterable[str]) -> tuple[str | None, str]:
     """
     Recognizes a prefix at the beginning of a string.
 
@@ -34,11 +43,11 @@ def split_prefix(s: str, sep: str, prefix: Union[str, Iterable[str]]) -> Tuple[O
     return None, s
 
 
-def _get_annotation_type(annotation: Union[type, str], callable: Callable) -> type:
-    "Maps a stringized reference to a type, as if using `from __future__ import annotations`."
+def _get_annotation_type(annotation: type[Any] | str, callable: Callable[..., Any]) -> type[Any]:
+    "Maps a string (forward) reference to a type, as if using `from __future__ import annotations`."
 
     if isinstance(annotation, str):
-        return eval(annotation, callable.__globals__)
+        return typing.cast(type[Any], eval(annotation, callable.__globals__))
     else:
         return annotation
 
@@ -54,7 +63,7 @@ class HTTPMethod(enum.Enum):
     PATCH = "PATCH"
 
 
-OperationParameter = Tuple[str, type]
+OperationParameter = tuple[str, type[Any]]
 
 
 class ValidationError(TypeError):
@@ -66,7 +75,7 @@ class EndpointOperation:
     """
     Type information and metadata associated with an endpoint operation.
 
-    "param defining_class: The most specific class that defines the endpoint operation.
+    :param defining_class: The most specific class that defines the endpoint operation.
     :param name: The short name of the endpoint operation.
     :param func_name: The name of the function to invoke when the operation is triggered.
     :param func_ref: The callable to invoke when the operation is triggered.
@@ -78,24 +87,26 @@ class EndpointOperation:
     :param response_type: The Python type of the data that is transmitted in the response body.
     :param http_method: The HTTP method used to invoke the endpoint such as POST, GET or PUT.
     :param public: True if the operation can be invoked without prior authentication.
+    :param deprecated: True if consumers should refrain from using the operation.
     :param request_examples: Sample requests that the operation might take.
     :param response_examples: Sample responses that the operation might produce.
     """
 
-    defining_class: type
+    defining_class: type[Any]
     name: str
     func_name: str
     func_ref: Callable[..., Any]
-    route: Optional[str]
-    path_params: List[OperationParameter]
-    query_params: List[OperationParameter]
-    request_param: Optional[OperationParameter]
-    event_type: Optional[type]
-    response_type: type
+    route: str | None
+    path_params: list[OperationParameter]
+    query_params: list[OperationParameter]
+    request_param: OperationParameter | None
+    event_type: type[Any] | None
+    response_type: type[Any]
     http_method: HTTPMethod
     public: bool
-    request_examples: Optional[List[Any]] = None
-    response_examples: Optional[List[Any]] = None
+    deprecated: bool
+    request_examples: list[Any] | None = None
+    response_examples: list[Any] | None = None
 
     def get_route(self) -> str:
         if self.route is not None:
@@ -108,9 +119,9 @@ class EndpointOperation:
 
 
 class _FormatParameterExtractor:
-    "A visitor to exract parameters in a format string."
+    "A visitor to extract parameters in a format string."
 
-    keys: List[str]
+    keys: list[str]
 
     def __init__(self) -> None:
         self.keys = []
@@ -120,13 +131,13 @@ class _FormatParameterExtractor:
         return None
 
 
-def _get_route_parameters(route: str) -> List[str]:
+def _get_route_parameters(route: str) -> list[str]:
     extractor = _FormatParameterExtractor()
     route.format_map(extractor)
     return extractor.keys
 
 
-def _get_endpoint_functions(endpoint: type, prefixes: List[str]) -> Iterator[Tuple[str, str, str, Callable]]:
+def _get_endpoint_functions(endpoint: type[Any], prefixes: list[str]) -> Iterator[tuple[str, str, str, Callable[..., Any]]]:
     if not inspect.isclass(endpoint):
         raise ValidationError(f"object is not a class type: {endpoint}")
 
@@ -139,7 +150,7 @@ def _get_endpoint_functions(endpoint: type, prefixes: List[str]) -> Iterator[Tup
         yield prefix, operation_name, func_name, func_ref
 
 
-def _get_defining_class(member_fn: str, derived_cls: type) -> type:
+def _get_defining_class(member_fn: str, derived_cls: type[Any]) -> type[Any]:
     "Find the class in which a member function is first defined in a class inheritance hierarchy."
 
     # iterate in reverse member resolution order to find most specific class first
@@ -151,7 +162,7 @@ def _get_defining_class(member_fn: str, derived_cls: type) -> type:
     raise ValidationError(f"cannot find defining class for {member_fn} in {derived_cls}")
 
 
-def get_endpoint_operations(endpoint: type, use_examples: bool = True) -> List[EndpointOperation]:
+def get_endpoint_operations(endpoint: type[Any], use_examples: bool = True) -> list[EndpointOperation]:
     """
     Extracts a list of member functions in a class eligible for HTTP interface binding.
 
@@ -171,7 +182,7 @@ def get_endpoint_operations(endpoint: type, use_examples: bool = True) -> List[E
     :param use_examples: Whether to return examples associated with member functions.
     """
 
-    result = []
+    result: list[EndpointOperation] = []
 
     for prefix, operation_name, func_name, func_ref in _get_endpoint_functions(
         endpoint,
@@ -188,25 +199,27 @@ def get_endpoint_operations(endpoint: type, use_examples: bool = True) -> List[E
         ],
     ):
         # extract routing information from function metadata
-        webmethod: Optional[WebMethod] = getattr(func_ref, "__webmethod__", None)
+        webmethod: WebMethod | None = getattr(func_ref, "__webmethod__", None)
         if webmethod is not None:
             route = webmethod.route
             route_params = _get_route_parameters(route) if route is not None else None
             public = webmethod.public
+            deprecated = webmethod.deprecated
             request_examples = webmethod.request_examples
             response_examples = webmethod.response_examples
         else:
             route = None
             route_params = None
             public = False
+            deprecated = False
             request_examples = None
             response_examples = None
 
         # inspect function signature for path and query parameters, and request/response payload type
         signature = get_signature(func_ref)
 
-        path_params = []
-        query_params = []
+        path_params: list[tuple[str, type[Any]]] = []
+        query_params: list[tuple[str, type[Any]]] = []
         request_param = None
 
         for param_name, parameter in signature.parameters.items():
@@ -221,7 +234,7 @@ def get_endpoint_operations(endpoint: type, use_examples: bool = True) -> List[E
                 raise ValidationError(f"parameter '{param_name}' in function '{func_name}' has no type annotation")
 
             if is_type_optional(param_type):
-                inner_type: type = unwrap_optional_type(param_type)
+                inner_type: type[Any] = unwrap_optional_type(param_type)
             else:
                 inner_type = param_type
 
@@ -247,7 +260,8 @@ def get_endpoint_operations(endpoint: type, use_examples: bool = True) -> List[E
                 if request_param is not None:
                     param = (param_name, param_type)
                     raise ValidationError(
-                        f"only a single composite type is permitted in a signature but multiple composite types found in function '{func_name}': {request_param} and {param}"
+                        f"only a single composite type is permitted in a signature but multiple composite types found in function '{func_name}': "
+                        f"{request_param} and {param}"
                     )
 
                 # composite types are read from body
@@ -263,7 +277,7 @@ def get_endpoint_operations(endpoint: type, use_examples: bool = True) -> List[E
         # where YieldType is the event type, SendType is None, and ReturnType is the immediate response type to the request
         if typing.get_origin(return_type) is collections.abc.Generator:
             event_type, send_type, response_type = typing.get_args(return_type)
-            if send_type is not type(None):
+            if send_type is not NoneType:
                 raise ValidationError(
                     f"function '{func_name}' has a return type Generator[Y,S,R] and therefore looks like an event but has an explicit send type"
                 )
@@ -299,6 +313,7 @@ def get_endpoint_operations(endpoint: type, use_examples: bool = True) -> List[E
                 response_type=response_type,
                 http_method=http_method,
                 public=public,
+                deprecated=deprecated,
                 request_examples=request_examples if use_examples else None,
                 response_examples=response_examples if use_examples else None,
             )
@@ -310,8 +325,8 @@ def get_endpoint_operations(endpoint: type, use_examples: bool = True) -> List[E
     return result
 
 
-def get_endpoint_events(endpoint: type) -> Dict[str, type]:
-    results = {}
+def get_endpoint_events(endpoint: type[Any]) -> dict[str, type[Any]]:
+    results: dict[str, type[Any]] = {}
 
     for decl in typing.get_type_hints(endpoint).values():
         # check if signature is Callable[...]
@@ -324,11 +339,11 @@ def get_endpoint_events(endpoint: type) -> Dict[str, type]:
         if len(args) != 2:
             continue
         params_type, return_type = args
-        if not isinstance(params_type, list):
+        if typing.get_origin(params_type) is not list:
             continue
 
         # check if signature is Callable[[...], None]
-        if not issubclass(return_type, type(None)):
+        if not issubclass(return_type, NoneType):
             continue
 
         # check if signature is Callable[[EventType], None]

pyopenapi/options.py

@@ -1,15 +1,22 @@
+"""
+Generate an OpenAPI specification from a Python class definition
+
+Copyright 2021-2026, Levente Hunyadi
+
+:see: https://github.com/hunyadi/pyopenapi
+"""
+
 import dataclasses
 from dataclasses import dataclass
 from http import HTTPStatus
-from typing import Callable, ClassVar, Dict, List, Optional, Tuple, Union
+from typing import Any, Callable, ClassVar
 
-from .specification import Info, SecurityScheme
+from .specification import Info, SecurityScheme, Server
 from .specification import SecuritySchemeAPI as SecuritySchemeAPI
 from .specification import SecuritySchemeHTTP as SecuritySchemeHTTP
 from .specification import SecuritySchemeOpenIDConnect as SecuritySchemeOpenIDConnect
-from .specification import Server
 
-HTTPStatusCode = Union[HTTPStatus, int, str]
+HTTPStatusCode = HTTPStatus | int | str
 
 
 @dataclass
@@ -30,17 +37,17 @@ class Options:
 
     server: Server
     info: Info
-    version: Tuple[int, int, int] = (3, 1, 0)
-    default_security_scheme: Optional[SecurityScheme] = None
-    extra_types: Union[List[type], Dict[str, List[type]], None] = None
+    version: tuple[int, int, int] = (3, 1, 0)
+    default_security_scheme: SecurityScheme | None = None
+    extra_types: list[type[Any]] | dict[str, list[type[Any]]] | None = None
     use_examples: bool = True
-    success_responses: Dict[type, HTTPStatusCode] = dataclasses.field(default_factory=dict)
-    error_responses: Dict[type, HTTPStatusCode] = dataclasses.field(default_factory=dict)
+    success_responses: dict[type[Any], HTTPStatusCode] = dataclasses.field(default_factory=dict[type[Any], HTTPStatusCode])
+    error_responses: dict[type[Any], HTTPStatusCode] = dataclasses.field(default_factory=dict[type[Any], HTTPStatusCode])
     error_wrapper: bool = False
-    property_description_fun: Optional[Callable[[type, str, str], str]] = None
-    captions: Optional[Dict[str, str]] = None
+    property_description_fun: Callable[[type, str, str], str] | None = None
+    captions: dict[str, str] | None = None
 
-    default_captions: ClassVar[Dict[str, str]] = {
+    default_captions: ClassVar[dict[str, str]] = {
         "Operations": "Operations",
         "Types": "Types",
         "Events": "Events",

pyopenapi/proxy.py

@@ -1,19 +1,29 @@
+"""
+Generate an OpenAPI specification from a Python class definition
+
+Copyright 2021-2026, Levente Hunyadi
+
+:see: https://github.com/hunyadi/pyopenapi
+"""
+
 import json
-from typing import Any, Callable, Dict, Optional, Tuple, Type, TypeVar
+import typing
+from typing import Any, Callable, TypeVar
 
 import aiohttp
+from strong_typing.inspection import get_signature
 from strong_typing.serialization import json_to_object, object_to_json
 
-from .operations import EndpointOperation, HTTPMethod, get_endpoint_operations, get_signature
+from .operations import EndpointOperation, HTTPMethod, get_endpoint_operations
 
 
 async def make_request(
     http_method: HTTPMethod,
     server: str,
     path: str,
-    query: Dict[str, str],
-    data: Optional[str],
-) -> Tuple[int, str]:
+    query: dict[str, str],
+    data: str | None,
+) -> tuple[int, str]:
     "Makes an asynchronous HTTP request and returns the response."
 
     headers = {"Accept": "application/json"}
@@ -90,14 +100,14 @@ class OperationProxy:
             data = None
 
         # make HTTP request
-        status, response = await make_request(self.op.http_method, endpoint_proxy.base_url, path, query, data)
+        _status, response = await make_request(self.op.http_method, endpoint_proxy.base_url, path, query, data)
 
         # process HTTP response
         if response:
             try:
                 s = json.loads(response)
             except json.JSONDecodeError:
-                raise ProxyInvokeError(f"response body is not well-formed JSON:\n{response}")
+                raise ProxyInvokeError(f"response body is not well-formed JSON:\n{response}") from None
 
             return json_to_object(self.op.response_type, s)
         else:
@@ -118,7 +128,7 @@ def _get_operation_proxy(op: EndpointOperation) -> Callable[..., Any]:
 T = TypeVar("T")
 
 
-def make_proxy_class(api: Type[T]) -> Type[T]:
+def make_proxy_class(api: type[T]) -> type[T]:
     """
     Creates a proxy class for calling an HTTP REST API.
 
@@ -127,5 +137,5 @@ def make_proxy_class(api: Type[T]) -> Type[T]:
 
     ops = get_endpoint_operations(api)
     properties = {op.func_name: _get_operation_proxy(op) for op in ops}
-    proxy = type(f"{api.__name__}Proxy", (api, EndpointProxy), properties)
-    return proxy
+    proxy = type(f"{api.__name__}Proxy", (api, EndpointProxy), properties)  # pyright: ignore[reportGeneralTypeIssues]
+    return typing.cast(type[T], proxy)

pyopenapi/specification.py

@@ -1,10 +1,18 @@
+"""
+Generate an OpenAPI specification from a Python class definition
+
+Copyright 2021-2026, Levente Hunyadi
+
+:see: https://github.com/hunyadi/pyopenapi
+"""
+
 import dataclasses
 import enum
 from dataclasses import dataclass
-from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Any, ClassVar
 
-from strong_typing.schema import JsonType as JsonType
-from strong_typing.schema import Schema, StrictJsonType
+from strong_typing.core import JsonType as JsonType
+from strong_typing.core import Schema, StrictJsonType
 
 URL = str
 
@@ -23,9 +31,6 @@ class SchemaRef(Ref):
     ref_type: ClassVar[str] = "schemas"
 
 
-SchemaOrRef = Union[Schema, SchemaRef]
-
-
 @dataclass
 class ResponseRef(Ref):
     ref_type: ClassVar[str] = "responses"
@@ -43,45 +48,45 @@ class ExampleRef(Ref):
 
 @dataclass
 class Contact:
-    name: Optional[str] = None
-    url: Optional[URL] = None
-    email: Optional[str] = None
+    name: str | None = None
+    url: URL | None = None
+    email: str | None = None
 
 
 @dataclass
 class License:
     name: str
-    url: Optional[URL] = None
+    url: URL | None = None
 
 
 @dataclass
 class Info:
     title: str
     version: str
-    description: Optional[str] = None
-    termsOfService: Optional[str] = None
-    contact: Optional[Contact] = None
-    license: Optional[License] = None
+    description: str | None = None
+    termsOfService: str | None = None
+    contact: Contact | None = None
+    license: License | None = None
 
 
 @dataclass
 class MediaType:
-    schema: Optional[SchemaOrRef] = None
-    example: Optional[Any] = None
-    examples: Optional[Dict[str, Union["Example", ExampleRef]]] = None
+    schema: Schema | SchemaRef | None = None
+    example: Any | None = None
+    examples: dict[str, "Example | ExampleRef"] | None = None
 
 
 @dataclass
 class RequestBody:
-    content: Dict[str, MediaType]
-    description: Optional[str] = None
-    required: Optional[bool] = None
+    content: dict[str, MediaType]
+    description: str | None = None
+    required: bool | None = None
 
 
 @dataclass
 class Response:
     description: str
-    content: Optional[Dict[str, MediaType]] = None
+    content: dict[str, MediaType] | None = None
 
 
 @enum.unique
@@ -96,37 +101,38 @@ class ParameterLocation(enum.Enum):
 class Parameter:
     name: str
     in_: ParameterLocation
-    description: Optional[str] = None
-    required: Optional[bool] = None
-    schema: Optional[SchemaOrRef] = None
-    example: Optional[Any] = None
+    description: str | None = None
+    required: bool | None = None
+    schema: Schema | SchemaRef | None = None
+    example: Any | None = None
 
 
 @dataclass
 class Operation:
-    responses: Dict[str, Union[Response, ResponseRef]]
-    tags: Optional[List[str]] = None
-    summary: Optional[str] = None
-    description: Optional[str] = None
-    operationId: Optional[str] = None
-    parameters: Optional[List[Parameter]] = None
-    requestBody: Optional[RequestBody] = None
-    callbacks: Optional[Dict[str, "Callback"]] = None
-    security: Optional[List["SecurityRequirement"]] = None
+    responses: dict[str, Response | ResponseRef]
+    tags: list[str] | None = None
+    summary: str | None = None
+    description: str | None = None
+    operationId: str | None = None
+    parameters: list[Parameter] | None = None
+    requestBody: RequestBody | None = None
+    callbacks: dict[str, "Callback"] | None = None
+    security: list["SecurityRequirement"] | None = None
+    deprecated: bool | None = None
 
 
 @dataclass
 class PathItem:
-    summary: Optional[str] = None
-    description: Optional[str] = None
-    get: Optional[Operation] = None
-    put: Optional[Operation] = None
-    post: Optional[Operation] = None
-    delete: Optional[Operation] = None
-    options: Optional[Operation] = None
-    head: Optional[Operation] = None
-    patch: Optional[Operation] = None
-    trace: Optional[Operation] = None
+    summary: str | None = None
+    description: str | None = None
+    get: Operation | None = None
+    put: Operation | None = None
+    post: Operation | None = None
+    delete: Operation | None = None
+    options: Operation | None = None
+    head: Operation | None = None
+    patch: Operation | None = None
+    trace: Operation | None = None
 
     def update(self, other: "PathItem") -> None:
         "Merges another instance of this class into this object."
@@ -138,21 +144,21 @@ class PathItem:
 
 
 # maps run-time expressions such as "$request.body#/url" to path items
-Callback = Dict[str, PathItem]
+Callback = dict[str, PathItem]
 
 
 @dataclass
 class Example:
-    summary: Optional[str] = None
-    description: Optional[str] = None
-    value: Optional[Any] = None
-    externalValue: Optional[URL] = None
+    summary: str | None = None
+    description: str | None = None
+    value: Any | None = None
+    externalValue: URL | None = None
 
 
 @dataclass
 class Server:
     url: URL
-    description: Optional[str] = None
+    description: str | None = None
 
 
 @enum.unique
@@ -183,9 +189,9 @@ class SecuritySchemeAPI(SecurityScheme):
 @dataclass(init=False)
 class SecuritySchemeHTTP(SecurityScheme):
     scheme: str
-    bearerFormat: Optional[str] = None
+    bearerFormat: str | None = None
 
-    def __init__(self, description: str, scheme: str, bearerFormat: Optional[str] = None) -> None:
+    def __init__(self, description: str, scheme: str, bearerFormat: str | None = None) -> None:
         super().__init__(SecuritySchemeType.HTTP, description)
         self.scheme = scheme
         self.bearerFormat = bearerFormat
@@ -202,24 +208,24 @@ class SecuritySchemeOpenIDConnect(SecurityScheme):
 
 @dataclass
 class Components:
-    schemas: Optional[Dict[str, Schema]] = None
-    responses: Optional[Dict[str, Response]] = None
-    parameters: Optional[Dict[str, Parameter]] = None
-    examples: Optional[Dict[str, Example]] = None
-    requestBodies: Optional[Dict[str, RequestBody]] = None
-    securitySchemes: Optional[Dict[str, SecurityScheme]] = None
-    callbacks: Optional[Dict[str, Callback]] = None
+    schemas: dict[str, Schema] | None = None
+    responses: dict[str, Response] | None = None
+    parameters: dict[str, Parameter] | None = None
+    examples: dict[str, Example] | None = None
+    requestBodies: dict[str, RequestBody] | None = None
+    securitySchemes: dict[str, SecurityScheme] | None = None
+    callbacks: dict[str, Callback] | None = None
 
 
 SecurityScope = str
-SecurityRequirement = Dict[str, List[SecurityScope]]
+SecurityRequirement = dict[str, list[SecurityScope]]
 
 
 @dataclass
 class Tag:
     name: str
-    description: Optional[str] = None
-    displayName: Optional[str] = None
+    description: str | None = None
+    displayName: str | None = None
 
 
 @dataclass
@@ -228,10 +234,13 @@ class TagGroup:
     A ReDoc extension to provide information about groups of tags.
 
     Exposed via the vendor-specific property "x-tagGroups" of the top-level object.
+
+    :param name: Group name.
+    :param tags: Tags that are members of this group.
     """
 
     name: str
-    tags: List[str]
+    tags: list[str]
 
 
 @dataclass
@@ -240,14 +249,24 @@ class Document:
     This class is a Python dataclass adaptation of the OpenAPI Specification.
 
     For details, see <https://swagger.io/specification/>
+
+    :param openapi: Version number of the OpenAPI Specification that the OpenAPI document uses.
+    :param info: Provides metadata about the API.
+    :param servers: An array of objects that provide connectivity information to a target server.
+    :param paths: The available paths and operations for the API.
+    :param jsonSchemaDialect: The default value for the `$schema` keyword within schema objects in this document, in the form of a URI.
+    :param components: An element to hold various objects for the OpenAPI description.
+    :param security: A declaration of which security mechanisms can be used across the API.
+    :param tags: A list of tags used by the OpenAPI description with additional metadata.
+    :param tagGroups: Provides information about a group of tags. (Extension to OpenAPI.)
     """
 
     openapi: str
     info: Info
-    servers: List[Server]
-    paths: Dict[str, PathItem]
-    jsonSchemaDialect: Optional[str] = None
-    components: Optional[Components] = None
-    security: Optional[List[SecurityRequirement]] = None
-    tags: Optional[List[Tag]] = None
-    tagGroups: Optional[List[TagGroup]] = None
+    servers: list[Server]
+    paths: dict[str, PathItem]
+    jsonSchemaDialect: str | None = None
+    components: Components | None = None
+    security: list[SecurityRequirement] | None = None
+    tags: list[Tag] | None = None
+    tagGroups: list[TagGroup] | None = None

pyopenapi/utility.py

@@ -1,10 +1,18 @@
+"""
+Generate an OpenAPI specification from a Python class definition
+
+Copyright 2021-2026, Levente Hunyadi
+
+:see: https://github.com/hunyadi/pyopenapi
+"""
+
 import importlib.resources
 import json
-import sys
 import typing
 from typing import TextIO
 
-from strong_typing.schema import StrictJsonType, object_to_json
+from strong_typing.core import StrictJsonType
+from strong_typing.serialization import object_to_json
 
 from .generator import Generator
 from .options import Options
@@ -94,12 +102,8 @@ class Specification:
         :param pretty_print: Whether to use line indents to beautify the JSON string in the HTML file.
         """
 
-        if sys.version_info >= (3, 9):
-            with importlib.resources.files(__package__).joinpath("template.html").open(encoding="utf-8", errors="strict") as html_template_file:
-                html_template = html_template_file.read()
-        else:
-            with importlib.resources.open_text(__package__, "template.html", encoding="utf-8", errors="strict") as html_template_file:
-                html_template = html_template_file.read()
+        with importlib.resources.files(__package__).joinpath("template.html").open(encoding="utf-8", errors="strict") as html_template_file:
+            html_template = html_template_file.read()
 
         html = html_template.replace(
             "{ /* OPENAPI_SPECIFICATION */ }",