File manager - Edit - /usr/local/CyberCP/lib/python3.10/site-packages/tornado/__pycache__/routing.cpython-310.pyc
Back
o �h�a � @ s d Z ddlZddlmZ ddlmZ ddlmZ ddlm Z m Z m Z ddl m Z ddlmZmZmZmZ dd lmZmZmZmZmZmZmZmZm Z G d d � d ej �Z G d d � d e �Z G dd� dej �Z!G dd� dej �Z"eedee eee#df ef eee#df eee#ef f eee#df eee#ef e#f f Z$G dd� de �Z%G dd� de e%�Z&G dd� de'�Z(G dd� de'�Z)G dd� de)�Z*G d d � d e)�Z+G d d � d e)�Z,G d d!� d!e)�Z-G d"d#� d#e(�Z.e d$e#d%e/fd&d'��Z0e d*d(d'��Z0d$ee# d%ee/ fd)d'�Z0dS )+ap Flexible 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_unescape�utf8)�app_log)�basestring_type� import_object� re_unescape� unicode_type) �Any�Union�Optional� Awaitable�List�Dict�Pattern�Tuple�overloadc @ sH e Zd ZdZdejdedeej fdd�Z de dej dejfd d �Z d S ) �RouterzAbstract router interface.�request�kwargs�returnc K � t � �)a� 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. ��NotImplementedError)�selfr r � r �B/usr/local/CyberCP/lib/python3.10/site-packages/tornado/routing.py� find_handler� s zRouter.find_handler� server_conn� request_connc C s t | ||�S �N)�_RoutingDelegate)r r! r" r r r � start_request� s zRouter.start_requestN) �__name__� __module__� __qualname__�__doc__r �HTTPServerRequestr r �HTTPMessageDelegater �object�HTTPConnectionr% r r r r r � s �� ����r c @ s* e Zd ZdZdededee fdd�ZdS )�ReversibleRouterzxAbstract router interface for routers that can handle named routes and support reversing them to original urls. �name�argsr c G r )a Returns 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/ r0 r r r � reverse_url� s z ReversibleRouter.reverse_urlN)r& r' r( r) �strr r r1 r r r r r. � s r. c @ s� e Zd Zdededejddfdd�Zdeej ej f d ej de e d fd d �Zd ede e d fd d�Zddd�Zddd�ZdS )r$ �routerr! r" r Nc C s || _ || _d | _|| _d S r# )r! r" �delegater3 )r r3 r! r" r r r �__init__� s z_RoutingDelegate.__init__� start_line�headersc C sj t |tj�sJ �tj| j| j||d�}| j�|�| _| jd u r.t � d|j |j � t | j�| _| j�||�S )N)� connection�server_connectionr6 r7 z$Delegate for %s %s request not found)� isinstancer �RequestStartLiner* r" r! r3 r r4 r �debug�method�path�_DefaultMessageDelegate�headers_received)r r6 r7 r r r r r@ � s � � z!_RoutingDelegate.headers_received�chunkc C s | j d usJ �| j �|�S r# )r4 � data_received)r rA r r r rB s z _RoutingDelegate.data_receivedc C � | j d usJ �| j �� d S r# )r4 �finish�r r r r rD � z_RoutingDelegate.finishc C rC r# )r4 �on_connection_closerE r r r rG rF z$_RoutingDelegate.on_connection_close�r N)r& r' r( r r, r r- r5 r r; �ResponseStartLine� HTTPHeadersr r r@ �bytesrB rD rG r r r r r$ � s( ��� ��� � r$ c @ s* e Zd Zdejddfdd�Zddd�ZdS ) r? r8 r Nc C s || _ d S r# )r8 )r r8 r r r r5 s z _DefaultMessageDelegate.__init__c C s* | j �t�ddd�t�� � | j �� d S )NzHTTP/1.1i� z Not Found)r8 � write_headersr rI rJ rD rE r r r rD s �z _DefaultMessageDelegate.finishrH )r& r' r( r r- r5 rD r r r r r? s r? �Rule�Matcherc @ s� e Zd ZdZddee ddfdd�Zdeddfdd�Zdd d �Zd e j de dee j fdd�Z de d e j de dee j fdd�ZdS )� RuleRouterz!Rule-based router implementation.N�rulesr c C s g | _ |r | �|� dS dS )aI Constructs 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)rP � add_rules�r rP r r r r5 / s �zRuleRouter.__init__c C sv |D ]6}t |ttf�r/t|�dv sJ �t |d t�r+tt|d �g|dd� �R � }nt|� }| j�| � |�� qdS )z�Appends new rules to the router. :arg rules: a list of Rule instances (or tuples of arguments, which are passed to Rule constructor). )� � � r � N) r: �tuple�list�lenr rM � PathMatchesrP �append� process_rule)r rP �ruler r r rQ N s "�zRuleRouter.add_rulesr] rM c C s |S )z�Override 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] r r r r\ ^ s zRuleRouter.process_ruler r c K sZ | j D ]'}|j�|�}|d ur*|jr|j|d< | j|j|fi |��}|d ur*| S qd S )N� target_kwargs)rP �matcher�matchr_ �get_target_delegate�target)r r r r] � target_paramsr4 r r r r f s ���zRuleRouter.find_handlerrc rd c K sx t |t�r|j|fi |��S t |tj�r#|jdusJ �|�|j|j�S t|�r:|jdus.J �t t |fi |��|j�S dS )a� Returns 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: r r r � HTTPServerConnectionDelegater8 r% r9 �callabler r )r rc r rd r r r rb x s �z RuleRouter.get_target_delegater# �r] rM r rM )r& r' r( r) r � _RuleListr5 rQ r\ r r* r r+ r rb r r r r rO , s* �� �����rO c sX e Zd ZdZddee ddf� fdd� Zd� fd d � Zd ed e dee fd d�Z � Z S )�ReversibleRuleRoutera A 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`). NrP r c s i | _ t� �|� d S r# )� named_rules�superr5 rR �� __class__r r r5 � s z ReversibleRuleRouter.__init__r] rM c s< t � �|�}|jr |j| jv rt�d|j� || j|j< |S )Nz4Multiple handlers named %s; replacing previous value)rk r\ r/ rj r �warningr^ rl r r r\ � s � z!ReversibleRuleRouter.process_ruler/ r0 c G s\ || j v r| j | jj|� S | jD ]}t|jt�r+|jj|g|�R � }|d ur+| S qd S r# )rj r` �reverserP r: rc r. r1 )r r/ r0 r] � reversed_urlr r r r1 � s �z ReversibleRuleRouter.reverse_urlr# rg ) r& r' r( r) r rh r5 r\ r2 r r1 � __classcell__r r rl r ri � s " ri c @ sh e Zd ZdZ ddddedeeeef dee ddf d d �Zd edee fd d �Z defdd�Z dS )rM zA routing rule.Nr` rN rc r_ r/ r c C s6 t |t�r t|�}|| _|| _|r|ni | _|| _dS )ad Constructs 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: r2 r r` rc r_ r/ )r r` rc r_ r/ r r r r5 � s z Rule.__init__r0 c G s | j j|� S r# )r` ro �r r0 r r r ro � s z Rule.reversec C s d| j j| j| j| j| jf S �Nz %s(%r, %s, kwargs=%r, name=%r))rm r& r` rc r_ r/ rE r r r �__repr__� s �z Rule.__repr__�NN) r& r' r( r) r r r r2 r5 ro rt r r r r rM � s" ����� �!c @ sF e Zd ZdZdejdeeee f fdd�Z de dee fdd�Z d S ) rN z*Represents a matcher for request features.r r c C r )a1 Matches 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.r �r r r r r ra � s z Matcher.matchr0 c G s dS )zEReconstructs full url from matcher instance and additional arguments.Nr rr r r r ro � � zMatcher.reverseN) r& r' r( r) r r* r r r2 r ra ro r r r r rN � s c @ s0 e Zd ZdZdejdeeee f fdd�Z dS )� AnyMatcheszMatches any request.r r c C s i S r# r rv r r r ra s zAnyMatches.matchN) r& r' r( r) r r* r r r2 r ra r r r r rx � s $rx c @ sJ e Zd ZdZdeeef ddfdd�Zdej de e ee f fdd �Z dS ) � HostMatchesz@Matches requests from hosts specified by ``host_pattern`` regex.� host_patternr Nc C s6 t |t�r|�d�s|d7 }t�|�| _d S || _d S )N�$)r: r �endswith�re�compilerz )r rz r r r r5 s zHostMatches.__init__r c C s | j �|j�r i S d S r# )rz ra � host_namerv r r r ra s zHostMatches.match)r& r' r( r) r r2 r r5 r r* r r r ra r r r r ry s $ry c @ sF e Zd ZdZdededdfdd�Zdejde e e ef fd d �Z dS ) �DefaultHostMatchesz�Matches requests from host that is equal to application's default_host. Always returns no match if ``X-Real-Ip`` header is present. � applicationrz r Nc C s || _ || _d S r# )r� rz )r r� rz r r r r5 s zDefaultHostMatches.__init__r c C s" d|j vr| j�| jj�ri S d S )Nz X-Real-Ip)r7 rz ra r� � default_hostrv r r r ra s zDefaultHostMatches.match) r& r' r( r) r r r5 r r* r r r2 ra r r r r r� s $r� c @ s~ e Zd ZdZdeeef ddfdd�Zdej de e ee f fdd �Z d e de e fd d �Zdee e e e f fd d�ZdS )rZ z@Matches requests with paths specified by ``path_pattern`` regex.� path_patternr Nc C sl t |t�r|�d�s|d7 }t�|�| _n|| _t| jj�d| jjfv s,J d| jj ��| � � \| _ | _ d S )Nr{ r zDgroups in url regexes must either be all named or all positional: %r) r: r r| r} r~ �regexrY � groupindex�groups�pattern� _find_groups�_path� _group_count)r r� r r r r5 + s ��zPathMatches.__init__r c C sp | j �|j�}|d u r d S | j jsi S g }i }| j jr)tdd� |�� �� D ��}n dd� |�� D �}t||d�S )Nc s s$ � | ] \}}t |�t|�fV qd S r# )r2 �_unquote_or_none)�.0�k�vr r r � <genexpr>I s � �z$PathMatches.match.<locals>.<genexpr>c S s g | ]}t |��qS r )r� )r� �sr r r � <listcomp>M s z%PathMatches.match.<locals>.<listcomp>)� path_args� path_kwargs)r� ra r> r� r� �dict� groupdict�items)r r ra r� r� r r r ra : s � zPathMatches.matchr0 c G s� | j d u r td| jj ��t|�| jksJ d��t|�s | j S g }|D ]}t|ttf�s0t |�}|� t t |�dd�� q#| j t |� S )NzCannot reverse url regex z&required number of arguments not foundF)�plus)r� � ValueErrorr� r� rY r� r: r rK r2 r[ r r rW )r r0 �converted_args�ar r r ro Q s �zPathMatches.reversec C s� | j j}|�d�r|dd� }|�d�r|dd� }| j j|�d�kr%dS g }|�d�D ]F}d|v r[|�d�}|d krZz t||d d� �}W n t yR Y dS w |� d | � q,zt|�}W n t yl Y dS w |� |� q,d � |�| j jfS ) z�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). �^rV Nr{ ����(ru �)r z%s� ) r� r� � startswithr| r� �count�split�indexr r� r[ �join)r r� �pieces�fragment� paren_loc�unescaped_fragmentr r r r� ` s4 �� � zPathMatches._find_groups)r& r' r( r) r r2 r r5 r r* r r r ra ro r �intr� r r r r rZ ( s "rZ c sb e Zd ZdZ d deeef dedee eef dee ddf � fdd � Z defd d �Z � Z S ) �URLSpecz�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. Nr� �handlerr r/ r c s4 t |�}t� �||||� |j| _| j| _|| _dS )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)rZ rk r5 r� rc � handler_classr )r r� r� r r/ r` rl r r r5 � s zURLSpec.__init__c C s d| j j| jj| j| j| jf S rs )rm r& r� r� r� r r/ rE r r r rt � s �zURLSpec.__repr__ru ) r& r' r( r) r r2 r r r r r5 rt rq r r rl r r� � s � ����� r� r� r c C � d S r# r �r� r r r r� � rw r� c C r� r# r r� r r r r� � rw c C s | du r| S t | ddd�S )z�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. NF)�encodingr� )r r� r r r r� � s )r� Nr N)1r) r} � functoolsr �tornador �tornado.httpserverr �tornado.escaper r r � tornado.logr � tornado.utilr r r r �typingr r r r r r r r r re r r. r+ r$ r? r2 rh rO ri r, rM rN rx ry r� rZ r� rK r� r r r r �<module> sL $ ,. ��� h%1a1
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings