o Eh4b @sdZddlZddlmZddlmZddlmZddlm Z m Z m Z ddl m Z ddlmZmZmZmZdd lmZmZmZmZmZmZmZmZmZmZGd d d ejZGd d d eZ Gdddej!Z"Gdddej!Z#eedeeeee$dfefeee$dfeee$effeee$dfeee$efe$ffZ%GdddeZ&Gddde e&Z'GdddZ(GdddZ)Gddde)Z*Gddde)Z+Gddde)Z,Gd d!d!e)Z-Gd"d#d#e(Z.ed$e$d%e/fd&d'Z0ed*d(d'Z0d$ee$d%ee/fd)d'Z0dS)+apFlexible routing implementation. Tornado routes HTTP requests to appropriate handlers using `Router` class implementations. The `tornado.web.Application` class is a `Router` implementation and may be used directly, or the classes in this module may be used for additional flexibility. The `RuleRouter` class can match on more criteria than `.Application`, or the `Router` interface can be subclassed for maximum customization. `Router` interface extends `~.httputil.HTTPServerConnectionDelegate` to provide additional routing capabilities. This also means that any `Router` implementation can be used directly as a ``request_callback`` for `~.httpserver.HTTPServer` constructor. `Router` subclass must implement a ``find_handler`` method to provide a suitable `~.httputil.HTTPMessageDelegate` instance to handle the request: .. code-block:: python class CustomRouter(Router): def find_handler(self, request, **kwargs): # some routing logic providing a suitable HTTPMessageDelegate instance return MessageDelegate(request.connection) class MessageDelegate(HTTPMessageDelegate): def __init__(self, connection): self.connection = connection def finish(self): self.connection.write_headers( ResponseStartLine("HTTP/1.1", 200, "OK"), HTTPHeaders({"Content-Length": "2"}), b"OK") self.connection.finish() router = CustomRouter() server = HTTPServer(router) The main responsibility of `Router` implementation is to provide a mapping from a request to `~.httputil.HTTPMessageDelegate` instance that will handle this request. In the example above we can see that routing is possible even without instantiating an `~.web.Application`. For routing to `~.web.RequestHandler` implementations we need an `~.web.Application` instance. `~.web.Application.get_handler_delegate` provides a convenient way to create `~.httputil.HTTPMessageDelegate` for a given request and `~.web.RequestHandler`. Here is a simple example of how we can we route to `~.web.RequestHandler` subclasses by HTTP method: .. code-block:: python resources = {} class GetResource(RequestHandler): def get(self, path): if path not in resources: raise HTTPError(404) self.finish(resources[path]) class PostResource(RequestHandler): def post(self, path): resources[path] = self.request.body class HTTPMethodRouter(Router): def __init__(self, app): self.app = app def find_handler(self, request, **kwargs): handler = GetResource if request.method == "GET" else PostResource return self.app.get_handler_delegate(request, handler, path_args=[request.path]) router = HTTPMethodRouter(Application()) server = HTTPServer(router) `ReversibleRouter` interface adds the ability to distinguish between the routes and reverse them to the original urls using route's name and additional arguments. `~.web.Application` is itself an implementation of `ReversibleRouter` class. `RuleRouter` and `ReversibleRuleRouter` are implementations of `Router` and `ReversibleRouter` interfaces and can be used for creating rule-based routing configurations. Rules are instances of `Rule` class. They contain a `Matcher`, which provides the logic for determining whether the rule is a match for a particular request and a target, which can be one of the following. 1) An instance of `~.httputil.HTTPServerConnectionDelegate`: .. code-block:: python router = RuleRouter([ Rule(PathMatches("/handler"), ConnectionDelegate()), # ... more rules ]) class ConnectionDelegate(HTTPServerConnectionDelegate): def start_request(self, server_conn, request_conn): return MessageDelegate(request_conn) 2) A callable accepting a single argument of `~.httputil.HTTPServerRequest` type: .. code-block:: python router = RuleRouter([ Rule(PathMatches("/callable"), request_callable) ]) def request_callable(request): request.write(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nOK") request.finish() 3) Another `Router` instance: .. code-block:: python router = RuleRouter([ Rule(PathMatches("/router.*"), CustomRouter()) ]) Of course a nested `RuleRouter` or a `~.web.Application` is allowed: .. code-block:: python router = RuleRouter([ Rule(HostMatches("example.com"), RuleRouter([ Rule(PathMatches("/app1/.*"), Application([(r"/app1/handler", Handler)])), ])) ]) server = HTTPServer(router) In the example below `RuleRouter` is used to route between applications: .. code-block:: python app1 = Application([ (r"/app1/handler", Handler1), # other handlers ... ]) app2 = Application([ (r"/app2/handler", Handler2), # other handlers ... ]) router = RuleRouter([ Rule(PathMatches("/app1.*"), app1), Rule(PathMatches("/app2.*"), app2) ]) server = HTTPServer(router) For more information on application-level routing see docs for `~.web.Application`. .. versionadded:: 4.5 N)partial)httputil)_CallableAdapter) url_escape url_unescapeutf8)app_log)basestring_type import_object re_unescape unicode_type) AnyUnionOptional AwaitableListDictPatternTupleoverloadSequencec@sHeZdZdZdejdedeejfddZ de dej dejfd d Z d S) RouterzAbstract router interface.requestkwargsreturncKt)aMust be implemented to return an appropriate instance of `~.httputil.HTTPMessageDelegate` that can serve the request. Routing implementations may pass additional kwargs to extend the routing logic. :arg httputil.HTTPServerRequest request: current HTTP request. :arg kwargs: additional keyword arguments passed by routing implementation. :returns: an instance of `~.httputil.HTTPMessageDelegate` that will be used to process the request. NotImplementedError)selfrrrP/var/www/html/Persson_Maskin/env/lib/python3.10/site-packages/tornado/routing.py find_handlers zRouter.find_handler server_conn request_conncCs t|||SN)_RoutingDelegate)rr"r#rrr start_requests zRouter.start_requestN) __name__ __module__ __qualname____doc__rHTTPServerRequestr rHTTPMessageDelegater!objectHTTPConnectionr&rrrr rs  rc@s*eZdZdZdededeefddZdS)ReversibleRouterzxAbstract router interface for routers that can handle named routes and support reversing them to original urls. nameargsrcGr)aReturns url string for a given route name and arguments or ``None`` if no match is found. :arg str name: route name. :arg args: url parameters. :returns: parametrized url string for a given route name (or ``None``). r)rr0r1rrr reverse_urlszReversibleRouter.reverse_urlN)r'r(r)r*strr rr2rrrr r/sr/c@seZdZdededejddfddZdeej ej fd ej de e dfd d Zd ede e dfd dZdddZdddZdS)r%routerr"r#rNcCs||_||_d|_||_dSr$)r"r#delegater4)rr4r"r#rrr __init__s z_RoutingDelegate.__init__ start_lineheaderscCsjt|tjsJtj|j|j||d}|j||_|jdur.t d|j |j t |j|_|j||S)N) connectionserver_connectionr7r8z$Delegate for %s %s request not found) isinstancerRequestStartLiner+r#r"r4r!r5rdebugmethodpath_DefaultMessageDelegateheaders_received)rr7r8rrrr rAs   z!_RoutingDelegate.headers_receivedchunkcCs|jdusJ|j|Sr$)r5 data_received)rrBrrr rCs z_RoutingDelegate.data_receivedcCs|jdusJ|jdSr$)r5finishrrrr rDsz_RoutingDelegate.finishcCs|jdur |jdSdSr$)r5on_connection_closerErrr rFs z$_RoutingDelegate.on_connection_closerN)r'r(r)rr-rr.r6rr<ResponseStartLine HTTPHeadersrrrAbytesrCrDrFrrrr r%s(    r%c@s*eZdZdejddfddZdddZdS) r@r9rNcCs ||_dSr$)r9)rr9rrr r6s z _DefaultMessageDelegate.__init__cCs*|jtdddt|jdS)NzHTTP/1.1iz Not Found)r9 write_headersrrHrIrDrErrr rD"s  z_DefaultMessageDelegate.finishrG)r'r(r)rr.r6rDrrrr r@sr@RuleMatcherc @seZdZdZddeeddfddZdeddfddZdd d Zd e j de dee j fddZ de d e j de dee j fddZdS) RuleRouterz!Rule-based router implementation.NrulesrcCsg|_|r ||dSdS)aIConstructs a router from an ordered list of rules:: RuleRouter([ Rule(PathMatches("/handler"), Target), # ... more rules ]) You can also omit explicit `Rule` constructor and use tuples of arguments:: RuleRouter([ (PathMatches("/handler"), Target), ]) `PathMatches` is a default matcher, so the example above can be simplified:: RuleRouter([ ("/handler", Target), ]) In the examples above, ``Target`` can be a nested `Router` instance, an instance of `~.httputil.HTTPServerConnectionDelegate` or an old-style callable, accepting a request argument. :arg rules: a list of `Rule` instances or tuples of `Rule` constructor arguments. N)rO add_rulesrrOrrr r6:szRuleRouter.__init__cCsv|D]6}t|ttfr/t|dvsJt|dtr+tt|dg|ddR}nt|}|j| |qdS)zAppends new rules to the router. :arg rules: a list of Rule instances (or tuples of arguments, which are passed to Rule constructor). )rN) r;tuplelistlenr rL PathMatchesrOappend process_rule)rrOrulerrr rPYs"zRuleRouter.add_rulesr\rLcCs|S)zOverride this method for additional preprocessing of each rule. :arg Rule rule: a rule to be processed. :returns: the same or modified Rule instance. rrr\rrr r[iszRuleRouter.process_rulerrcKsZ|jD]'}|j|}|dur*|jr|j|d<|j|j|fi|}|dur*|SqdS)N target_kwargs)rOmatchermatchr^get_target_delegatetarget)rrrr\ target_paramsr5rrr r!qs   zRuleRouter.find_handlerrbrccKsxt|tr|j|fi|St|tjr#|jdusJ||j|jSt|r:|jdus.Jt t |fi||jSdS)aReturns an instance of `~.httputil.HTTPMessageDelegate` for a Rule's target. This method is called by `~.find_handler` and can be extended to provide additional target types. :arg target: a Rule's target. :arg httputil.HTTPServerRequest request: current request. :arg target_params: additional parameters that can be useful for `~.httputil.HTTPMessageDelegate` creation. N) r;rr!rHTTPServerConnectionDelegater9r&r:callablerr)rrbrrcrrr ras  zRuleRouter.get_target_delegater$r\rLrrL)r'r(r)r*r _RuleListr6rPr[rr+r r,r!rarrrr rN7s*  rNcsXeZdZdZddeeddffdd Zdfd d Zd ed e deefd dZ Z S)ReversibleRuleRouteraA rule-based router that implements ``reverse_url`` method. Each rule added to this router may have a ``name`` attribute that can be used to reconstruct an original uri. The actual reconstruction takes place in a rule's matcher (see `Matcher.reverse`). NrOrcsi|_t|dSr$) named_rulessuperr6rQ __class__rr r6szReversibleRuleRouter.__init__r\rLcs<t|}|jr|j|jvrtd|j||j|j<|S)Nz4Multiple handlers named %s; replacing previous value)rjr[r0rirwarningr]rkrr r[s   z!ReversibleRuleRouter.process_ruler0r1cGs\||jvr|j|jj|S|jD]}t|jtr+|jj|g|R}|dur+|SqdSr$)rir_reverserOr;rbr/r2)rr0r1r\ reversed_urlrrr r2s   z ReversibleRuleRouter.reverse_urlr$rf) r'r(r)r*rrgr6r[r3r r2 __classcell__rrrkr rhs " rhc @sheZdZdZ  ddddedeeeefdeeddf d d Zd edeefd d Z defddZ dS)rLzA routing rule.Nr_rMrbr^r0rcCs6t|tr t|}||_||_|r|ni|_||_dS)adConstructs a Rule instance. :arg Matcher matcher: a `Matcher` instance used for determining whether the rule should be considered a match for a specific request. :arg target: a Rule's target (typically a ``RequestHandler`` or `~.httputil.HTTPServerConnectionDelegate` subclass or even a nested `Router`, depending on routing implementation). :arg dict target_kwargs: a dict of parameters that can be useful at the moment of target instantiation (for example, ``status_code`` for a ``RequestHandler`` subclass). They end up in ``target_params['target_kwargs']`` of `RuleRouter.get_target_delegate` method. :arg str name: the name of the rule that can be used to find it in `ReversibleRouter.reverse_url` implementation. N)r;r3r r_rbr^r0)rr_rbr^r0rrr r6s  z Rule.__init__r1cGs |jj|Sr$)r_rnrr1rrr rns z Rule.reversecCsd|jj|j|j|j|jSNz${}({!r}, {}, kwargs={!r}, name={!r}))formatrlr'r_rbr^r0rErrr __repr__sz Rule.__repr__NN) r'r(r)r*r rrr3r6rnrtrrrr rLs" !c@sFeZdZdZdejdeeee ffddZ de deefddZ d S) rMz*Represents a matcher for request features.rrcCr)a1Matches current instance against the request. :arg httputil.HTTPServerRequest request: current HTTP request :returns: a dict of parameters to be passed to the target handler (for example, ``handler_kwargs``, ``path_args``, ``path_kwargs`` can be passed for proper `~.web.RequestHandler` instantiation). An empty dict is a valid (and common) return value to indicate a match when the argument-passing features are not used. ``None`` must be returned to indicate that there is no match.rrrrrr r`s z Matcher.matchr1cGsdS)zEReconstructs full url from matcher instance and additional arguments.Nrrqrrr rnzMatcher.reverseN) r'r(r)r*rr+rrr3r r`rnrrrr rMs  c@s0eZdZdZdejdeeee ffddZ dS) AnyMatcheszMatches any request.rrcCsiSr$rrvrrr r` szAnyMatches.matchN) r'r(r)r*rr+rrr3r r`rrrr rx s$rxc@sJeZdZdZdeeefddfddZdej de e ee ffdd Z dS) HostMatchesz@Matches requests from hosts specified by ``host_pattern`` regex. host_patternrNcCs6t|tr|ds|d7}t||_dS||_dS)N$)r;r endswithrecompilerz)rrzrrr r6s   zHostMatches.__init__rcCs|j|jr iSdSr$)rzr` host_namervrrr r`szHostMatches.match)r'r(r)r*rr3rr6rr+rrr r`rrrr rys$ryc@sFeZdZdZdededdfddZdejde e e effd d Z dS) DefaultHostMatcheszMatches requests from host that is equal to application's default_host. Always returns no match if ``X-Real-Ip`` header is present. applicationrzrNcCs||_||_dSr$)rrz)rrrzrrr r6's zDefaultHostMatches.__init__rcCs"d|jvr|j|jjriSdS)Nz X-Real-Ip)r8rzr`r default_hostrvrrr r`+s zDefaultHostMatches.match) r'r(r)r*r rr6rr+rrr3r`rrrr r"s$rc@s~eZdZdZdeeefddfddZdej de e ee ffdd Z d e de efd d Zdee ee effd dZdS)rYz@Matches requests with paths specified by ``path_pattern`` regex. path_patternrNcCslt|tr|ds|d7}t||_n||_t|jjd|jjfvs,Jd|jj | \|_ |_ dS)Nr{rzDgroups in url regexes must either be all named or all positional: %r) r;r r|r}r~regexrX groupindexgroupspattern _find_groups_path _group_count)rrrrr r66s  zPathMatches.__init__rcCsl|j|j}|dur dS|jjsiSg}i}|jjr'dd|D}n dd|D}t||dS)NcSsi|] \}}t|t|qSr)r3_unquote_or_none).0kvrrr Tsz%PathMatches.match..cSsg|]}t|qSr)r)rsrrr Xsz%PathMatches.match..) path_args path_kwargs)rr`r?rr groupdictitemsdict)rrr`rrrrr r`Es  zPathMatches.matchr1cGs|jdur td|jjt||jksJdt|s|jSg}|D]}t|ttfs0t |}| t t |ddq#|jt |S)NzCannot reverse url regex z&required number of arguments not foundF)plus)r ValueErrorrrrXrr;r rJr3rZrrrV)rr1converted_argsarrr rn\s zPathMatches.reversec Cs|jj}|dr|dd}|dr|dd}|jj|dkr%dSg}|dD]F}d|vr[|d}|d krZz t||dd}Wn t yRYdSw| d |q,zt|}Wn t ylYdSw| |q,d ||jjfS) zReturns a tuple (reverse string, group count) for a url. For example: Given the url pattern /([0-9]{4})/([a-z-]+)/, this method would return ('/%s/%s/', 2). ^rUNr{(ru)rz%s) rr startswithr|rcountsplitindexr rrZjoin)rrpiecesfragment paren_locunescaped_fragmentrrr rks4         zPathMatches._find_groups)r'r(r)r*rr3rr6rr+rrr r`rnrintrrrrr rY3s  "rYc sbeZdZdZ  d deeefdedee eefdeeddf fdd Z defd d Z Z S) URLSpeczSpecifies mappings between URLs and handlers. .. versionchanged: 4.5 `URLSpec` is now a subclass of a `Rule` with `PathMatches` matcher and is preserved for backwards compatibility. Nrhandlerrr0rcs4t|}t|||||j|_|j|_||_dS)aParameters: * ``pattern``: Regular expression to be matched. Any capturing groups in the regex will be passed in to the handler's get/post/etc methods as arguments (by keyword if named, by position if unnamed. Named and unnamed capturing groups may not be mixed in the same rule). * ``handler``: `~.web.RequestHandler` subclass to be invoked. * ``kwargs`` (optional): A dictionary of additional arguments to be passed to the handler's constructor. * ``name`` (optional): A name for this handler. Used by `~.web.Application.reverse_url`. N)rYrjr6rrb handler_classr)rrrrr0r_rkrr r6s  zURLSpec.__init__cCs d|jj|jj|j|j|jSrr)rsrlr'rrrrr0rErrr rtszURLSpec.__repr__ru) r'r(r)r*rr3rr rrr6rtrprrrkr rs   rrrcCdSr$rrrrr rrwrcCrr$rrrrr rrwcCs|dur|St|dddS)zNone-safe wrapper around url_unescape to handle unmatched optional groups correctly. Note that args are passed as bytes so the handler can decide what encoding to use. NF)encodingr)rrrrr rs)rNrN)1r*r} functoolsrtornadortornado.httpserverrtornado.escaperrr tornado.logr tornado.utilr r r r typingr rrrrrrrrrrdrr/r,r%r@r3rgrNrhrLrMrxryrrYrrJrrrrr sL$    0. h%1a1