R?ga SrSSKrSSKJr SSKJr SSKJr SSKJ r J r J r SSK J r SSKJrJrJrJr SS KJrJrJrJrJrJrJrJrJr "S S \R:5r"S S \5r"SS\R@5r!"SS\R@5r"\\S\\\\\#S4\4\\\#S4\\\#\44\\\#S4\\\#\4\#44r$"SS\5r%"SS\\%5r&"SS\'5r("SS\'5r)"SS\)5r*"SS\)5r+"SS\)5r,"S S!\)5r-"S"S#\(5r.\S$\#S%\/4S&j5r0\S)S'j5r0S$\\#S%\\/4S(jr0g)*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 AwaitableListDictPatternTupleoverloadc\rSrSrSrS\R S\S\\R4Sjr S\ S\RS\R4S jr S rg ) RouterzAbstract router interface.requestkwargsreturnc [5e)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)selfrrs 1/usr/lib/python3/dist-packages/tornado/routing.py find_handlerRouter.find_handlers "## server_conn request_connc[XU5$N)_RoutingDelegate)r r%r&s r! start_requestRouter.start_requests <@@r$N)__name__ __module__ __qualname____firstlineno____doc__rHTTPServerRequestrrHTTPMessageDelegater"objectHTTPConnectionr*__static_attributes__r,r$r!rrs`$ $11 $=@ $ (.. / $A!A191H1HA  % %Ar$rc4\rSrSrSrS\S\S\\4SjrSr g) ReversibleRouterzpAbstract router interface for routers that can handle named routes and support reversing them to original urls. nameargsrc[5e)zReturns 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)r r:r;s r! reverse_urlReversibleRouter.reverse_urls "##r$r,N) r-r.r/r0r1strrrr=r6r,r$r!r8r8s%$$C$HSM$r$r8c\rSrSrS\S\S\RSS4SjrS\ \R\R4S \RS\ \S4S jrS \S\ \S4S jrSS jrSSjrSrg)r)routerr%r&rNc6X lX0lSUlXlgr()r%r&delegaterB)r rBr%r&s r!__init___RoutingDelegate.__init__s'(  r$ start_lineheadersc[U[R5(de[R"URUR UUS9nUR RU5UlURcF[R"SURUR5 [UR5UlURRX5$)N) connectionserver_connectionrGrHz$Delegate for %s %s request not found) isinstancerRequestStartLiner2r&r%rBr"rDr debugmethodpath_DefaultMessageDelegateheaders_received)r rGrHrs r!rR!_RoutingDelegate.headers_receiveds *h&?&?@@@@,,(("..!   009 == MM6!!  4D4E4EFDM}}--jBBr$chunkcVURceURRU5$r()rD data_received)r rTs r!rV_RoutingDelegate.data_receiveds'}}(((}}**511r$cVURceURR5 gr()rDfinishr s r!rY_RoutingDelegate.finish s"}}((( r$cVURceURR5 gr()rDon_connection_closerZs r!r]$_RoutingDelegate.on_connection_closes"}}((( ))+r$)rDr&rBr%rN)r-r.r/r0rr4rr5rErrMResponseStartLine HTTPHeadersrrrRbytesrVrYr]r6r,r$r!r)r)s+1AIAXAX C(33X5O5OOPC%%C )D/ " C0252Xio-F2,r$r)cD\rSrSrS\R SS4SjrSSjrSrg) rQirJrNcXlgr(rJ)r rJs r!rE _DefaultMessageDelegate.__init__s$r$cURR[R"SSS5[R"55 URR 5 g)NzHTTP/1.1z Not Found)rJ write_headersrr`rarYrZs r!rY_DefaultMessageDelegate.finishsD %%  & &z3 D  "   r$rer_) r-r.r/r0rr5rErYr6r,r$r!rQrQs %8#:#:%t%!r$rQRuleMatcherc \rSrSrSrSS\\SS4SjjrS\SS4SjrSSjr S \ RS \ S\\ R4S jrS \ S \ RS \ S\\ R4SjrSrg) RuleRouteri,z!Rule-based router implementation.NrulesrcD/UlU(aURU5 gg)aConstructs 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_rules)r ros r!rERuleRouter.__init__/s6  NN5 ! r$c:UHn[U[[45(aM[U5S;de[US[5(a[ [ US5/USSQ76nO[ U6nURRURU55 M g)zAppends new rules to the router. :arg rules: a list of Rule instances (or tuples of arguments, which are passed to Rule constructor). )rN) rLtuplelistlenr rk PathMatchesroappend process_rule)r rorules r!rqRuleRouter.add_rulesNs D$ ..4yI---d1g77 DG 4@tABx@D;D JJ  d//5 6r$cU$)zOverride this method for additional preprocessing of each rule. :arg Rule rule: a rule to be processed. :returns: the same or modified Rule instance. r,)r r~s r!r}RuleRouter.process_rule^s  r$rrc URHhnURRU5nUcM#UR(aURUS'UR"UR U40UD6nUcMfUs $ g)N target_kwargs)romatchermatchrget_target_delegatetarget)r rrr~ target_paramsrDs r!r"RuleRouter.find_handlerfsxJJD LL..w7M(%%595G5GM/233KK,9'#Or$rrc z[U[5(aUR"U40UD6$[U[R5(a5UR ceUR URUR 5$[U5(a/UR ce[[U40UD6UR 5$g)axReturns 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) rLrr"rHTTPServerConnectionDelegaterJr*rKcallablerr)r rrrs r!rRuleRouter.get_target_delegatexs ff % %&&w@-@ @  E E F F%%1 11''(A(A7CUCUV V f  %%1 11#0-0'2D2D r$)ror(r~rkrrk)r-r.r/r0r1r _RuleListrErqr}rr2rr3r"rr6r,r$r!rnrn,s+"hy1"T">7y7T7 11=@ (.. /$$,$>$>QT (.. /r$rncn^\rSrSrSrS S\\SS4U4SjjjrS U4SjjrS\ S \ S\\ 4S jr S r U=r $)ReversibleRuleRouterrhzA 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`). Nrorc2>0Ul[TU] U5 gr() named_rulessuperrE)r ro __class__s r!rEReversibleRuleRouter.__init__s r$c>[TU]U5nUR(aSURUR;a![R "SUR5 XRUR'U$)Nz4Multiple handlers named %s; replacing previous value)rr}r:rr warning)r r~rs r!r}!ReversibleRuleRouter.process_rulesYw#D) 99yyD,,,JDII+/  TYY ' r$r:r;cXR;a&URURR"U6$URHHn[ UR [ 5(dM$UR R"U/UQ76nUcMFUs $ gr()rrreverserorLrr8r=)r r:r;r~ reversed_urls r!r= ReversibleRuleRouter.reverse_urlsz ## ###D)11994@ @JJD$++'788#{{66tCdC +''  r$)rr(r)r-r.r/r0r1rrrEr}r?rr=r6 __classcell__rs@r!rrsM hy1 T     C HSM  r$rc z\rSrSrSrSSSS\S\\\\4S\\S S4 S jjr S \S \\4S jr S \4S jr Sr g)rkizA routing rule.Nrrlrrr:rc[U[5(a [U5nXlX lU(aUO0UlX@lg)aConstructs 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)rLr?r rrrr:)r rrrr:s r!rE Rule.__init__s8. fc " "#6*F  .;] r$r;c4URR"U6$r()rrr r;s r!r Rule.reverses||##T**r$c URR<SUR<SUR<SUR<SUR <S3 $N(z, z , kwargs=z, name=))rr-rrrr:rZs r!__repr__ Rule.__repr__s7 NN # # LL KK    II   r$)rr:rrNN) r-r.r/r0r1rrrr?rErrr6r,r$r!rkrksw 37"  S#X/  sm   B+S+Xc]+ # r$cf\rSrSrSrS\R S\\\ \ 44Sjr S\ S\\ 4Sjr Sr g ) rliz*Represents a matcher for request features.rrc[5e)aMatches 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.rr rs r!r Matcher.matchs "##r$r;cg)zEReconstructs full url from matcher instance and additional arguments.Nr,rs r!rMatcher.reversesr$r,N)r-r.r/r0r1rr2rrr?rrrr6r,r$r!rlrlsB4 $X77 $HT#s(^$PathMatches.match..Is%,-8a-/9R-S* MM$);";<"()4X)>&  01%+(wwv 1 111&, ,,"(((s$+D D, D)(D), D:9D:)rrr)r-r.r/r0r1rr?rrErr2rrrrrrintrr6r,r$r!r{r{(sJ [U5n[TU] XRX45 URUlURUlX0lg)a+Parameters: * ``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)r{rrErr handler_classr)r rrrr:rrs r!rEURLSpec.__init__s:0g& 68]] ![[ r$c URR<SURR<SUR<SUR <SUR <S3 $r)rr-rrrrr:rZs r!rURLSpec.__repr__s= NN # # JJ      KK II   r$)rrrr)r-r.r/r0r1rr?rrrrrErr6rrs@r!rrsu,0" sG|$c3h(  sm   > #  r$rrrcgr(r,rs r!rrr$cgr(r,rs r!rrrr$c"UcU$[USSS9$)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)rrs r!rrs y Du 55r$)rNrN)1r1r functoolsrtornadortornado.httpserverrtornado.escaperrr tornado.logr tornado.utilr r r r typingrrrrrrrrrrrr8r3r)rQr?rrnrr4rkrlrrrr{rrbrr,r$r!rsaF /99RRXXXAX 2 2A. $v $ +,x33+,\ !h:: !   S  eCN#S() eCN#S$sCx.89 eCN#S$sCx.#=>  @  eeP"+Z"J. 6. bf('$"^2'^2B. d. b           6 6(5/ 6r$