o NK&hMk @sddlmZddlZddlZddlZddlZddlZddlmZmZm Z m Z m Z m Z ddl mZddlmZmZddlmZmZmZmZddlmZmZddlmZdd lmZmZdd lm Z dd l!m"Z"dd l#m$Z$dd l%m%Z%ddl&m'Z'ddl(m)Z)ddl*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7ddl8m9Z9m:Z:ddl;mm?Z?ddl@mAZAddlBmCZCmDZDddlEmFZFmGZGddlHmIZIddlJmKZKddlLmMZMddlNmOZOmPZPddlQmRZRmSZSddlTmUZUmVZVmWZWmXZXddlYmZZZddl[m\Z\m]Z]ddl^m_Z_dd l`maZambZbmcZcdd!ldmeZedd"lfmgZgmhZhdd#limjZjdd$lkmlZldd%lmmnZndd&lompZpdd'lqmrZrdd(lsmtZtmuZumvZvmwZwmxZxmyZydd)lzm{Z{m|Z|dd*lzm}Z~dd+lmZdd,lmZmZmZdd-lmZdd.lmZdd/lmZmZmZdd0lmZmZdd1lmZdd2lmZdd3lmZdd4lmZe+rzdd5lmZdd6lmZWneye4d7eZYnweOrePe4d8Ze4d9eSd:ZGd;d<d) annotationsN)AbstractEventLoopCancelledErrorTask ensure_futureget_running_loopwait_for)Future) defaultdictdeque) Awaitable CoroutineIterableIterator)contextmanagersuppress)Enum)partialwraps) isawaitable)environ)Path)socket) format_exc)SimpleNamespace) TYPE_CHECKINGAnyAnyStrCallableClassVarDequeGenericLiteralOptionalTypeVarUnioncastoverload) urlencode urlunparse)FinalizationErrorNotFound)Route) setup_ext)ApplicationState ServerStage)ASGIAppLifespan) BaseSanic)BlueprintGroup) Blueprint) OS_IS_WINDOWSenable_windows_color_support) SANIC_PREFIXConfig) BadRequestSanicException ServerError URLBuildError) ErrorHandler)Default_default)Stage)LOGGING_CONFIG_DEFAULTS error_loggerlogger) setup_logging) MiddlewareMiddlewareLocation) CommandMixin) ListenerEvent) StartupMixin)StaticHandleMixin) REPLContext)FutureExceptionFutureListenerFutureMiddlewareFutureRegistry FutureRoute FutureSignal) ListenerTypeMiddlewareType)Sanic)Request)BaseHTTPResponse HTTPResponseResponseStream)Router)ConnectionClosed)EventSignal SignalRouter)TouchUp TouchUpMeta) SharedContext) Inspector) CertLoader) WorkerManager)Extend) Extensionrdctx_type config_type)boundcseZdZUdZdZdZiZded<dZded<e d d d d d e d dd d d d dd d fdd+d,Z e d d d d d e d dd d d d dd d fdd/d,Z e d d d d d e d dd d d d dd d fdd2d,Z e d d d d d e d dd d d d dd d fdd4d,Z d d d d d e d dd d d d dd d fdfd5d, Z e d d7d8Z d9d:d!d@dAZ Bd"ed:d#dGdHZ Bd"ed:d$dLdMZ d%d&dQdRZd'dTdUZ d(d)dZd[Z d%d*d]d^Zd+dbdcZe d d d dddd,dmdnZe d d d dddod-drdnZd d d dddod.dtdnZ d%d d dud/dzd{Zd0d~dZd1d2ddZd d d d d dd3ddZd4ddZ d1d5ddZd6ddZd dddZe d7ddZ e d8ddZ!ddZ"ddZ#ddZ$e%ddZ&e'd9ddZ(e%ddZ)e%d d dd:ddZ*e'd;ddZ+e'ddd„Z.e d?dd„Z.e d@dd„Z.d dƜd@dd„Z. d%d dƜdAddʄZ/dBdd̄Z0 ͐dCdDdd҄Z1e dEddՄZ2ddׄZ3d Z4dFddڄZ5e dGdd܄Z6e6j7dHdd܄Z6e dGddZ8e dGddZ9e9j7dHddZ9e dIddZ:e dJddZ;e dKddZe%dMddZ?e% d%dddNddZ@e%dBddZAeBdOddZCdBddZDd1dPddZEddZFdBdd ZGdQd d ZH d%dRddZI d%dSddZJe dTddZKe dUddZLZMS(VrTa The main application instance You will create an instance of this class and use it to register routes, listeners, middleware, blueprints, error handlers, etc. By convention, it is often called `app`. It must be named using the `name` parameter and is roughly constrained to the same restrictions as a Python module name, however, it can contain hyphens (`-`). ```python # will cause an error because it contains spaces Sanic("This is not legal") ``` ```python # this is legal Sanic("Hyphens-are-legal_or_also_underscores") ``` Args: name (str): The name of the application. Must be a valid Python module name (including hyphens). config (Optional[config_type]): The configuration to use for the application. Defaults to `None`. ctx (Optional[ctx_type]): The context to use for the application. Defaults to `None`. router (Optional[Router]): The router to use for the application. Defaults to `None`. signal_router (Optional[SignalRouter]): The signal router to use for the application. Defaults to `None`. error_handler (Optional[ErrorHandler]): The error handler to use for the application. Defaults to `None`. env_prefix (Optional[str]): The prefix to use for environment variables. Defaults to `SANIC_`. request_class (Optional[Type[Request]]): The request class to use for the application. Defaults to `Request`. strict_slashes (bool): Whether to enforce strict slashes. Defaults to `False`. log_config (Optional[Dict[str, Any]]): The logging configuration to use for the application. Defaults to `None`. configure_logging (bool): Whether to configure logging. Defaults to `True`. dumps (Optional[Callable[..., AnyStr]]): The function to use for serializing JSON. Defaults to `None`. loads (Optional[Callable[..., Any]]): The function to use for deserializing JSON. Defaults to `None`. inspector (bool): Whether to enable the inspector. Defaults to `False`. inspector_class (Optional[Type[Inspector]]): The inspector class to use for the application. Defaults to `None`. certloader_class (Optional[Type[CertLoader]]): The certloader class to use for the application. Defaults to `None`. )handle_requesthandle_exception_run_response_middleware_run_request_middleware)+ _asgi_app_asgi_lifespan _asgi_client_blueprint_order_delayed_tasks_ext_future_commands_future_exceptions_future_listeners_future_middleware_future_registry_future_routes_future_signals_future_statics _inspector_manager_state_task_registry _test_client _test_manager blueprintscertloader_classconfigconfigure_loggingctx error_handlerinspector_classgo_fast listeners multiplexernamed_request_middlewarenamed_response_middlewarerepl_ctx request_classrequest_middlewareresponse_middlewarerouter shared_ctx signal_routersockstrict_slasheswebsocket_enabledwebsocket_taskszClassVar[dict[str, Sanic]] _app_registryFzClassVar[bool] test_modeNTselfSanic[Config, SimpleNamespace]namestrrNonerrOptional[Router]rOptional[SignalRouter]rOptional[ErrorHandler] env_prefix Optional[str]rOptional[type[Request]]rbool log_configOptional[dict[str, Any]]rdumpsOptional[Callable[..., AnyStr]]loadsOptional[Callable[..., Any]] inspectorrOptional[type[Inspector]]rOptional[type[CertLoader]]returncCdSNrrrrrrrrrrrrrrrrrrr|_?||j4j"_@||j8j"_@|jAB|| r| tC_D| r| t._EdSdS)NrzEWhen instantiating Sanic with config, you cannot also pass env_prefix)rappF)FsuperrrAloggingr dictConfigr7r:r&rgr8 INSPECTORrmrnrorprqrOrwr{r|r.r}r~rrasgi auto_reloadrrbrrrfrrr=rrarr listrrrrKrrUrr rrrYrr`rr]rrrrsetrrunrr __class__ register_apprV_dumps_loads)rrrrrrrrrrrrrrrrr dict_configrrrr9sr             rcCs^|jjtjur|jdurtdztWSty.tj dkr(t YSt YSw)a&Synonymous with asyncio.get_event_loop(). .. note:: Only supported when using the `app.run` method. Returns: AbstractEventLoop: The event loop for the application. Raises: SanicException: If the application is not running. FziLoop can only be retrieved after the app has started running. Not supported with `create_server` function) ) statestager/STOPPEDrr:r RuntimeErrorsys version_infoasyncioget_event_loop_policyget_event_looprrrrloops    z Sanic.looprprioritylistenerListenerType[SanicVar]eventrintc Cszt|}Wn ttfy(dtddtj}td|d|wd|vr>|j |j |dt |j |d|S|rIt d |j |j|j ||S) zRegister the listener for a given event. Args: listener (Callable): The listener to register. event (str): The event to listen for. Returns: Callable: The listener that was registered. , cSs|Sr)lower)xrrrsz)Sanic.register_listener..zInvalid event: z. Use one of: .r)rzPriority is not supported for )rHupper ValueErrorAttributeErrorjoinmap __members__keysr9signalvaluer _listenerrBwarningrappend)rrrr_eventvalidrrrregister_listeners&   zSanic.register_listenerrequest middleware!Union[MiddlewareType, Middleware] attach_toUnion[Default, int]cCs|}t|}t|tst||t|tr|ndd}n|j|kr/t|tr/t|j|j|d}|tjur?||j vr?|j ||tj urO||j vrO|j ||S)abRegister a middleware to be called before a request is handled. Args: middleware (Callable): A callable that takes in a request. attach_to (str): Whether to attach to request or response. Defaults to `'request'`. priority (int): The priority level of the middleware. Lower numbers are executed first. Defaults to `0`. Returns: Union[Callable, Callable[[Callable], Callable]]: The decorated middleware function or a partial function depending on how the method was called. rlocationr)rFr isinstancerErrfuncrREQUESTrrRESPONSEr appendleft)rrrrretvalrrrrregister_middlewares*        zSanic.register_middlewarerS route_names Iterable[str]cCs|}t|}t|tst||t|tr|ndd}n|j|kr/t|tr/t|j|j|d}|tjurS|D]}||j vrCt |j |<||j |vrR|j | |q6|tj urw|D]}||j vrgt |j |<||j |vrv|j ||qZ|S)aUsed to register named middleqare (middleware typically on blueprints) Args: middleware (Callable): A callable that takes in a request. route_names (Iterable[str]): The route names to attach the middleware to. attach_to (str): Whether to attach to request or response. Defaults to `'request'`. priority (int): The priority level of the middleware. Lower numbers are executed first. Defaults to `0`. Returns: Union[Callable, Callable[[Callable], Callable]]: The decorated middleware function or a partial function depending on how the method was called. rr)rFrrrErrrrrrr rrrr)rrrrrrr_rnrrrregister_named_middlewares:        zSanic.register_named_middlewarehandlerrLOptional[list[str]]cCsP|jD]!}t|ttfr|D] }|j||j|qq|j||j|q|jS)zDecorate a function to be registered as a handler for exceptions :param exceptions: exceptions :return: decorated function ) exceptionsrtuplerraddr)rrr exceptionerrr_apply_exception_handler7s zSanic._apply_exception_handlerrMcCs|j|j|j|jdS)Nr)rrrr)rrrrr_apply_listenerJs zSanic._apply_listenerrouterP overwrite list[Route]c Cs|}||d<|dd}|dd}|r/|t|j|j|d}|jj|_d|_||d<|d}|2|j j d i|}t |t rJ|g}|D]} || j _|d d| j _| jj|qLWd|S1smwY|S) Nr websocketF subprotocolsrTr route_contextstaticr)_asdictpopenable_websocketr_websocket_handlerr__name__ is_websocketamendrr rr,extrargetrr__dict__update) rrrparamsrrwebsocket_handlerrroutesrrrr _apply_routeOs8         zSanic._apply_routerNcCs`|"|r||j||jWdS||j|jWdS1s)wYdSr)rrrrr)rrrrrr_apply_middlewareps  $zSanic._apply_middlewarerrQr\cCsL||jj|j|j|j|j|jdWdS1swYdS)N)rr condition exclusiver)rrr rrr)r*r)rrrrr _apply_signals $zSanic._apply_signal)r)contextfail_not_foundreverser)Optional[dict[str, str]]r,r-inline Literal[True]r.#Coroutine[Any, Any, Awaitable[Any]]cCrrrrrr)r,r-r0r.rrrdispatch zSanic.dispatch)r)r,r-r0r.Literal[False]$Coroutine[Any, Any, Awaitable[Task]]cCrrrr3rrrr4r50Coroutine[Any, Any, Awaitable[Union[Task, Any]]]cCs|jj||||||dS)a~Dispatches an event to the signal router. Args: event (str): Name of the event to dispatch. condition (Optional[Dict[str, str]]): Condition for the event dispatch. context (Optional[Dict[str, Any]]): Context for the event dispatch. fail_not_found (bool): Whether to fail if the event is not found. Default is `True`. inline (bool): If `True`, returns the result directly. If `False`, returns a `Task`. Default is `False`. reverse (bool): Whether to reverse the dispatch order. Default is `False`. Returns: Coroutine[Any, Any, Awaitable[Union[Task, Any]]]: An awaitable that returns the result directly if `inline=True`, or a `Task` if `inline=False`. Examples: ```python @app.signal("user.registration.created") async def send_registration_email(**context): await send_email(context["email"], template="registration") @app.post("/register") async def handle_registration(request): await do_registration(request) await request.app.dispatch( "user.registration.created", context={"email": request.json.email} }) ``` )r,r)r0r.r-)rr4r3rrrr4s,)r)r*Union[str, Enum]timeoutOptional[Union[int, float]]r*csv|j|||}|s'|jjr'|j|d||j|||}|j|s0td|t| |dIdHS)aeWait for a specific event to be triggered. This method waits for a named event to be triggered and can be used in conjunction with the signal system to wait for specific signals. If the event is not found and auto-registration of events is enabled, the event will be registered and then waited on. If the event is not found and auto-registration is not enabled, a `NotFound` exception is raised. Auto-registration can be handled by setting the `EVENT_AUTOREGISTER` config value to `True`. ```python app.config.EVENT_AUTOREGISTER = True ``` Args: event (str): The name of the event to wait for. timeout (Optional[Union[int, float]]): An optional timeout value in seconds. If provided, the wait will be terminated if the timeout is reached. Defaults to `None`, meaning no timeout. condition: If provided, method will only return when the signal is dispatched with the given condition. exclusive: When true (default), the signal can only be dispatched when the condition has been met. When ``False``, the signal can be dispatched either with or without it. Raises: NotFound: If the event is not found and auto-registration of events is not enabled. Returns: The context dict of the dispatched signal. Examples: ```python async def wait_for_event(app): while True: print("> waiting") await app.event("foo.bar.baz") print("> event found") @app.after_server_start async def after_server_start(app, loop): app.add_task(wait_for_event(app)) ``` NzCould not find signal )r:) r get_waiterrEVENT_AUTOREGISTERreset add_signalfinalizer+rwait)rrr:r)r*waiterrrrrs8    z Sanic.event7Callable[[Sanic, Exception], Coroutine[Any, Any, None]]0Callable[[Exception], Coroutine[Any, Any, None]]cs.td fdd }j|tjjd|S) aRegister a handler to report exceptions. A convenience method to register a handler for the signal that is emitted when an exception occurs. It is typically used to report exceptions to an external service. It is equivalent to: ```python @app.signal(Event.SERVER_EXCEPTION_REPORT) async def report(exception): await do_something_with_error(exception) ``` Args: handler (Callable[[Sanic, Exception], Coroutine[Any, Any, None]]): The handler to register. Returns: Callable[[Sanic, Exception], Coroutine[Any, Any, None]]: The handler that was registered. r  Exceptionrrcs|IdHdSrr)r rrrrreport5sz&Sanic.report_exception..report)rrN)r rErr)rr?r[SERVER_EXCEPTION_REPORTr)rrrGrrFrreport_exceptions zSanic.report_exceptionenablecCs |js |d|j||_dS)aEnable or disable the support for websocket. Websocket is enabled automatically if websocket routes are added to the application. This typically will not need to be called manually. Args: enable (bool, optional): If set to `True`, enables websocket support. If set to `False`, disables websocket support. Defaults to `True`. Returns: None before_server_stopN)rr_cancel_websocket_tasks)rrJrrrr?s zSanic.enable_websocket) url_prefixversionrversion_prefix name_prefix blueprint5Union[Blueprint, Iterable[Blueprint], BlueprintGroup]rMrN Optional[Union[int, float, str]]Optional[bool]rOrPc Csi}|dur ||d<|dur||d<|dur||d<|dur"||d<|dur*||d<t|ttfr|D]}i|} t|tr|dd|jpGdg} t|tsV| |jpTddd d | Dd} d| | d<d D]} t|| durt|| p~|| | | <ql|j d kr|j d kr|d| d<n|j | d<t|dd}|rd| vr|| d<|j |fi| q3dS|j |j vr|j |j |usJd |j fn ||j |j <|j ||jdur|jdur|j|_|||dS)aRegister a blueprint on the application. See [Blueprints](/en/guide/best-practices/blueprints) for more information. Args: blueprint (Union[Blueprint, Iterable[Blueprint], BlueprintGroup]): Blueprint object or (list, tuple) thereof. url_prefix (Optional[str]): Prefix for all URLs bound to the blueprint. Defaults to `None`. version (Optional[Union[int, float, str]]): Version prefix for URLs. Defaults to `None`. strict_slashes (Optional[bool]): Enforce the trailing slashes. Defaults to `None`. version_prefix (Optional[str]): Prefix for version. Defaults to `None`. name_prefix (Optional[str]): Prefix for the blueprint name. Defaults to `None`. Example: ```python app = Sanic("TestApp") bp = Blueprint('TestBP') @bp.route('/route') def handler(request): return text('Hello, Blueprint!') app.blueprint(bp, url_prefix='/blueprint') ``` NrMrNrrOrP/css"|] }|rt|dVqdS)rVN)rstrip).0urrr s   z"Sanic.blueprint..)rNrz/vzVA blueprint with the name "%s" is already registered. Blueprint names must be unique.)rrr3r rMrrrstripgetattrrOrQrrrprregister) rrQrMrNrrOrPoptionsitemr# merge_from merged_prefix_attrrrrrQVsr"              zSanic.blueprint view_namec Ksi}d|vr|jd|}|dr'|dd}|r!|d|}|j|d|jj|fi|}|s;td|d|j}t |j ddrq|d d }d |vrq| d d d}|drb|dd}| drm|d d}||d <|dkr|dr|j s|jdds|dd}| dsd|}|} |dd|dd } |dd} |ddpt| } |dd } |j jr| r| st|j jd krtdd|j j| r| |j jvrtd| d|j j| st|j jd} | r| std|dd}|dur| r| p|jdd }| rL| s;d|ddvr.|dd dd d} nd } |j jr;| d d!} d"|ddvrL| d"d d}||jD]u}z t||j}Wntyrtd#|jd$w|jrt|jtr|jd n|j}| |}|s|j!turd%|d&|jd'|j!j"d(|j}t|d%|d&|jd)|j}t|d*|jd+}t#$||| } qU|rt%|d,d-nd }t&| || d || f} | S).a Build a URL based on a view name and the values provided. This method constructs URLs for a given view name, taking into account various special keyword arguments that can be used to modify the resulting URL. It can handle internal routing as well as external URLs with different schemes. There are several special keyword arguments that can be used to modify the URL that is built. They each begin with an underscore. They are: - `_anchor` - `_external` - `_host` - `_server` - `_scheme` Args: view_name (str): String referencing the view name. _anchor (str): Adds an "#anchor" to the end. _scheme (str): Should be either "http" or "https", default is "http". _external (bool): Whether to return the path or a full URL with scheme and host. _host (str): Used when one or more hosts are defined for a route to tell Sanic which to use. _server (str): If not using "_host", this will be used for defining the hostname of the URL. **kwargs: Keys and values that are used to build request parameters and query string arguments. Raises: URLBuildError: If there are issues with constructing the URL. Returns: str: The built URL. Examples: Building a URL for a specific view with parameters: ```python url_for('view_name', param1='value1', param2='value2') # /view-name?param1=value1¶m2=value2 ``` Creating an external URL with a specific scheme and anchor: ```python url_for('view_name', _scheme='https', _external=True, _anchor='section1') # https://example.com/view-name#section1 ``` Creating a URL with a specific host: ```python url_for('view_name', _host='subdomain.example.com') # http://subdomain.example.com/view-name rz.staticrNrrzEndpoint with name `z` was not foundfilenamerU __file_uri__z<__file_uri__:rrV_method_anchor_host _externalF_schemezHost is ambiguous: rzRequested host (z#) is not available for this route: z/When specifying _scheme, _external must be True_server SERVER_NAME:httpwsz://zRequired parameter `z` was not passed to url_forzValue "z" for parameter `z#` does not match pattern for type `z`: z` does not satisfy pattern z()T)doseq)'rendswithrreplacer"rfind_route_by_view_namer<pathr\rsplit startswithstrictraw_pathrhostslenrrrrr rr@r#valuesrKeyErrorpatternrr matchr&rresubr(r))rrckwargskwrrurirdfolder_outanchorhostexternalschemenetloc param_infosupplied_paramrpasses_patternmsgreplacement_regex query_stringrrrurl_fors4                           z Sanic.url_forrUr  BaseExceptionrun_middlewarec sd}t|dds |jdd|idIdH|jdd||d d IdH|jdurZ|jjtjurZtj|dd t d |d |j ||rI|j nd}|rXt d|jddS|rz|jod|jjjpg|j}|||IdH}Wnty}z|||dIdHWYd}~Sd}~ww|sz|j ||}t|r|IdH}Wn6ty}z*t|tr|j ||}n|jrtd|dtdd}ntddd}WYd}~nd}~ww|dur z|||IdH}Wn#ty|jr|j||j ddIdHw|jr|jj}t|t!r0|jdd||dd IdH|j ddIdHdSt|t"rT||IdH}|jdd||dd IdH|#IdHdSt$d|d)aA handler that catches specific exceptions and outputs a response. .. note:: This method is typically used internally, and you should not need to call it directly. Args: request (Request): The current request object. exception (BaseException): The exception that was raised. run_middleware (bool): Whether to run middleware. Defaults to `True`. Raises: ServerError: response 500. N__dispatched__Fserver.exception.reportr r,zhttp.lifecycle.exceptionT)rr r0r,)exc_infozOThe error response will not be sent to the client for the following exception:"z8". A previous response has at least partially been sent.zAn error occurred while handling the request after at least some part of the response was sent to the client. The response from your custom exception handler ag will not be sent to the client.Exception handlers should only be used to generate the exception responses. If you would like to perform any other action on a raised exception, consider using a signal handler like `@app.signal("http.lifecycle.exception")` For further information, please see the docs: https://sanicframework.org/en/guide/advanced/signals.htmlzError while handling error: z Stack: i)statusz)An error occurred while handling an error end_streamhttp.lifecycle.responserresponseInvalid response type  (need HTTPResponse))%r\r4streamrr@HANDLERrBr rCerrorr_lookuprrrrrrrlrErjrrrr:defaultdebugrWrreset_responserespondrsendrVrXeofr;) rrr rrrrr resprrrrjus             zSanic.handle_exceptionc sd}|jddd|idIdHd}d}z!|jddd|idIdH|j|j|j|jdd\}}}i||_||_|jdd||||d dIdH|j rk|j j rk|j j skt |d rdtd |j _n|IdHd }|jj jr~|||jj jIdH}|s|durtd |jddd|idIdH||fi|j}t|r|IdH}|jddd|idIdH|jr|durtd|j dur|j j}n|dur||IdH}n t |ds|j j}t|tr|jdd||ddIdH |jddIdHWdSt|tr&||IdH}|jdd||ddIdH|IdHWdSt |ds4td|dWdSt y?t!y]} z|j"|| |dIdHWYd} ~ dSd} ~ ww)aLHandles a request by dispatching it to the appropriate handler. .. note:: This method is typically used internally, and you should not need to call it directly. Args: request (Request): The current request object. Raises: ServerError: response 500. Tzhttp.lifecycle.handlerrNzhttp.routing.beforerzhttp.routing.after)rrrr is_streaminfFz>'None' was returned while requesting a handler from the routerzhttp.handler.beforezhttp.handler.afterzxThe response object returned by the route handler will not be sent to client. The request has already been responded to.rrrrrr)r)#r4rr rwmethodheadersgetone _match_inforr request_bodyr ignore_bodyhasattrfloatrequest_max_size receive_bodyrrlr; match_infor respondedrBrrrrrVrrXrrrErj) rr__tracebackhide__rrrrrrr rrrris                      zSanic.handle_requestrc s|jr|j}||IdHn|j}|||IdH}|jdd||dddIdHt|||g|Ri|}|j |d} zgz|IdH|jdd||ddddIdHWn6t t fyjd} Yn*t y} z|j || |jdd||| d dddIdHWYd} ~ nd} ~ wwW|j|| r|d dS|IdHdS|j|| r|d w|IdHw) Nzwebsocket.handler.beforeT)rrF)r0r,r-zwebsocket.handler.after)r0r,r.r-zwebsocket.handler.exception)rrr i)r transportget_websocket_connectionaccept get_protocolwebsocket_handshaker4rrr rrZrErlogremoveend_connectionclose) rrrrargsrrrprotocolfut cancelledr rrrrs\         zSanic._websocket_handlerSanicTestClientcC6|jr|jS|jr |jjSddlm}|||_|jS)aA testing client that uses httpx and a live running server to reach into the application to execute handlers. This property is available if the `sanic-testing` package is installed. See [Test Clients](/en/plugins/sanic-testing/clients#wsgi-client-sanictestclient) for details. Returns: SanicTestClient: A testing client from the `sanic-testing` package. r)r)rr test_clientsanic_testing.testingr)rrrrrr   zSanic.test_clientSanicASGITestClientcCr)aA testing client that uses ASGI to reach into the application to execute handlers. This property is available if the `sanic-testing` package is installed. See [Test Clients](/en/plugins/sanic-testing/clients#asgi-async-client-sanicasgitestclient) for details. Returns: SanicASGITestClient: A testing client from the `sanic-testing` package. r)r)ror asgi_clientrr)rrrrrrrzSanic.asgi_clientcsd|_|D]7}|jdd|ddddidIdH||}t|r&|IdH}|jdd|ddddidIdH|r=|SqdS)NThttp.middleware.beforerrrr0r,r)http.middleware.after)_request_middleware_startedr4r)rrmiddleware_collectionrrrrrrls4     zSanic._run_request_middlewarecs|D]H}|jdd||dddidIdH|||}t|r$|IdH}|jdd||r-|n|dddidIdH|rK|}t|trH|j|}|Sq|S)NrTrrrrr)r4rrrVrr)rrrrr _responserrrrk$s:       zSanic._run_response_middlewarecGs|jg|}d|S)Nr)rr)rpartsrrr_build_endpoint_nameGs  zSanic._build_endpoint_namecCs|jD]}|qdSr)rcancel)clsrrtaskrrrrLKs  zSanic._cancel_websocket_tasksrrrRcsNz||}Wnty|||}Ynw|r#t|r%|IdHdSdSdSr) TypeErrorr)rrr maybe_cororrrrPs   zSanic._listenercsfdd}||S)Nc sz&t|rz|}Wn ty|}Ynwt|r%|IdHWdSWdSty8td|dtyP}z jdd|idIdHd}~ww)NzTask z# was cancelled before it completed.rr r)callablerrrrBrrEr4)rr rrrdofs0      zSanic._prep_task..dor)rrrrrrrr _prep_task_s zSanic._prep_taskrr]r]rcCs@|}t|ts||||}|j||d}|r|r||j|<|S)Nr)rr r create_taskr~)rrrrrr]tskpreppedrrr_loop_add_task}s  zSanic._loop_add_taskcs6|jD]}|j|||ddIdHq|jdS)aSignal handler for dispatching delayed tasks. This is used to dispatch tasks that were added before the loop was started, and will be called after the loop has started. It is not typically used directly. Args: app (Sanic): The Sanic application instance. loop (AbstractEventLoop): The event loop in which the tasks are being run. Returns: None rrrN)rqr4clear)rrrrrrdispatch_delayed_taskss zSanic.dispatch_delayed_tasksr-Union[Future[Any], Task[Any], Awaitable[Any]]cs||||}|IdHdS)aFExecutes a delayed task within the context of a given app and loop. This method prepares a given task by invoking the app's private `_prep_task` method and then awaits the execution of the prepared task. Args: app (Any): The application instance on which the task will be executed. loop (AbstractEventLoop): The event loop where the task will be scheduled. task (Task[Any]): The task function that will be prepared and executed. Returns: None N)r)rrrrrrrrun_delayed_taskszSanic.run_delayed_taskUz%Sanic.purge_tasks..)r~itemsdoner)rkeyrrrr purge_tasksHs  zSanic.purge_tasks皙?Optional[float] incrementrcCs|jD] }|dkr|q|dur|jj}t|jrO|rQttt }| t |Wdn1s9wY| ||8}t|jrS|sdSdSdSdS)aCancel all tasks except the server task. This method is used to cancel all tasks except the server task. It iterates through the task registry, cancelling all tasks except the server task, and then waits for the tasks to complete. Optionally, you can provide a timeout and an increment to control how long the method will wait for the tasks to complete. Args: timeout (Optional[float]): The amount of time to wait for the tasks to complete. Defaults to `None`. increment (float): The amount of time to wait between checks for whether the tasks have completed. Defaults to `0.1`. RunServerN)tasksget_namerrGRACEFUL_SHUTDOWN_TIMEOUTr}r~rrrrun_until_completersleepr)rr:rr running_looprrrshutdown_tasksYs   zSanic.shutdown_tasksIterable[Task[Any]]cCsddt|jDS)zThe tasks that are currently registered with the application. Returns: Iterable[Task[Any]]: The tasks that are currently registered with the application. css|] }|dur|VqdSrr)rXrrrrrZszSanic.tasks..)iterr~r~rrrrrxs z Sanic.taskscs||ddkr)t|jj|jjd|_|dt|||||_|IdHdSt ||||IdH|_ | IdHdS)z To be ASGI compliant, our instance must be a callable that accepts three arguments: scope, receive, send. See the ASGI reference for more details: https://asgi.readthedocs.io/en/latest typelifespanTrUN) rDris_debugrNO_COLORrmotdr1rnr0createrm)rscopereceiverrrr__call__s  zSanic.__call__Union[bytes, str, dict, Any]cCs|j|dS)aUpdate the application configuration. This method is used to update the application configuration. It can accept a configuration object, a dictionary, or a path to a file that contains a configuration object or dictionary. See [Configuration](/en/guide/deployment/configuration) for details. Args: config (Union[bytes, str, dict, Any]): The configuration object, dictionary, or path to a configuration file. N)r update_config)rrrrrrszSanic.update_configcC|jjS)z(Whether the app is running in ASGI mode.rrrrrrrz Sanic.asgircCs ||j_dSrrrrrrrrs cCr)z)Whether the app is running in debug mode.)rrrrrrrrz Sanic.debugcCr)z/Whether the app is running in auto-reload mode.)r AUTO_RELOADrrrrrrzSanic.auto_reloadcCs||j_||j_dSr)rrrrrrrrrs r.cCs|jS)zuThe application state. Returns: ApplicationState: The current state of the application. )r}rrrrrsz Sanic.state set[Path]cCr)zThe directories that are monitored for auto-reload. Returns: Set[str]: The set of directories that are monitored for auto-reload. )r reload_dirsrrrrrszSanic.reload_dirsrdcCs.t|ds t|ddt|dstd|jS)aConvenience property for accessing Sanic Extensions. This property is available if the `sanic-ext` package is installed. See [Sanic Extensions](/en/plugins/sanic-ext/getting-started) for details. Returns: Extend: The Sanic Extensions instance. Examples: A typical use case might be for registering a dependency injection. ```python app.ext.dependency(SomeObject()) ``` rrT)failzSanic Extensions is not installed. You can add it to your environment using: $ pip install sanic[ext] or $ pip install sanic-ext)rr-rrrrrrrexts   z Sanic.ext) extensionsbuilt_in_extensionsrr"Optional[list[type[Extension]]]r#'Optional[Union[Config, dict[str, Any]]]cKs2t|dr tdt|f|||dd||jS)aExtend Sanic with additional functionality using Sanic Extensions. This method enables you to add one or more Sanic Extensions to the current Sanic instance. It allows for more control over the Extend object, such as enabling or disabling built-in extensions or providing custom configuration. See [Sanic Extensions](/en/plugins/sanic-ext/getting-started) for details. Args: extensions (Optional[List[Type[Extension]]], optional): A list of extensions to add. Defaults to `None`, meaning only built-in extensions are added. built_in_extensions (bool, optional): Whether to enable built-in extensions. Defaults to `True`. config (Optional[Union[Config, Dict[str, Any]]], optional): Optional custom configuration for the extensions. Defaults to `None`. **kwargs: Additional keyword arguments that might be needed by specific extensions. Returns: Extend: The Sanic Extensions instance. Raises: RuntimeError: If an attempt is made to extend Sanic after Sanic Extensions has already been set up. Examples: A typical use case might be to add a custom extension along with built-in ones. ```python app.extend( extensions=[MyCustomExtension], built_in_extensions=True ) ``` rrz:Cannot extend Sanic after Sanic Extensions has been setup.T)r"r#rr )rrr-r!)rr"r#rrrrrextends /z Sanic.extendcCsFt||s td|j}||jvr|jstd|d||j|<dS)aRegister a Sanic instance with the class registry. This method adds a Sanic application instance to the class registry, which is used for tracking all instances of the application. It is usually used internally, but can be used to register an application that may have otherwise been created outside of the class registry. Args: app (Sanic): The Sanic instance to be registered. Raises: SanicException: If the app is not an instance of Sanic or if the name of the app is already in use (unless in test mode). Examples: ```python Sanic.register_app(my_app) ``` +Registered app must be an instance of SaniczSanic app name "z" already in use.N)rr:rrrrrrrrrr=s zSanic.register_appcCs2t||s td|j}||jvr|j|=dSdS)a}Unregister a Sanic instance from the class registry. This method removes a previously registered Sanic application instance from the class registry. This can be useful for cleanup purposes, especially in testing or when an app instance is no longer needed. But, it is typically used internally and should not be needed in most cases. Args: app (Sanic): The Sanic instance to be unregistered. Raises: SanicException: If the app is not an instance of Sanic. Examples: ```python Sanic.unregister_app(my_app) ``` r'N)rr:rrr(rrrunregister_app[s   zSanic.unregister_app force_creater+cCs|dur#t|jdkrtdt|jdkrtdt|jdSz|j|WStyM|dkr=|jd|dYS|rE||YStd |d w) aRetrieve an instantiated Sanic instance by name. This method is best used when needing to get access to an already defined application instance in another part of an app. .. warning:: Be careful when using this method in the global scope as it is possible that the import path running will cause it to error if the imported global scope runs before the application instance is created. It is typically best used in a function or method that is called after the application instance has been created. ```python def setup_routes(): app = Sanic.get_app() app.add_route(handler_1, '/route1') app.add_route(handler_2, '/route2') ``` Args: name (Optional[str], optional): Name of the application instance to retrieve. When not specified, it will return the only application instance if there is only one. If not specified and there are multiple application instances, it will raise an exception. Defaults to `None`. force_create (bool, optional): If `True` and the named app does not exist, a new instance will be created. Defaults to `False`. Returns: Sanic: The requested Sanic app instance. Raises: SanicException: If there are multiple or no Sanic apps found, or if the specified name is not found. Example: ```python app1 = Sanic("app1") app2 = Sanic.get_app("app1") # app2 is the same instance as app1 ``` Nrfz8Multiple Sanic apps found, use Sanic.get_app("app_name")rz#No Sanic apps have been registered.__main__ __mp_main__r*zSanic app name 'z' not found. App instantiation must occur outside if __name__ == '__main__' block or by using an AppLoader. See https://sanic.dev/en/guide/deployment/app-loader.html for more details.)r}rr:rr~rget_app)rrr+rrrr.vs&0    z Sanic.get_appcCs2dd|jD}t|dkrtddSdS)NcSsh|]}|jjqSr)r USE_UVLOOP)rXrrrr z/Sanic._check_uvloop_conflict..rfzIt looks like you're running several apps with different uvloop settings. This is not supported and may lead to unintended behaviour.)rr~r}rBr)rr~rrr_check_uvloop_conflicts  zSanic._check_uvloop_conflictIterator[None]ccsr|jjs dVdS|jj}|jj}|r|j|r |jdV|r/|tt|j j |r7| dSdS)aContext manager to allow changes to the app after it has started. Typically, once an application has started and is running, you cannot make certain changes, like adding routes, middleware, or signals. This context manager allows you to make those changes, and then finalizes the app again when the context manager exits. Yields: None Example: ```python with app.amend(): app.add_route(handler, '/new_route') ``` N) r is_startedr finalizedrr> signalizer&rrTOUCHUPr@)r do_routerdo_signal_routerrrrrs    z Sanic.amendc CsJz|jWnty}z tjs|WYd}~nd}~ww|dS)a;Finalize the routing configuration for the Sanic application. This method completes the routing setup by calling the router's finalize method, and it also finalizes any middleware that has been added to the application. If the application is not in test mode, any finalization errors will be raised. Finalization consists of identifying defined routes and optimizing Sanic's performance to meet the application's specific needs. If you are manually adding routes, after Sanic has started, you will typically want to use the `amend` context manager rather than calling this method directly. .. note:: This method is usually called internally during the server setup process and does not typically need to be invoked manually. Raises: FinalizationError: If there is an error during the finalization process, and the application is not in test mode. Example: ```python app.finalize() ``` N)rr@r*rTrfinalize_middleware)rr rrrr@s  zSanic.finalizeallow_fail_builtinc CsJ||j_z|jWdSty$}z tjs|WYd}~dSd}~ww)aFinalize the signal handling configuration for the Sanic application. This method completes the signal handling setup by calling the signal router's finalize method. If the application is not in test mode, any finalization errors will be raised. Finalization consists of identifying defined signaliz and optimizing Sanic's performance to meet the application's specific needs. If you are manually adding signals, after Sanic has started, you will typically want to use the `amend` context manager rather than calling this method directly. .. note:: This method is usually called internally during the server setup process and does not typically need to be invoked manually. Args: allow_fail_builtin (bool, optional): If set to `True`, will allow built-in signals to fail during the finalization process. Defaults to `True`. Raises: FinalizationError: If there is an error during the signal finalization process, and the application is not in test mode. Example: ```python app.signalize(allow_fail_builtin=False) ``` N)rr;r@r*rTr)rr;r rrrr6 szSanic.signalizecs|jt|dst|t|dr|j|jjr(|jj dur(d|j_ n t |jj t r3d|j_ | |jj | dd|jjDfddD}|rad|}d |d }t|t|jjrr|jj rrt|d|j_dS) NrrTFcSsg|]}|jjqSr)rident)rXrrrr G r1z"Sanic._startup..csh|] }|dkr|qS)rf)count)rXrrrrr0H rz!Sanic._startup..rz Duplicate route names detected: a. You should rename one or more of them explicitly by using the `name` param, or changing the implicit name derived from the class and function name. For more details, please see https://sanic.dev/en/guide/release-notes/v23.3.html#duplicated-route-names-are-no-longer-allowed)rwrrr-r!_displayrrrr7rr>r6r@rr%rr;rTr2primaryr^rr4)r duplicatesnamesmessagerr?r_startup6 s4          zSanic._startupcCst|dr |jdSdS)zShorthand to send an ack message to the Server Manager. In general, this should usually not need to be called manually. It is used to tell the Manager that a process is operational and ready to begin operation. rN)rrackrrrrrFa s z Sanic.ackservingcCs&||j_t|dr|j|dSdS)a'Set the serving state of the application. This method is used to set the serving state of the application. It is used internally by Sanic and should not typically be called manually. Args: serving (bool): Whether the application is serving. rN)r is_runningrr set_serving)rrGrrrrIk s zSanic.set_servingconcernactionOptional[AbstractEventLoop]csd|d|}|dvs|dvrtd|tjd|ddid |d k}|dur/|j}|j|d |d ||d dIdHdS)Nzserver.r)beforeafter)initshutdownzInvalid server event: zTriggering server events: verbosityrf)rrPFTr)r-r.r0r,)r:rCrrr4)rrJrKrrr.rrr _server_eventy s&zSanic._server_eventpassthrucCs|j|j}||ur|jjs|jj|j_|}|r@|D]"\}}t|tr9|D] \}}tt ||||q*qt|||qt |drJ|j |S)aRefresh the application instance. **This is used internally by Sanic**. .. warning:: This method is intended for internal use only and should not be called directly. Args: passthru (Optional[Dict[str, Any]], optional): Optional dictionary of attributes to pass through to the new instance. Defaults to `None`. Returns: Sanic: The refreshed application instance. r) rr.rr server_inforrdictsetattrr\rrlock)rrS registeredattrinforrrrrrefresh s    z Sanic.refreshracCtds|js td|jS)a?An instance of Inspector for accessing the application's state. This can only be accessed from a worker process, and only if the inspector has been enabled. See [Inspector](/en/guide/deployment/inspector) for details. Returns: Inspector: An instance of Inspector. SANIC_WORKER_PROCESSzCan only access the inspector from the main process after main_process_start has run. For example, you most likely want to use it inside the @app.main_process_ready event listener.)rr r{r:rrrrr s  zSanic.inspectorrccCr\)aX Property to access the WorkerManager instance. This property provides access to the WorkerManager object controlling the worker processes. It can only be accessed from the main process. .. note:: Make sure to only access this property from the main process, as attempting to do so from a worker process will result in an exception. See [WorkerManager](/en/guide/deployment/manager) for details. Returns: WorkerManager: The manager responsible for managing worker processes. Raises: SanicException: If an attempt is made to access the manager from a worker process or if the manager is not initialized. Example: ```python app.manager.manage(...) ``` r]zCan only access the manager from the main process after main_process_start has run. For example, you most likely want to use it inside the @app.main_process_ready event listener.)rr r|r:rrrrmanager s z Sanic.manager)$rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr)$rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr)$rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr)$rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr)"rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr)rr)rrrrrrrr)r)rrrrrrrr)rrSrrrrrrr)rrLrr)rrM)F)rrPrrrr)rrNrr)rrQrr\)rrr)r/r,rr-rr0r1r.rrr2)rrr)r/r,rr-rr0r6r.rrr7)rrr)r/r,rr-rr0rr.rrr8) rr9r:r;r)rr*rrr)rrCrrD)T)rJrrr)rQrRrMrrNrSrrTrOrrPrrr)rcr)rrUr rrrrr)rrUrr)rr)rr)rrTrrrrR)rrr]rrr)rrTrrrr)rrTrrrrrr)rrrrr]rrr)rrrr1rr)rrrr6rr)rrrrrr)rrrrrrrr)rr)Nr)r:rrrrr)rr )rrrr)rr)rr)rr.)rr)rrd)r"r$r#rrr%rrd)rrTrr)rrr+rrrT)rr3)r;rrr)rGrrr)rJrrKrrrLrr)rSrrrT)rra)rrc)Nr __module__ __qualname____doc__ __touchup__ __slots__r__annotations__rr'r7rpropertyrrr?rrrrr'r(r+r4rrIrrQrrjrirrrrlrkr classmethodrL staticmethodrrrrrrrrrr rr_asgi_single_callablerrsetterrrrrr!r&rr)r.r2rrr@r6rErFrIrRr[rr^ __classcell__rrrrrTos 7 . W")19 $   8 E$ ]G ! 5"#  0 /  AH  " &+ #"rT) metaclass) __future__rrrlogging.configrrrrrrrrasyncio.futuresr collectionsr r collections.abcr r rr contextlibrrenumr functoolsrrinspectrosrpathlibrr tracebackrtypesrtypingrrrrrr r!r"r#r$r%r&r' urllib.parser(r)sanic_routing.exceptionsr*r+sanic_routing.router,sanic.application.extr-sanic.application.stater.r/ sanic.asgir0r1sanic.base.rootr2sanic.blueprint_groupr3sanic.blueprintsr4 sanic.compatr5r6 sanic.configr7r8sanic.exceptionsr9r:r;r<sanic.handlersr= sanic.helpersr>r? sanic.httpr@ sanic.logrArBrCsanic.logging.setuprDsanic.middlewarerErFsanic.mixins.commandsrGsanic.mixins.listenersrHsanic.mixins.startuprIsanic.mixins.staticrJsanic.models.ctx_typesrKsanic.models.futuresrLrMrNrOrPrQsanic.models.handler_typesrRrSrTSanicVar sanic.requestrUsanic.responserVrWrX sanic.routerrYsanic.server.websockets.implrZ sanic.signalsr[r\r] sanic.touchupr^r_sanic.types.shared_ctxr`sanic.worker.inspectorrasanic.worker.loaderrbsanic.worker.managerrc sanic_extrdsanic_ext.extensions.basere ImportErrorrrfrgrrrrs          <