330 lines
11 KiB
Python
330 lines
11 KiB
Python
from typing import Any, Dict, List, Optional, Union
|
|
|
|
|
|
class ReferenceObject:
|
|
def __init__(self, ref: str = ""):
|
|
self.ref = ref
|
|
|
|
@classmethod
|
|
def load(cls, data: Dict[str, Any]) -> "ReferenceObject":
|
|
return cls(ref=data.get("$ref", ""))
|
|
|
|
|
|
class SchemaObject:
|
|
def __init__(
|
|
self,
|
|
title: Optional[str] = None,
|
|
multipleOf: Optional[float] = None,
|
|
maximum: Optional[float] = None,
|
|
exclusiveMaximum: Optional[bool] = None,
|
|
minimum: Optional[float] = None,
|
|
exclusiveMinimum: Optional[bool] = None,
|
|
maxLength: Optional[int] = None,
|
|
minLength: Optional[int] = None,
|
|
pattern: Optional[str] = None,
|
|
maxItems: Optional[int] = None,
|
|
minItems: Optional[int] = None,
|
|
uniqueItems: Optional[bool] = None,
|
|
maxProperties: Optional[int] = None,
|
|
minProperties: Optional[int] = None,
|
|
required: Optional[List[str]] = None,
|
|
enum: Optional[List[Any]] = None,
|
|
type: Optional[str] = None,
|
|
allOf: Optional[List[Union["SchemaObject", ReferenceObject]]] = None,
|
|
oneOf: Optional[List[Union["SchemaObject", ReferenceObject]]] = None,
|
|
anyOf: Optional[List[Union["SchemaObject", ReferenceObject]]] = None,
|
|
not_: Optional[Union["SchemaObject", ReferenceObject]] = None,
|
|
items: Optional[
|
|
Union[
|
|
"SchemaObject",
|
|
ReferenceObject,
|
|
List[Union["SchemaObject", ReferenceObject]],
|
|
]
|
|
] = None,
|
|
properties: Optional[Dict[str, Union["SchemaObject", ReferenceObject]]] = None,
|
|
additionalProperties: Optional[Union[bool, "SchemaObject"]] = None,
|
|
description: Optional[str] = None,
|
|
format: Optional[str] = None,
|
|
default: Optional[Any] = None,
|
|
xtags: Optional[List[str]] = None,
|
|
example: Optional[str] = None,
|
|
):
|
|
self.title = title
|
|
self.multipleOf = multipleOf
|
|
self.maximum = maximum
|
|
self.exclusiveMaximum = exclusiveMaximum
|
|
self.minimum = minimum
|
|
self.exclusiveMinimum = exclusiveMinimum
|
|
self.maxLength = maxLength
|
|
self.minLength = minLength
|
|
self.pattern = pattern
|
|
self.maxItems = maxItems
|
|
self.minItems = minItems
|
|
self.uniqueItems = uniqueItems
|
|
self.maxProperties = maxProperties
|
|
self.minProperties = minProperties
|
|
self.required = required
|
|
self.enum = enum
|
|
self.type = type
|
|
self.allOf = allOf
|
|
self.oneOf = oneOf
|
|
self.anyOf = anyOf
|
|
self.not_ = not_
|
|
self.items = items
|
|
self.properties = properties
|
|
self.additionalProperties = additionalProperties
|
|
self.description = description
|
|
self.format = format
|
|
self.default = default
|
|
self.xtags = xtags
|
|
self.example = example
|
|
|
|
@classmethod
|
|
def load(cls, data: Dict[str, Any]) -> "SchemaObject":
|
|
return cls(
|
|
title=data.get("title"),
|
|
multipleOf=data.get("multipleOf"),
|
|
maximum=data.get("maximum"),
|
|
exclusiveMaximum=data.get("exclusiveMaximum"),
|
|
minimum=data.get("minimum"),
|
|
exclusiveMinimum=data.get("exclusiveMinimum"),
|
|
maxLength=data.get("maxLength"),
|
|
minLength=data.get("minLength"),
|
|
pattern=data.get("pattern"),
|
|
maxItems=data.get("maxItems"),
|
|
minItems=data.get("minItems"),
|
|
uniqueItems=data.get("uniqueItems"),
|
|
maxProperties=data.get("maxProperties"),
|
|
minProperties=data.get("minProperties"),
|
|
required=data.get("required"),
|
|
enum=data.get("enum"),
|
|
type=data.get("type"),
|
|
allOf=(
|
|
[
|
|
(
|
|
ReferenceObject.load(item)
|
|
if "$ref" in item
|
|
else SchemaObject.load(item)
|
|
)
|
|
for item in data.get("allOf", [])
|
|
]
|
|
if "allOf" in data
|
|
else None
|
|
),
|
|
oneOf=(
|
|
[
|
|
(
|
|
ReferenceObject.load(item)
|
|
if "$ref" in item
|
|
else SchemaObject.load(item)
|
|
)
|
|
for item in data.get("oneOf", [])
|
|
]
|
|
if "oneOf" in data
|
|
else None
|
|
),
|
|
anyOf=(
|
|
[
|
|
(
|
|
ReferenceObject.load(item)
|
|
if "$ref" in item
|
|
else SchemaObject.load(item)
|
|
)
|
|
for item in data.get("anyOf", [])
|
|
]
|
|
if "anyOf" in data
|
|
else None
|
|
),
|
|
not_=(
|
|
(
|
|
ReferenceObject.load(data)
|
|
if "$ref" in data
|
|
else SchemaObject.load(data)
|
|
)
|
|
if "not" in data
|
|
else None
|
|
),
|
|
items=(
|
|
(
|
|
ReferenceObject.load(data["items"])
|
|
if "$ref" in data["items"]
|
|
else SchemaObject.load(data["items"])
|
|
)
|
|
if isinstance(data.get("items"), dict)
|
|
else (
|
|
[
|
|
(
|
|
ReferenceObject.load(item)
|
|
if "$ref" in item
|
|
else SchemaObject.load(item)
|
|
)
|
|
for item in data.get("items", [])
|
|
]
|
|
if "items" in data
|
|
else None
|
|
)
|
|
),
|
|
properties=(
|
|
{
|
|
k: (
|
|
ReferenceObject.load(v) if "$ref" in v else SchemaObject.load(v)
|
|
)
|
|
for k, v in data.get("properties", {}).items()
|
|
}
|
|
if "properties" in data
|
|
else None
|
|
),
|
|
additionalProperties=(
|
|
SchemaObject.load(data["additionalProperties"])
|
|
if isinstance(data.get("additionalProperties"), dict)
|
|
else data.get("additionalProperties")
|
|
),
|
|
description=data.get("description"),
|
|
format=data.get("format"),
|
|
default=data.get("default"),
|
|
xtags=data.get("x-tags"),
|
|
example=data.get("example"),
|
|
)
|
|
|
|
|
|
class ContentDescriptorObject:
|
|
def __init__(
|
|
self,
|
|
name: str,
|
|
schema: Union[SchemaObject, ReferenceObject],
|
|
summary: Optional[str] = None,
|
|
description: Optional[str] = None,
|
|
required: Optional[bool] = None,
|
|
deprecated: Optional[bool] = None,
|
|
):
|
|
self.name = name
|
|
self.summary = summary
|
|
self.description = description
|
|
self.required = required
|
|
self.schema = schema
|
|
self.deprecated = deprecated
|
|
|
|
@classmethod
|
|
def load(cls, data: Dict[str, Any]) -> "ContentDescriptorObject":
|
|
return cls(
|
|
name=data["name"],
|
|
summary=data.get("summary"),
|
|
description=data.get("description"),
|
|
required=data.get("required"),
|
|
schema=(
|
|
ReferenceObject.load(data["schema"])
|
|
if "$ref" in data["schema"]
|
|
else SchemaObject.load(data["schema"])
|
|
),
|
|
deprecated=data.get("deprecated"),
|
|
)
|
|
|
|
|
|
class ExternalDocumentationObject:
|
|
def __init__(self, url: str, description: Optional[str] = None):
|
|
self.description = description
|
|
self.url = url
|
|
|
|
@classmethod
|
|
def load(cls, data: Dict[str, Any]) -> "ExternalDocumentationObject":
|
|
return cls(description=data.get("description"), url=data["url"])
|
|
|
|
|
|
class ExampleObject:
|
|
def __init__(
|
|
self,
|
|
name: str,
|
|
summary: Optional[str] = None,
|
|
description: Optional[str] = None,
|
|
value: Optional[Any] = None,
|
|
externalValue: Optional[str] = None,
|
|
):
|
|
self.name = name
|
|
self.summary = summary
|
|
self.description = description
|
|
self.value = value
|
|
self.externalValue = externalValue
|
|
|
|
@classmethod
|
|
def load(cls, data: Dict[str, Any]) -> "ExampleObject":
|
|
return cls(
|
|
name=data["name"],
|
|
summary=data.get("summary"),
|
|
description=data.get("description"),
|
|
value=data.get("value"),
|
|
externalValue=data.get("externalValue"),
|
|
)
|
|
|
|
|
|
class ErrorObject:
|
|
def __init__(self, code: int, message: str, data: Optional[Any] = None):
|
|
self.code = code
|
|
self.message = message
|
|
self.data = data
|
|
|
|
@classmethod
|
|
def load(cls, data: Dict[str, Any]) -> "ErrorObject":
|
|
return cls(code=data["code"], message=data["message"], data=data.get("data"))
|
|
|
|
|
|
class ExamplePairingObject:
|
|
def __init__(
|
|
self,
|
|
name: str,
|
|
result: Union[ExampleObject, ReferenceObject],
|
|
params: List[ExampleObject],
|
|
description: Optional[str] = None,
|
|
summary: Optional[str] = None,
|
|
):
|
|
self.name = name
|
|
self.description = description
|
|
self.summary = summary
|
|
self.params = params
|
|
self.result = result
|
|
|
|
def get_x() -> Union[str, int]:
|
|
a = [1, 2, 3]
|
|
b = ["a", "b", "c"]
|
|
z = Union()
|
|
|
|
@classmethod
|
|
def load(cls, data: Dict[str, Any]) -> "ExamplePairingObject":
|
|
return cls(
|
|
name=data["name"],
|
|
description=data.get("description"),
|
|
summary=data.get("summary"),
|
|
params=[ExampleObject.load(item) for item in data["params"]],
|
|
result=(
|
|
ExampleObject.load(data["result"])
|
|
if isinstance(data["result"], dict) and "value" in data["result"]
|
|
else ReferenceObject.load(data["result"])
|
|
),
|
|
)
|
|
|
|
|
|
class TagObject:
|
|
def __init__(
|
|
self,
|
|
name: str,
|
|
summary: Optional[str] = None,
|
|
description: Optional[str] = None,
|
|
externalDocs: Optional[ExternalDocumentationObject] = None,
|
|
):
|
|
self.name = name
|
|
self.summary = summary
|
|
self.description = description
|
|
self.externalDocs = externalDocs
|
|
|
|
@classmethod
|
|
def load(cls, data: Dict[str, Any]) -> "TagObject":
|
|
return cls(
|
|
name=data["name"],
|
|
summary=data.get("summary"),
|
|
description=data.get("description"),
|
|
externalDocs=(
|
|
ExternalDocumentationObject.load(data["externalDocs"])
|
|
if "externalDocs" in data
|
|
else None
|
|
),
|
|
)
|