diff options
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | python-openapi-schema-pydantic.spec | 949 | ||||
| -rw-r--r-- | sources | 1 |
3 files changed, 951 insertions, 0 deletions
@@ -0,0 +1 @@ +/openapi-schema-pydantic-1.2.4.tar.gz diff --git a/python-openapi-schema-pydantic.spec b/python-openapi-schema-pydantic.spec new file mode 100644 index 0000000..bc1906f --- /dev/null +++ b/python-openapi-schema-pydantic.spec @@ -0,0 +1,949 @@ +%global _empty_manifest_terminate_build 0 +Name: python-openapi-schema-pydantic +Version: 1.2.4 +Release: 1 +Summary: OpenAPI (v3) specification schema as pydantic class +License: MIT License +URL: https://github.com/kuimono/openapi-schema-pydantic +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/8e/8f/9d2fd2d5a233d916c03d7463c0c0bc2a1bfffb91abee80ef2d3bd9b40cda/openapi-schema-pydantic-1.2.4.tar.gz +BuildArch: noarch + +Requires: python3-pydantic + +%description +# openapi-schema-pydantic + +[](https://pypi.org/project/openapi-schema-pydantic/) +[](https://github.com/kuimono/openapi-schema-pydantic/blob/master/LICENSE) + +OpenAPI (v3) specification schema as [Pydantic](https://github.com/samuelcolvin/pydantic) classes. + +The naming of the classes follows the schema in +[OpenAPI specification](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#schema). + +## Installation + +`pip install openapi-schema-pydantic` + +## Try me + +```python +from openapi_schema_pydantic import OpenAPI, Info, PathItem, Operation, Response + +# Construct OpenAPI by pydantic objects +open_api = OpenAPI( + info=Info( + title="My own API", + version="v0.0.1", + ), + paths={ + "/ping": PathItem( + get=Operation( + responses={ + "200": Response( + description="pong" + ) + } + ) + ) + }, +) +print(open_api.json(by_alias=True, exclude_none=True, indent=2)) +``` + +Result: + +```json +{ + "openapi": "3.1.0", + "info": { + "title": "My own API", + "version": "v0.0.1" + }, + "servers": [ + { + "url": "/" + } + ], + "paths": { + "/ping": { + "get": { + "responses": { + "200": { + "description": "pong" + } + }, + "deprecated": false + } + } + } +} +``` + +## Take advantage of Pydantic + +Pydantic is a great tool, allow you to use object / dict / mixed data for for input. + +The following examples give the same OpenAPI result as above: + +```python +from openapi_schema_pydantic import OpenAPI, PathItem, Response + +# Construct OpenAPI from dict +open_api = OpenAPI.parse_obj({ + "info": {"title": "My own API", "version": "v0.0.1"}, + "paths": { + "/ping": { + "get": {"responses": {"200": {"description": "pong"}}} + } + }, +}) + +# Construct OpenAPI with mix of dict/object +open_api = OpenAPI.parse_obj({ + "info": {"title": "My own API", "version": "v0.0.1"}, + "paths": { + "/ping": PathItem( + get={"responses": {"200": Response(description="pong")}} + ) + }, +}) +``` + +## Use Pydantic classes as schema + +- The [Schema Object](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.3.md#schemaObject) + in OpenAPI has definitions and tweaks in JSON Schema, which is hard to comprehend and define a good data class +- Pydantic already has a good way to [create JSON schema](https://pydantic-docs.helpmanual.io/usage/schema/), + let's not re-invent the wheel + +The approach to deal with this: + +1. Use `PydanticSchema` objects to represent the `Schema` in `OpenAPI` object +2. Invoke `construct_open_api_with_schema_class` to resolve the JSON schemas and references + +```python +from pydantic import BaseModel, Field + +from openapi_schema_pydantic import OpenAPI +from openapi_schema_pydantic.util import PydanticSchema, construct_open_api_with_schema_class + +def construct_base_open_api() -> OpenAPI: + return OpenAPI.parse_obj({ + "info": {"title": "My own API", "version": "v0.0.1"}, + "paths": { + "/ping": { + "post": { + "requestBody": {"content": {"application/json": { + "schema": PydanticSchema(schema_class=PingRequest) + }}}, + "responses": {"200": { + "description": "pong", + "content": {"application/json": { + "schema": PydanticSchema(schema_class=PingResponse) + }}, + }}, + } + } + }, + }) + +class PingRequest(BaseModel): + """Ping Request""" + req_foo: str = Field(description="foo value of the request") + req_bar: str = Field(description="bar value of the request") + +class PingResponse(BaseModel): + """Ping response""" + resp_foo: str = Field(description="foo value of the response") + resp_bar: str = Field(description="bar value of the response") + +open_api = construct_base_open_api() +open_api = construct_open_api_with_schema_class(open_api) + +# print the result openapi.json +print(open_api.json(by_alias=True, exclude_none=True, indent=2)) +``` + +Result: + +```json +{ + "openapi": "3.1.0", + "info": { + "title": "My own API", + "version": "v0.0.1" + }, + "servers": [ + { + "url": "/" + } + ], + "paths": { + "/ping": { + "post": { + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/PingRequest" + } + } + }, + "required": false + }, + "responses": { + "200": { + "description": "pong", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/PingResponse" + } + } + } + } + }, + "deprecated": false + } + } + }, + "components": { + "schemas": { + "PingRequest": { + "title": "PingRequest", + "required": [ + "req_foo", + "req_bar" + ], + "type": "object", + "properties": { + "req_foo": { + "title": "Req Foo", + "type": "string", + "description": "foo value of the request" + }, + "req_bar": { + "title": "Req Bar", + "type": "string", + "description": "bar value of the request" + } + }, + "description": "Ping Request" + }, + "PingResponse": { + "title": "PingResponse", + "required": [ + "resp_foo", + "resp_bar" + ], + "type": "object", + "properties": { + "resp_foo": { + "title": "Resp Foo", + "type": "string", + "description": "foo value of the response" + }, + "resp_bar": { + "title": "Resp Bar", + "type": "string", + "description": "bar value of the response" + } + }, + "description": "Ping response" + } + } + } +} +``` + +## Notes + +### Use of OpenAPI.json() / OpenAPI.dict() + +When using `OpenAPI.json()` / `OpenAPI.dict()` function, +arguments `by_alias=True, exclude_none=True` has to be in place. +Otherwise the result json will not fit the OpenAPI standard. + +```python +# OK +open_api.json(by_alias=True, exclude_none=True, indent=2) + +# Not good +open_api.json(indent=2) +``` + +More info about field alias: + +| OpenAPI version | Field alias info | +| --------------- | ---------------- | +| 3.1.0 | [here](https://github.com/kuimono/openapi-schema-pydantic/blob/master/openapi_schema_pydantic/v3/v3_1_0/README.md#alias) | +| 3.0.3 | [here](https://github.com/kuimono/openapi-schema-pydantic/blob/master/openapi_schema_pydantic/v3/v3_0_3/README.md#alias) | + +### Non-pydantic schema types + +Some schema types are not implemented as pydantic classes. +Please refer to the following for more info: + +| OpenAPI version | Non-pydantic schema type info | +| --------------- | ----------------------------- | +| 3.1.0 | [here](https://github.com/kuimono/openapi-schema-pydantic/blob/master/openapi_schema_pydantic/v3/v3_1_0/README.md#non-pydantic-schema-types) | +| 3.0.3 | [here](https://github.com/kuimono/openapi-schema-pydantic/blob/master/openapi_schema_pydantic/v3/v3_0_3/README.md#non-pydantic-schema-types) | + +### Use OpenAPI 3.0.3 instead of 3.1.0 + +Some UI renderings (e.g. Swagger) still do not support OpenAPI 3.1.0. +It is allowed to use the old 3.0.3 version by importing from different paths: + +```python +from openapi_schema_pydantic.v3.v3_0_3 import OpenAPI, ... +from openapi_schema_pydantic.v3.v3_0_3.util import PydanticSchema, construct_open_api_with_schema_class +``` + +## License + +[MIT License](https://github.com/kuimono/openapi-schema-pydantic/blob/master/LICENSE) + + +%package -n python3-openapi-schema-pydantic +Summary: OpenAPI (v3) specification schema as pydantic class +Provides: python-openapi-schema-pydantic +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-openapi-schema-pydantic +# openapi-schema-pydantic + +[](https://pypi.org/project/openapi-schema-pydantic/) +[](https://github.com/kuimono/openapi-schema-pydantic/blob/master/LICENSE) + +OpenAPI (v3) specification schema as [Pydantic](https://github.com/samuelcolvin/pydantic) classes. + +The naming of the classes follows the schema in +[OpenAPI specification](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#schema). + +## Installation + +`pip install openapi-schema-pydantic` + +## Try me + +```python +from openapi_schema_pydantic import OpenAPI, Info, PathItem, Operation, Response + +# Construct OpenAPI by pydantic objects +open_api = OpenAPI( + info=Info( + title="My own API", + version="v0.0.1", + ), + paths={ + "/ping": PathItem( + get=Operation( + responses={ + "200": Response( + description="pong" + ) + } + ) + ) + }, +) +print(open_api.json(by_alias=True, exclude_none=True, indent=2)) +``` + +Result: + +```json +{ + "openapi": "3.1.0", + "info": { + "title": "My own API", + "version": "v0.0.1" + }, + "servers": [ + { + "url": "/" + } + ], + "paths": { + "/ping": { + "get": { + "responses": { + "200": { + "description": "pong" + } + }, + "deprecated": false + } + } + } +} +``` + +## Take advantage of Pydantic + +Pydantic is a great tool, allow you to use object / dict / mixed data for for input. + +The following examples give the same OpenAPI result as above: + +```python +from openapi_schema_pydantic import OpenAPI, PathItem, Response + +# Construct OpenAPI from dict +open_api = OpenAPI.parse_obj({ + "info": {"title": "My own API", "version": "v0.0.1"}, + "paths": { + "/ping": { + "get": {"responses": {"200": {"description": "pong"}}} + } + }, +}) + +# Construct OpenAPI with mix of dict/object +open_api = OpenAPI.parse_obj({ + "info": {"title": "My own API", "version": "v0.0.1"}, + "paths": { + "/ping": PathItem( + get={"responses": {"200": Response(description="pong")}} + ) + }, +}) +``` + +## Use Pydantic classes as schema + +- The [Schema Object](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.3.md#schemaObject) + in OpenAPI has definitions and tweaks in JSON Schema, which is hard to comprehend and define a good data class +- Pydantic already has a good way to [create JSON schema](https://pydantic-docs.helpmanual.io/usage/schema/), + let's not re-invent the wheel + +The approach to deal with this: + +1. Use `PydanticSchema` objects to represent the `Schema` in `OpenAPI` object +2. Invoke `construct_open_api_with_schema_class` to resolve the JSON schemas and references + +```python +from pydantic import BaseModel, Field + +from openapi_schema_pydantic import OpenAPI +from openapi_schema_pydantic.util import PydanticSchema, construct_open_api_with_schema_class + +def construct_base_open_api() -> OpenAPI: + return OpenAPI.parse_obj({ + "info": {"title": "My own API", "version": "v0.0.1"}, + "paths": { + "/ping": { + "post": { + "requestBody": {"content": {"application/json": { + "schema": PydanticSchema(schema_class=PingRequest) + }}}, + "responses": {"200": { + "description": "pong", + "content": {"application/json": { + "schema": PydanticSchema(schema_class=PingResponse) + }}, + }}, + } + } + }, + }) + +class PingRequest(BaseModel): + """Ping Request""" + req_foo: str = Field(description="foo value of the request") + req_bar: str = Field(description="bar value of the request") + +class PingResponse(BaseModel): + """Ping response""" + resp_foo: str = Field(description="foo value of the response") + resp_bar: str = Field(description="bar value of the response") + +open_api = construct_base_open_api() +open_api = construct_open_api_with_schema_class(open_api) + +# print the result openapi.json +print(open_api.json(by_alias=True, exclude_none=True, indent=2)) +``` + +Result: + +```json +{ + "openapi": "3.1.0", + "info": { + "title": "My own API", + "version": "v0.0.1" + }, + "servers": [ + { + "url": "/" + } + ], + "paths": { + "/ping": { + "post": { + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/PingRequest" + } + } + }, + "required": false + }, + "responses": { + "200": { + "description": "pong", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/PingResponse" + } + } + } + } + }, + "deprecated": false + } + } + }, + "components": { + "schemas": { + "PingRequest": { + "title": "PingRequest", + "required": [ + "req_foo", + "req_bar" + ], + "type": "object", + "properties": { + "req_foo": { + "title": "Req Foo", + "type": "string", + "description": "foo value of the request" + }, + "req_bar": { + "title": "Req Bar", + "type": "string", + "description": "bar value of the request" + } + }, + "description": "Ping Request" + }, + "PingResponse": { + "title": "PingResponse", + "required": [ + "resp_foo", + "resp_bar" + ], + "type": "object", + "properties": { + "resp_foo": { + "title": "Resp Foo", + "type": "string", + "description": "foo value of the response" + }, + "resp_bar": { + "title": "Resp Bar", + "type": "string", + "description": "bar value of the response" + } + }, + "description": "Ping response" + } + } + } +} +``` + +## Notes + +### Use of OpenAPI.json() / OpenAPI.dict() + +When using `OpenAPI.json()` / `OpenAPI.dict()` function, +arguments `by_alias=True, exclude_none=True` has to be in place. +Otherwise the result json will not fit the OpenAPI standard. + +```python +# OK +open_api.json(by_alias=True, exclude_none=True, indent=2) + +# Not good +open_api.json(indent=2) +``` + +More info about field alias: + +| OpenAPI version | Field alias info | +| --------------- | ---------------- | +| 3.1.0 | [here](https://github.com/kuimono/openapi-schema-pydantic/blob/master/openapi_schema_pydantic/v3/v3_1_0/README.md#alias) | +| 3.0.3 | [here](https://github.com/kuimono/openapi-schema-pydantic/blob/master/openapi_schema_pydantic/v3/v3_0_3/README.md#alias) | + +### Non-pydantic schema types + +Some schema types are not implemented as pydantic classes. +Please refer to the following for more info: + +| OpenAPI version | Non-pydantic schema type info | +| --------------- | ----------------------------- | +| 3.1.0 | [here](https://github.com/kuimono/openapi-schema-pydantic/blob/master/openapi_schema_pydantic/v3/v3_1_0/README.md#non-pydantic-schema-types) | +| 3.0.3 | [here](https://github.com/kuimono/openapi-schema-pydantic/blob/master/openapi_schema_pydantic/v3/v3_0_3/README.md#non-pydantic-schema-types) | + +### Use OpenAPI 3.0.3 instead of 3.1.0 + +Some UI renderings (e.g. Swagger) still do not support OpenAPI 3.1.0. +It is allowed to use the old 3.0.3 version by importing from different paths: + +```python +from openapi_schema_pydantic.v3.v3_0_3 import OpenAPI, ... +from openapi_schema_pydantic.v3.v3_0_3.util import PydanticSchema, construct_open_api_with_schema_class +``` + +## License + +[MIT License](https://github.com/kuimono/openapi-schema-pydantic/blob/master/LICENSE) + + +%package help +Summary: Development documents and examples for openapi-schema-pydantic +Provides: python3-openapi-schema-pydantic-doc +%description help +# openapi-schema-pydantic + +[](https://pypi.org/project/openapi-schema-pydantic/) +[](https://github.com/kuimono/openapi-schema-pydantic/blob/master/LICENSE) + +OpenAPI (v3) specification schema as [Pydantic](https://github.com/samuelcolvin/pydantic) classes. + +The naming of the classes follows the schema in +[OpenAPI specification](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#schema). + +## Installation + +`pip install openapi-schema-pydantic` + +## Try me + +```python +from openapi_schema_pydantic import OpenAPI, Info, PathItem, Operation, Response + +# Construct OpenAPI by pydantic objects +open_api = OpenAPI( + info=Info( + title="My own API", + version="v0.0.1", + ), + paths={ + "/ping": PathItem( + get=Operation( + responses={ + "200": Response( + description="pong" + ) + } + ) + ) + }, +) +print(open_api.json(by_alias=True, exclude_none=True, indent=2)) +``` + +Result: + +```json +{ + "openapi": "3.1.0", + "info": { + "title": "My own API", + "version": "v0.0.1" + }, + "servers": [ + { + "url": "/" + } + ], + "paths": { + "/ping": { + "get": { + "responses": { + "200": { + "description": "pong" + } + }, + "deprecated": false + } + } + } +} +``` + +## Take advantage of Pydantic + +Pydantic is a great tool, allow you to use object / dict / mixed data for for input. + +The following examples give the same OpenAPI result as above: + +```python +from openapi_schema_pydantic import OpenAPI, PathItem, Response + +# Construct OpenAPI from dict +open_api = OpenAPI.parse_obj({ + "info": {"title": "My own API", "version": "v0.0.1"}, + "paths": { + "/ping": { + "get": {"responses": {"200": {"description": "pong"}}} + } + }, +}) + +# Construct OpenAPI with mix of dict/object +open_api = OpenAPI.parse_obj({ + "info": {"title": "My own API", "version": "v0.0.1"}, + "paths": { + "/ping": PathItem( + get={"responses": {"200": Response(description="pong")}} + ) + }, +}) +``` + +## Use Pydantic classes as schema + +- The [Schema Object](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.3.md#schemaObject) + in OpenAPI has definitions and tweaks in JSON Schema, which is hard to comprehend and define a good data class +- Pydantic already has a good way to [create JSON schema](https://pydantic-docs.helpmanual.io/usage/schema/), + let's not re-invent the wheel + +The approach to deal with this: + +1. Use `PydanticSchema` objects to represent the `Schema` in `OpenAPI` object +2. Invoke `construct_open_api_with_schema_class` to resolve the JSON schemas and references + +```python +from pydantic import BaseModel, Field + +from openapi_schema_pydantic import OpenAPI +from openapi_schema_pydantic.util import PydanticSchema, construct_open_api_with_schema_class + +def construct_base_open_api() -> OpenAPI: + return OpenAPI.parse_obj({ + "info": {"title": "My own API", "version": "v0.0.1"}, + "paths": { + "/ping": { + "post": { + "requestBody": {"content": {"application/json": { + "schema": PydanticSchema(schema_class=PingRequest) + }}}, + "responses": {"200": { + "description": "pong", + "content": {"application/json": { + "schema": PydanticSchema(schema_class=PingResponse) + }}, + }}, + } + } + }, + }) + +class PingRequest(BaseModel): + """Ping Request""" + req_foo: str = Field(description="foo value of the request") + req_bar: str = Field(description="bar value of the request") + +class PingResponse(BaseModel): + """Ping response""" + resp_foo: str = Field(description="foo value of the response") + resp_bar: str = Field(description="bar value of the response") + +open_api = construct_base_open_api() +open_api = construct_open_api_with_schema_class(open_api) + +# print the result openapi.json +print(open_api.json(by_alias=True, exclude_none=True, indent=2)) +``` + +Result: + +```json +{ + "openapi": "3.1.0", + "info": { + "title": "My own API", + "version": "v0.0.1" + }, + "servers": [ + { + "url": "/" + } + ], + "paths": { + "/ping": { + "post": { + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/PingRequest" + } + } + }, + "required": false + }, + "responses": { + "200": { + "description": "pong", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/PingResponse" + } + } + } + } + }, + "deprecated": false + } + } + }, + "components": { + "schemas": { + "PingRequest": { + "title": "PingRequest", + "required": [ + "req_foo", + "req_bar" + ], + "type": "object", + "properties": { + "req_foo": { + "title": "Req Foo", + "type": "string", + "description": "foo value of the request" + }, + "req_bar": { + "title": "Req Bar", + "type": "string", + "description": "bar value of the request" + } + }, + "description": "Ping Request" + }, + "PingResponse": { + "title": "PingResponse", + "required": [ + "resp_foo", + "resp_bar" + ], + "type": "object", + "properties": { + "resp_foo": { + "title": "Resp Foo", + "type": "string", + "description": "foo value of the response" + }, + "resp_bar": { + "title": "Resp Bar", + "type": "string", + "description": "bar value of the response" + } + }, + "description": "Ping response" + } + } + } +} +``` + +## Notes + +### Use of OpenAPI.json() / OpenAPI.dict() + +When using `OpenAPI.json()` / `OpenAPI.dict()` function, +arguments `by_alias=True, exclude_none=True` has to be in place. +Otherwise the result json will not fit the OpenAPI standard. + +```python +# OK +open_api.json(by_alias=True, exclude_none=True, indent=2) + +# Not good +open_api.json(indent=2) +``` + +More info about field alias: + +| OpenAPI version | Field alias info | +| --------------- | ---------------- | +| 3.1.0 | [here](https://github.com/kuimono/openapi-schema-pydantic/blob/master/openapi_schema_pydantic/v3/v3_1_0/README.md#alias) | +| 3.0.3 | [here](https://github.com/kuimono/openapi-schema-pydantic/blob/master/openapi_schema_pydantic/v3/v3_0_3/README.md#alias) | + +### Non-pydantic schema types + +Some schema types are not implemented as pydantic classes. +Please refer to the following for more info: + +| OpenAPI version | Non-pydantic schema type info | +| --------------- | ----------------------------- | +| 3.1.0 | [here](https://github.com/kuimono/openapi-schema-pydantic/blob/master/openapi_schema_pydantic/v3/v3_1_0/README.md#non-pydantic-schema-types) | +| 3.0.3 | [here](https://github.com/kuimono/openapi-schema-pydantic/blob/master/openapi_schema_pydantic/v3/v3_0_3/README.md#non-pydantic-schema-types) | + +### Use OpenAPI 3.0.3 instead of 3.1.0 + +Some UI renderings (e.g. Swagger) still do not support OpenAPI 3.1.0. +It is allowed to use the old 3.0.3 version by importing from different paths: + +```python +from openapi_schema_pydantic.v3.v3_0_3 import OpenAPI, ... +from openapi_schema_pydantic.v3.v3_0_3.util import PydanticSchema, construct_open_api_with_schema_class +``` + +## License + +[MIT License](https://github.com/kuimono/openapi-schema-pydantic/blob/master/LICENSE) + + +%prep +%autosetup -n openapi-schema-pydantic-1.2.4 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-openapi-schema-pydantic -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Fri May 05 2023 Python_Bot <Python_Bot@openeuler.org> - 1.2.4-1 +- Package Spec generated @@ -0,0 +1 @@ +4e23392aa8851d6a3eb0f80adb8d648b openapi-schema-pydantic-1.2.4.tar.gz |