python-openapi 0.1.9__tar.gz → 0.1.10__tar.gz

{python-openapi-0.1.9 → python_openapi-0.1.10}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021-2022 Levente Hunyadi
+Copyright (c) 2021-2025 Levente Hunyadi
 Copyright (c) 2021-2022 Instructure Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy

{python-openapi-0.1.9 → python_openapi-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-openapi
-Version: 0.1.9
+Version: 0.1.10
 Summary: Generate an OpenAPI specification from a Python class definition
 Home-page: https://github.com/hunyadi/pyopenapi
 Author: Levente Hunyadi
@@ -15,12 +15,16 @@ 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: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: aiohttp>=3.11
+Requires-Dist: json_strong_typing>=0.3.7
 
 # Generate an OpenAPI specification from a Python class
 

{python-openapi-0.1.9 → python_openapi-0.1.10}/pyopenapi/__init__.py

@@ -1,10 +1,10 @@
-from typing import Any, Callable, Optional, TypeVar
+from typing import Any, Callable, List, Optional, TypeVar
 
 from .metadata import WebMethod
-from .options import *
-from .utility import Specification
+from .options import *  # noqa: F403
+from .utility import Specification as Specification
 
-__version__ = "0.1.9"
+__version__ = "0.1.10"
 
 T = TypeVar("T")
 
@@ -29,13 +29,9 @@ def webmethod(
     """
 
     if request_example is not None and request_examples is not None:
-        raise ValueError(
-            "arguments `request_example` and `request_examples` are exclusive"
-        )
+        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"
-        )
+        raise ValueError("arguments `response_example` and `response_examples` are exclusive")
 
     if request_example:
         request_examples = [request_example]

{python-openapi-0.1.9 → python_openapi-0.1.10}/pyopenapi/generator.py

@@ -1,35 +1,20 @@
+import dataclasses
 import hashlib
 import ipaddress
 import typing
-from typing import Any, Dict, Set, Union
+from dataclasses import dataclass
+from http import HTTPStatus
+from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
 
 from strong_typing.core import JsonType
 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.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, Schema, 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,
-)
-from .options import *
+from .operations import EndpointOperation, HTTPMethod, get_endpoint_events, get_endpoint_operations
+from .options import HTTPStatusCode, Options
 from .specification import (
     Components,
     Document,
@@ -165,9 +150,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):
@@ -179,12 +162,10 @@ 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  # type: ignore
+            schema_transformer: Callable[[SchemaOrRef], SchemaOrRef] = self.schema_transformer
             schema = schema_transformer(schema)
 
         if not examples:
@@ -198,25 +179,14 @@ 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."
 
-        if self.sample_transformer:
-            sample_transformer: Callable[[JsonType], JsonType] = self.sample_transformer  # type: ignore
-        else:
-            sample_transformer = lambda sample: sample
+        builder = ExampleBuilder(self.sample_transformer)
 
         results: Dict[str, Union[Example, ExampleRef]] = {}
         for example in examples:
-            value = sample_transformer(object_to_json(example))
-
-            hash_string = (
-                hashlib.md5(json_dump_string(value).encode("utf-8")).digest().hex()
-            )
-            name = f"ex-{hash_string}"
-
+            name, value = builder.get_named(example)
             results[name] = Example(value=value)
 
         return results
@@ -224,12 +194,43 @@ class ContentBuilder:
     def _build_example(self, example: Any) -> Any:
         "Creates a single example for a media type."
 
-        if self.sample_transformer:
-            sample_transformer: Callable[[JsonType], JsonType] = self.sample_transformer  # type: ignore
+        builder = ExampleBuilder(self.sample_transformer)
+        return builder.get_anonymous(example)
+
+
+class ExampleBuilder:
+    sample_transformer: Callable[[JsonType], JsonType]
+
+    def __init__(
+        self,
+        sample_transformer: Optional[Callable[[JsonType], JsonType]] = None,
+    ) -> None:
+        if sample_transformer:
+            self.sample_transformer = sample_transformer
         else:
-            sample_transformer = lambda sample: sample
+            self.sample_transformer = lambda sample: sample  # noqa: E731
+
+    def _get_value(self, example: Any) -> JsonType:
+        return self.sample_transformer(object_to_json(example))
+
+    def get_anonymous(self, example: Any) -> JsonType:
+        return self._get_value(example)
+
+    def get_named(self, example: Any) -> Tuple[str, JsonType]:
+        value = self._get_value(example)
+
+        name: Optional[str] = None
 
-        return sample_transformer(object_to_json(example))
+        if type(example).__str__ is not object.__str__:
+            friendly_name = str(example)
+            if friendly_name.isprintable():
+                name = friendly_name
+
+        if name is None:
+            hash_string = hashlib.md5(json_dump_string(value).encode("utf-8")).digest().hex()
+            name = f"ex-{hash_string}"
+
+        return name, value
 
 
 @dataclass
@@ -262,15 +263,11 @@ class ResponseBuilder:
     def __init__(self, content_builder: ContentBuilder) -> None:
         self.content_builder = content_builder
 
-    def _get_status_responses(
-        self, options: ResponseOptions
-    ) -> 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)
-            )
+            status_code = http_status_to_string(options.status_catalog.get(response_type, options.default_status_code))
 
             # look up response for status code
             if status_code not in status_responses:
@@ -282,17 +279,11 @@ class ResponseBuilder:
 
             # append examples that have the matching response type
             if options.examples:
-                status_response.examples.extend(
-                    example
-                    for example in options.examples
-                    if isinstance(example, response_type)
-                )
+                status_response.examples.extend(example for example in options.examples if isinstance(example, response_type))
 
         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.
         """
@@ -310,10 +301,7 @@ class ResponseBuilder:
             description = " **OR** ".join(
                 filter(
                     None,
-                    (
-                        options.type_descriptions[response_type]
-                        for response_type in response_types
-                    ),
+                    (options.type_descriptions[response_type] for response_type in response_types),
                 )
             )
 
@@ -388,14 +376,10 @@ class Generator:
         description = typing.cast(str, schema.get("description"))
         return Tag(
             name=ref,
-            description="\n\n".join(
-                s for s in (title, description, definition) if s is not None
-            ),
+            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.
 
@@ -419,9 +403,7 @@ class Generator:
 
     def _build_operation(self, op: EndpointOperation) -> Operation:
         doc_string = parse_type(op.func_ref)
-        doc_params = dict(
-            (param.name, param.description) for param in doc_string.params.values()
-        )
+        doc_params = dict((param.name, param.description) for param in doc_string.params.values())
 
         # parameters passed in URL component path
         path_parameters = [
@@ -462,11 +444,7 @@ class Generator:
             builder = ContentBuilder(self.schema_builder)
             request_name, request_type = op.request_param
             requestBody = RequestBody(
-                content={
-                    "application/json": builder.build_media_type(
-                        request_type, op.request_examples
-                    )
-                },
+                content={"application/json": builder.build_media_type(request_type, op.request_examples)},
                 description=doc_params.get(request_name),
                 required=True,
             )
@@ -476,29 +454,16 @@ 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
+                item: doc_string.short_description for item, doc_string in success_type_docstring.items() if doc_string.short_description
             }
         else:
             # use return type as a single response type
-            success_type_descriptions = {
-                op.response_type: (
-                    doc_string.returns.description if doc_string.returns else "OK"
-                )
-            }
+            success_type_descriptions = {op.response_type: (doc_string.returns.description if doc_string.returns else "OK")}
 
         response_examples = op.response_examples or []
-        success_examples = [
-            example
-            for example in response_examples
-            if not isinstance(example, Exception)
-        ]
+        success_examples = [example for example in response_examples if not isinstance(example, Exception)]
 
         content_builder = ContentBuilder(self.schema_builder)
         response_builder = ResponseBuilder(content_builder)
@@ -512,14 +477,8 @@ 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_examples = [
-                example
-                for example in response_examples
-                if isinstance(example, Exception)
-            ]
+            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:
                 schema_transformer = schema_error_wrapper
@@ -548,9 +507,7 @@ class Generator:
                 f"{op.func_name}_callback": {
                     "{$request.query.callback}": PathItem(
                         post=Operation(
-                            requestBody=RequestBody(
-                                content=builder.build_content(op.event_type)
-                            ),
+                            requestBody=RequestBody(content=builder.build_content(op.event_type)),
                             responses={"200": Response(description="OK")},
                         )
                     )
@@ -574,9 +531,7 @@ class Generator:
     def generate(self) -> Document:
         paths: Dict[str, PathItem] = {}
         endpoint_classes: Set[type] = set()
-        for op in get_endpoint_operations(
-            self.endpoint, use_examples=self.options.use_examples
-        ):
+        for op in get_endpoint_operations(self.endpoint, use_examples=self.options.use_examples):
             endpoint_classes.add(op.defining_class)
 
             operation = self._build_operation(op)
@@ -612,10 +567,7 @@ class Generator:
             )
 
         # types that are produced/consumed by operations
-        type_tags = [
-            self._build_type_tag(ref, schema)
-            for ref, schema in self.schema_builder.schemas.items()
-        ]
+        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] = []
@@ -628,17 +580,11 @@ class Generator:
         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}
-                )
+                extra_tag_groups = self._build_extra_tag_groups({"AdditionalTypes": self.options.extra_types})
             elif isinstance(self.options.extra_types, dict):
-                extra_tag_groups = self._build_extra_tag_groups(
-                    self.options.extra_types
-                )
+                extra_tag_groups = self._build_extra_tag_groups(self.options.extra_types)
             else:
-                raise TypeError(
-                    f"type mismatch for collection of extra types: {type(self.options.extra_types)}"
-                )
+                raise TypeError(f"type mismatch for collection of extra types: {type(self.options.extra_types)}")
 
         # list all operations and types
         tags: List[Tag] = []
@@ -686,11 +632,7 @@ class Generator:
         return Document(
             openapi=".".join(str(item) for item in self.options.version),
             info=self.options.info,
-            jsonSchemaDialect=(
-                "https://json-schema.org/draft/2020-12/schema"
-                if self.options.version >= (3, 1, 0)
-                else None
-            ),
+            jsonSchemaDialect=("https://json-schema.org/draft/2020-12/schema" if self.options.version >= (3, 1, 0) else None),
             servers=[self.options.server],
             paths=paths,
             components=Components(

{python-openapi-0.1.9 → python_openapi-0.1.10}/pyopenapi/operations.py

@@ -6,19 +6,12 @@ import uuid
 from dataclasses import dataclass
 from typing import Any, Callable, Dict, Iterable, Iterator, List, Optional, Tuple, Union
 
-from strong_typing.inspection import (
-    get_signature,
-    is_type_enum,
-    is_type_optional,
-    unwrap_optional_type,
-)
+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.
 
@@ -50,6 +43,7 @@ def _get_annotation_type(annotation: Union[type, str], callable: Callable) -> ty
         return annotation
 
 
+@enum.unique
 class HTTPMethod(enum.Enum):
     "HTTP method used to invoke an endpoint operation."
 
@@ -132,9 +126,7 @@ def _get_route_parameters(route: str) -> List[str]:
     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]]:
     if not inspect.isclass(endpoint):
         raise ValidationError(f"object is not a class type: {endpoint}")
 
@@ -156,14 +148,10 @@ def _get_defining_class(member_fn: str, derived_cls: type) -> type:
             if name == member_fn:
                 return cls
 
-    raise ValidationError(
-        f"cannot find defining class for {member_fn} in {derived_cls}"
-    )
+    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.
 
@@ -230,36 +218,23 @@ def get_endpoint_operations(
 
             # check if all parameters have explicit type
             if parameter.annotation is inspect.Parameter.empty:
-                raise ValidationError(
-                    f"parameter '{param_name}' in function '{func_name}' has no type annotation"
-                )
+                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)
             else:
                 inner_type = param_type
 
-            if (
-                inner_type is bool
-                or inner_type is int
-                or inner_type is float
-                or inner_type is str
-                or inner_type is uuid.UUID
-                or is_type_enum(inner_type)
-            ):
+            if inner_type is bool or inner_type is int or inner_type is float or inner_type is str or inner_type is uuid.UUID or is_type_enum(inner_type):
                 if parameter.kind == inspect.Parameter.POSITIONAL_ONLY:
                     if route_params is not None and param_name not in route_params:
-                        raise ValidationError(
-                            f"positional parameter '{param_name}' absent from user-defined route '{route}' for function '{func_name}'"
-                        )
+                        raise ValidationError(f"positional parameter '{param_name}' absent from user-defined route '{route}' for function '{func_name}'")
 
                     # simple type maps to route path element, e.g. /study/{uuid}/{version}
                     path_params.append((param_name, param_type))
                 else:
                     if route_params is not None and param_name in route_params:
-                        raise ValidationError(
-                            f"query parameter '{param_name}' found in user-defined route '{route}' for function '{func_name}'"
-                        )
+                        raise ValidationError(f"query parameter '{param_name}' found in user-defined route '{route}' for function '{func_name}'")
 
                     # simple type maps to key=value pair in query string
                     query_params.append((param_name, param_type))
@@ -280,9 +255,7 @@ def get_endpoint_operations(
 
         # check if function has explicit return type
         if signature.return_annotation is inspect.Signature.empty:
-            raise ValidationError(
-                f"function '{func_name}' has no return type annotation"
-            )
+            raise ValidationError(f"function '{func_name}' has no return type annotation")
 
         return_type = _get_annotation_type(signature.return_annotation, func_ref)
 

{python-openapi-0.1.9 → python_openapi-0.1.10}/pyopenapi/options.py

@@ -3,14 +3,11 @@ from dataclasses import dataclass
 from http import HTTPStatus
 from typing import Callable, ClassVar, Dict, List, Optional, Tuple, Union
 
-from .specification import (
-    Info,
-    SecurityScheme,
-    SecuritySchemeAPI,
-    SecuritySchemeHTTP,
-    SecuritySchemeOpenIDConnect,
-    Server,
-)
+from .specification import Info, SecurityScheme
+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]
 
@@ -37,12 +34,8 @@ class Options:
     default_security_scheme: Optional[SecurityScheme] = 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

{python-openapi-0.1.9 → python_openapi-0.1.10}/pyopenapi/proxy.py

@@ -4,12 +4,7 @@ from typing import Any, Callable, Dict, Optional, Tuple, Type, TypeVar
 import aiohttp
 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, get_signature
 
 
 async def make_request(
@@ -51,9 +46,9 @@ class ProxyInvokeError(RuntimeError):
 class EndpointProxy:
     "The HTTP REST proxy class for an endpoint."
 
-    url: str
+    base_url: str
 
-    def __init__(self, base_url: str):
+    def __init__(self, base_url: str) -> None:
         self.base_url = base_url
 
 
@@ -65,22 +60,18 @@ class OperationProxy:
     payload, builds an HTTP request, and processes the HTTP response.
     """
 
-    def __init__(self, op: EndpointOperation):
+    def __init__(self, op: EndpointOperation) -> None:
         self.op = op
         self.sig = get_signature(op.func_ref)
 
-    async def __call__(
-        self, endpoint_proxy: EndpointProxy, *args: Any, **kwargs: Any
-    ) -> Any:
+    async def __call__(self, endpoint_proxy: EndpointProxy, *args: Any, **kwargs: Any) -> Any:
         "Invokes an API operation via HTTP REST."
 
         ba = self.sig.bind(self, *args, **kwargs)
 
         # substitute parameters in URL path
         route = self.op.get_route()
-        path = route.format_map(
-            {name: ba.arguments[name] for name, _type in self.op.path_params}
-        )
+        path = route.format_map({name: ba.arguments[name] for name, _type in self.op.path_params})
 
         # gather URL query parameters
         query = {name: str(ba.arguments[name]) for name, _type in self.op.query_params}
@@ -99,18 +90,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}")
 
             return json_to_object(self.op.response_type, s)
         else:
@@ -122,9 +109,7 @@ def _get_operation_proxy(op: EndpointOperation) -> Callable[..., Any]:
 
     operation_proxy = OperationProxy(op)
 
-    async def _operation_proxy_fn(
-        self: EndpointProxy, *args: Any, **kwargs: Any
-    ) -> Any:
+    async def _operation_proxy_fn(self: EndpointProxy, *args: Any, **kwargs: Any) -> Any:
         return await operation_proxy(self, *args, **kwargs)
 
     return _operation_proxy_fn

{python-openapi-0.1.9 → python_openapi-0.1.10}/pyopenapi/specification.py

@@ -3,7 +3,8 @@ import enum
 from dataclasses import dataclass
 from typing import Any, ClassVar, Dict, List, Optional, Union
 
-from strong_typing.schema import JsonType, Schema, StrictJsonType
+from strong_typing.schema import JsonType as JsonType
+from strong_typing.schema import Schema, StrictJsonType
 
 URL = str
 
@@ -83,6 +84,7 @@ class Response:
     content: Optional[Dict[str, MediaType]] = None
 
 
+@enum.unique
 class ParameterLocation(enum.Enum):
     Query = "query"
     Header = "header"
@@ -153,6 +155,7 @@ class Server:
     description: Optional[str] = None
 
 
+@enum.unique
 class SecuritySchemeType(enum.Enum):
     ApiKey = "apiKey"
     HTTP = "http"
@@ -182,9 +185,7 @@ class SecuritySchemeHTTP(SecurityScheme):
     scheme: str
     bearerFormat: Optional[str] = None
 
-    def __init__(
-        self, description: str, scheme: str, bearerFormat: Optional[str] = None
-    ) -> None:
+    def __init__(self, description: str, scheme: str, bearerFormat: Optional[str] = None) -> None:
         super().__init__(SecuritySchemeType.HTTP, description)
         self.scheme = scheme
         self.bearerFormat = bearerFormat

{python-openapi-0.1.9 → python_openapi-0.1.10}/pyopenapi/utility.py

@@ -14,7 +14,7 @@ from .specification import Document
 class Specification:
     document: Document
 
-    def __init__(self, endpoint: type, options: Options):
+    def __init__(self, endpoint: type, options: Options) -> None:
         generator = Generator(endpoint, options)
         self.document = generator.generate()
 
@@ -53,9 +53,7 @@ class Specification:
 
         json_doc = self.get_json()
         if pretty_print:
-            return json.dumps(
-                json_doc, check_circular=False, ensure_ascii=False, indent=4
-            )
+            return json.dumps(json_doc, check_circular=False, ensure_ascii=False, indent=4)
         else:
             return json.dumps(
                 json_doc,
@@ -97,14 +95,10 @@ class Specification:
         """
 
         if sys.version_info >= (3, 9):
-            with importlib.resources.files(__package__).joinpath("template.html").open(
-                encoding="utf-8", errors="strict"
-            ) as html_template_file:
+            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:
+            with importlib.resources.open_text(__package__, "template.html", encoding="utf-8", errors="strict") as html_template_file:
                 html_template = html_template_file.read()
 
         html = html_template.replace(

{python-openapi-0.1.9 → python_openapi-0.1.10}/pyproject.toml

@@ -1,3 +1,6 @@
 [build-system]
 requires = ["setuptools>=42", "wheel"]
 build-backend = "setuptools.build_meta"
+
+[tool.ruff]
+line-length = 160

{python-openapi-0.1.9 → python_openapi-0.1.10}/python_openapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-openapi
-Version: 0.1.9
+Version: 0.1.10
 Summary: Generate an OpenAPI specification from a Python class definition
 Home-page: https://github.com/hunyadi/pyopenapi
 Author: Levente Hunyadi
@@ -15,12 +15,16 @@ 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: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: aiohttp>=3.11
+Requires-Dist: json_strong_typing>=0.3.7
 
 # Generate an OpenAPI specification from a Python class
 

python_openapi-0.1.10/python_openapi.egg-info/requires.txt

@@ -0,0 +1,2 @@
+aiohttp>=3.11
+json_strong_typing>=0.3.7

{python-openapi-0.1.9 → python_openapi-0.1.10}/setup.cfg

@@ -18,6 +18,8 @@ classifiers =
 	Programming Language :: Python :: 3.9
 	Programming Language :: Python :: 3.10
 	Programming Language :: Python :: 3.11
+	Programming Language :: Python :: 3.12
+	Programming Language :: Python :: 3.13
 	Topic :: Software Development :: Code Generators
 	Topic :: Software Development :: Libraries :: Python Modules
 	Typing :: Typed
@@ -28,8 +30,8 @@ include_package_data = True
 packages = find:
 python_requires = >=3.8
 install_requires = 
-	aiohttp >= 3.8
-	json_strong_typing >= 0.2.7
+	aiohttp >= 3.11
+	json_strong_typing >= 0.3.7
 
 [options.packages.find]
 exclude = 

{python-openapi-0.1.9 → python_openapi-0.1.10}/tests/test_openapi.py

@@ -6,28 +6,20 @@ from http import HTTPStatus
 from typing import TextIO
 from uuid import UUID
 
-from endpoint import (
-    AuthenticationError,
-    BadRequestError,
-    Endpoint,
-    InternalServerError,
-    NotFoundError,
-    Student,
-    Teacher,
-    ValidationError,
-)
+from endpoint import AuthenticationError, BadRequestError, Endpoint, InternalServerError, NotFoundError, Student, Teacher, ValidationError
 
 from pyopenapi import Info, Options, Server, Specification
 from pyopenapi.specification import SecuritySchemeHTTP
 
 try:
     from pygments import highlight
+    from pygments.formatter import Formatter
     from pygments.formatters import HtmlFormatter
     from pygments.lexers import get_lexer_by_name
 
     def save_with_highlight(f: TextIO, code: str, format: str) -> None:
         lexer = get_lexer_by_name(format)
-        formatter = HtmlFormatter()
+        formatter: Formatter = HtmlFormatter()
         style = formatter.get_style_defs(".highlight")
         f.writelines(
             [
@@ -82,7 +74,7 @@ class TestOpenAPI(unittest.TestCase):
         with open(os.path.join(os.path.dirname(__file__), "endpoint.md"), "r") as f:
             description = f.read()
 
-        self.root = os.path.join(os.path.dirname(__file__), "..", "examples")
+        self.root = os.path.join(os.path.dirname(__file__), "..", "website", "examples")
         os.makedirs(self.root, exist_ok=True)
         self.specification = Specification(
             Endpoint,

{python-openapi-0.1.9 → python_openapi-0.1.10}/tests/test_proxy.py

@@ -1,3 +1,4 @@
+import sys
 import unittest
 from dataclasses import dataclass
 from typing import Dict, Optional, Protocol
@@ -32,12 +33,10 @@ class HTTPBinPostResponse(HTTPBinResponse):
 
 class API(Protocol):
     @webmethod(route="/get")
-    async def get_method(self, /, id: str) -> HTTPBinResponse:
-        ...
+    async def get_method(self, /, id: str) -> HTTPBinResponse: ...
 
     @webmethod(route="/put")
-    async def set_method(self, /, id: str, doc: Document) -> HTTPBinPostResponse:
-        ...
+    async def set_method(self, /, id: str, doc: Document) -> HTTPBinPostResponse: ...
 
 
 class TestOpenAPI(unittest.IsolatedAsyncioTestCase):
@@ -55,6 +54,7 @@ class TestOpenAPI(unittest.IsolatedAsyncioTestCase):
         if headers:
             self.assertDictSubset(headers, response.headers)
 
+    @unittest.skipUnless(sys.version_info >= (3, 9), "requires Python 3.9 or later")
     async def test_http(self) -> None:
         Proxy = make_proxy_class(API)  # type: ignore
         proxy = Proxy("http://httpbin.org")  # type: ignore
@@ -63,9 +63,7 @@ class TestOpenAPI(unittest.IsolatedAsyncioTestCase):
         self.assertResponse(response, params={"id": "abc"})
 
         response = await proxy.set_method("abc", Document("title", "text"))
-        self.assertResponse(
-            response, params={"id": "abc"}, headers={"Content-Type": "application/json"}
-        )
+        self.assertResponse(response, params={"id": "abc"}, headers={"Content-Type": "application/json"})
 
 
 if __name__ == "__main__":

python-openapi-0.1.9/python_openapi.egg-info/requires.txt

@@ -1,2 +0,0 @@
-aiohttp>=3.8
-json_strong_typing>=0.2.7