ó ¨œž[c@`sdZddlmZmZmZddlZddlmZddlm Z ddl m Z ddl m Z mZmZddlmZdd lmZmZmZmZyddlZWnek rÏnXd e jfd „ƒYZd efd „ƒYZde jfd„ƒYZde jfd„ƒYZdefd„ƒYZdeefd„ƒYZ de!fd„ƒYZ"de!fd„ƒYZ#de#fd„ƒYZ$de#fd„ƒYZ%de#fd„ƒYZ&d e#fd!„ƒYZ'd"e"fd#„ƒYZ(d$„Z)dS(%sqFlexible 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 i(tabsolute_importtdivisiontprint_functionN(tpartial(thttputil(t_CallableAdapter(t url_escapet url_unescapetutf8(tapp_log(tbasestring_typet import_objectt re_unescapet unicode_typetRoutercB`s eZdZd„Zd„ZRS(sAbstract router interface.cK`s tƒ‚dS(sòMust 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. N(tNotImplementedError(tselftrequesttkwargs((s.lib/python2.7/site-packages/tornado/routing.pyt find_handlerÆs cC`st|||ƒS(N(t_RoutingDelegate(Rt server_connt request_conn((s.lib/python2.7/site-packages/tornado/routing.pyt start_requestÓs(t__name__t __module__t__doc__RR(((s.lib/python2.7/site-packages/tornado/routing.pyRÃs tReversibleRoutercB`seZdZd„ZRS(sxAbstract router interface for routers that can handle named routes and support reversing them to original urls. cG`s tƒ‚dS(sReturns 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``). N(R(Rtnametargs((s.lib/python2.7/site-packages/tornado/routing.pyt reverse_urlÜs(RRRR(((s.lib/python2.7/site-packages/tornado/routing.pyR×sRcB`s5eZd„Zd„Zd„Zd„Zd„ZRS(cC`s(||_||_d|_||_dS(N(RRtNonetdelegatetrouter(RR!RR((s.lib/python2.7/site-packages/tornado/routing.pyt__init__ès   c C`stjd|jd|jd|d|ƒ}|jj|ƒ|_|jdkr|tj d|j |j ƒt |jƒ|_n|jj ||ƒS(Nt connectiontserver_connectiont start_linetheaderss$Delegate for %s %s request not found(RtHTTPServerRequestRRR!RR RR tdebugtmethodtpatht_DefaultMessageDelegatetheaders_received(RR%R&R((s.lib/python2.7/site-packages/tornado/routing.pyR,îs    cC`s|jj|ƒS(N(R t data_received(Rtchunk((s.lib/python2.7/site-packages/tornado/routing.pyR-üscC`s|jjƒdS(N(R tfinish(R((s.lib/python2.7/site-packages/tornado/routing.pyR/ÿscC`s|jjƒdS(N(R ton_connection_close(R((s.lib/python2.7/site-packages/tornado/routing.pyR0s(RRR"R,R-R/R0(((s.lib/python2.7/site-packages/tornado/routing.pyRçs     R+cB`seZd„Zd„ZRS(cC`s ||_dS(N(R#(RR#((s.lib/python2.7/site-packages/tornado/routing.pyR"scC`s9|jjtjdddƒtjƒƒ|jjƒdS(NsHTTP/1.1i”s Not Found(R#t write_headersRtResponseStartLinet HTTPHeadersR/(R((s.lib/python2.7/site-packages/tornado/routing.pyR/ s (RRR"R/(((s.lib/python2.7/site-packages/tornado/routing.pyR+s t RuleRoutercB`s>eZdZdd„Zd„Zd„Zd„Zd„ZRS(s!Rule-based router implementation.cC`s#g|_|r|j|ƒndS(sIConstructs 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(trulest add_rules(RR5((s.lib/python2.7/site-packages/tornado/routing.pyR"s cC`sx–|D]Ž}t|ttfƒr|t|ƒdks:t‚t|dtƒrmtt|dƒ|dŒ}q|t|Œ}n|jj |j |ƒƒqWdS(s£Appends new rules to the router. :arg rules: a list of Rule instances (or tuples of arguments, which are passed to Rule constructor). iiiiiN(iii( t isinstancettupletlisttlentAssertionErrorR tRulet PathMatchesR5tappendt process_rule(RR5trule((s.lib/python2.7/site-packages/tornado/routing.pyR62s  cC`s|S(s¯Override this method for additional preprocessing of each rule. :arg Rule rule: a rule to be processed. :returns: the same or modified Rule instance. ((RR@((s.lib/python2.7/site-packages/tornado/routing.pyR?BscK`szxs|jD]h}|jj|ƒ}|dk r |jrG|j|dst path_argst path_kwargs( R^RCR*RR`R_tdictt groupdicttitemsRf(RRRCRjRkts((s.lib/python2.7/site-packages/tornado/routing.pyRC s    %cG`sÇ|jdkr(td|jjƒ‚nt|ƒ|jksItdƒ‚t|ƒs\|jSg}xQ|D]I}t|t t fƒs“t |ƒ}n|j t t|ƒdtƒƒqiW|jt|ƒS(NsCannot reverse url regex s&required number of arguments not foundtplus(RcRt ValueErrorR^RaR:RdR;R7R tbytesROR>RRtFalseR8(RRtconverted_argsta((s.lib/python2.7/site-packages/tornado/routing.pyRM"s!  #cC`s|jj}|jdƒr(|d}n|jdƒrD|d }n|jj|jdƒkrcd Sg}x|jdƒD]~}d|krÅ|jdƒ}|dkr÷|j d||dƒq÷qyyt |ƒ}Wnt k réd SX|j |ƒqyWd j |ƒ|jjfS( s¶Returns 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). t^iRUiÿÿÿÿt(t)is%stN(NN(NN( R^Rat startswithRVR`tcountRtsplittindexR>R Rqtjoin(RRatpiecestfragmentt paren_loctunescaped_fragment((s.lib/python2.7/site-packages/tornado/routing.pyRb0s&      (RRRR"RCRMRb(((s.lib/python2.7/site-packages/tornado/routing.pyR=ûs    tURLSpeccB`s&eZdZddd„Zd„ZRS(sÍSpecifies 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. cC`sMtt|ƒjt|ƒ|||ƒ|jj|_|j|_||_dS(sƒ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( RKRƒR"R=RBR^REt handler_classR(RRathandlerRR((s.lib/python2.7/site-packages/tornado/routing.pyR"Zs% cC`s,d|jj|jj|j|j|jfS(Ns%s(%r, %s, kwargs=%r, name=%r)(RPRR^RaR„RR(R((s.lib/python2.7/site-packages/tornado/routing.pyRQrsN(RRRRR"RQ(((s.lib/python2.7/site-packages/tornado/routing.pyRƒSscC`s&|dkr|St|dddtƒS(s¹None-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. tencodingRpN(RRRs(Ro((s.lib/python2.7/site-packages/tornado/routing.pyRfxs (*Rt __future__RRRRWt functoolsRttornadoRttornado.httpserverRttornado.escapeRRRt tornado.logR t tornado.utilR R R R ttypingt ImportErrorRGRRtHTTPMessageDelegateRR+R4RItobjectR<RRRSRTR[R=RƒRf(((s.lib/python2.7/site-packages/tornado/routing.pyt°s4 "  a%'X%