ruạṛ
a [��f� � @ s� d Z ddlZddlmZ ddlmZ ddlmZ ddlm Z ddl m Z ddl m Z mZmZmZmZ dd lmZmZ dd lmZ dd lmZ ejZejZe� Z G d d � d e �Z G dd� de �Z dS )zResponse class.� N)�PY2)� string_types)� http_cookies)�DEFAULT_MEDIA_TYPE)�Handlers)�format_content_disposition�format_header_value_list� format_range�header_property�is_ascii_encodable)� dt_to_http� TimezoneGMT)�encode)� encode_valuec @ s& e Zd ZdZdZeZd8dd�Zedd� �Z e j dd� �Z d d � Z d d � Z d9dd�Z dd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd:d d �Zed d e�Zed d!e�Zed"d#e�Zed$d%�Z ed&d'e �Z ed(d)�Z ed*d+e �Z!ed,d-e�Z"ed.d/e#�Z$ed0d1e�Z%ed2d3�Z&d;d4d5�Z'de(fd6d7�Z)dS )<�ResponseaO Represents an HTTP response to a client request. Note: `Response` is not meant to be instantiated directly by responders. Keyword Arguments: options (dict): Set of global options passed from the API handler. Attributes: status (str): HTTP status line (e.g., '200 OK'). Falcon requires the full status line, not just the code (e.g., 200). This design makes the framework more efficient because it does not have to do any kind of conversion or lookup when composing the WSGI response. If not set explicitly, the status defaults to '200 OK'. Note: Falcon provides a number of constants for common status codes. They all start with the ``HTTP_`` prefix, as in: ``falcon.HTTP_204``. media (object): A serializable object supported by the media handlers configured via :class:`falcon.RequestOptions`. See :ref:`media` for more information regarding media handling. body (str or unicode): String representing response content. If set to a Unicode type (``unicode`` in Python 2, or ``str`` in Python 3), Falcon will encode the text as UTF-8 in the response. If the content is already a byte string, use the :attr:`data` attribute instead (it's faster). data (bytes): Byte string representing response content. Use this attribute in lieu of `body` when your content is already a byte string (``str`` or ``bytes`` in Python 2, or simply ``bytes`` in Python 3). See also the note below. Note: Under Python 2.x, if your content is of type ``str``, using the `data` attribute instead of `body` is the most efficient approach. However, if your text is of type ``unicode``, you will need to use the `body` attribute instead. Under Python 3.x, on the other hand, the 2.x ``str`` type can be thought of as having been replaced by what was once the ``unicode`` type, and so you will need to always use the `body` attribute for strings to ensure Unicode characters are properly encoded in the HTTP response. stream: Either a file-like object with a `read()` method that takes an optional size argument and returns a block of bytes, or an iterable object, representing response content, and yielding blocks as byte strings. Falcon will use *wsgi.file_wrapper*, if provided by the WSGI server, in order to efficiently serve file-like objects. stream_len (int): Expected length of `stream`. If `stream` is set, but `stream_len` is not, Falcon will not supply a Content-Length header to the WSGI server. Consequently, the server may choose to use chunked encoding or one of the other strategies suggested by PEP-3333. context (dict): Dictionary to hold any data about the response which is specific to your app. Falcon itself will not interact with this attribute after it has been initialized. context_type (class): Class variable that determines the factory or type to use for initializing the `context` attribute. By default, the framework will instantiate standard ``dict`` objects. However, you may override this behavior by creating a custom child class of ``falcon.Response``, and then passing that new class to `falcon.API()` by way of the latter's `response_type` parameter. Note: When overriding `context_type` with a factory function (as opposed to a class), the function is called like a method of the current Response instance. Therefore the first argument is the Response instance itself (self). options (dict): Set of global options passed from the API handler. ) �body�data�_headers�_cookies�status�stream� stream_len�context�options�__dict__Nc C sN d| _ i | _|r|nt� | _d | _d | _d | _d | _d | _d | _ | � � | _ d S )Nz200 OK) r r �ResponseOptionsr r �_mediar r r r � context_typer )�selfr � r �s/sparta/input/_build_configuration/image_build+validate/lib/bmcenv/lib64/python3.9/site-packages/falcon/response.py�__init__� s zResponse.__init__c C s | j S �N)r �r r r r �media� s zResponse.mediac C s> || _ | js| jj| _| jj�| j| jj�}|�| j �| _d S r" )r � content_typer �default_media_type�media_handlers�find_by_media_type� serializer )r �obj�handlerr r r r$ � s �c C s d| j j| jf S )Nz<%s: %s>)� __class__�__name__r r# r r r �__repr__� s zResponse.__repr__c C s || _ || _dS )a6 Convenience method for setting both `stream` and `stream_len`. Although the `stream` and `stream_len` properties may be set directly, using this method ensures `stream_len` is not accidentally neglected when the length of the stream is known in advance. Note: If the stream length is unknown, you can set `stream` directly, and ignore `stream_len`. In this case, the WSGI server may choose to use chunked encoding or one of the other strategies suggested by PEP-3333. N)r r )r r r r r r � set_stream� s zResponse.set_streamTc C sH t |�std��t |�s td��t|�}t|�}| jdu rBt� | _z|| j|< W n0 ty� } ztt| ���W Y d} ~ n d} ~ 0 0 |r�d} |jdu r�|�| �| j| d< n |� t �} | �| �| j| d< |r�t |�| j| d< |r�|| j| d< |�r|| j| d< |du �r| j j } n|} | �r0d | j| d < |�rD|| j| d < dS ) ag Set a response cookie. Note: This method can be called multiple times to add one or more cookies to the response. See Also: To learn more about setting cookies, see :ref:`Setting Cookies <setting-cookies>`. The parameters listed below correspond to those defined in `RFC 6265`_. Args: name (str): Cookie name value (str): Cookie value Keyword Args: expires (datetime): Specifies when the cookie should expire. By default, cookies expire when the user agent exits. (See also: RFC 6265, Section 4.1.2.1) max_age (int): Defines the lifetime of the cookie in seconds. By default, cookies expire when the user agent exits. If both `max_age` and `expires` are set, the latter is ignored by the user agent. Note: Coercion to ``int`` is attempted if provided with ``float`` or ``str``. (See also: RFC 6265, Section 4.1.2.2) domain (str): Restricts the cookie to a specific domain and any subdomains of that domain. By default, the user agent will return the cookie only to the origin server. When overriding this default behavior, the specified domain must include the origin server. Otherwise, the user agent will reject the cookie. (See also: RFC 6265, Section 4.1.2.3) path (str): Scopes the cookie to the given path plus any subdirectories under that path (the "/" character is interpreted as a directory separator). If the cookie does not specify a path, the user agent defaults to the path component of the requested URI. Warning: User agent interfaces do not always isolate cookies by path, and so this should not be considered an effective security measure. (See also: RFC 6265, Section 4.1.2.4) secure (bool): Direct the client to only return the cookie in subsequent requests if they are made over HTTPS (default: ``True``). This prevents attackers from reading sensitive cookie data. Note: The default value for this argument is normally ``True``, but can be modified by setting :py:attr:`~.ResponseOptions.secure_cookies_by_default` via :any:`API.resp_options`. Warning: For the `secure` cookie attribute to be effective, your application will need to enforce HTTPS. (See also: RFC 6265, Section 4.1.2.5) http_only (bool): Direct the client to only transfer the cookie with unscripted HTTP requests (default: ``True``). This is intended to mitigate some forms of cross-site scripting. (See also: RFC 6265, Section 4.1.2.6) Raises: KeyError: `name` is not a valid cookie name. ValueError: `value` is not a valid cookie value. .. _RFC 6265: http://tools.ietf.org/html/rfc6265 z "name" is not ascii encodablez "value" is not ascii encodableNz%a, %d %b %Y %H:%M:%S GMT�expireszmax-age�domain�pathT�secure�httponly)r �KeyError� ValueError�strr � SimpleCookie� CookieError�tzinfo�strftime� astimezone� GMT_TIMEZONE�intr �secure_cookies_by_default) r �name�valuer0 �max_ager1 r2 r3 � http_only�e�fmt� gmt_expires� is_securer r r � set_cookie� s> X " zResponse.set_cookiec C s. | j du rt� | _ d| j |< d| j | d< dS )ai Unset a cookie in the response Clears the contents of the cookie, and instructs the user agent to immediately expire its own copy of the cookie. Warning: In order to successfully remove a cookie, both the path and the domain must match the values that were used when the cookie was created. N� ���r0 )r r8 �r r@ r r r � unset_cookieb s zResponse.unset_cookiec C s | j �|�� d�S )a~ Retrieve the raw string value for the given header. Args: name (str): Header name, case-insensitive. Must be of type ``str`` or ``StringType``, and only character values 0x00 through 0xFF may be used on platforms that use wide characters. Returns: str: The header's value if set, otherwise ``None``. N)r �get�lowerrK r r r � get_headery s zResponse.get_headerc C s" t |�}t |�}|| j|�� < dS )a� Set a header for this response to a given value. Warning: Calling this method overwrites the existing value, if any. Warning: For setting cookies, see instead :meth:`~.set_cookie` Args: name (str): Header name (case-insensitive). The restrictions noted below for the header's value also apply here. value (str): Value for the header. Must be convertable to ``str`` or be of type ``str`` or ``StringType``. Strings must contain only US-ASCII characters. Under Python 2.x, the ``unicode`` type is also accepted, although such strings are also limited to US-ASCII. N)r7 r rN �r r@ rA r r r � set_header� s zResponse.set_headerc C s | j �|�� d� dS )a� Delete a header that was previously set for this response. If the header was not previously set, nothing is done (no error is raised). Note that calling this method is equivalent to setting the corresponding header property (when said property is available) to ``None``. For example:: resp.etag = None Args: name (str): Header name (case-insensitive). Must be of type ``str`` or ``StringType`` and contain only US-ASCII characters. Under Python 2.x, the ``unicode`` type is also accepted, although such strings are also limited to US-ASCII. N)r �poprN rK r r r � delete_header� s zResponse.delete_headerc C sB t |�}t |�}|�� }|| jv r4| j| d | }|| j|< dS )aY Set or append a header for this response. Warning: If the header already exists, the new value will be appended to it, delimited by a comma. Most header specifications support this format, Set-Cookie being the notable exceptions. Warning: For setting cookies, see :py:meth:`~.set_cookie` Args: name (str): Header name (case-insensitive). The restrictions noted below for the header's value also apply here. value (str): Value for the header. Must be convertable to ``str`` or be of type ``str`` or ``StringType``. Strings must contain only US-ASCII characters. Under Python 2.x, the ``unicode`` type is also accepted, although such strings are also limited to US-ASCII. �,N)r7 rN r rP r r r � append_header� s zResponse.append_headerc C sF t |t�r|�� }| j}|D ]$\}}t|�}t|�}|||�� < q dS )a Set several headers at once. Warning: Calling this method overwrites existing values, if any. Args: headers (dict or list): A dictionary of header names and values to set, or a ``list`` of (*name*, *value*) tuples. Both *name* and *value* must be of type ``str`` or ``StringType`` and contain only US-ASCII characters. Under Python 2.x, the ``unicode`` type is also accepted, although such strings are also limited to US-ASCII. Note: Falcon can process a list of tuples slightly faster than a dict. Raises: ValueError: `headers` was not a ``dict`` or ``list`` of ``tuple``. N)� isinstance�dict�itemsr r7 rN )r �headersr r@ rA r r r � set_headers� s zResponse.set_headersc C sF d|v rBd|v r2dd� dd� |�� D �� d }ndt|� d }dt|� d | }|durn|d | d 7 }|dur�|d |d d t|d � 7 }|dur�|d| d 7 }|dur�t|t�r�|d| 7 }n |d7 }|d� dd� |D ��7 }|du�r |dt|� d 7 }t|�}| j} d| v �r:| d d| 7 < n|| d< dS )a� Add a link header to the response. (See also: RFC 5988, Section 1) Note: Calling this method repeatedly will cause each link to be appended to the Link header value, separated by commas. Note: So-called "link-extension" elements, as defined by RFC 5988, are not yet supported. See also Issue #288. Args: target (str): Target IRI for the resource identified by the link. Will be converted to a URI, if necessary, per RFC 3987, Section 3.1. rel (str): Relation type of the link, such as "next" or "bookmark". (See also: http://www.iana.org/assignments/link-relations/link-relations.xhtml) Keyword Args: title (str): Human-readable label for the destination of the link (default ``None``). If the title includes non-ASCII characters, you will need to use `title_star` instead, or provide both a US-ASCII version using `title` and a Unicode version using `title_star`. title_star (tuple of str): Localized title describing the destination of the link (default ``None``). The value must be a two-member tuple in the form of (*language-tag*, *text*), where *language-tag* is a standard language identifier as defined in RFC 5646, Section 2.1, and *text* is a Unicode string. Note: *language-tag* may be an empty string, in which case the client will assume the language from the general context of the current request. Note: *text* will always be encoded as UTF-8. If the string contains non-ASCII characters, it should be passed as a ``unicode`` type string (requires the 'u' prefix in Python 2). anchor (str): Override the context IRI with a different URI (default None). By default, the context IRI for the link is simply the IRI of the requested resource. The value provided may be a relative URI. hreflang (str or iterable): Either a single *language-tag*, or a ``list`` or ``tuple`` of such tags to provide a hint to the client as to the language of the result of following the link. A list of tags may be given in order to indicate to the client that the target resource is available in multiple languages. type_hint(str): Provides a hint as to the media type of the result of dereferencing the link (default ``None``). As noted in RFC 5988, this is only a hint and does not override the Content-Type header returned when the link is followed. z//� �"c S s g | ] }t |��qS r )� uri_encode)�.0�rr r r � <listcomp>S � z%Response.add_link.<locals>.<listcomp>�<z>; rel=Nz ; title="z; title*=UTF-8'r �'� z; type="z ; hreflang=z; c S s g | ] }d | �qS )z hreflang=r )r^ �langr r r r` i ra z ; anchor="�linkz, )�join�splitr] �uri_encode_valuerV � STRING_TYPESr7 r ) r �target�rel�title� title_star�anchor�hreflang� type_hintrA r r r r �add_link s: M�� � zResponse.add_linkz Cache-Controlz�Set the Cache-Control header. Used to set a list of cache directives to use as the value of the Cache-Control header. The list will be joined with ", " to produce the value for the header. zContent-Locationa Set the Content-Location header. This value will be URI encoded per RFC 3986. If the value that is being set is already URI encoded it should be decoded first or the header should be set manually using the set_header method. z Content-Rangea� A tuple to use in constructing a value for the Content-Range header. The tuple has the form (*start*, *end*, *length*, [*unit*]), where *start* and *end* designate the range (inclusive), and *length* is the total length, or '\*' if unknown. You may pass ``int``'s for these numbers (no need to convert to ``str`` beforehand). The optional value *unit* describes the range unit and defaults to 'bytes' Note: You only need to use the alternate form, 'bytes \*/1234', for responses that use the status '416 Range Not Satisfiable'. In this case, raising ``falcon.HTTPRangeNotSatisfiable`` will do the right thing. (See also: RFC 7233, Section 4.2) z Content-Typea� Sets the Content-Type header. The ``falcon`` module provides a number of constants for common media types, including ``falcon.MEDIA_JSON``, ``falcon.MEDIA_MSGPACK``, ``falcon.MEDIA_YAML``, ``falcon.MEDIA_XML``, ``falcon.MEDIA_HTML``, ``falcon.MEDIA_JS``, ``falcon.MEDIA_TEXT``, ``falcon.MEDIA_JPEG``, ``falcon.MEDIA_PNG``, and ``falcon.MEDIA_GIF``. zContent-Dispositiona Set the Content-Disposition header using the given filename. The value will be used for the *filename* directive. For example, given ``'report.pdf'``, the Content-Disposition header would be set to: ``'attachment; filename="report.pdf"'``. �ETagzSet the ETag header.z Last-Modifiedz�Set the Last-Modified header. Set to a ``datetime`` (UTC) instance. Note: Falcon will format the ``datetime`` as an HTTP date string. �Locationz�Set the Location header. This value will be URI encoded per RFC 3986. If the value that is being set is already URI encoded it should be decoded first or the header should be set manually using the set_header method. z Retry-Afterz�Set the Retry-After header. The expected value is an integral number of seconds to use as the value for the header. The HTTP-date syntax is not supported. �Varya� Value to use for the Vary header. Set this property to an iterable of header names. For a single asterisk or field value, simply pass a single-element ``list`` or ``tuple``. The "Vary" header field in a response describes what parts of a request message, aside from the method, Host header field, and request target, might influence the origin server's process for selecting and representing this response. The value consists of either a single asterisk ("*") or a list of header field names (case-insensitive). (See also: RFC 7231, Section 7.1.4) z Accept-Rangesa� Set the Accept-Ranges header. The Accept-Ranges header field indicates to the client which range units are supported (e.g. "bytes") for the target resource. If range requests are not supported for the target resource, the header may be set to "none" to advise the client not to attempt any such requests. Note: "none" is the literal string, not Python's built-in ``None`` type. c C s& |duod| j v}|r"| �d|� dS )z�Wrapper around set_header to set a content-type. Args: media_type: Media type to use for the Content-Type header. Nz content-type)r rQ )r � media_type�set_content_typer r r �_set_media_type� s �zResponse._set_media_typec C sP | j }| �|� |r |�� }n t|�� �}| jdurL|dd� | j�� D �7 }|S )z�Convert headers into the format expected by WSGI servers. Args: media_type: Default media type to use for the Content-Type header if the header was not set explicitly (default ``None``). Nc S s g | ]}d |� � f�qS )z set-cookie)� OutputString)r^ �cr r r r` , s �z*Response._wsgi_headers.<locals>.<listcomp>)r rx rX �listr �values)r rv �py2rY rX r r r � _wsgi_headers s �zResponse._wsgi_headers)N)NNNNNT)NNNNN)N)*r- � __module__� __qualname__�__doc__� __slots__rW r r! �propertyr$ �setterr. r/ rH rL rO rQ rS rU rZ rr r r � cache_controlr] �content_locationr � content_ranger% r �downloadable_as�etagr � last_modified�locationr7 � retry_after�vary� accept_rangesrx r r~ r r r r r / s� V � "( � w� � �� � �� � � �� r c @ s e Zd ZdZdZdd� ZdS )r aS Defines a set of configurable response options. An instance of this class is exposed via :any:`API.resp_options` for configuring certain :py:class:`~.Response` behaviors. Attributes: secure_cookies_by_default (bool): Set to ``False`` in development environments to make the `secure` attribute for all cookies default to ``False``. This can make testing easier by not requiring HTTPS. Note, however, that this setting can be overridden via `set_cookie()`'s `secure` kwarg. default_media_type (str): The default Internet media type (RFC 2046) to use when deserializing a response. This value is normally set to the media type provided when a :class:`falcon.API` is initialized; however, if created independently, this will default to the ``DEFAULT_MEDIA_TYPE`` specified by Falcon. media_handlers (Handlers): A dict-like object that allows you to configure the media-types that you would like to handle. By default, a handler is provided for the ``application/json`` media type. static_media_types (dict): A mapping of dot-prefixed file extensions to Internet media types (RFC 2046). Defaults to ``mimetypes.types_map`` after calling ``mimetypes.init()``. )r? r& r' �static_media_typesc C s( d| _ t| _t� | _t�� tj| _d S )NT) r? r r& r r' � mimetypes�init� types_mapr� r# r r r r! T s zResponseOptions.__init__N)r- r r� r� r� r! r r r r r 1 s r ) r� r� �sixr r rj � six.movesr �falconr � falcon.mediar �falcon.response_helpersr r r r r � falcon.utilr r �falcon.util.urir r] r ri r8 r9 r= �objectr r r r r r �<module> s*
cải xoăn