o NK&hd{@sddlmZmZmZddlmZddlmZddlm Z m Z ddl m Z ddl mZmZmZmZmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZmZdd l m!Z!ddl"m#Z#ee!gee!e$ee!fffZ%GdddeedZ&dS)) NodeVisitorReturnparse)Iterable)suppress) getsource signature)dedent)AnyCallableOptionalUnioncast)Route) SanicMeta) HTTP_METHODS)RESPONSE_MAPPING) BaseMixin) FutureRoute FutureStatic) RouteHandler) HashableDictc#@sReZdZd:ddZdedeefddZ            d;d ed e e ed e e eeefde e de de e e eefde ede de de eede de de dede ededef"ddZedhdddddd ddf ded ed e ed e e eeefde e de e e eefde ede dede ede dedefdd Z     dd ed e e eeefde e de e e eefde ede dede ededefd-d.Z      d?d ed e e eeefde e de eede e e eefde ede dede edefd/d0Z      d@d ed e e eeefde e de e e eefde edede edefd1d2Zdefd3d4Zd5d6Zd7e eefde!fd8d9Z"dS)A RouteMixinreturnNcOst|_t|_dSN)set_future_routes_future_statics)selfargskwargsr!F/var/www/html/venv/lib/python3.10/site-packages/sanic/mixins/routes.py__init__s zRouteMixin.__init__routecCstr)NotImplementedError)rr$r!r!r" _apply_route#szRouteMixin._apply_routeFT/vurimethodshoststrict_slashesstreamversionname ignore_bodyapply subprotocols websocketunquotestaticversion_prefix error_format ctx_kwargsc sz ds s tdrd  durj s s tdh| fdd}|S)aDecorate a function to be registered as a route. Args: uri (str): Path of the URL. methods (Optional[Iterable[str]]): List or tuple of methods allowed. host (Optional[Union[str, List[str]]]): The host, if required. strict_slashes (Optional[bool]): Whether to apply strict slashes to the route. stream (bool): Whether to allow the request to stream its body. version (Optional[Union[int, str, float]]): Route specific versioning. name (Optional[str]): User-defined route name for url_for. ignore_body (bool): Whether the handler should ignore request body (e.g. `GET` requests). apply (bool): Apply middleware to the route. subprotocols (Optional[List[str]]): List of subprotocols. websocket (bool): Enable WebSocket support. unquote (bool): Unquote special characters in the URL path. static (bool): Enable static route. version_prefix (str): URL path that should be before the version value; default: `"/v"`. error_format (Optional[str]): Error format for the route. ctx_kwargs (Any): Keyword arguments that begin with a `ctx_*` prefix will be appended to the route context (`route.ctx`). Returns: RouteWrapper: Tuple of routes, decorated function. Examples: Using the method to define a GET endpoint: ```python @app.route("/hello") async def hello(request: Request): return text("Hello, World!") ``` Adding context kwargs to the route: ```python @app.route("/greet", ctx_name="World") async def greet(request: Request): name = request.route.ctx.name return text(f"Hello, {name}!") ``` /routerNGETcst|tr |\}}|ttrtgnr5tts5ztWn ty4tdwt tr?t  n t trHt  rNdkrS |t | rZdntddD  }t dd}|rtt fddj _ j |tt|j}rt|d kr|j}td |d |s|j}td |d s r |_rňj||d r||fS|S)Nz:Expected either string or Iterable of host strings, not %sautocSsg|]}|qSr!)upper).0xr!r!r" sz7RouteMixin.route..decorator.._allow_route_overwriteFcs |jkSrr()r>rAr!r"s z5RouteMixin.route..decorator..z8Required parameter `request` and/or `ws` missing in the z () route?z,Required parameter `request` missing in the ) overwrite) isinstancetuple generate_namestr frozenset TypeError ValueErrorlistr_determine_error_formatrgetattrfilterraddr parameterskeyslen__name__ is_streamr&)handler_r$rDr handler_namer0r6r*r/r)r. route_contextrr4r,r+r1r3r(r-r5r2r!r" decoratorvs             z#RouteMixin.route..decorator) startswithhasattrr+rI_build_route_context)rr(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r[r!rYr"r$&sE  ,]zRouteMixin.router:rVc  Kst|dr(t}tD]} t|d}t|| d}|r'|| t|dr'd}q |dur/|j}|jd|||||||| | | d | ||S)aA helper method to register class-based view or functions as a handler to the application url routes. Args: handler (RouteHandler): Function or class-based view used as a route handler. uri (str): Path of the URL. methods (Iterable[str]): List or tuple of methods allowed; these are overridden if using an HTTPMethodView. host (Optional[Union[str, List[str]]]): Hostname or hostnames to match for this route. strict_slashes (Optional[bool]): If set, a route's slashes will be strict. E.g. `/foo` will not match `/foo/`. version (Optional[Union[int, str, float]]): Version of the API for this route. name (Optional[str]): User-defined route name for `url_for`. stream (bool): Boolean specifying if the handler is a stream handler. version_prefix (str): URL path that should be before the version value; default: ``/v``. error_format (Optional[str]): Custom error format string. unquote (bool): Boolean specifying if the handler requires unquoting. ctx_kwargs (Any): Keyword arguments that begin with a `ctx_*` prefix will be appended to the route context (``route.ctx``). See below for examples. Returns: RouteHandler: The route handler. Examples: ```python from sanic import Sanic, text app = Sanic("test") async def handler(request): return text("OK") app.add_route(handler, "/test", methods=["GET", "POST"]) ``` You can use `ctx_kwargs` to add custom context to the route. This can often be useful when wanting to add metadata to a route that can be used by other parts of the application (like middleware). ```python from sanic import Sanic, text app = Sanic("test") async def handler(request): return text("OK") async def custom_middleware(request): if request.route.ctx.monitor: do_some_monitoring() app.add_route(handler, "/test", methods=["GET", "POST"], ctx_monitor=True) app.register_middleware(custom_middleware) view_classNrUT) r(r)r*r+r,r-r.r5r6r3r!)r]rrrNlowerrPr+r$)rrVr(r)r*r+r-r.r,r5r6r3r7methodr__handlerr!r!r" add_routes: B      zRouteMixin.add_routec K0tt|j|ftdh|||||||d| S)a0Decorate a function handler to create a route definition using the **GET** HTTP method. Args: uri (str): URL to be tagged to GET method of HTTP. host (Optional[Union[str, List[str]]]): Host IP or FQDN for the service to use. strict_slashes (Optional[bool]): Instruct Sanic to check if the request URLs need to terminate with a `/`. version (Optional[Union[int, str, float]]): API Version. name (Optional[str]): Unique name that can be used to identify the route. ignore_body (bool): Whether the handler should ignore request body. This means the body of the request, if sent, will not be consumed. In that instance, you will see a warning in the logs. Defaults to `True`, meaning do not consume the body. version_prefix (str): URL path that should be before the version value. Defaults to `"/v"`. error_format (Optional[str]): Custom error format string. **ctx_kwargs (Any): Keyword arguments that begin with a `ctx_* prefix` will be appended to the route context (`route.ctx`). Returns: RouteHandler: Object decorated with route method. r:r)r*r+r-r.r/r5r6rrr$rI rr(r*r+r-r.r/r5r6r7r!r!r"get5"% zRouteMixin.getc Krd)aoDecorate a function handler to create a route definition using the **POST** HTTP method. Args: uri (str): URL to be tagged to POST method of HTTP. host (Optional[Union[str, List[str]]]): Host IP or FQDN for the service to use. strict_slashes (Optional[bool]): Instruct Sanic to check if the request URLs need to terminate with a `/`. stream (bool): Whether or not to stream the request body. Defaults to `False`. version (Optional[Union[int, str, float]]): API Version. name (Optional[str]): Unique name that can be used to identify the route. version_prefix (str): URL path that should be before the version value. Defaults to `"/v"`. error_format (Optional[str]): Custom error format string. **ctx_kwargs (Any): Keyword arguments that begin with a `ctx_*` prefix will be appended to the route context (`route.ctx`). Returns: RouteHandler: Object decorated with route method. POSTr)r*r+r,r-r.r5r6rf rr(r*r+r,r-r.r5r6r7r!r!r"postj"# zRouteMixin.postc Krd)amDecorate a function handler to create a route definition using the **PUT** HTTP method. Args: uri (str): URL to be tagged to PUT method of HTTP. host (Optional[Union[str, List[str]]]): Host IP or FQDN for the service to use. strict_slashes (Optional[bool]): Instruct Sanic to check if the request URLs need to terminate with a `/`. stream (bool): Whether or not to stream the request body. Defaults to `False`. version (Optional[Union[int, str, float]]): API Version. name (Optional[str]): Unique name that can be used to identify the route. version_prefix (str): URL path that should be before the version value. Defaults to `"/v"`. error_format (Optional[str]): Custom error format string. **ctx_kwargs (Any): Keyword arguments that begin with a `ctx_*` prefix will be appended to the route context (`route.ctx`). Returns: RouteHandler: Object decorated with route method. PUTrkrfrlr!r!r"putrnzRouteMixin.putc Krd)a2Decorate a function handler to create a route definition using the **HEAD** HTTP method. Args: uri (str): URL to be tagged to HEAD method of HTTP. host (Optional[Union[str, List[str]]]): Host IP or FQDN for the service to use. strict_slashes (Optional[bool]): Instruct Sanic to check if the request URLs need to terminate with a `/`. version (Optional[Union[int, str, float]]): API Version. name (Optional[str]): Unique name that can be used to identify the route. ignore_body (bool): Whether the handler should ignore request body. This means the body of the request, if sent, will not be consumed. In that instance, you will see a warning in the logs. Defaults to `True`, meaning do not consume the body. version_prefix (str): URL path that should be before the version value. Defaults to `"/v"`. error_format (Optional[str]): Custom error format string. **ctx_kwargs (Any): Keyword arguments that begin with a `ctx_*` prefix will be appended to the route context (`route.ctx`). Returns: RouteHandler: Object decorated with route method. HEADrerfrgr!r!r"headrizRouteMixin.headc Krd)a8Decorate a function handler to create a route definition using the **OPTIONS** HTTP method. Args: uri (str): URL to be tagged to OPTIONS method of HTTP. host (Optional[Union[str, List[str]]]): Host IP or FQDN for the service to use. strict_slashes (Optional[bool]): Instruct Sanic to check if the request URLs need to terminate with a `/`. version (Optional[Union[int, str, float]]): API Version. name (Optional[str]): Unique name that can be used to identify the route. ignore_body (bool): Whether the handler should ignore request body. This means the body of the request, if sent, will not be consumed. In that instance, you will see a warning in the logs. Defaults to `True`, meaning do not consume the body. version_prefix (str): URL path that should be before the version value. Defaults to `"/v"`. error_format (Optional[str]): Custom error format string. **ctx_kwargs (Any): Keyword arguments that begin with a `ctx_*` prefix will be appended to the route context (`route.ctx`). Returns: RouteHandler: Object decorated with route method. OPTIONSrerfrgr!r!r"optionsrizRouteMixin.optionsc Krd)aDecorate a function handler to create a route definition using the **PATCH** HTTP method. Args: uri (str): URL to be tagged to PATCH method of HTTP. host (Optional[Union[str, List[str]]]): Host IP or FQDN for the service to use. strict_slashes (Optional[bool]): Instruct Sanic to check if the request URLs need to terminate with a `/`. stream (bool): Set to `True` if full request streaming is needed, `False` otherwise. Defaults to `False`. version (Optional[Union[int, str, float]]): API Version. name (Optional[str]): Unique name that can be used to identify the route. version_prefix (str): URL path that should be before the version value. Defaults to `"/v"`. error_format (Optional[str]): Custom error format string. **ctx_kwargs (Any): Keyword arguments that begin with a `ctx_*` prefix will be appended to the route context (`route.ctx`). Returns: RouteHandler: Object decorated with route method. PATCHrkrfrlr!r!r"patch:rnzRouteMixin.patchc Krd)asDecorate a function handler to create a route definition using the **DELETE** HTTP method. Args: uri (str): URL to be tagged to the DELETE method of HTTP. host (Optional[Union[str, List[str]]]): Host IP or FQDN for the service to use. strict_slashes (Optional[bool]): Instruct Sanic to check if the request URLs need to terminate with a */*. version (Optional[Union[int, str, float]]): API Version. name (Optional[str]): Unique name that can be used to identify the Route. ignore_body (bool): Whether or not to ignore the body in the request. Defaults to `False`. version_prefix (str): URL path that should be before the version value. Defaults to `"/v"`. error_format (Optional[str]): Custom error format string. **ctx_kwargs (Any): Keyword arguments that begin with a `ctx_*` prefix will be appended to the route context (`route.ctx`). Returns: RouteHandler: Object decorated with route method. DELETErerfrgr!r!r"deletems"" zRouteMixin.deletec Ks(|jd||d|||||d|| d | S)aDecorate a function to be registered as a websocket route. Args: uri (str): Path of the URL. host (Optional[Union[str, List[str]]]): Host IP or FQDN details. strict_slashes (Optional[bool]): If the API endpoint needs to terminate with a `"/"` or not. subprotocols (Optional[List[str]]): Optional list of str with supported subprotocols. version (Optional[Union[int, str, float]]): WebSocket protocol version. name (Optional[str]): A unique name assigned to the URL so that it can be used with url_for. apply (bool): If set to False, it doesn't apply the route to the app. Default is `True`. version_prefix (str): URL path that should be before the version value. Defaults to `"/v"`. error_format (Optional[str]): Custom error format string. **ctx_kwargs (Any): Keyword arguments that begin with a `ctx_* prefix` will be appended to the route context (`route.ctx`). Returns: tuple: Tuple of routes, decorated function. NT) r(r*r)r+r-r.r0r1r2r5r6r!)r$) rr(r*r+r1r-r.r0r5r6r7r!r!r"r2s& zRouteMixin.websocketc Ks&|jd|||||||| d| |S)azA helper method to register a function as a websocket route. Args: handler (Callable): A callable function or instance of a class that can handle the websocket request. uri (str): URL path that will be mapped to the websocket handler. host (Optional[Union[str, List[str]]]): Host IP or FQDN details. strict_slashes (Optional[bool]): If the API endpoint needs to terminate with a `"/"` or not. subprotocols (Optional[List[str]]): Subprotocols to be used with websocket handshake. version (Optional[Union[int, str, float]]): Versioning information. name (Optional[str]): A unique name assigned to the URL. version_prefix (str): URL path before the version value. Defaults to `"/v"`. error_format (Optional[str]): Format for error handling. **ctx_kwargs (Any): Keyword arguments beginning with `ctx_*` prefix will be appended to the route context (`route.ctx`). Returns: Callable: Object passed as the handler. )r(r*r+r1r-r.r5r6Nr!)r2) rrVr(r*r+r1r-r.r5r6r7r!r!r"add_websocket_routes#  zRouteMixin.add_websocket_routecCstttt+tt|}t|}||}t|dkr(tt |WdSWddS1s3wYdS)N) rOSErrorrJr rr_get_response_typesrSnextiter)rrVsrctreehttp_response_typesr!r!r"rMs      z"RouteMixin._determine_error_formatcs*tGfdddt}||S)Ncs"eZdZdedeffdd ZdS)z;RouteMixin._get_response_types..HttpResponseVisitornodercsxtt.|jjjg}|jjr|dd|jjD7}|D] }|tvr)t|qWddS1s5wYdS)NcSsg|] }|jdkr|jqS) content_type)argvalue)r=kr!r!r"r?s  z\RouteMixin._get_response_types..HttpResponseVisitor.visit_Return..)rAttributeErrorrfuncidkeywordsrrP)rrcheckschecktypesr!r" visit_Returns  "zHRouteMixin._get_response_types..HttpResponseVisitor.visit_ReturnN)rT __module__ __qualname__rr rr!rr!r"HttpResponseVisitorsr)rrvisit)rrrr!rr"r}s zRouteMixin._get_response_typesrawcsBfddiD}rd}td|t|S)Ncs*i|]}|dr|dd|qS)ctx_r{)r\replacepop)r=keyrr!r" 's z3RouteMixin._build_route_context..z, zUnexpected keyword arguments: )rRjoinrJr)rrr7unexpected_argumentsr!rr"r^&s  zRouteMixin._build_route_context)rN)NNNFNNFTNFFFr'N)NNNNTr'N)NNFNNr'N)NNNNFr'N)NNNNNTr'N)NNNNNr'N)#rTrrr#rrLrr&rHr rr boolintfloatr RouteWrapperr$rIrrcrhrmrprrrtrvrxr2ryrMr}dictrr^r!r!r!r"rs        4      c   8   6   6   8   8   6   5    9   / r) metaclassN)'astrrrcollections.abcr contextlibrinspectrrtextwrapr typingr r r r rsanic_routing.routersanic.base.metarsanic.constantsrsanic.errorpagesrsanic.mixins.basersanic.models.futuresrrsanic.models.handler_typesr sanic.typesrrFrrr!r!r!r"s$