o
    >h                     @   s   d dl Z d dlmZmZmZmZmZmZmZm	Z	 d dl
mZ d dlmZmZmZ d dlmZmZmZ er<d dlmZmZ edZeded	ef d
ZG dd dZded	ef defddZedddZeeG dd dZdS )    N)TYPE_CHECKINGAnyCallableListOptionalTypeVarUnionoverload)implementer)MissingRenderMethodMissingTemplateLoaderUnexposedMethodError)IRenderableIRequestITemplateLoader)FlattenableTagT_Tc.)boundc                   @   s   e Zd ZdZdededef defddZe Ze	ded	e
dedef fd
dZe	ded	e
dedeedef ef fddZefded	e
dedefddZdS )Exposea/  
    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.
    ffuncObjs.returnc                G   s:   t |g|D ]}t|dg }||  t|d| q|S )a;  
        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}.
        exposedThrough)	itertoolschaingetattrappendsetattr)selfr   r   fObjr    r"   t/var/www/vedio/testing/chatpythonscript.ninositsolution.com/env/lib/python3.10/site-packages/twisted/web/_element.py__call__,   s
   
zExpose.__call__instance
methodNamec                 C      d S Nr"   )r    r%   r&   r"   r"   r#   getP   s   z
Expose.getdefaultc                 C   r'   r(   r"   )r    r%   r&   r*   r"   r"   r#   r)   T   s   c                 C   s<   t ||d}t |dg }| |vr|| ju rt| ||S |S )aB  
        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.
        Nr   )r   
_nodefaultr   )r    r%   r&   r*   methodr   r"   r"   r#   r)   Z   s   

N)__name__
__module____qualname____doc__r   r   objectr$   r+   r	   strr   r)   r   r   r"   r"   r"   r#   r   "   s4    	" r   thunkr   c                 C   s   t  }| j|_|S r(   )r   r0   )r3   exposer"   r"   r#   exposero   s   r5   c                   C   s   dS )a  
    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.')

        <div xmlns:t="http://twistedmatrix.com/ns/twisted.web.template/0.1">
            <span t:render="twiddle" />
        </div>

    Will result in this final output::

        <div>
            <span>Hello, world.</span>
        </div>
    Nr"   r"   r"   r"   r#   rendereru   s    r6   c                   @   sn   e Zd ZU dZdZee ed< ddee fddZde	de
ee dgd	f fd
dZdee dd	fddZdS )Elementa  
    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}.
    Nloaderc                 C   s   |d ur	|| _ d S d S r(   )r8   )r    r8   r"   r"   r#   __init__   s   
zElement.__init__namer   r   r   c                 C   s$   t | |d}|du rt| ||S )z=
        Look up and return the named render method.
        N)r6   r)   r   )r    r:   r,   r"   r"   r#   lookupRenderMethod   s   
zElement.lookupRenderMethodrequestc                 C   s   | j }|du rt| | S )a  
        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}.)
        N)r8   r   load)r    r<   r8   r"   r"   r#   render   s   zElement.renderr(   )r-   r.   r/   r0   r8   r   r   __annotations__r9   r2   r   r   r;   r>   r"   r"   r"   r#   r7      s   
 
r7   )r   N)r   typingr   r   r   r   r   r   r   r	   zope.interfacer
   twisted.web.errorr   r   r   twisted.web.iwebr   r   r   twisted.web.templater   r   r   r1   r   r   r5   r6   r7   r"   r"   r"   r#   <module>   s   (M