def responses(self) -> List[EndpointResponse]: _responses = [] responses = list(self.endpoint.definition["responses"].items()) default_response = self.endpoint.definition["responses"].get("default") if default_response and "content" in default_response: responses.extend(list(default_response.items())) for status_code, response_definition in responses: if "content" not in response_definition: empty_response = EndpointResponse( status_code=status_code, data_type=make_data_type({}), definition={}, content_type="default", ) if empty_response not in _responses: _responses.append(empty_response) continue for content_type, response_schema in response_definition[ "content"].items(): response = EndpointResponse( status_code=status_code, data_type=make_data_type(response_schema["schema"]), definition=response_schema["schema"], content_type=content_type, ) if response not in _responses: _responses.append(response) return sorted(_responses, key=lambda o: (o.status_code, o.content_type))
def test_parse_object_with_alias_field(): assert make_data_type( { "x-name": "Obj", "type": "object", "properties": {"fields": {"type": "string", "default": "yes"}}, } ) == ObjectDataType( python_type="Obj", members=[ DataType( python_type="str", member_name="fields_", member_value="pydantic.Field('yes', alias=\"fields\")", ), ], ) assert make_data_type( { "x-name": "Obj", "type": "object", "properties": {"fields": {"type": "integer"}}, } ) == ObjectDataType( python_type="Obj", members=[ DataType( python_type="int", member_name="fields_", member_value='pydantic.Field(None, alias="fields")', ), ], )
def test_parse_all_of_any_of_one_of(): int_schema = {"type": "integer"} object_schema = { "type": "object", "properties": {"name": {"type": "string"}}, "required": ["name"], } fields = ("oneOf", "allOf", "anyOf") for field in fields: data_type = make_data_type({field: [int_schema]}) assert data_type == DataType(python_type="int", members=[DataType(python_type="int")]) data_type = make_data_type({field: [int_schema, {}]}) assert data_type == DataType( python_type="typing.Union[int, None]", members=[DataType(python_type="int"), DataType(python_type="None")], ) data_type = make_data_type({field: [object_schema]}) assert data_type == DataType( python_type="None", members=[ ObjectDataType( python_type=None, members=[ DataType( python_type="str", member_name="name", ) ], ) ], )
def test_parse_enum(): data_type = make_data_type({"enum": ["one", "two"]}) assert data_type == DataType(python_type="str") data_type = make_data_type({ "title": "PriceType", "enum": [1], "type": "integer" }) assert data_type == DataType(python_type="int")
def test_parse_string(): assert make_data_type({"type": "string", "format": "binary"}) == DataType(python_type="bytes") assert make_data_type({"type": "string", "format": "date-time"}) == DataType( python_type="datetime.datetime" ) assert make_data_type({"type": "string", "format": "date"}) == DataType( python_type="datetime.date" ) assert make_data_type({"type": "string", "format": "time"}) == DataType(python_type="time.time") assert make_data_type({"type": "string"}) == DataType(python_type="str")
def test_parse_object(): assert make_data_type({"type": "object"}) == DataType(python_type="typing.Dict") assert make_data_type({ "type": "object", "additionalProperties": { "type": "boolean" } }) == DataType(python_type="typing.Dict[str, bool]", members=[DataType(python_type="bool")])
def test_parse_array(): assert make_data_type({ "type": "array", "items": {} }) == DataType(python_type="typing.List") assert make_data_type({ "type": "array", "items": { "type": "integer" } }) == DataType(python_type="typing.List[int]", members=[DataType(python_type="int")])
def test_parse_object_with_recursive_reference(): assert make_data_type( { "x-name": "Obj1", "type": "object", "required": ["recursive"], "properties": { "recursive": { "x-name": "Obj1", "type": "object", "required": ["recursive"], "properties": { "recursive": { "x-name": "Obj1", "type": "object", "properties": {"recursive": {}}, "required": ["recursive"], }, }, }, }, } ) == ObjectDataType( python_type="Obj1", members=[ ObjectDataType( python_type="Obj1", member_name="recursive", is_recursive=True, ), ], )
def test_parse_object_with_required_and_or_default(): r = make_data_type( { "x-name": "Obj", "type": "object", "properties": { "a": {"type": "string", "default": "a"}, "b": {"type": "string", "default": "b"}, "c": {"type": "string"}, "d": {"type": "string"}, }, "required": ["a", "c"], } ) assert r == ObjectDataType( python_type="Obj", members=[ DataType( python_type="str", member_name="a", member_value="'a'", ), DataType(python_type="str", member_name="b", member_value="'b'"), DataType(python_type="str", member_name="c"), DataType( python_type="str", member_name="d", member_value="None", is_optional_type=True, ), ], )
def test_parse_complex_object(): assert make_data_type({ "x-name": "Obj1", "type": "object", "properties": { "field1": { "type": "integer" }, "field2": { "type": "string", "default": "some-value" }, }, }) == ObjectDataType( python_type="Obj1", members=[ DataType( python_type="int", member_name="field1", member_value="None", is_optional_type=True, ), DataType(python_type="str", member_name="field2", member_value="'some-value'"), ], )
def body_request(self) -> Optional[EndpointRequest]: name = "__request__" if self.endpoint.body: return EndpointRequest( name=name, data_type=make_data_type(self.endpoint.body), definition=self.endpoint.body, content_type="application/json", ) if self.endpoint.form_data: return EndpointRequest( name=name, data_type=make_data_type(self.endpoint.form_data), definition=self.endpoint.form_data, content_type="multipart/form-data", ) return None
def to_argument(self, name: str, schema: dict, is_required: bool): argument = { "name": name, "type": make_data_type(schema).python_type, "required": is_required, } default = schema.get("default") if default: argument["default"] = repr(default) if not is_required and "default" not in argument: argument["default"] = "..." return argument
def test_parse_allof_oneof_anyof_without_names(): schema = { "type": "object", "properties": { "source": { "allOf": [ { "type": "object", "properties": { "prop": { "type": "string", } }, }, { "type": "object", "properties": { "prop": { "type": "integer", }, }, }, ] } }, } assert make_data_type(schema) == ObjectDataType( python_type=None, members=[ DataType( python_type="typing.Union[Source1, Source2]", member_name="source", member_value="None", members=[ ObjectDataType( python_type="Source1", is_recursive=True, ), ObjectDataType( python_type="Source2", is_recursive=True, ), ], is_optional_type=True, ) ], )
def test_parse_complex_object_read_only(): assert make_data_type( { "x-name": "Obj1", "type": "object", "properties": { "field1": {"type": "integer", "readOnly": True}, "field2": {"type": "string", "default": "some-value"}, }, }, for_writes=True, ) == ObjectDataType( python_type="Obj1", members=[ DataType(python_type="str", member_name="field2", member_value="'some-value'"), ], )
def test_parse_nested_object(): data_type = make_data_type( { "x-name": "top_level_model", "type": "object", "properties": { "string_property": {"type": "string"}, "nested_property": { "type": "object", "properties": { "number_property": { "type": "number", }, }, }, }, }, ) assert data_type == ObjectDataType( python_type="top_level_model", members=[ DataType( python_type="str", member_name="string_property", member_value="None", is_optional_type=True, is_recursive=False, ), ObjectDataType( python_type="top_level_modelNested_property", member_name="nested_property", member_value="None", is_optional_type=True, is_recursive=False, members=[ DataType( python_type="float", member_name="number_property", is_optional_type=True, member_value="None", ) ], ), ], )
def test_parse_raises_if_schema_is_invalid(): with pytest.raises(ValueError): make_data_type({"something": True, "type": "invalid"})
def test_parse_additional_properties(): false_properties = make_data_type({"type": "object", "additionalProperties": False}) true_properties = make_data_type({"type": "object", "additionalProperties": True}) assert false_properties == DataType(python_type="typing.Dict") assert true_properties == DataType(python_type="typing.Dict")
def test_parse_primitive_types(): assert make_data_type({"type": "integer"}) == DataType(python_type="int") assert make_data_type({"type": "number"}) == DataType(python_type="float") assert make_data_type({"type": "boolean"}) == DataType(python_type="bool") assert make_data_type({"type": "null"}) == DataType(python_type="None")
def test_parse_missing_schema(): data_type = make_data_type({"description": "string"}) assert data_type == DataType(python_type="typing.Any")
def test_parse_empty_schema(): data_type = make_data_type({}) assert data_type == DataType(python_type="None")
def test_parse_enum(): data_type = make_data_type({"enum": ["one", "two"]}) assert data_type == DataType(python_type="str")