Typeddict from schema or the other way around

[fretchen]

I love the Schema class for anything related to the json API. Imagine for example an API that returns some schema:

MyFancySchema(Schema):
  name: str
  number: int

Now I have some other functions that create the schema and I would like to type check with mypy that the right type gets created. For simplicity let's say that it would look like this:

def calculate_fancy()-> MyFancySchema:
   ...
   return {'name': NameStr, 'number': 42}

As far as I can saw mypy complains about the type here as it does not have the right type. However, if MyFancySchema was a TypedDict everything would work out quite nicely. So is there a way to transform on into another in rather straight forward fashion ? I simply did not find anything about this out there but it felt like it must be something standard that I am simply missing.

For reference, I wanted to add a similiar question from StackOverflow here.

[bufke]

Is there a reason you don't want to reuse Schema in your fancy function?

def calculate_fancy()-> MyFancySchema:
   ...
   return MyFancySchema(name="something", number=42)

Perhaps you don't like that it does unnecessary runtime validation? Another option would be to define the TypedDict. Then assign that to the Schema.

 MyFancySchema(Schema):
    data = FancyTypedDict

mypy complains about the type here

I think you're confusing how the api decorator works vs without it. When you make an API endpoint, with the decorator, you can set a response to a Schema class. The decorator function is converting the returned data into the Pydantic schema. That lets you return any object that can possibly be serialized via the schema. But that doesn't just magically happen otherwise and it isn't the type hint alone that makes it happen. The Python type hint on calculate_fancy has no effect on the code at all. So if you tell Python it returns a MyFancySchema but then you return a dict, mypy correctly raises an error.

[fretchen]

Hmm,

thanks for the hints. I am almost sure that you are right that I am confusing something, but I am really not sure what. Here is the typical code that I have. The API endpoint is something like this:

@api.get( "/get_status", response={200: MyFancySchema, codes_4xx: JobResponseSchema})
def get_backend_status(request):
    """
    Returns some fancy status.
    """
    return calculate_fancy()

The function now calls

def calculate_fancy()-> MyFancyTypedDict:
   return {'name': NameStr, 'number': 42}

And the types would then be defined through:

MyFancySchema(Schema):
  name: str
  number: int

MyFancyTypedDict(TypedDict):
  name: str
  number: int

I am honestly not able to see how I could use your recommendation to use only one of the two MyFancySchema or MyFancyTypedDict. Any recommendation would be very instructive.

[bufke]

I'm not sure what you don't want calculate_fancy to return MyFancySchema. Then there is no need to convert it. Can you explain your use case?

[fretchen]

I must admit that I simply never properly considered this approach. The working solution was:

def calculate_fancy()-> MyFancyTypedSchema:

   dict = {'name': NameStr, 'number': 42}
   return MyFancyTypedSchema(**dict)

Whenever, I needed access to the specific entries, for example in tests, I use the MyFancyTypedSchema.dict() function and I am back to the standard work with a dict.

Thanks getting me out of the loop.