ruạṛ
a [��f�{ � @ s� d Z ddlZddlZddlmZmZmZ ddlm Z ddl m Z ddl m Z mZ ddlZddlmZmZ ddlmZ ddlmZ G d d � d e�ZdS ) zFalcon API class.� N)� api_helpers�DEFAULT_MEDIA_TYPE�routing)� HTTPError)� HTTPStatus)�Request�RequestOptions)�Response�ResponseOptions)� get_argnamesc @ s� e Zd ZdZeejejejej g�Z dZ dZ e eedddfdd�Zdd � Zed d � �Zd d � Zd%dd�Zd&dd�Zd'dd�Zdd� Zdd� Zdd� Zdd � Zd d � Z d d � Z d!d"� Z d(d#d$�Z dS ))�APIa; This class is the main entry point into a Falcon-based app. Each API instance provides a callable WSGI interface and a routing engine. Keyword Arguments: media_type (str): Default media type to use as the value for the Content-Type header on responses (default 'application/json'). The ``falcon`` module provides a number of constants for common media types, such as ``falcon.MEDIA_MSGPACK``, ``falcon.MEDIA_YAML``, ``falcon.MEDIA_XML``, etc. middleware(object or list): Either a single object or a list of objects (instantiated classes) that implement the following middleware component interface:: class ExampleComponent(object): def process_request(self, req, resp): """Process the request before routing it. Args: req: Request object that will eventually be routed to an on_* responder method. resp: Response object that will be routed to the on_* responder. """ def process_resource(self, req, resp, resource, params): """Process the request and resource *after* routing. Note: This method is only called when the request matches a route to a resource. Args: req: Request object that will be passed to the routed responder. resp: Response object that will be passed to the responder. resource: Resource object to which the request was routed. May be None if no route was found for the request. params: A dict-like object representing any additional params derived from the route's URI template fields, that will be passed to the resource's responder method as keyword arguments. """ def process_response(self, req, resp, resource, req_succeeded) """Post-processing of the response (after routing). Args: req: Request object. resp: Response object. resource: Resource object to which the request was routed. May be None if no route was found for the request. req_succeeded: True if no exceptions were raised while the framework processed and routed the request; otherwise False. """ (See also: :ref:`Middleware <middleware>`) request_type (Request): ``Request``-like class to use instead of Falcon's default class. Among other things, this feature affords inheriting from ``falcon.request.Request`` in order to override the ``context_type`` class variable. (default ``falcon.request.Request``) response_type (Response): ``Response``-like class to use instead of Falcon's default class. (default ``falcon.response.Response``) router (object): An instance of a custom router to use in lieu of the default engine. (See also: :ref:`Custom Routers <routing_custom>`) independent_middleware (bool): Set to ``True`` if response middleware should be executed independently of whether or not request middleware raises an exception (default ``False``). Attributes: req_options: A set of behavioral options related to incoming requests. (See also: :py:class:`~.RequestOptions`) resp_options: A set of behavioral options related to outgoing responses. (See also: :py:class:`~.ResponseOptions`) router_options: Configuration options for the router. If a custom router is in use, and it does not expose any configurable options, referencing this attribute will raise an instance of ``AttributeError``. (See also: :ref:`CompiledRouterOptions <compiled_router_options>`) i ) � _request_type�_response_type�_error_handlers� _media_type�_router�_sinks�_serialize_error� req_options� resp_options� _middleware�_independent_middleware�_router_search�_static_routesNFc C s� g | _ || _g | _tj||d�| _|| _|p2t�� | _ t� | j �| _ || _ || _ g | _tj| _t� | _t� | _|| j_|| j_| �tj| j� | �tj| j� d S )N)�independent_middleware) r r r �helpers�prepare_middlewarer r r � DefaultRouterr �make_router_searchr r r r �default_serialize_errorr r r r r �default_media_type�add_error_handler�falconr �_http_error_handlerr �_http_status_handler)�self� media_type� request_type� response_type� middleware�routerr � r+ �n/sparta/input/_build_configuration/image_build+validate/lib/bmcenv/lib64/python3.9/site-packages/falcon/api.py�__init__� s& �z API.__init__c C s� | j || jd�}| j| jd�}d}i }g }| j\}} } d} �zvz`| jr\|D ]} | ||� qJn,|D ]&\} } | rv| ||� | r`|�d| � q`| �|�\}}}|_W n6 t y� } z | � ||||�s�� W Y d}~n�d}~0 0 z:|dur�| D ]}|||||� q�|||fi |�� d} W n: t �yJ } z | � ||||��s6� W Y d}~n d}~0 0 W | �pV|D ]X} z| |||| � W n> t �y� } z$| � ||||��s�� d} W Y d}~n d}~0 0 �qXnf| �p�|D ]X} z| |||| � W n> t �y } z$| � ||||��s�� d} W Y d}~n d}~0 0 �q�0 t j �r,t |j�n|j}|jdk�sJ|| jv �rPg }n.| �||�d��\}}|du�r~t |�|jd< |tjtjfv �r�d}n| j}|�|�}|||� |S ) a� WSGI `app` method. Makes instances of API callable from a WSGI server. May be used to host an API or called directly in order to simulate requests when testing the API. (See also: PEP 3333) Args: env (dict): A WSGI environment dictionary start_response (callable): A WSGI helper function for setting status and headers on a response. )�optionsNFr T�HEADzwsgi.file_wrapperzcontent-length)r r r r r r �insert�_get_responder� uri_template� Exception�_handle_exception�six�PY2�str�status�method�_BODILESS_STATUS_CODES� _get_body�get�_headers�HTTP_204�HTTP_304r � _wsgi_headers)r% �env�start_response�req�resp�resource�params�dependent_mw_resp_stack� mw_req_stack� mw_rsrc_stack� mw_resp_stack� req_succeeded�process_request�process_response� responder�ex�process_resource� resp_status�body�lengthr& �headersr+ r+ r, �__call__� sp � z API.__call__c C s | j jS �N)r r. )r% r+ r+ r, �router_options* s zAPI.router_optionsc O sl t |tj�std��|�d�s&td��d|v r6td��t�|�}t�|� | j j |||g|�R i |�� dS )a� Associate a templatized URI path with a resource. Falcon routes incoming requests to resources based on a set of URI templates. If the path requested by the client matches the template for a given route, the request is then passed on to the associated resource for processing. If no route matches the request, control then passes to a default responder that simply raises an instance of :class:`~.HTTPNotFound`. (See also: :ref:`Routing <routing>`) Args: uri_template (str): A templatized URI. Care must be taken to ensure the template does not mask any sink patterns, if any are registered. (See also: :meth:`~.add_sink`) resource (instance): Object which represents a REST resource. Falcon will pass "GET" requests to on_get, "PUT" requests to on_put, etc. If any HTTP methods are not supported by your resource, simply don't define the corresponding request handlers, and Falcon will do the right thing. Note: Any additional args and kwargs not defined above are passed through to the underlying router's ``add_route()`` method. The default router does not expect any additional arguments, but custom routers may take advantage of this feature to receive additional options when setting up routes. z uri_template is not a string�/z uri_template must start with '/'z//z!uri_template may not contain '//'N) � isinstancer5 � string_types� TypeError� startswith� ValueErrorr �map_http_methods�set_default_respondersr � add_route)r% r2 rE �args�kwargs� method_mapr+ r+ r, r` . s ' �z API.add_routec C s | j �dtj|||d�� dS )a� Add a route to a directory of static files. Static routes provide a way to serve files directly. This feature provides an alternative to serving files at the web server level when you don't have that option, when authorization is required, or for testing purposes. Warning: Serving files directly from the web server, rather than through the Python app, will always be more efficient, and therefore should be preferred in production deployments. Static routes are matched in LIFO order. Therefore, if the same prefix is used for two routes, the second one will override the first. This also means that more specific routes should be added *after* less specific ones. For example, the following sequence would result in ``'/foo/bar/thing.js'`` being mapped to the ``'/foo/bar'`` route, and ``'/foo/xyz/thing.js'`` being mapped to the ``'/foo'`` route:: api.add_static_route('/foo', foo_path) api.add_static_route('/foo/bar', foobar_path) Args: prefix (str): The path prefix to match for this route. If the path in the requested URI starts with this string, the remainder of the path will be appended to the source directory to determine the file to serve. This is done in a secure manner to prevent an attacker from requesting a file outside the specified directory. Note that static routes are matched in LIFO order, and are only attempted after checking dynamic routes and sinks. directory (str): The source directory from which to serve files. downloadable (bool): Set to ``True`` to include a Content-Disposition header in the response. The "filename" directive is simply set to the name of the requested file. r )� downloadableN)r r0 r � StaticRoute)r% �prefix� directoryrd r+ r+ r, �add_static_routec s *�zAPI.add_static_routerX c C s* t |d�st�|�}| j�d||f� dS )a0 Register a sink method for the API. If no route matches a request, but the path in the requested URI matches a sink prefix, Falcon will pass control to the associated sink, regardless of the HTTP method requested. Using sinks, you can drain and dynamically handle a large number of routes, when creating static resources and responders would be impractical. For example, you might use a sink to create a smart proxy that forwards requests to one or more backend services. Args: sink (callable): A callable taking the form ``func(req, resp)``. prefix (str): A regex string, typically starting with '/', which will trigger the sink if it matches the path portion of the request's URI. Both strings and precompiled regex objects may be specified. Characters are matched starting at the beginning of the URI path. Note: Named groups are converted to kwargs and passed to the sink as such. Warning: If the prefix overlaps a registered route template, the route will take precedence and mask the sink. (See also: :meth:`~.add_route`) �matchr N)�hasattr�re�compiler r0 )r% �sinkrf r+ r+ r, �add_sink� s ! z API.add_sinkc C sD |du r.z |j }W n ty, td��Y n0 | j�d||f� dS )a Register a handler for a given exception error type. Error handlers may be registered for any type, including :class:`~.HTTPError`. This feature provides a central location for logging and otherwise handling exceptions raised by responders, hooks, and middleware components. A handler can raise an instance of :class:`~.HTTPError` or :class:`~.HTTPStatus` to communicate information about the issue to the client. Alternatively, a handler may modify `resp` directly. Error handlers are matched in LIFO order. In other words, when searching for an error handler to match a raised exception, and more than one handler matches the exception type, the framework will choose the one that was most recently registered. Therefore, more general error handlers (e.g., for the standard ``Exception`` type) should be added first, to avoid masking more specific handlers for subclassed types. Args: exception (type): Whenever an error occurs when handling a request that is an instance of this exception class, the associated handler will be called. handler (callable): A function or callable object taking the form ``func(ex, req, resp, params)``. If not specified explicitly, the handler will default to ``exception.handle``, where ``exception`` is the error type specified above, and ``handle`` is a static method (i.e., decorated with @staticmethod) that accepts the same params just described. For example:: class CustomException(CustomBaseException): @staticmethod def handle(ex, req, resp, params): # TODO: Log the error # Convert to an instance of falcon.HTTPError raise falcon.HTTPError(falcon.HTTP_792) Nz�handler must either be specified explicitly or defined as a staticmethod named "handle" that is a member of the given exception class.r )�handle�AttributeErrorr r0 )r% � exception�handlerr+ r+ r, r! � s - zAPI.add_error_handlerc C s$ t t|��dkrt�|�}|| _dS )a Override the default serializer for instances of :class:`~.HTTPError`. When a responder raises an instance of :class:`~.HTTPError`, Falcon converts it to an HTTP response automatically. The default serializer supports JSON and XML, but may be overridden by this method to use a custom serializer in order to support other media types. Note: If a custom media type is used and the type includes a "+json" or "+xml" suffix, the default serializer will convert the error to JSON or XML, respectively. The :class:`~.HTTPError` class contains helper methods, such as `to_json()` and `to_dict()`, that can be used from within custom serializers. For example:: def my_serializer(req, resp, exception): representation = None preferred = req.client_prefers(('application/x-yaml', 'application/json')) if preferred is not None: if preferred == 'application/json': representation = exception.to_json() else: representation = yaml.dump(exception.to_dict(), encoding=None) resp.body = representation resp.content_type = preferred resp.append_header('Vary', 'Accept') Args: serializer (callable): A function taking the form ``func(req, resp, exception)``, where `req` is the request object that was passed to the responder method, `resp` is the response object, and `exception` is an instance of ``falcon.HTTPError``. � N)�lenr r �wrap_old_error_serializerr )r% � serializerr+ r+ r, �set_error_serializer� s , zAPI.set_error_serializerc C s� |j }|j}d}| j||d�}|durVz|\}}}}W qZ tyR |\}}}Y qZ0 nd}|dur�z || } W q� ty� tjj} Y q�0 nXi }| jD ]&\} } | � |�} | r�| � � }| } q�q�| j D ]} | � |�r�| } q�q�tjj } | |||fS )aQ Search routes for a matching responder. Args: req: The request object. Returns: tuple: A 3-member tuple consisting of a responder callable, a ``dict`` containing parsed path fields (if any were specified in the matching route's URI template), and a reference to the responder's resource instance. Note: If a responder was matched to the given URI, but the HTTP method was not found in the method_map for the responder, the responder callable element of the returned tuple will be `falcon.responder.bad_request`. Likewise, if no responder was matched for the given URI, then the responder callable element of the returned tuple will be `falcon.responder.path_not_found` N)rC ) �pathr9 r r] �KeyErrorr" � responders� bad_requestr ri � groupdictr �path_not_found)r% rC rx r9 r2 �routerE rc rF rN �patternrm �m�srr+ r+ r, r1 + s8 zAPI._get_responderc C s* |j |_ |jdur |�|j� |j|_dS )z5Compose a response for the given HTTPStatus instance.N)r8 rT � set_headersrR )r% rC rD � http_statusr+ r+ r, �_compose_status_responseq s z API._compose_status_responsec C s6 |j |_ |jdur |�|j� |jr2| �|||� dS )z4Compose a response for the given HTTPError instance.N)r8 rT r� �has_representationr )r% rC rD �errorr+ r+ r, �_compose_error_response� s zAPI._compose_error_responsec C s | � |||� d S rV )r� )r% r8 rC rD rF r+ r+ r, r$ � s zAPI._http_status_handlerc C s | � |||� d S rV )r� )r% r� rC rD rF r+ r+ r, r# � s zAPI._http_error_handlerc C s� | j D ]�\}}t||�rz|||||� W nb ty\ } z| �|||� W Y d}~n:d}~0 ty� } z| �|||� W Y d}~n d}~0 0 dS qdS )aU Handle an exception raised from mw or a responder. Args: ex: Exception to handle req: Current request object to pass to the handler registered for the given exception type resp: Current response object to pass to the handler registered for the given exception type params: Responder params to pass to the handler registered for the given exception type Returns: bool: ``True`` if a handler was found and called for the exception, ``False`` otherwise. NTF)r rY r r� r r� ) r% rO rC rD rF �err_type� err_handlerr8 r� r+ r+ r, r4 � s "$zAPI._handle_exceptionc C s� |j }|dur0t|t�s"|�d�}|gt|�fS |j}|durL|gt|�fS |j}|dur�t|d�r�|durz||| j�}q�t � || j�}n|}||j fS g dfS )a� Convert resp content into an iterable as required by PEP 333 Args: resp: Instance of falcon.Response wsgi_file_wrapper: Reference to wsgi.file_wrapper from the WSGI environ dict, if provided by the WSGI server. Used when resp.stream is a file-like object (default None). Returns: tuple: A two-member tuple of the form (iterable, content_length). The length is returned as ``None`` when unknown. The iterable is determined as follows: * If resp.body is not ``None``, returns [resp.body], encoded as UTF-8 if it is a Unicode string. Bytestrings are returned as-is. * If resp.data is not ``None``, returns [resp.data] * If resp.stream is not ``None``, returns resp.stream iterable using wsgi.file_wrapper, if possible. * Otherwise, returns [] Nzutf-8�readr ) rR rY �bytes�encodert �data�streamrj �_STREAM_BLOCK_SIZEr �CloseableStreamIterator� stream_len)r% rD �wsgi_file_wrapperrR r� r� �iterabler+ r+ r, r; � s& � z API._get_body)F)rX )N)N) �__name__� __module__� __qualname__�__doc__�setr8 �HTTP_100�HTTP_101r> r? r: r� � __slots__r r r r- rU �propertyrW r` rh rn r! rw r1 r� r� r$ r# r4 r; r+ r+ r+ r, r s: c�� x 5 / * :5F %r )r� rk r5 r" r r r r �falcon.http_errorr �falcon.http_statusr �falcon.requestr r �falcon.responders�falcon.responser r �falcon.status_codes� status_codesr8 �falcon.util.miscr �objectr r+ r+ r+ r, �<module> s
cải xoăn