o NK&h@sFddlmZddlZddlmZddlmZmZmZm Z ddl m Z ddl m Z mZddlmZddlmZdd lmZdd lmZmZmZmZmZmZdd lmZdd lmZdd l m!Z!ddl"m#Z#ddl$m%Z%m&Z&ddl'm(Z(m)Z)m*Z*ddl+m,Z,m-Z-m.Z.erddl/m0Z0dddZ1Gddde!Z2ee2Z3Gddde3Z4dS)) annotationsN) defaultdict)IterableIteratorMutableSequenceSequence)deepcopy)partialwraps isfunctionchain)SimpleNamespace) TYPE_CHECKINGAnyCallableOptionalUnionoverload)NotFound)Route) BaseSanic)SanicException)Default_default) FutureRoute FutureSignal FutureStatic) ListenerTypeMiddlewareType RouteHandler)SanicTcstfdd}|S)zDecorator to register a function to be called later. Args: func (Callable): Function to be called later. as_decorator (bool): Whether the function should be called immediately or not. csDdd<d}rtdrdfdd}r|S||S)NFapplyrcsDgRi}r||}jr jD]}|iq|SN) registeredappsregister)handlerfutureapp)args as_decoratorbpfunckwargsC/var/www/html/venv/lib/python3.10/site-packages/sanic/blueprints.pywrapper9s z(lazy..decorator..wrapperr )r-r+r/ pass_handlerr2r,r.)r+r-r/r1 decorator0s  zlazy..decorator)r )r.r,r5r0r4r1lazy's r6cs,eZdZdZdZ     dMdNfdd ZdOddZedPddZedQddZ e e j Z e e j Z e e jZe e jZe e jZe e jddZdRddZeeeeed dfdSd)d*Zeddddd+d,dTd1d2Zd3d4Zd5d6Z dUdd7dVd=d>Zd?d@ZedAdBZedWdEdFZedXdKdLZZS)Y BlueprintaA logical collection of URLs that consist of a similar logical domain. A Blueprint object is the main tool for grouping functionality and similar endpoints. It allows the developer to organize routes, exception handlers, middleware, and other web functionalities into separate, modular groups. See [Blueprints](/en/guide/best-practices/blueprints) for more information. Args: name (str): The name of the blueprint. url_prefix (Optional[str]): The URL prefix for all routes defined on this blueprint. host (Optional[Union[List[str], str]]): Host or list of hosts that this blueprint should respond to. version (Optional[Union[int, str, float]]): Version number of the API implemented by this blueprint. strict_slashes (Optional[bool]): Whether or not the URL should end with a slash. version_prefix (str): Prefix for the version. Default is "/v". )_apps_future_commands_future_routes_future_statics_future_middleware_future_listeners_future_exceptions_future_signals_allow_route_overwrite copied_fromctx exceptionshost listeners middlewaresroutesstaticsstrict_slashes url_prefixversionversion_prefixwebsocket_routesN/vnamestrrJ Optional[str]rDOptional[Union[list[str], str]]rK Optional[Union[int, str, float]]rIOptional[bool]rLcsftj|d|d|_d|_t|_||_||_|r(| dr(|ddn||_ ||_ ||_ dS)NrOF/) super__init__resetr@rArrBrDrIendswithrJrKrL)selfrOrJrDrKrIrL __class__r0r1rZss  zBlueprint.__init__returncs$dfdddD}d|dS)Nz, csFg|]}tt|tr|dt|dn |dt|qS)z=""=) isinstancegetattrrP).0attrr]r0r1 s z&Blueprint.__repr__..)rOrJrDrKrIz Blueprint())join)r]r+r0rgr1__repr__s   zBlueprint.__repr__ set[Sanic]cCs|js t|d|jS)aGet the set of apps that this blueprint is registered to. Returns: Set[Sanic]: Set of apps that this blueprint is registered to. Raises: SanicException: If the blueprint has not yet been registered to an app. z& has not yet been registered to an app)r8rrgr0r0r1r&s  zBlueprint.appsboolcC t|jS)zCheck if the blueprint has been registered to an app. Returns: bool: `True` if the blueprint has been registered to an app, `False` otherwise. )rmr8rgr0r0r1r%s zBlueprint.registeredF)r,NonecCs6t|_d|_g|_i|_g|_g|_g|_g|_dS)z)Reset the blueprint to its initial state.FN) setr8r@rCrErFrGrHrMrgr0r0r1r[s zBlueprint.resetTOptional[Union[str, Default]])Optional[Union[int, str, float, Default]]Union[str, Default]allow_route_overwriteUnion[bool, Default]Optional[Union[bool, Default]]with_registrationwith_ctxc Cs|j|j|j|j|j|j|jd} |t|} || _ |j | _ t |t s(|| _ t |t s0|| _t |t s8|| _t |t s@|| _t |t sH|| _| D] \} } t|| | qL|rn|jrn| jrctd|jD]} | | qf|stt| _| S)aCopy a blueprint instance with some optional parameters to override the values of attributes in the old instance. Args: name (str): Unique name of the blueprint. url_prefix (Optional[Union[str, Default]]): URL to be prefixed before all route URLs. version (Optional[Union[int, str, float, Default]]): Blueprint version. version_prefix (Union[str, Default]): The prefix of the version number shown in the URL. allow_route_overwrite (Union[bool, Default]): Whether to allow route overwrite or not. strict_slashes (Optional[Union[bool, Default]]): Enforce the API URLs are requested with a trailing "/*". with_registration (bool): Whether to register the new blueprint instance with Sanic apps that were registered with the old instance or not. Default is `True`. with_ctx (bool): Whether the ``ctx`` will be copied or not. Default is `False`. Returns: Blueprint: A new Blueprint instance with the specified attributes. )r8rGrMrFrCrErHzUStatic routes registered with the old blueprint instance, cannot be registered again.)r8rGrMrFrCrErHr[rrOrArcrrJrKrIrLr@itemssetattrr;r blueprintrrB)r]rOrJrKrLrtrIrwrx attrs_backupnew_bpkeyvaluer*r0r0r1copysD         zBlueprint.copyrVrJrKrIrL name_prefix blueprints Union[Blueprint, BlueprintGroup]rBlueprintGroupcs<dfdd t|||||d}|D]}||q|S)aPGroup multiple blueprints (or other blueprint groups) together. Gropuping blueprings is a method for modularizing and organizing your application's code. This can be a powerful tool for creating reusable components, logically structuring your application code, and easily maintaining route definitions in bulk. This is the preferred way to group multiple blueprints together. Args: blueprints (Union[Blueprint, BlueprintGroup]): Blueprints to be registered as a group. url_prefix (Optional[str]): URL route to be prepended to all sub-prefixes. Default is `None`. version (Optional[Union[int, str, float]]): API Version to be used for Blueprint group. Default is `None`. strict_slashes (Optional[bool]): Indicate strict slash termination behavior for URL. Default is `None`. version_prefix (str): Prefix to be used for the version in the URL. Default is "/v". name_prefix (Optional[str]): Prefix to be used for the name of the blueprints in the group. Default is an empty string. Returns: BlueprintGroup: A group of blueprints. Example: The resulting group will have the URL prefixes `'/v2/bp1'` and `'/v2/bp2'` for bp1 and bp2, respectively. ```python bp1 = Blueprint('bp1', url_prefix='/bp1') bp2 = Blueprint('bp2', url_prefix='/bp2') group = group(bp1, bp2, version=2) ``` r`Iterable[Blueprint]c3s4|D]}t|ttfr|EdHq|VqdS)z!Iterate through nested blueprintsN)rclisttuple)nestedir r0r1r<s zBlueprint.group..chainrN)r`r)rappend)rJrKrIrLrrbpsr-r0r r1groups-  zBlueprint.groupcCs|j||d|j}|dd}|dd}|d|j}|dd}|d|jj}g} g} g} tt} t } |j D]}| |j |}|j rM|j n|}|j}|j|fD] }|rc|dkrc|}nqW||j||j}||j||j}|j}|r|d |j}||}|jp|j}t|trt|}t|j||j|||j|||j|j|j|j|j|||j}||f|j vrq>| ||j!||j"d }|j#r|D]}|j$|j#|j|_|j%j&$|j#|j|j%_&qt|tr| j'n| j(}||q>|j)D]-}| |j |}t*|g|d dR}||f|j vrq| ||+|}| (|qd d | D}|re|j,D]}||f|j vr@q4| (|-||q4|j.D]}||f|j vrZqN| (|/||qN|j0D]}||f|j vrtqh| |j1(|2|qh|j3D]%}||f|j vrq|j45d|ji|6t7|j|j1|j4d|j8q|j9dd | D7_9|j:dd |j9D7_:|j;| 7_;|j<| 7_<|j=5t>| |j?r|@|jA|tB| |j,|j.|j0|j3|jCrtDddS)zRegister the blueprint to the sanic app. Args: app (Sanic): Sanic app to register the blueprint to. options (dict): Options to be passed to the blueprint. rJrKNrIrLr error_formatrN_) overwritecSsg|]}|r|jqSr0rUrerouter0r0r1rhsz&Blueprint.register.. __blueprint__FcSsg|] }t|tr|qSr0)rcrrr0r0r1rhcSsg|]}|jjr|qSr0)extra websocketrr0r0r1rhs z6Registering commands with blueprints is not supported.)Er8addgetrJrLconfigFALLBACK_ERROR_FORMATrrrpr: _setup_uriurir_extract_valuerKrIrO generate_namerDrcrrr(methodsstream ignore_bodyr subprotocolsunquotestatic route_context_future_registry _apply_router@rAreplaceridentextendrr;r _apply_staticr<_apply_middlewarer>_apply_exception_handlerr=event_apply_listenerr? conditionupdate _apply_signalrpriorityrGrMrFrCrEdictr%register_futuresr&rr9r)r]r*optionsrJ opt_versionopt_strict_slashesopt_version_prefixopt_name_prefixrrG middlewareexception_handlersrEr%r)rroute_error_formatrLprefixrKrIrOrD apply_routerr operation route_namesr0r0r1r'Os                           zBlueprint.registercsHdi}|d|ji|d<tjfdd|jDIdHS)zDispatch a signal event Args: *args: Arguments to be passed to the signal event. **kwargs: Keyword arguments to be passed to the signal event. rrcsg|] }|jiqSr0)dispatch)rer*r+r/r0r1rh sz&Blueprint.dispatch..N)poprrOasynciogatherr&)r]r+r/rr0rr1rs  zBlueprint.dispatch)rrtimeoutOptional[Union[int, float]]rOptional[dict[str, Any]]cCsd|duri}|d|jig}|jD]}|jj||dd}|s&td|||q|||S)aWait for a signal event to be dispatched. Args: event (str): Name of the signal event. timeout (Optional[Union[int, float]]): Timeout for the event to be dispatched. condition: If provided, method will only return when the signal is dispatched with the given condition. Returns: Awaitable: Awaitable for the event to be dispatched. NrF) exclusivezCould not find signal %s)rrOr& signal_router get_waiterrr_event)r]rrrwaitersr*waiterr0r0r1r s    zBlueprint.eventcsRtjdd|Dtj|dIdH\}}|D]}|q|s"t|\}|S)NcSsg|] }t|qSr0)r create_taskwait)rerr0r0r1rh1rz$Blueprint._event..) return_whenr)rrFIRST_COMPLETEDcancel TimeoutErrorresult)r]rrdonependingtask finished_taskr0r0r1r/s  zBlueprint._eventcGs(|d}|D] }|dur|}|Sq|S)NrXr0)valuesrvr0r0r1r<szBlueprint._extract_valuebasercCsT|}|r|}|dr|dr||dd7}n||7}|dr(|ddS|S)NrWrz//) startswithr\)rrrr0r0r1rEszBlueprint._setup_urir&r-futuresSequence[tuple[Any, ...]]cs(|D]}|jfdd|DqdS)a%Register futures to the apps. Args: apps (Set[Sanic]): Set of apps to register the futures to. bp (Blueprint): Blueprint that the futures belong to. futures (Sequence[Tuple[Any, ...]]): Sequence of futures to be registered. csh|]}|fqSr0r0)reitemr-r0r1 _sz-Blueprint.register_futures..N)rr)r&r-rr*r0rr1rQs zBlueprint.register_futures)NNNNrN) rOrPrJrQrDrRrKrSrIrTrLrPr`rP)r`rl)r`rm)r`ro)rOrPrJrqrKrrrLrsrtrurIrvrwrmrxrm)rrrJrQrKrSrIrTrLrPrrQr`rr$)rrPrrrr)rrPrrQ)r&rlr-r7rr)__name__ __module__ __qualname____doc__ __slots__rZrkpropertyr&r%r6r exceptionlistenerrrsignalrr[rr staticmethodrr'rrrrrr __classcell__r0r0r^r1r7Isd         F?1"   r7c@s>eZdZdZdZ     dLdMddZedNddZedOddZedPddZ edQddZ edRddZ edSddZ dTd!d"Z edUd&d'ZedVd*d'ZdWd-d'ZedXd0d1ZedYd3d1ZdZd5d1Zed[d6d7Zed\d8d7Zd]d9d7Zd^d:d;Zd_d=d>Zd`dBdCZdXdDdEZdFdGZdadHdIZdadJdKZdS)braThis class provides a mechanism to implement a Blueprint Group. The `BlueprintGroup` class allows grouping blueprints under a common URL prefix, version, and other shared attributes. It integrates with Sanic's Blueprint system, offering a custom iterator to treat an object of this class as a list/tuple. Although possible to instantiate a group directly, it is recommended to use the `Blueprint.group` method to create a group of blueprints. Args: url_prefix (Optional[str]): URL to be prefixed before all the Blueprint Prefixes. Default is `None`. version (Optional[Union[int, str, float]]): API Version for the blueprint group, inherited by each Blueprint. Default is `None`. strict_slashes (Optional[bool]): URL Strict slash behavior indicator. Default is `None`. version_prefix (str): Prefix for the version in the URL. Default is `"/v"`. name_prefix (Optional[str]): Prefix for the name of the blueprints in the group. Default is an empty string. Examples: ```python bp1 = Blueprint("bp1", url_prefix="/bp1") bp2 = Blueprint("bp2", url_prefix="/bp2") bp3 = Blueprint("bp3", url_prefix="/bp4") bp4 = Blueprint("bp3", url_prefix="/bp4") group1 = Blueprint.group(bp1, bp2) group2 = Blueprint.group(bp3, bp4, version_prefix="/api/v", version="1") @bp1.on_request async def bp1_only_middleware(request): print("applied on Blueprint : bp1 Only") @bp1.route("/") async def bp1_route(request): return text("bp1") @bp2.route("/") async def bp2_route(request, param): return text(param) @bp3.route("/") async def bp3_route(request): return text("bp3") @bp4.route("/") async def bp4_route(request, param): return text(param) @group1.on_request async def group_middleware(request): print("common middleware applied for both bp1 and bp2") # Register Blueprint group under the app app.blueprint(group1) app.blueprint(group2) ``` ) _blueprints _url_prefix_version_strict_slashes_version_prefix _name_prefixNrNrVrJrQrKrSrIrTrLrPrcCs(g|_||_||_||_||_||_dSr$)rrrrrr)r]rJrKrIrLrr0r0r1rZs  zBlueprintGroup.__init__r`cC|jS)zThe URL prefix for the Blueprint Group. Returns: Optional[Union[int, str, float]]: URL prefix for the Blueprint Group. )rrgr0r0r1rJzBlueprintGroup.url_prefixlist[Blueprint]cCr)zA list of all the available blueprints under this group. Returns: List[Blueprint]: List of all the available blueprints under this group. rrgr0r0r1rrzBlueprintGroup.blueprints Optional[Union[str, int, float]]cCr)zAPI Version for the Blueprint Group, if any. Returns: Optional[Union[str, int, float]]: API Version for the Blueprint )rrgr0r0r1rKzBlueprintGroup.versioncCr)zWhether to enforce strict slashes for the Blueprint Group. Returns: Optional[bool]: Whether to enforce strict slashes for the )rrgr0r0r1rIrzBlueprintGroup.strict_slashescCr)z{Version prefix for the Blueprint Group. Returns: str: Version prefix for the Blueprint Group. )rrgr0r0r1rLrzBlueprintGroup.version_prefixcCr)zName prefix for the Blueprint Group. This is mainly needed when blueprints are copied in order to avoid name conflicts. Returns: Optional[str]: Name prefix for the Blueprint Group. )rrgr0r0r1rs zBlueprintGroup.name_prefixIterator[Blueprint]cCrn)zIterate over the list of blueprints in the group. Returns: Iterator[Blueprint]: Iterator for the list of blueprints in )iterrrgr0r0r1__iter__ zBlueprintGroup.__iter__rintr7cCdSr$r0r]rr0r0r1 __getitem__zBlueprintGroup.__getitem__sliceMutableSequence[Blueprint]cCrr$r0rr0r0r1r rUnion[int, slice],Union[Blueprint, MutableSequence[Blueprint]]cCs |j|S)a%Get the Blueprint object at the specified index. This method returns a blueprint inside the group specified by an index value. This will enable indexing, splice and slicing of the blueprint group like we can do with regular list/tuple. This method is provided to ensure backward compatibility with any of the pre-existing usage that might break. Returns: Blueprint: Blueprint object at the specified index. Raises: IndexError: If the index is out of range. rrr0r0r1rs indexrocCrr$r0r]r rr0r0r1 __setitem__"rzBlueprintGroup.__setitem__rcCrr$r0r r0r0r1r %r%Union[Blueprint, Iterable[Blueprint]]cCs`t|trt|tstd||j|<dSt|tr,t|ts#tdt||j|<dStd)a Set the Blueprint object at the specified index. Abstract method implemented to turn the `BlueprintGroup` class into a list like object to support all the existing behavior. This method is used to perform the list's indexed setter operation. Args: index (int): Index to use for removing a new Blueprint item item (Blueprint): New `Blueprint` object. Returns: None Raises: IndexError: If the index is out of range. zExpected a Blueprint instancez+Expected an iterable of Blueprint instanceszIndex must be int or sliceN)rcrr7 TypeErrorrrrrr r0r0r1r (s    cCrr$r0r]r r0r0r1 __delitem__IrzBlueprintGroup.__delitem__cCrr$r0rr0r0r1rLrcCs |j|=dS)aDelete the Blueprint object at the specified index. Abstract method implemented to turn the `BlueprintGroup` class into a list like object to support all the existing behavior. This method is used to delete an item from the list of blueprint groups like it can be done on a regular list with index. Args: index (int): Index to use for removing a new Blueprint item Returns: None Raises: IndexError: If the index is out of range. Nrrr0r0r1rOs cCrn)zGet the Length of the blueprint group object. Returns: int: Length of the blueprint group object. )lenrrgr0r0r1__len__crzBlueprintGroup.__len__rcCs|j|dS)aAdd a new Blueprint object to the group. The Abstract class `MutableSequence` leverages this append method to perform the `BlueprintGroup.append` operation. Args: value (Blueprint): New `Blueprint` object. Returns: None N)rr)r]rr0r0r1rks zBlueprintGroup.appendrC Exceptionrcsfdd}|S)aDecorate a function to handle exceptions for all blueprints in the group. In case of nested Blueprint Groups, the same handler is applied across each of the Blueprints recursively. Args: *exceptions (Exception): Exceptions to handle **kwargs (dict): Optional Keyword arg to use with Middleware Returns: Partial function to apply the middleware Examples: ```python bp1 = Blueprint("bp1", url_prefix="/bp1") bp2 = Blueprint("bp2", url_prefix="/bp2") group1 = Blueprint.group(bp1, bp2) @group1.exception(Exception) def handler(request, exception): return text("Exception caught") ``` cs$jD] }|ji|qdSr$)rrfnr{rCr/r]r0r1)register_exception_handler_for_blueprintss zKBlueprintGroup.exception..register_exception_handler_for_blueprintsr0)r]rCr/rr0rr1ryszBlueprintGroup.exceptioncCs|j||dS)aInsert a new Blueprint object to the group at the specified index. The Abstract class `MutableSequence` leverages this insert method to perform the `BlueprintGroup.append` operation. Args: index (int): Index to use for removing a new Blueprint item item (Blueprint): New `Blueprint` object. Returns: None N)rinsertr r0r0r1rs zBlueprintGroup.insertcsDfdd}r tdr d}tdd||S|S)aA decorator that can be used to implement a Middleware for all blueprints in the group. In case of nested Blueprint Groups, the same middleware is applied across each of the Blueprints recursively. Args: *args (Optional): Optional positional Parameters to be use middleware **kwargs (Optional): Optional Keyword arg to use with Middleware Returns: Partial function to apply the middleware cs(jD]}|j|gRiqdSr$)rrrr+r/r]r0r1"register_middleware_for_blueprintss zEBlueprintGroup.middleware..register_middleware_for_blueprintsrrN)callabler)r]r+r/rrr0rr1rs zBlueprintGroup.middlewarecC"t|r ||dSt|jddS)a Convenience method to register a request middleware for all blueprints in the group. Args: middleware (Optional): Optional positional Parameters to be use middleware Returns: Partial function to apply the middleware request attach_torrr r]rr0r0r1 on_request zBlueprintGroup.on_requestcCr)a Convenience method to register a response middleware for all blueprints in the group. Args: middleware (Optional): Optional positional Parameters to be use middleware Returns: Partial function to apply the middleware responserr!r"r0r0r1 on_responser$zBlueprintGroup.on_response)NNNrNrV) rJrQrKrSrIrTrLrPrrQ)r`rS)r`r)r`r)r`rTr)r`rQ)r`r)rrr`r7)rrr`r)rr r`r )r rrr7r`ro)r rrrr`ro)r r rrr`ro)r rr`ro)r rr`ro)r r r`ro)r`r)rr7r`ro)rCrr`rr$)rrrrrrZrrJrrKrIrLrrrrr rrrrrrr#r&r0r0r0r1resXG               !        r)T)5 __future__rr collectionsrcollections.abcrrrrrr functoolsr r inspectr itertoolsrtypesrtypingrrrrrrsanic_routing.exceptionsrsanic_routing.routersanic.base.rootrsanic.exceptionsr sanic.helpersrrsanic.models.futuresrrrsanic.models.handler_typesrr r!sanicr"r6r7bpg_baserr0r0r0r1s6            "