Request Object

[dev0Guy]

While reading NestJs docs I've stumble upon Request object that allow use attribute decorator to map attribute to request.
For example,

@Get(':id')findOne(@Param()params: any): string{console.log(params.id);return`This action returns a #${params.id} cat`;}

I would really be happy to see a use of this feature in PyNest.
Here is a description of couple of the features:

Path Param

@Get("/{id}/{category}")deffind_one(self, id: Param[uuid.uuid4], category: Param[str]) ->str:
print(id, category)
returnf`This action returns a #{id} cat with category of {category}`;

can use regex with inspect module to validate all path param declared in route inside function signature

Query Param

@Get("/")deffind_one_by_id(self, id: Query[uuid.uuid4]) ->str:
print(id, category)
returnf`This action returns a #{id} cat with category of {category}`;

Headers

@Get("/")deffind_one_by_id(self, id: Header[uuid.uuid4]) ->str:
print(id, category)
returnf`This action returns a #{id} cat with category of {category}`;

Body

@Get("/")deffind_one_by_id(self, id: Body[uuid.uuid4]) ->str:
print(id, category)
returnf`This action returns a #{id} cat with category of {category}`;

After reviewing the existing code I've notice a strong reliance of FastApi Router (I know I can use default implementation of FastAPI like Query, Headers).
By Providing an proxy types we can decoupling between PyNest and FastApi, Thus allowing usage of
other framework like Litestar, Blackship ....

Only by changing original function signature into desired one (like FastAPI or Lightstar).

[dev0Guy]

Example of code that thoes so:

fromfastapiimportQuery, Path, HeaderimportinspectimporttypingfromtypingimportAnnotatedimportabcT=typing.TypeVar('T')
classRequestAttribute(abc.ABC, typing.Generic[T]):
...
classRequestHeader(RequestAttribute[T]):
...
defconvert_to_fastapi_annotations(func):
sig=inspect.signature(func)
new_params= []
forname, paraminsig.parameters.items():
annotation=param.annotation# Check if the annotation is RequestHeader[T]iftyping.get_origin(annotation) ==RequestHeader:
# Extract the type T from RequestHeader[T]inner_type=typing.get_args(annotation)[0]
# Replace with Annotated[T, Header()]new_annotation=Annotated[inner_type, Header()]
new_params.append(
inspect.Parameter(
name=name,
kind=param.kind,
default=param.default,
annotation=new_annotation
)
)
else:
# Keep other parameters unchangednew_params.append(param)
# Create a new signaturenew_sig=sig.replace(parameters=new_params)
# Update the function's signaturefunc.__signature__=new_sigreturnfunc@convert_to_fastapi_annotationsdefsome_function(x: RequestHeader[int], y: int) ->int:
returnx+ydefsome_function_fastapi(x: typing.Annotated[int, Header()], y: int) ->int:
returnx+y# Testingprint(inspect.signature(some_function))
print(inspect.signature(some_function_fastapi))
print(some_function(10, 12))

output:

(x: typing.Annotated[int, Header(PydanticUndefined)], y: int) -> int
(x: typing.Annotated[int, Header(PydanticUndefined)], y: int) -> int
22

[dev0Guy]

Motivation

Today request attribute extraction is not done in the framework itself (bellow) but inside fastAPI.
In NestJs docs we can see in controller section which allow the developer to access request attribute , I want to implement this feature inside the package itself as Protocol Thus allowing easer replacement of the underline engine in the future .

Request Attribute:

Today request is done by passing extra attribute to the underline fastAPI decorator.

fromfastapiimportHeaderfromtypingimportAnnotationimportuuid@Get("/")defget_somthing(id: Annotation[uuid.uuid4, Header()]) ->None:
...

the code passing it to fastapi.

defadd_route_to_router(router: APIRouter, method_function: callable) ->None:
"""Add the configured route to the router."""route_kwargs= {
"path": method_function.__route_path__,
"endpoint": method_function,
"methods": [method_function.__http_method__.value],
**method_function.__kwargs__,
}
ifhasattr(method_function, "status_code"):
route_kwargs["status_code"] =method_function.status_coderouter.add_api_route(**route_kwargs)

By creating Request protocol inside the library we'll be able to deploy the package as plug&play while the underline engine can be swapped easier. A prime example is faststream and how same developer function can be Redis Broker or KafkaBroker with minimal codebase change.
Furthermore, we can add feature with ease, here some simple example:

frompynestimportGet, Header, Response@Get("/")deffind_one_by_id(self, id: Header[uuid.uuid4]) ->Response[str,StatusCode[200]]:
print(id, category)
returnf`This action returns a #{id} cat with category of {category}`;

Note

Same should be done for Route and Routing as Protocol which will map each one for the correct framework.
I will refer to all of the code where I seen use in fastAPI directly. After mapping all of the assurance we can build/create an interface or Protocol to replace all of them.
Afterward we can try to integrate another framework like socketify.py