Gecko [ www.jobworksschool.com ]

Name	Size	Permission	Date
__pycache__	[ DIR ]	drwxr-xr-x	2026-06-04 06:40
_auth	[ DIR ]	drwxr-xr-x	2026-06-04 06:40
newsfragments	[ DIR ]	drwxr-xr-x	2026-06-04 06:40
test	[ DIR ]	drwxr-xr-x	2026-06-04 06:40
__init__.py	384 B	-rw-r--r--	2026-05-22 14:58
_element.py	5.89 KB	-rw-r--r--	2026-05-22 14:58
_flatten.py	17.72 KB	-rw-r--r--	2026-05-22 14:58
_http2.py	47.48 KB	-rw-r--r--	2026-05-22 14:58
_newclient.py	62.33 KB	-rw-r--r--	2026-05-22 14:58
_responses.py	2.93 KB	-rw-r--r--	2026-05-22 14:58
_stan.py	10.69 KB	-rw-r--r--	2026-05-22 14:58
_template_util.py	30.77 KB	-rw-r--r--	2026-05-22 14:58
client.py	57.52 KB	-rw-r--r--	2026-05-22 14:58
demo.py	516 B	-rw-r--r--	2026-05-22 14:58
distrib.py	11.8 KB	-rw-r--r--	2026-05-22 14:58
domhelpers.py	8.88 KB	-rw-r--r--	2026-05-22 14:58
error.py	13.33 KB	-rw-r--r--	2026-05-22 14:58
guard.py	587 B	-rw-r--r--	2026-05-22 14:58
html.py	1.51 KB	-rw-r--r--	2026-05-22 14:58
http.py	110.22 KB	-rw-r--r--	2026-05-22 14:58
http_headers.py	8.86 KB	-rw-r--r--	2026-05-22 14:58
iweb.py	27.07 KB	-rw-r--r--	2026-05-22 14:58
microdom.py	36.41 KB	-rw-r--r--	2026-05-22 14:58
pages.py	3.94 KB	-rw-r--r--	2026-05-22 14:58
proxy.py	9.64 KB	-rw-r--r--	2026-05-22 14:58
resource.py	15.04 KB	-rw-r--r--	2026-05-22 14:58
rewrite.py	1.82 KB	-rw-r--r--	2026-05-22 14:58
script.py	5.64 KB	-rw-r--r--	2026-05-22 14:58
server.py	28.97 KB	-rw-r--r--	2026-05-22 14:58
soap.py	5.08 KB	-rw-r--r--	2026-05-22 14:58
static.py	36.61 KB	-rw-r--r--	2026-05-22 14:58
sux.py	20.39 KB	-rw-r--r--	2026-05-22 14:58
tap.py	10.02 KB	-rw-r--r--	2026-05-22 14:58
template.py	1.27 KB	-rw-r--r--	2026-05-22 14:58
twcgi.py	11.71 KB	-rw-r--r--	2026-05-22 14:58
util.py	749 B	-rw-r--r--	2026-05-22 14:58
vhost.py	4.32 KB	-rw-r--r--	2026-05-22 14:58
wsgi.py	21.45 KB	-rw-r--r--	2026-05-22 14:58
xmlrpc.py	20.65 KB	-rw-r--r--	2026-05-22 14:58

Rename

# -*- test-case-name: twisted.web.test.test_template -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

import itertools
from typing import (
    TYPE_CHECKING,
    Any,
    Callable,
    List,
    Optional,
    TypeVar,
    Union,
    overload,
)

from zope.interface import implementer

from twisted.web.error import (
    MissingRenderMethod,
    MissingTemplateLoader,
    UnexposedMethodError,
)
from twisted.web.iweb import IRenderable, IRequest, ITemplateLoader

if TYPE_CHECKING:
    from twisted.web.template import Flattenable, Tag

T = TypeVar("T")
_Tc = TypeVar("_Tc", bound=Callable[..., object])

class Expose:
    """
    Helper for exposing methods for various uses using a simple decorator-style
    callable.

Instances of this class can be called with one or more functions as
    positional arguments.  The names of these functions will be added to a list
    on the class object of which they are methods.
    """

def __call__(self, f: _Tc, /, *funcObjs: Callable[..., object]) -> _Tc:
        """
        Add one or more functions to the set of exposed functions.

This is a way to declare something about a class definition, similar to
        L{zope.interface.implementer}.  Use it like this::

magic = Expose('perform extra magic')
            class Foo(Bar):
                def twiddle(self, x, y):
                    ...
                def frob(self, a, b):
                    ...
                magic(twiddle, frob)

Later you can query the object::

aFoo = Foo()
            magic.get(aFoo, 'twiddle')(x=1, y=2)

The call to C{get} will fail if the name it is given has not been
        exposed using C{magic}.

@param funcObjs: One or more function objects which will be exposed to
        the client.

@return: The first of C{funcObjs}.
        """
        for fObj in itertools.chain([f], funcObjs):
            exposedThrough: List[Expose] = getattr(fObj, "exposedThrough", [])
            exposedThrough.append(self)
            setattr(fObj, "exposedThrough", exposedThrough)
        return f

_nodefault = object()

@overload
    def get(self, instance: object, methodName: str) -> Callable[..., Any]:
        ...

@overload
    def get(
        self, instance: object, methodName: str, default: T
    ) -> Union[Callable[..., Any], T]:
        ...

def get(
        self, instance: object, methodName: str, default: object = _nodefault
    ) -> object:
        """
        Retrieve an exposed method with the given name from the given instance.

@raise UnexposedMethodError: Raised if C{default} is not specified and
        there is no exposed method with the given name.

@return: A callable object for the named method assigned to the given
        instance.
        """
        method = getattr(instance, methodName, None)
        exposedThrough = getattr(method, "exposedThrough", [])
        if self not in exposedThrough:
            if default is self._nodefault:
                raise UnexposedMethodError(self, methodName)
            return default
        return method

def exposer(thunk: Callable[..., object]) -> Expose:
    expose = Expose()
    expose.__doc__ = thunk.__doc__
    return expose

@exposer
def renderer() -> None:
    """
    Decorate with L{renderer} to use methods as template render directives.

For example::

class Foo(Element):
            @renderer
            def twiddle(self, request, tag):
                return tag('Hello, world.')

Will result in this final output::

<div>
            <span>Hello, world.</span>
        </div>
    """

@implementer(IRenderable)
class Element:
    """
    Base for classes which can render part of a page.

An Element is a renderer that can be embedded in a stan document and can
    hook its template (from the loader) up to render methods.

An Element might be used to encapsulate the rendering of a complex piece of
    data which is to be displayed in multiple different contexts.  The Element
    allows the rendering logic to be easily re-used in different ways.

Element returns render methods which are registered using
    L{twisted.web._element.renderer}.  For example::

class Menu(Element):
            @renderer
            def items(self, request, tag):
                ....

Render methods are invoked with two arguments: first, the
    L{twisted.web.http.Request} being served and second, the tag object which
    "invoked" the render method.

@ivar loader: The factory which will be used to load documents to
        return from C{render}.
    """

loader: Optional[ITemplateLoader] = None

def __init__(self, loader: Optional[ITemplateLoader] = None):
        if loader is not None:
            self.loader = loader

def lookupRenderMethod(
        self, name: str
    ) -> Callable[[Optional[IRequest], "Tag"], "Flattenable"]:
        """
        Look up and return the named render method.
        """
        method = renderer.get(self, name, None)
        if method is None:
            raise MissingRenderMethod(self, name)
        return method

def render(self, request: Optional[IRequest]) -> "Flattenable":
        """
        Implement L{IRenderable} to allow one L{Element} to be embedded in
        another's template or rendering output.

(This will simply load the template from the C{loader}; when used in a
        template, the flattening engine will keep track of this object
        separately as the object to lookup renderers on and call
        L{Element.renderer} to look them up.  The resulting object from this
        method is not directly associated with this L{Element}.)
        """
        loader = self.loader
        if loader is None:
            raise MissingTemplateLoader(self)
        return loader.load()