2 fa >dZddlZddlmZddlmZddlmZddlm Z m Z m Z ddl m Z ddlmZmZmZmZdd lmZmZmZmZmZmZmZmZmZGd d ejZGd d eZGddej Z!Gddej Z"eedeeeee#dfefeee#dfeee#effeee#dfeee#efe#ffZ$GddeZ%Gddee%Z&Gdde'Z(Gdde'Z)Gdde)Z*Gdde)Z+Gdde)Z,Gd d!e)Z-Gd"d#e(Z.ed$e#d%e/fd&Z0ed)d'Z0d$ee#d%ee/fd(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 AwaitableListDictPatternTupleoverloadcneZdZdZdejdedeejfdZ de dej dejfdZ d S) RouterzAbstract router interface.requestkwargsreturnc t)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 E/var/www/equiseq/venv/lib/python3.11/site-packages/tornado/routing.py find_handlerzRouter.find_handlers"### server_conn request_connc$t|||SN)_RoutingDelegate)rr#r$s r start_requestzRouter.start_requests k<@@@r"N) __name__ __module__ __qualname____doc__rHTTPServerRequestrrHTTPMessageDelegater!objectHTTPConnectionr(r"r rrs$$ $1 $=@ $ (. / $ $ $ $A!A191HA  %AAAAAAr"rc2eZdZdZdededeefdZdS)ReversibleRouterzxAbstract router interface for routers that can handle named routes and support reversing them to original urls. nameargsrct)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)rr4r5s r reverse_urlzReversibleRouter.reverse_urls"###r"N)r)r*r+r,strrrr7r1r"r r3r3sK$$C$HSM$$$$$$r"r3ceZdZdededejddfdZdeej ej fdej de e dfd Zd ede e dfd Zdd Zdd ZdS)r'routerr#r$rNc>||_||_d|_||_dSr&)r#r$delegater:)rr:r#r$s r __init__z_RoutingDelegate.__init__s&'(  r" start_lineheaderscrt|tjsJtj|j|j||}|j||_|j9tj d|j |j t|j|_|j||S)N) connectionserver_connectionr>r?z$Delegate for %s %s request not found) isinstancerRequestStartLiner-r$r#r:r!r<r debugmethodpath_DefaultMessageDelegateheaders_received)rr>r?rs r rIz!_RoutingDelegate.headers_receiveds *h&?@@@@@,(".!     0099 = M6!    4D4EFFDM}--j'BBBr"chunkcH|jJ|j|Sr&)r< data_received)rrJs r rLz_RoutingDelegate.data_receiveds&}(((}**5111r"cJ|jJ|jdSr&)r<finishrs r rNz_RoutingDelegate.finish s*}((( r"cJ|jJ|jdSr&)r<on_connection_closerOs r rQz$_RoutingDelegate.on_connection_closes*}((( ))+++++r"rN)r)r*r+rr/rr0r=rrDResponseStartLine HTTPHeadersrrrIbytesrLrNrQr1r"r r'r's+1AIAX C(3X5OOPC%C )D/ " CCCC0252Xio-F2222,,,,,,r"r'c0eZdZdejddfdZddZdS)rHrArNc||_dSr&)rA)rrAs r r=z _DefaultMessageDelegate.__init__s $r"c|jtjdddtj|jdS)NzHTTP/1.1iz Not Found)rA write_headersrrSrTrNrOs r rNz_DefaultMessageDelegate.finishsV %%  &z3 D D  " "         r"rR)r)r*r+rr0r=rNr1r"r rHrHsM%8#:%t%%%%!!!!!!r"rHRuleMatcherc eZdZdZddeeddfdZdeddfdZdd Zd e j d e dee j fd Z d e d e j de dee j fdZdS) RuleRouterz!Rule-based router implementation.NrulesrcFg|_|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)r^ add_rules)rr^s r r=zRuleRouter.__init__/s56  " NN5 ! ! ! ! ! " "r"cb|D]}t|ttfr`t|dvsJt|dtr)t t |dg|ddR}n t |}|j| |dS)zAppends new rules to the router. :arg rules: a list of Rule instances (or tuples of arguments, which are passed to Rule constructor). )rN) rCtuplelistlenr rZ PathMatchesr^append process_rule)rr^rules r r`zRuleRouter.add_rulesNs  7 7D$ .. '4yyI----d1g77' DG 4 4@tABBx@@@DD;D J  d//55 6 6 6 6 7 7r"rlrZc|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. r1)rrls r rkzRuleRouter.process_rule^s  r"rrc |jD]I}|j|}|+|jr |j|d<|j|j|fi|}||cSJdS)N target_kwargs)r^matchermatchroget_target_delegatetarget)rrrrl target_paramsr<s r r!zRuleRouter.find_handlerfsJ $ $D L..w77M(%H595GM/2343K,9'#OOOtr"rsrtc Bt|tr|j|fi|St|tjr)|jJ||j|jSt|r)|jJtt|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) rCrr!rHTTPServerConnectionDelegaterAr(rBcallablerr)rrsrrts r rrzRuleRouter.get_target_delegatexs ff % % &6&w@@-@@ @  E F F %111''(A7CUVV V f   %111#00-00'2D tr"r&rlrZrrZ)r)r*r+r,r _RuleListr=r`rkrr-rr.r!rrr1r"r r]r],s++""hy1"T"""">7y7T7777 1=@ (. /$$,$>QT (. /r"r]cfeZdZdZd deeddffd Zd fd Zd ed e deefd Z xZ 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`). Nr^rcXi|_t|dSr&) named_rulessuperr=)rr^ __class__s r r=zReversibleRuleRouter.__init__s) r"rlrZct|}|jr7|j|jvrt jd|j||j|j<|S)Nz4Multiple handlers named %s; replacing previous value)r~rkr4r}r warning)rrlrs r rkz!ReversibleRuleRouter.process_ruleseww##D)) 9 /yD,,,JDI+/D TY ' r"r4r5c||jvr|j|jj|S|jD]5}t |jt r|jj|g|R}||cS6dSr&)r}rpreverser^rCrsr3r7)rr4r5rl reversed_urls r r7z ReversibleRuleRouter.reverse_urls 4# # #94#D)194@ @J ( (D$+'788 (6t{6tCdCCC +''''tr"r&rx) r)r*r+r,rryr=rkr8rr7 __classcell__rs@r r{r{s  hy1 T              C HSM        r"r{c eZdZdZ d dddedeeeefdeeddf d Zd edeefd Z defd Z dS)rZzA routing rule.Nrpr[rsror4rct|trt|}||_||_|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)rCr8r rprsror4)rrprsror4s r r=z Rule.__init__sO. fc " " +#6**F  .;C]] r"r5c |jj|Sr&)rprrr5s r rz Rule.reverses#t|#T**r"c `|jjd|jd|jd|jd|jd SN(z, z , kwargs=z, name=))rr)rprsror4rOs r __repr__z Rule.__repr__sA N # # # LLL KKK     III   r"NN) r)r*r+r,rrrr8r=rrr1r"r rZrZs 37"  S#X/  sm   B+S+Xc]++++ #      r"cdeZdZdZdejdeeee ffdZ de deefdZ dS)r[z*Represents a matcher for request features.rrct)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.rrrs r rqz Matcher.matchs"###r"r5cdS)zEReconstructs full url from matcher instance and additional arguments.Nr1rs r rzMatcher.reversestr"N) r)r*r+r,rr-rrr8rrqrr1r"r r[r[sr44 $X7 $HT#s(^t d|D}nd|D}t ||S)Nc3XK|]%\}}t|t|fV&dSr&)r8_unquote_or_none).0kvs r z$PathMatches.match..IsK281aQ)!,,-r"c,g|]}t|Sr1)r)rss r z%PathMatches.match..Ms!EEE)!,,EEEr") path_args path_kwargs)rrqrGrrdict groupdictitems)rrrqrrs r rqzPathMatches.match:s   .. =4z  I  :  F>,-8)a-//9R-S-S**%,,, ,|||,MM$);";<<<()4X)>)>&&!((((<<<( 01111wwv 111s$)C CC0D DD)r)r*r+r,rr8rr=rr-rrrrqrrintrr1r"r riri(sJJ  #        r"rrrcdSr&r1rs r rrDr"cdSr&r1rs r rrrr"c.||St|ddS)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 5 5 55r")rNrN)1r,r functoolsrtornadortornado.httpserverrtornado.escaperrr tornado.logr tornado.utilr r r r typingrrrrrrrrrrvrr3r.r'rHr8ryr]r{r/rZr[rrrrirrUrr1r"r rs3aaF //////9999999999RRRRRRRRRRRRXXXXXXXXXXXXXXXXXXXXXXAAAAAX 2AAA. $ $ $ $ $v $ $ $ +,+,+,+,+,x3+,+,+,\ ! ! ! ! !h: ! ! !   S  eCN#S() eCN#S$sCx.89 eCN#S$sCx.#=>  @  eeeeeeeeP"""""+Z"""J. . . . . 6. . . bf('$"^2^2^2^2^2'^2^2^2B. . . . . d. . . b               6 6(5/ 6 6 6 6 6 6r"