def get_models_from_rpc_methods(methods: Dict[str, Callable]) -> TypeModelSet:
clean_models: List[Type[BaseModel]] = [
create_model(
"Health",
is_sick=(bool, False),
checks=(Dict[str, str], Field(..., example={"srv": "ok"})),
version=(str, Field(..., example="1.0.0")),
start_time=(datetime, ...),
up_time=(str, Field(..., example="0:00:12.850850")),
)
]
for method, func in methods.items():
sig = inspect.signature(func)
method_name = getattr(func, "__rpc_name__", method)
request_params_model = getattr(func, "__rpc_request_model__", None)
response_result_model = getattr(func, "__rpc_response_model__", None)
camel_method_name = snake_to_camel(method_name)
request_model_name = f"{camel_method_name}Request"
request_params_model_name = f"{camel_method_name}RequestParams"
response_model_name = f"{camel_method_name}Response"
response_result_model_name = f"{camel_method_name}ResponseResult"
RequestParamsModel = request_params_model or create_model(
request_params_model_name,
**get_field_definitions(sig.parameters),
)
if getattr(RequestParamsModel, "__name__", "") == request_model_name:
fix_model_name(RequestParamsModel, request_params_model_name)
RequestModel = create_model(
request_model_name,
method=(str, Field(..., example=method_name)),
params=(RequestParamsModel, ...),
)
response: Dict[str, Any] = dict(
code=(int, Field(..., example=0)),
message=(str, Field(..., example="OK")),
)
ResponseResultModel = response_result_model or sig.return_annotation
if ResponseResultModel is not None:
if (getattr(ResponseResultModel, "__name__",
"") == response_model_name):
fix_model_name(ResponseResultModel, response_result_model_name)
response["result"] = (ResponseResultModel, None)
ResponseModel = create_model(response_model_name, **response)
clean_models.extend([RequestParamsModel, RequestModel, ResponseModel])
flat_models = get_flat_models_from_models(clean_models)
return flat_models
def test_model_name_maps():
create_testing_submodules()
from pydantic_schema_test.modulea.modela import Model as ModelA
from pydantic_schema_test.moduleb.modelb import Model as ModelB
from pydantic_schema_test.modulec.modelc import Model as ModelC
from pydantic_schema_test.moduled.modeld import Model as ModelD
class Foo(BaseModel):
a: str
class Bar(BaseModel):
b: Foo
class Baz(BaseModel):
c: Bar
flat_models = get_flat_models_from_models([Baz, ModelA, ModelB, ModelC, ModelD])
model_name_map = get_model_name_map(flat_models)
assert model_name_map == {
Foo: 'Foo',
Bar: 'Bar',
Baz: 'Baz',
ModelA: 'pydantic_schema_test__modulea__modela__Model',
ModelB: 'pydantic_schema_test__moduleb__modelb__Model',
ModelC: 'pydantic_schema_test__modulec__modelc__Model',
}
def test_flat_models_unique_models():
create_testing_submodules()
from pydantic_schema_test.modulea.modela import Model as ModelA
from pydantic_schema_test.moduleb.modelb import Model as ModelB
from pydantic_schema_test.moduled.modeld import Model as ModelD
flat_models = get_flat_models_from_models([ModelA, ModelB, ModelD])
assert flat_models == set([ModelA, ModelB])
def test_flat_models_with_submodels_from_sequence():
class Foo(BaseModel):
a: str
class Bar(BaseModel):
b: Foo
class Ingredient(BaseModel):
name: str
class Pizza(BaseModel):
name: str
ingredients: List[Ingredient]
flat_models = get_flat_models_from_models([Bar, Pizza])
assert flat_models == set([Foo, Bar, Ingredient, Pizza])
