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

pyopenapi/__init__.py

@@ -1,54 +1,14 @@
-from typing import Any, Callable, List, Optional, TypeVar
+"""
+Generate an OpenAPI specification from a Python class definition
 
-from .metadata import WebMethod
-from .options import *  # noqa: F403
-from .utility import Specification as Specification
+Copyright 2022-2025, Levente Hunyadi
 
-__version__ = "0.1.10"
+:see: https://github.com/hunyadi/pyopenapi
+"""
 
-T = TypeVar("T")
-
-
-def webmethod(
-    route: Optional[str] = None,
-    public: Optional[bool] = False,
-    request_example: Optional[Any] = None,
-    response_example: Optional[Any] = None,
-    request_examples: Optional[List[Any]] = None,
-    response_examples: Optional[List[Any]] = None,
-) -> Callable[[T], T]:
-    """
-    Decorator that supplies additional metadata to an endpoint operation function.
-
-    :param route: The URL path pattern associated with this operation which path parameters are substituted into.
-    :param public: True if the operation can be invoked without prior authentication.
-    :param request_example: A sample request that the operation might take.
-    :param response_example: A sample response that the operation might produce.
-    :param request_examples: Sample requests that the operation might take. Pass a list of objects, not JSON.
-    :param response_examples: Sample responses that the operation might produce. Pass a list of objects, not JSON.
-    """
-
-    if request_example is not None and request_examples is not None:
-        raise ValueError("arguments `request_example` and `request_examples` are exclusive")
-    if response_example is not None and response_examples is not None:
-        raise ValueError("arguments `response_example` and `response_examples` are exclusive")
-
-    if request_example:
-        request_examples = [request_example]
-    if response_example:
-        response_examples = [response_example]
-
-    def wrap(cls: T) -> T:
-        setattr(
-            cls,
-            "__webmethod__",
-            WebMethod(
-                route=route,
-                public=public or False,
-                request_examples=request_examples,
-                response_examples=response_examples,
-            ),
-        )
-        return cls
-
-    return wrap
+__version__ = "0.2.0"
+__author__ = "Levente Hunyadi"
+__copyright__ = "Copyright 2022-2025, Levente Hunyadi"
+__license__ = "MIT"
+__maintainer__ = "Levente Hunyadi"
+__status__ = "Production"

pyopenapi/decorators.py

@@ -0,0 +1,51 @@
+"""
+Generate an OpenAPI specification from a Python class definition
+
+Copyright 2022-2025, Levente Hunyadi
+
+:see: https://github.com/hunyadi/pyopenapi
+"""
+
+from typing import Any, Callable, Optional, TypeVar
+
+from .metadata import WebMethod
+from .options import *  # noqa: F403
+from .utility import Specification as Specification
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def webmethod(
+    route: Optional[str] = None,
+    public: Optional[bool] = False,
+    request_example: Optional[Any] = None,
+    response_example: Optional[Any] = None,
+    request_examples: Optional[list[Any]] = None,
+    response_examples: Optional[list[Any]] = None,
+) -> Callable[[F], F]:
+    """
+    Decorator that supplies additional metadata to an endpoint operation function.
+
+    :param route: The URL path pattern associated with this operation which path parameters are substituted into.
+    :param public: True if the operation can be invoked without prior authentication.
+    :param request_example: A sample request that the operation might take.
+    :param response_example: A sample response that the operation might produce.
+    :param request_examples: Sample requests that the operation might take. Pass a list of objects, not JSON.
+    :param response_examples: Sample responses that the operation might produce. Pass a list of objects, not JSON.
+    """
+
+    if request_example is not None and request_examples is not None:
+        raise ValueError("arguments `request_example` and `request_examples` are exclusive")
+    if response_example is not None and response_examples is not None:
+        raise ValueError("arguments `response_example` and `response_examples` are exclusive")
+
+    if request_example:
+        request_examples = [request_example]
+    if response_example:
+        response_examples = [response_example]
+
+    def wrap(cls: F) -> F:
+        cls.__webmethod__ = WebMethod(route=route, public=public or False, request_examples=request_examples, response_examples=response_examples)  # type: ignore[attr-defined]
+        return cls
+
+    return wrap

pyopenapi/generator.py

@@ -1,16 +1,24 @@
+"""
+Generate an OpenAPI specification from a Python class definition
+
+Copyright 2022-2025, Levente Hunyadi
+
+:see: https://github.com/hunyadi/pyopenapi
+"""
+
 import dataclasses
 import hashlib
 import ipaddress
 import typing
 from dataclasses import dataclass
 from http import HTTPStatus
-from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
+from typing import Any, Callable, Optional, Union
 
-from strong_typing.core import JsonType
+from strong_typing.core import JsonType, Schema
 from strong_typing.docstring import Docstring, parse_type
 from strong_typing.inspection import is_generic_list, is_type_optional, is_type_union, unwrap_generic_list, unwrap_optional_type, unwrap_union_types
 from strong_typing.name import python_type_to_name
-from strong_typing.schema import JsonSchemaGenerator, Schema, SchemaOptions, get_schema_identifier, register_schema
+from strong_typing.schema import JsonSchemaGenerator, SchemaOptions, get_schema_identifier, register_schema
 from strong_typing.serialization import json_dump_string, object_to_json
 
 from .operations import EndpointOperation, HTTPMethod, get_endpoint_events, get_endpoint_operations
@@ -78,7 +86,7 @@ def http_status_to_string(status_code: HTTPStatusCode) -> str:
 
 class SchemaBuilder:
     schema_generator: JsonSchemaGenerator
-    schemas: Dict[str, Schema]
+    schemas: dict[str, Schema]
 
     def __init__(self, schema_generator: JsonSchemaGenerator) -> None:
         self.schema_generator = schema_generator
@@ -150,7 +158,7 @@ class ContentBuilder:
         self.schema_transformer = schema_transformer
         self.sample_transformer = sample_transformer
 
-    def build_content(self, payload_type: type, examples: Optional[List[Any]] = None) -> Dict[str, MediaType]:
+    def build_content(self, payload_type: type, examples: Optional[list[Any]] = None) -> dict[str, MediaType]:
         "Creates the content subtree for a request or response."
 
         if is_generic_list(payload_type):
@@ -162,7 +170,7 @@ class ContentBuilder:
 
         return {media_type: self.build_media_type(item_type, examples)}
 
-    def build_media_type(self, item_type: type, examples: Optional[List[Any]] = None) -> MediaType:
+    def build_media_type(self, item_type: type, examples: Optional[list[Any]] = None) -> MediaType:
         schema = self.schema_builder.classdef_to_ref(item_type)
         if self.schema_transformer:
             schema_transformer: Callable[[SchemaOrRef], SchemaOrRef] = self.schema_transformer
@@ -179,12 +187,12 @@ class ContentBuilder:
             examples=self._build_examples(examples),
         )
 
-    def _build_examples(self, examples: List[Any]) -> Dict[str, Union[Example, ExampleRef]]:
+    def _build_examples(self, examples: list[Any]) -> dict[str, Union[Example, ExampleRef]]:
         "Creates a set of several examples for a media type."
 
         builder = ExampleBuilder(self.sample_transformer)
 
-        results: Dict[str, Union[Example, ExampleRef]] = {}
+        results: dict[str, Union[Example, ExampleRef]] = {}
         for example in examples:
             name, value = builder.get_named(example)
             results[name] = Example(value=value)
@@ -208,7 +216,7 @@ class ExampleBuilder:
         if sample_transformer:
             self.sample_transformer = sample_transformer
         else:
-            self.sample_transformer = lambda sample: sample  # noqa: E731
+            self.sample_transformer = lambda sample: sample
 
     def _get_value(self, example: Any) -> JsonType:
         return self.sample_transformer(object_to_json(example))
@@ -216,12 +224,12 @@ class ExampleBuilder:
     def get_anonymous(self, example: Any) -> JsonType:
         return self._get_value(example)
 
-    def get_named(self, example: Any) -> Tuple[str, JsonType]:
+    def get_named(self, example: Any) -> tuple[str, JsonType]:
         value = self._get_value(example)
 
         name: Optional[str] = None
 
-        if type(example).__str__ is not object.__str__:
+        if type(example).__str__ is not object.__str__:  # type: ignore[comparison-overlap]
             friendly_name = str(example)
             if friendly_name.isprintable():
                 name = friendly_name
@@ -244,17 +252,17 @@ class ResponseOptions:
     :param default_status_code: HTTP status code assigned to responses that have no mapping.
     """
 
-    type_descriptions: Dict[type, str]
-    examples: Optional[List[Any]]
-    status_catalog: Dict[type, HTTPStatusCode]
+    type_descriptions: dict[type, str]
+    examples: Optional[list[Any]]
+    status_catalog: dict[type, HTTPStatusCode]
     default_status_code: HTTPStatusCode
 
 
 @dataclass
 class StatusResponse:
     status_code: str
-    types: List[type] = dataclasses.field(default_factory=list)
-    examples: List[Any] = dataclasses.field(default_factory=list)
+    types: list[type] = dataclasses.field(default_factory=list)
+    examples: list[Any] = dataclasses.field(default_factory=list)
 
 
 class ResponseBuilder:
@@ -263,8 +271,8 @@ class ResponseBuilder:
     def __init__(self, content_builder: ContentBuilder) -> None:
         self.content_builder = content_builder
 
-    def _get_status_responses(self, options: ResponseOptions) -> Dict[str, StatusResponse]:
-        status_responses: Dict[str, StatusResponse] = {}
+    def _get_status_responses(self, options: ResponseOptions) -> dict[str, StatusResponse]:
+        status_responses: dict[str, StatusResponse] = {}
 
         for response_type in options.type_descriptions.keys():
             status_code = http_status_to_string(options.status_catalog.get(response_type, options.default_status_code))
@@ -283,12 +291,12 @@ class ResponseBuilder:
 
         return dict(sorted(status_responses.items()))
 
-    def build_response(self, options: ResponseOptions) -> Dict[str, Union[Response, ResponseRef]]:
+    def build_response(self, options: ResponseOptions) -> dict[str, Union[Response, ResponseRef]]:
         """
         Groups responses that have the same status code.
         """
 
-        responses: Dict[str, Union[Response, ResponseRef]] = {}
+        responses: dict[str, Union[Response, ResponseRef]] = {}
         status_responses = self._get_status_responses(options)
         for status_code, status_response in status_responses.items():
             response_types = tuple(status_response.types)
@@ -315,9 +323,9 @@ class ResponseBuilder:
 
     def _build_response(
         self,
-        response_type: type,
+        response_type: Optional[type],
         description: str,
-        examples: Optional[List[Any]] = None,
+        examples: Optional[list[Any]] = None,
     ) -> Response:
         "Creates a response subtree."
 
@@ -355,7 +363,7 @@ class Generator:
     endpoint: type
     options: Options
     schema_builder: SchemaBuilder
-    responses: Dict[str, Response]
+    responses: dict[str, Response]
 
     def __init__(self, endpoint: type, options: Options) -> None:
         self.endpoint = endpoint
@@ -379,17 +387,17 @@ class Generator:
             description="\n\n".join(s for s in (title, description, definition) if s is not None),
         )
 
-    def _build_extra_tag_groups(self, extra_types: Dict[str, List[type]]) -> Dict[str, List[Tag]]:
+    def _build_extra_tag_groups(self, extra_types: dict[str, list[type]]) -> dict[str, list[Tag]]:
         """
         Creates a dictionary of tag group captions as keys, and tag lists as values.
 
         :param extra_types: A dictionary of type categories and list of types in that category.
         """
 
-        extra_tags: Dict[str, List[Tag]] = {}
+        extra_tags: dict[str, list[Tag]] = {}
 
         for category_name, category_items in extra_types.items():
-            tag_list: List[Tag] = []
+            tag_list: list[Tag] = []
 
             for extra_type in category_items:
                 name = python_type_to_name(extra_type)
@@ -454,7 +462,7 @@ class Generator:
         # success response types
         if doc_string.returns is None and is_type_union(op.response_type):
             # split union of return types into a list of response types
-            success_type_docstring: Dict[type, Docstring] = {typing.cast(type, item): parse_type(item) for item in unwrap_union_types(op.response_type)}
+            success_type_docstring: dict[type, Docstring] = {typing.cast(type, item): parse_type(item) for item in unwrap_union_types(op.response_type)}
             success_type_descriptions = {
                 item: doc_string.short_description for item, doc_string in success_type_docstring.items() if doc_string.short_description
             }
@@ -477,7 +485,7 @@ class Generator:
 
         # failure response types
         if doc_string.raises:
-            exception_types: Dict[type, str] = {item.raise_type: item.description for item in doc_string.raises.values()}
+            exception_types: dict[type, str] = {item.raise_type: item.description for item in doc_string.raises.values()}
             exception_examples = [example for example in response_examples if isinstance(example, Exception)]
 
             if self.options.error_wrapper:
@@ -529,8 +537,8 @@ class Generator:
         )
 
     def generate(self) -> Document:
-        paths: Dict[str, PathItem] = {}
-        endpoint_classes: Set[type] = set()
+        paths: dict[str, PathItem] = {}
+        endpoint_classes: set[type] = set()
         for op in get_endpoint_operations(self.endpoint, use_examples=self.options.use_examples):
             endpoint_classes.add(op.defining_class)
 
@@ -555,7 +563,7 @@ class Generator:
             else:
                 paths[route] = pathItem
 
-        operation_tags: List[Tag] = []
+        operation_tags: list[Tag] = []
         for cls in endpoint_classes:
             doc_string = parse_type(cls)
             operation_tags.append(
@@ -570,14 +578,14 @@ class Generator:
         type_tags = [self._build_type_tag(ref, schema) for ref, schema in self.schema_builder.schemas.items()]
 
         # types that are emitted by events
-        event_tags: List[Tag] = []
+        event_tags: list[Tag] = []
         events = get_endpoint_events(self.endpoint)
         for ref, event_type in events.items():
             event_schema = self.schema_builder.classdef_to_named_schema(ref, event_type)
             event_tags.append(self._build_type_tag(ref, event_schema))
 
         # types that are explicitly declared
-        extra_tag_groups: Dict[str, List[Tag]] = {}
+        extra_tag_groups: dict[str, list[Tag]] = {}
         if self.options.extra_types is not None:
             if isinstance(self.options.extra_types, list):
                 extra_tag_groups = self._build_extra_tag_groups({"AdditionalTypes": self.options.extra_types})
@@ -587,7 +595,7 @@ class Generator:
                 raise TypeError(f"type mismatch for collection of extra types: {type(self.options.extra_types)}")
 
         # list all operations and types
-        tags: List[Tag] = []
+        tags: list[Tag] = []
         tags.extend(operation_tags)
         tags.extend(type_tags)
         tags.extend(event_tags)

pyopenapi/metadata.py

@@ -1,5 +1,13 @@
+"""
+Generate an OpenAPI specification from a Python class definition
+
+Copyright 2022-2025, Levente Hunyadi
+
+:see: https://github.com/hunyadi/pyopenapi
+"""
+
 from dataclasses import dataclass
-from typing import Any, List, Optional
+from typing import Any, Optional
 
 
 @dataclass
@@ -15,5 +23,5 @@ class WebMethod:
 
     route: Optional[str] = None
     public: bool = False
-    request_examples: Optional[List[Any]] = None
-    response_examples: Optional[List[Any]] = None
+    request_examples: Optional[list[Any]] = None
+    response_examples: Optional[list[Any]] = None

pyopenapi/operations.py

@@ -1,17 +1,25 @@
+"""
+Generate an OpenAPI specification from a Python class definition
+
+Copyright 2022-2025, 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 typing import Any, Callable, Iterable, Iterator, Optional, Union
 
 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: Union[str, Iterable[str]]) -> tuple[Optional[str], str]:
     """
     Recognizes a prefix at the beginning of a string.
 
@@ -34,11 +42,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: Union[type, str], callable: Callable[..., Any]) -> type:
+    "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, eval(annotation, callable.__globals__))
     else:
         return annotation
 
@@ -54,7 +62,7 @@ class HTTPMethod(enum.Enum):
     PATCH = "PATCH"
 
 
-OperationParameter = Tuple[str, type]
+OperationParameter = tuple[str, type]
 
 
 class ValidationError(TypeError):
@@ -87,15 +95,15 @@ class EndpointOperation:
     func_name: str
     func_ref: Callable[..., Any]
     route: Optional[str]
-    path_params: List[OperationParameter]
-    query_params: List[OperationParameter]
+    path_params: list[OperationParameter]
+    query_params: list[OperationParameter]
     request_param: Optional[OperationParameter]
     event_type: Optional[type]
     response_type: type
     http_method: HTTPMethod
     public: bool
-    request_examples: Optional[List[Any]] = None
-    response_examples: Optional[List[Any]] = None
+    request_examples: Optional[list[Any]] = None
+    response_examples: Optional[list[Any]] = None
 
     def get_route(self) -> str:
         if self.route is not None:
@@ -108,9 +116,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 +128,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, 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}")
 
@@ -151,7 +159,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, use_examples: bool = True) -> list[EndpointOperation]:
     """
     Extracts a list of member functions in a class eligible for HTTP interface binding.
 
@@ -247,7 +255,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
@@ -310,7 +319,7 @@ def get_endpoint_operations(endpoint: type, use_examples: bool = True) -> List[E
     return result
 
 
-def get_endpoint_events(endpoint: type) -> Dict[str, type]:
+def get_endpoint_events(endpoint: type) -> dict[str, type]:
     results = {}
 
     for decl in typing.get_type_hints(endpoint).values():

pyopenapi/options.py

@@ -1,13 +1,20 @@
+"""
+Generate an OpenAPI specification from a Python class definition
+
+Copyright 2022-2025, 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 Callable, ClassVar, Optional, Union
 
-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]
 
@@ -30,17 +37,17 @@ class Options:
 
     server: Server
     info: Info
-    version: Tuple[int, int, int] = (3, 1, 0)
+    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
+    extra_types: Union[list[type], dict[str, list[type]], 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, HTTPStatusCode] = dataclasses.field(default_factory=dict)
+    error_responses: dict[type, HTTPStatusCode] = dataclasses.field(default_factory=dict)
     error_wrapper: bool = False
     property_description_fun: Optional[Callable[[type, str, str], str]] = None
-    captions: Optional[Dict[str, str]] = None
+    captions: Optional[dict[str, str]] = 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,28 @@
+"""
+Generate an OpenAPI specification from a Python class definition
+
+Copyright 2022-2025, Levente Hunyadi
+
+:see: https://github.com/hunyadi/pyopenapi
+"""
+
 import json
-from typing import Any, Callable, Dict, Optional, Tuple, Type, TypeVar
+from typing import Any, Callable, Optional, 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],
+    query: dict[str, str],
     data: Optional[str],
-) -> Tuple[int, str]:
+) -> tuple[int, str]:
     "Makes an asynchronous HTTP request and returns the response."
 
     headers = {"Accept": "application/json"}
@@ -97,7 +106,7 @@ class OperationProxy:
             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 +127,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.
 

pyopenapi/specification.py

@@ -1,10 +1,18 @@
+"""
+Generate an OpenAPI specification from a Python class definition
+
+Copyright 2022-2025, 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, Optional, Union
 
-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
 
@@ -68,12 +76,12 @@ class Info:
 class MediaType:
     schema: Optional[SchemaOrRef] = None
     example: Optional[Any] = None
-    examples: Optional[Dict[str, Union["Example", ExampleRef]]] = None
+    examples: Optional[dict[str, Union["Example", ExampleRef]]] = None
 
 
 @dataclass
 class RequestBody:
-    content: Dict[str, MediaType]
+    content: dict[str, MediaType]
     description: Optional[str] = None
     required: Optional[bool] = None
 
@@ -81,7 +89,7 @@ class RequestBody:
 @dataclass
 class Response:
     description: str
-    content: Optional[Dict[str, MediaType]] = None
+    content: Optional[dict[str, MediaType]] = None
 
 
 @enum.unique
@@ -104,15 +112,15 @@ class Parameter:
 
 @dataclass
 class Operation:
-    responses: Dict[str, Union[Response, ResponseRef]]
-    tags: Optional[List[str]] = None
+    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
+    parameters: Optional[list[Parameter]] = None
     requestBody: Optional[RequestBody] = None
-    callbacks: Optional[Dict[str, "Callback"]] = None
-    security: Optional[List["SecurityRequirement"]] = None
+    callbacks: Optional[dict[str, "Callback"]] = None
+    security: Optional[list["SecurityRequirement"]] = None
 
 
 @dataclass
@@ -138,7 +146,7 @@ class PathItem:
 
 
 # maps run-time expressions such as "$request.body#/url" to path items
-Callback = Dict[str, PathItem]
+Callback = dict[str, PathItem]
 
 
 @dataclass
@@ -202,17 +210,17 @@ 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: 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
 
 
 SecurityScope = str
-SecurityRequirement = Dict[str, List[SecurityScope]]
+SecurityRequirement = dict[str, list[SecurityScope]]
 
 
 @dataclass
@@ -231,7 +239,7 @@ class TagGroup:
     """
 
     name: str
-    tags: List[str]
+    tags: list[str]
 
 
 @dataclass
@@ -244,10 +252,10 @@ class Document:
 
     openapi: str
     info: Info
-    servers: List[Server]
-    paths: Dict[str, PathItem]
+    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
+    security: Optional[list[SecurityRequirement]] = None
+    tags: Optional[list[Tag]] = None
+    tagGroups: Optional[list[TagGroup]] = None

pyopenapi/utility.py

@@ -1,10 +1,18 @@
+"""
+Generate an OpenAPI specification from a Python class definition
+
+Copyright 2022-2025, 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 */ }",

{python_openapi-0.1.10.dist-info → python_openapi-0.2.0.dist-info}/METADATA

@@ -1,30 +1,32 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-openapi
-Version: 0.1.10
+Version: 0.2.0
 Summary: Generate an OpenAPI specification from a Python class definition
-Home-page: https://github.com/hunyadi/pyopenapi
-Author: Levente Hunyadi
-Author-email: hunyadi@gmail.com
-License: MIT
+Author-email: Levente Hunyadi <hunyadi@gmail.com>
+Maintainer-email: Levente Hunyadi <hunyadi@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/hunyadi/pyopenapi
+Project-URL: Source, https://github.com/hunyadi/pyopenapi
+Keywords: openapi3,openapi,redoc,swagger,json-schema-generator,dataclasses,type-inspection
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aiohttp>=3.11
-Requires-Dist: json-strong-typing>=0.3.7
+Requires-Dist: aiohttp>=3.12
+Requires-Dist: json_strong_typing>=0.3.9
+Dynamic: license-file
 
 # Generate an OpenAPI specification from a Python class
 
@@ -35,7 +37,7 @@ Requires-Dist: json-strong-typing>=0.3.7
 * supports standard and asynchronous functions (`async def`)
 * maps function name prefixes such as `get_` or `create_` to HTTP GET, POST, PUT, DELETE, PATCH
 * handles both simple and composite types (`int`, `str`, `Enum`, `@dataclass`)
-* handles generic types (`List[T]`, `Dict[K, V]`, `Optional[T]`, `Union[T1, T2, T3]`)
+* handles generic types (`list[T]`, `dict[K, V]`, `Optional[T]`, `Union[T1, T2, T3]`)
 * maps Python positional-only and keyword-only arguments (of simple types) to path and query parameters, respectively
 * maps composite types to HTTP request body
 * supports user-defined routes, request and response samples with decorator `@webmethod`
@@ -88,7 +90,7 @@ Let's take a look at the definition of a simple endpoint called `JobManagement`:
 
 ```python
 class JobManagement:
-    def create_job(self, items: List[URL]) -> uuid.UUID:
+    def create_job(self, items: list[URL]) -> uuid.UUID:
         ...
 
     def get_job(self, job_id: uuid.UUID, /, format: Format) -> Job:
@@ -127,7 +129,7 @@ The custom path must have placeholders for all positional-only parameters in the
 
 ### Documenting operations
 
-Use Python ReST (ReStructured Text) doc-strings to attach documentation to operations: 
+Use Python ReST (ReStructured Text) doc-strings to attach documentation to operations:
 
 ```python
 def get_job(self, job_id: uuid.UUID, /, format: Format) -> Job:
@@ -170,7 +172,7 @@ The Python objects in `request_examples` and `response_examples` are translated
 
 ### Mapping function name prefixes to HTTP verbs
 
-The following table identifies which function name prefixes map to which HTTP verbs: 
+The following table identifies which function name prefixes map to which HTTP verbs:
 
 | Prefix | HTTP verb   |
 | ------ | ----------- |

python_openapi-0.2.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+pyopenapi/__init__.py,sha256=6XdaFzQkGdBLTQj0lv-7FyuMN8gFpLKctsA1nIW4pSU,345
+pyopenapi/__main__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyopenapi/decorators.py,sha256=wYZNlZ7diaT5tnr8BsdS7aYpgFTndhfknqbhrU3jR4g,2065
+pyopenapi/generator.py,sha256=HclcfyADHymH3be5w3Xa39MHe0xLsU28kWJhCTLmrG4,23971
+pyopenapi/metadata.py,sha256=-w5C5qiphvnuOkyh9QEUURg7OT-5UffRowjAwmZJkc8,916
+pyopenapi/operations.py,sha256=oprIalF_1XD1-7AjfmJQQeC3xRLdB8oeLlMEhjO2wGc,13529
+pyopenapi/options.py,sha256=S6RWhpZfWrrZBqXzIsPwlVKOkvaI7eyDDUBqGICTlZo,2906
+pyopenapi/proxy.py,sha256=ExDvESQdULTqfnunmfRKtkdjGbcLt5v9yaHd2h9HHlo,4279
+pyopenapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyopenapi/specification.py,sha256=ZKQbhl0mhf5ceHan-2ymzt-tba3MhMH-nGsFQ_07XBE,6114
+pyopenapi/template.html,sha256=hmZsSnN3awQcwlN6u-j06qrw_qYzWqYBLC8uPt_x17A,1234
+pyopenapi/utility.py,sha256=Cdub8VUrklyUvZ9cmahDmIYKq4d6X7IT--rMP_ogd_4,3553
+python_openapi-0.2.0.dist-info/licenses/LICENSE,sha256=sNQ9jvMoMB8FfhB7JbkJYLr8SWSO6jrYvcS-mRL485w,1118
+python_openapi-0.2.0.dist-info/METADATA,sha256=eAVEMvh6P1YF-HWODkAXv7p0N5mOFQJ_6mlUP5IRWSg,10499
+python_openapi-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+python_openapi-0.2.0.dist-info/top_level.txt,sha256=3M9FA79QfjyZyTipZP5fDiMcrRdcbSl7lW-iaq5RIRQ,10
+python_openapi-0.2.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+python_openapi-0.2.0.dist-info/RECORD,,

{python_openapi-0.1.10.dist-info → python_openapi-0.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.2)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

python_openapi-0.1.10.dist-info/RECORD

@@ -1,17 +0,0 @@
-pyopenapi/__init__.py,sha256=4HS5YmQwTzehGw1lUPkZmlKqnL05kAx7aKRq3Q1Lt_4,2020
-pyopenapi/__main__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyopenapi/generator.py,sha256=DVR4n06TmSghR14_9tLPX6yCX1_Arfbh2pU7UvBD7C8,23807
-pyopenapi/metadata.py,sha256=RnAfH79SJVE7-3HWJmdXAm_Kc5L5-4gutyh6xOZc8Fs,766
-pyopenapi/operations.py,sha256=b2wiW93chm9b3pOOXrk4wip1DdjLsB7tgzszyBg2RcU,13318
-pyopenapi/options.py,sha256=uc-nnyGJeaI3qHWvtDzDz-JBInhETEySF-SplyOr9_w,2795
-pyopenapi/proxy.py,sha256=xEO541yqA6ed8jCq01b339_JW1pDSrMN_vxKYk_ZhBg,4096
-pyopenapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyopenapi/specification.py,sha256=qr9K9DyDIW6B-MkrAS26_op1Qj3eosNyD92XimtLRn4,5974
-pyopenapi/template.html,sha256=hmZsSnN3awQcwlN6u-j06qrw_qYzWqYBLC8uPt_x17A,1234
-pyopenapi/utility.py,sha256=ZLe1Ss0MGBRD7fL0uSu7nWqUlMIIfAK2supDbN5-uCU,3625
-python_openapi-0.1.10.dist-info/LICENSE,sha256=sNQ9jvMoMB8FfhB7JbkJYLr8SWSO6jrYvcS-mRL485w,1118
-python_openapi-0.1.10.dist-info/METADATA,sha256=_g7APIZO9ZbYMkYghCx0RoRzlIzhkWt2CU1KD5Gmcr8,10305
-python_openapi-0.1.10.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-python_openapi-0.1.10.dist-info/top_level.txt,sha256=3M9FA79QfjyZyTipZP5fDiMcrRdcbSl7lW-iaq5RIRQ,10
-python_openapi-0.1.10.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-python_openapi-0.1.10.dist-info/RECORD,,