U
|
Þ=®d ã @ sT d dl mZ d dlZd dlZd dlmZ d dlmZ ddl m
|
Z
|
ddlm Z ddl m Z dd lmZ dd
|
lmZ dd lmZ dd lmZ dd lmZ d dlmZ d dlmZ d dlmZ d dlm Z d dlm Z d dlm Z d dl m Z ej!r d dl"m#Z# d dl"m$Z$ d dl"m%Z% ddl&m'Z' ddd d d d Z(G d d! d!eZ G d"d# d#Z)dS )$é )Ú annotationsN)Ú
|
HTTPStatus)Úurljoiné )ÚHeaders)Úremove_entity_headers)ÚResponse)Ú_invalid_iri_to_uri)Ú
|
iri_to_uri)Úcached_property)ÚClosingIterator)Úget_current_url)Ú _get_environ)Ú generate_etag)Ú http_date)Úis_resource_modified)Ú parse_etags)Úparse_range_header)Ú _RangeWrapper)Ú StartResponse)ÚWSGIApplication)ÚWSGIEnvironmenté )ÚRequestzt.Iterable[str | bytes]Ústrút.Iterator[bytes])ÚiterableÚcharsetÚreturnc c s, | D ]"}t |tr | |¡V q|V qd S ©N)Ú
|
isinstancer Úencode)r r Úitem© r# úQd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\werkzeug/wrappers/response.pyÚ _iter_encoded s
|
r% c s e Zd ZU dZdZdZdZded< drddd d
|
d
|
d d d fdd ZdddddZ ddddZ
|
e dsd dd dddZ e dtd d d d d d d Z ejdud!d"d#d$d%Zejd&dd#d'd%Zdvd d(d#d)d%Zd(d d*d+d,Zeeed-d.Zd/dd0d1Zdwd d d2d3d4Zd dd5d6Zd7dd8d9Zed dd:d;Zed dd<d=Zd dd>d?Zd dd@dAZdBdC Z d ddDdEZ d dFdGdHdIZ d dJdGdKdLZ d dMdGdNdOZ d dPdJdQdRdSZ!e"Z#edTddUdVZ"ejdxd d!dXdYdZd[Z$ejdyd d dTdYd\d[Z$dzd d dTdYd]d[Z$e%d^dd_d`Z&dadad dbdcddZ'd d dGdedfZ(d d/dgd dhdidjZ)d{dkdgd/d dldmdnZ*d|d d d dodpdqZ+ Z,S )}r a¤ Represents an outgoing WSGI HTTP response with body, status, and
|
headers. Has properties and methods for using the functionality
|
defined by various HTTP specs.
|
|
The response body is flexible to support different use cases. The
|
simple form is passing bytes, or a string which will be encoded as
|
UTF-8. Passing an iterable of bytes or strings makes this a
|
streaming response. A generator is particularly useful for building
|
a CSV file in memory or using SSE (Server Sent Events). A file-like
|
object is also iterable, although the
|
:func:`~werkzeug.utils.send_file` helper should be used in that
|
case.
|
|
The response object is itself a WSGI application callable. When
|
called (:meth:`__call__`) with ``environ`` and ``start_response``,
|
it will pass its status and headers to ``start_response`` then
|
return its body as an iterable.
|
|
.. code-block:: python
|
|
from werkzeug.wrappers.response import Response
|
|
def index():
|
return Response("Hello, World!")
|
|
def application(environ, start_response):
|
path = environ.get("PATH_INFO") or "/"
|
|
if path == "/":
|
response = index()
|
else:
|
response = Response("Not Found", status=404)
|
|
return response(environ, start_response)
|
|
:param response: The data for the body of the response. A string or
|
bytes, or tuple or list of strings or bytes, for a fixed-length
|
response, or any other iterable of strings or bytes for a
|
streaming response. Defaults to an empty body.
|
:param status: The status code for the response. Either an int, in
|
which case the default status message is added, or a string in
|
the form ``{code} {message}``, like ``404 Not Found``. Defaults
|
to 200.
|
:param headers: A :class:`~werkzeug.datastructures.Headers` object,
|
or a list of ``(key, value)`` tuples that will be converted to a
|
``Headers`` object.
|
:param mimetype: The mime type (content type without charset or
|
other parameters) of the response. If the value starts with
|
``text/`` (or matches some other special cases), the charset
|
will be added to create the ``content_type``.
|
:param content_type: The full content type of the response.
|
Overrides building the value from ``mimetype``.
|
:param direct_passthrough: Pass the response body directly through
|
as the WSGI iterable. This can be used when the body is a binary
|
file or other iterator of bytes, to skip some unnecessary
|
checks. Use :func:`~werkzeug.utils.send_file` instead of setting
|
this manually.
|
|
.. versionchanged:: 2.1
|
Old ``BaseResponse`` and mixin classes were removed.
|
|
.. versionchanged:: 2.0
|
Combine ``BaseResponse`` and mixins into a single ``Response``
|
class.
|
|
.. versionchanged:: 0.5
|
The ``direct_passthrough`` parameter was added.
|
TFz#t.Iterable[str] | t.Iterable[bytes]ÚresponseNz8t.Iterable[bytes] | bytes | t.Iterable[str] | str | Nonez int | str | HTTPStatus | NonezJt.Mapping[str, str | t.Iterable[str]] | t.Iterable[tuple[str, str]] | Nonez
|
str | NoneÚboolÚNone)r& ÚstatusÚheadersÚmimetypeÚ content_typeÚdirect_passthroughr c sV t j||||d || _g | _|d kr0g | _n"t|tttfrL| |¡ n|| _d S )N)r) r* r+ r, )
|
ÚsuperÚ__init__r- Ú _on_closer& r r ÚbytesÚ bytearrayÚset_data)Úselfr& r) r* r+ r, r- ©Ú __class__r# r$ r/ s ü zResponse.__init__zt.Callable[[], t.Any])Úfuncr c C s | j |¡ |S )a Adds a function to the internal list of functions that should
|
be called as part of closing down the response. Since 0.7 this
|
function also returns the function that was passed so that this
|
can be used as a decorator.
|
|
.. versionadded:: 0.6
|
)r0 Úappend©r4 r7 r# r# r$ Ú call_on_close³ s zResponse.call_on_closer ©r c C sN | j r ttt| ¡ d}n| jr*dnd}dt| j d| d| j dS )Nz bytesZstreamedzlikely-streamedú<ú z [z]>) Ú is_sequenceÚsumÚmapÚlenÚ iter_encodedÚ is_streamedÚtypeÚ__name__r) )r4 Z body_infor# r# r$ Ú__repr__¾ s zResponse.__repr__zWSGIEnvironment | None)r& Úenvironr c C s> t |ts4|dkrtdddlm} t||| }| |_|S )aÌ Enforce that the WSGI response is a response object of the current
|
type. Werkzeug will use the :class:`Response` internally in many
|
situations like the exceptions. If you call :meth:`get_response` on an
|
exception you will get back a regular :class:`Response` object, even
|
if you are using a custom subclass.
|
|
This method can enforce a given response type, and it will also
|
convert arbitrary WSGI callables into response objects if an environ
|
is provided::
|
|
# convert a Werkzeug response object into an instance of the
|
# MyResponseClass subclass.
|
response = MyResponseClass.force_type(response)
|
|
# convert any WSGI application into a response object
|
response = MyResponseClass.force_type(response, environ)
|
|
This is especially useful if you want to post-process responses in
|
the main dispatcher and use functionality provided by your subclass.
|
|
Keep in mind that this will modify response objects in place if
|
possible!
|
|
:param response: a response object or wsgi application.
|
:param environ: a WSGI environment object.
|
:return: a response object.
|
NzHcannot convert WSGI application into response objects without an environr ©Ú run_wsgi_app)r r Ú TypeErrorÚtestrI r6 )Úclsr& rG rI r# r# r$ Ú
|
force_typeÅ s
|
ÿ zResponse.force_typer r )ÚapprG Úbufferedr c C s ddl m} | |||| S )a Create a new response object from an application output. This
|
works best if you pass it an application that returns a generator all
|
the time. Sometimes applications may use the `write()` callable
|
returned by the `start_response` function. This tries to resolve such
|
edge cases automatically. But if you don't get the expected output
|
you should set `buffered` to `True` which enforces buffering.
|
|
:param app: the WSGI application to execute.
|
:param environ: the WSGI environment to execute against.
|
:param buffered: set to `True` to enforce buffering.
|
:return: a response object.
|
r rH )rK rI )rL rN rG rO rI r# r# r$ Úfrom_appò s zResponse.from_appzt.Literal[False]r1 )Úas_textr c C s d S r r# ©r4 rQ r# r# r$ Úget_data s zResponse.get_datazt.Literal[True]c C s d S r r# rR r# r# r$ rS
|
s z bytes | strc C s* | ¡ d | ¡ ¡}|r&| | j¡S |S )a¹ The string representation of the response body. Whenever you call
|
this property the response iterable is encoded and flattened. This
|
can lead to unwanted behavior if you stream big data.
|
|
This behavior can be disabled by setting
|
:attr:`implicit_sequence_conversion` to `False`.
|
|
If `as_text` is set to `True` the return value will be a decoded
|
string.
|
|
.. versionadded:: 0.9
|
ó )Ú_ensure_sequenceÚjoinrB ÚdecodeÚ_charset)r4 rQ Úrvr# r# r$ rS s
|
©Úvaluer c C s: t |tr| | j¡}|g| _| jr6tt|| jd< dS )zÏSets a new string as response. The value must be a string or
|
bytes. If a string is set it's encoded to the charset of the
|
response (utf-8 by default).
|
|
.. versionadded:: 0.9
|
úContent-LengthN)r r r! rX r& Ú automatically_set_content_lengthrA r* ©r4 r[ r# r# r$ r3 # s
|
|
zResponse.set_dataz>A descriptor that calls :meth:`get_data` and :meth:`set_data`.)Údocz
|
int | Nonec C s: z | ¡ W n tk
|
r" Y dS X tdd | ¡ D S )z<Returns the content length if available or `None` otherwise.Nc s s | ]}t |V qd S r ©rA ©Ú.0Úxr# r# r$ Ú <genexpr>< s z4Response.calculate_content_length.<locals>.<genexpr>)rU Ú RuntimeErrorr? rB ©r4 r# r# r$ Úcalculate_content_length6 s
|
z!Response.calculate_content_length)Úmutabler c C sN | j r&|r"t| jts"t| j| _dS | jr4td| jsBtd| ¡ dS )zÓThis method can be called by methods that need a sequence. If
|
`mutable` is true, it will also ensure that the response sequence
|
is a standard Python list.
|
|
.. versionadded:: 0.6
|
Nz]Attempted implicit sequence conversion but the response object is in direct passthrough mode.zThe response object required the iterable to be a sequence, but the implicit conversion was disabled. Call make_sequence() yourself.)r> r r& Úlistr- re Ú implicit_sequence_conversionÚ make_sequence)r4 rh r# r# r$ rU > s ÿÿzResponse._ensure_sequencec C s8 | j s4t| jdd}t| ¡ | _|dk r4| |¡ dS )aC Converts the response iterator in a list. By default this happens
|
automatically if required. If `implicit_sequence_conversion` is
|
disabled, this method is not automatically called and some properties
|
might raise exceptions. This also encodes all the items.
|
|
.. versionadded:: 0.6
|
ÚcloseN)r> Úgetattrr& ri rB r: )r4 rl r# r# r$ rk W s
|
zResponse.make_sequencer c C s t | j| jS )a Iter the response encoded with the encoding of the response.
|
If the response object is invoked as WSGI application the return
|
value of this method is used as application iterator unless
|
:attr:`direct_passthrough` was activated.
|
)r% r& rX rf r# r# r$ rB h s zResponse.iter_encodedc C s. zt | j W n ttfk
|
r( Y dS X dS )a¿ If the response is streamed (the response is not an iterable with
|
a length information) this property is `True`. In this case streamed
|
means that there is no information about the number of iterations.
|
This is usually `True` if a generator is passed to the response object.
|
|
This is useful for checking before applying some sort of post
|
filtering that should not take place for streamed responses.
|
TF)rA r& rJ ÚAttributeErrorrf r# r# r$ rC s s
|
|
zResponse.is_streamedc C s t | jttfS )zÜIf the iterator is buffered, this property will be `True`. A
|
response object will consider an iterator to be buffered if the
|
response attribute is a list or tuple.
|
|
.. versionadded:: 0.6
|
)r r& Útupleri rf r# r# r$ r> s zResponse.is_sequencec C s, t | jdr| j ¡ | jD ]
|
}| q dS )zÛClose the wrapped response if possible. You can also use the object
|
in a with statement which will automatically close it.
|
|
.. versionadded:: 0.9
|
Can now be used in a with statement.
|
rl N)Úhasattrr& rl r0 r9 r# r# r$ rl s
|
|
zResponse.closec C s | S r r# rf r# r# r$ Ú __enter__ s zResponse.__enter__c C s | ¡ d S r )rl )r4 Úexc_typeÚ exc_valueÚtbr# r# r$ Ú__exit__ s zResponse.__exit__c C s4 t | ¡ | _tttt| j| jd< | ¡ dS )aM Make the response object ready to be pickled. Does the
|
following:
|
|
* Buffer the response into a list, ignoring
|
:attr:`implicity_sequence_conversion` and
|
:attr:`direct_passthrough`.
|
* Set the ``Content-Length`` header.
|
* Generate an ``ETag`` header if one is not already set.
|
|
.. versionchanged:: 2.1
|
Removed the ``no_etag`` parameter.
|
|
.. versionchanged:: 2.0
|
An ``ETag`` header is always added.
|
|
.. versionchanged:: 0.6
|
The ``Content-Length`` header is set.
|
r\ N) ri rB r& r r? r@ rA r* Úadd_etagrf r# r# r$ Úfreeze s zResponse.freezer )rG r c C sH t | j}d}d}d}| j}|D ]8\}}| ¡ } | dkr>|}q | dkrL|}q | dkr |}q |dk rt|}| jrt|dd}
|
t|
|
}
|
t|
|
|}||d< |dk rªt||d< d | kr¾d
|
k sÈn |d krÔ| d ¡ n|d krät
|
| | j rD| j rD|dkrD|dkrDd | kr d
|
k sDn t dd | ¡ D }t||d < |S )ak This is automatically called right before the response is started
|
and returns headers modified for the given environment. It returns a
|
copy of the headers from the response with some modifications applied
|
if necessary.
|
|
For example the location header (if present) is joined with the root
|
URL of the environment. Also the content length is automatically set
|
to zero here for certain status codes.
|
|
.. versionchanged:: 0.6
|
Previously that function was called `fix_headers` and modified
|
the response object in place. Also since 0.6, IRIs in location
|
and content-location headers are handled properly.
|
|
Also starting with 0.6, Werkzeug will attempt to set the content
|
length if it is able to figure it out on its own. This is the
|
case if all the strings in the response iterable are already
|
encoded and the iterable is buffered.
|
|
:param environ: the WSGI environment of the request.
|
:return: returns a new :class:`~werkzeug.datastructures.Headers`
|
object.
|
NÚlocationzcontent-locationúcontent-lengthT)Zstrip_querystringZLocationzContent-Locationéd éÈ éÌ r\ é0 ©r| r} c s s | ]}t |V qd S r r` ra r# r# r$ rd s z,Response.get_wsgi_headers.<locals>.<genexpr>)r r* Ú status_codeÚlowerr Úautocorrect_location_headerr r
|
r Úremover r] r> r? rB r ) r4 rG r* rx Úcontent_locationÚcontent_lengthr) Úkeyr[ ÚikeyZ current_urlr# r# r$ Úget_wsgi_headers¸ sT
|
|
ÿþýü û
|
û
|
zResponse.get_wsgi_headersút.Iterable[bytes]c C sV | j }|d dks0d| kr&dk s0n |dkr6d}n| jrB| jS | ¡ }t|| jS )a Returns the application iterator for the given environ. Depending
|
on the request method and the current status code the return value
|
might be an empty response rather than the one from the response.
|
|
If the request method is `HEAD` or the status code is in a range
|
where the HTTP specification requires an empty response, an empty
|
iterable is returned.
|
|
.. versionadded:: 0.6
|
|
:param environ: the WSGI environment of the request.
|
:return: a response iterable.
|
ÚREQUEST_METHODÚHEADrz r{ r~ r# )r r- r& rB r rl )r4 rG r) r r# r# r$ Ú get_app_iter
|
s
|
ÿ þþýzResponse.get_app_iterz4tuple[t.Iterable[bytes], str, list[tuple[str, str]]]c C s$ | |¡}| |¡}|| j| ¡ fS )aF Returns the final WSGI response as tuple. The first item in
|
the tuple is the application iterator, the second the status and
|
the third the list of headers. The response returned is created
|
specially for the given environment. For example if the request
|
method in the WSGI environment is ``'HEAD'`` the response will
|
be empty and only the headers and status code will be present.
|
|
.. versionadded:: 0.6
|
|
:param environ: the WSGI environment of the request.
|
:return: an ``(app_iter, status, headers)`` tuple.
|
)r r r) Z to_wsgi_list)r4 rG r* Úapp_iterr# r# r$ Úget_wsgi_response% s
|
|
zResponse.get_wsgi_responser )rG Ústart_responser c C s | |¡\}}}||| |S )züProcess this response as WSGI application.
|
|
:param environ: the WSGI environment.
|
:param start_response: the response callable provided by the WSGI
|
server.
|
:return: an application iterator
|
)r )r4 rG r r r) r* r# r# r$ Ú__call__8 s
|
|
zResponse.__call__z t.Any | Nonec C s | ¡ S )zµThe parsed JSON data if :attr:`mimetype` indicates JSON
|
(:mimetype:`application/json`, see :attr:`is_json`).
|
|
Calls :meth:`get_json` with default arguments.
|
)Úget_jsonrf r# r# r$ ÚjsonL s z Response.json.zt.Any)ÚforceÚsilentr c C s d S r r# ©r4 r r r# r# r$ r U s zResponse.get_jsonc C s d S r r# r r# r# r$ r Y s c C sF |s| j sdS | ¡ }z| j |¡W S tk
|
r@ |s: Y dS X dS )a« Parse :attr:`data` as JSON. Useful during testing.
|
|
If the mimetype does not indicate JSON
|
(:mimetype:`application/json`, see :attr:`is_json`), this
|
returns ``None``.
|
|
Unlike :meth:`Request.get_json`, the result is not cached.
|
|
:param force: Ignore the mimetype and always try to parse JSON.
|
:param silent: Silence parsing errors and return ``None``
|
instead.
|
N)Zis_jsonrS Ú json_moduleÚloadsÚ
|
ValueError)r4 r r Údatar# r# r$ r ] s
|
ÚResponseStreamc C s t | S )z+The response iterable as write-only stream.)r rf r# r# r$ Ústreamy s zResponse.streamÚint)ÚstartÚlengthr c C s | j dkrt| j||| _dS )z8Wrap existing Response in case of Range Request context.éÎ N)r r r& )r4 r r r# r# r$ Ú_wrap_range_response~ s
|
z Response._wrap_range_responsec C s4 d|ks,t || j d¡d| j d¡dd o2d|kS )zReturn ``True`` if `Range` header is present and if underlying
|
resource is considered unchanged when compared with `If-Range` header.
|
Z HTTP_IF_RANGEÚetagNú last-modifiedF)Zignore_if_rangeÚ
|
HTTP_RANGE)r r* Úget)r4 rG r# r# r$ Ú _is_range_request_processable s
|
|
ûþ ÷z&Response._is_range_request_processablez
|
bool | str)rG Úcomplete_lengthÚ accept_rangesr c C sÌ ddl m} |r*|dks*|dks*| |¡s.dS |dkr:d}t| d¡}|dkrX||| |¡}| |¡}|dks||dkr|||d |d }t|| jd
|
< || jd < || _ d | _
|
| |d |¡ dS ) a. Handle Range Request related headers (RFC7233). If `Accept-Ranges`
|
header is valid, and Range Request is processable, we set the headers
|
as described by the RFC, and wrap the underlying response in a
|
RangeWrapper.
|
|
Returns ``True`` if Range Request can be fulfilled, ``False`` otherwise.
|
|
:raises: :class:`~werkzeug.exceptions.RequestedRangeNotSatisfiable`
|
if `Range` header could not be parsed or satisfied.
|
|
.. versionchanged:: 2.0
|
Returns ``False`` if the length is 0.
|
r )Ú RequestedRangeNotSatisfiableNr FTr1 r¢ r r\ z Accept-Rangesr ) Ú
|
exceptionsr§ r¤ r r£ Zrange_for_lengthZto_content_range_headerr r* Z content_ranger r ) r4 rG r¥ r¦ r§ Z parsed_rangeZ range_tupleZcontent_range_headerr r# r# r$ Ú_process_range_request s4 ÿþýü
|
|
|
z Response._process_range_requestzWSGIEnvironment | Request)Úrequest_or_environr¦ r¥ r c C s¨ t |}|d dkr¤d| jkr*t | jd< | |||¡}|svt|| j d¡d| j d¡svt| d¡rpd | _nd
|
| _| jr¤d | jkr¤| ¡ }|dk r¤t
|
|| jd < | S ) ab Make the response conditional to the request. This method works
|
best if an etag was defined for the response already. The `add_etag`
|
method can be used to do that. If called without etag just the date
|
header is set.
|
|
This does nothing if the request method in the request or environ is
|
anything but GET or HEAD.
|
|
For optimal performance when handling range requests, it's recommended
|
that your response data object implements `seekable`, `seek` and `tell`
|
methods as described by :py:class:`io.IOBase`. Objects returned by
|
:meth:`~werkzeug.wsgi.wrap_file` automatically implement those methods.
|
|
It does not remove the body of the response because that's something
|
the :meth:`__call__` function does for us automatically.
|
|
Returns self so that you can do ``return resp.make_conditional(req)``
|
but modifies the object in-place.
|
|
:param request_or_environ: a request object or WSGI environment to be
|
used to make the response conditional
|
against.
|
:param accept_ranges: This parameter dictates the value of
|
`Accept-Ranges` header. If ``False`` (default),
|
the header is not set. If ``True``, it will be set
|
to ``"bytes"``. If it's a string, it will use this
|
value.
|
:param complete_length: Will be used only in valid Range Requests.
|
It will set `Content-Range` complete length
|
value and compute `Content-Length` real value.
|
This parameter is mandatory for successful
|
Range Requests completion.
|
:raises: :class:`~werkzeug.exceptions.RequestedRangeNotSatisfiable`
|
if `Range` header could not be parsed or satisfied.
|
|
.. versionchanged:: 2.0
|
Range processing is skipped if length is 0 instead of
|
raising a 416 Range Not Satisfiable error.
|
r )ÚGETr ÚdateÚDater Nr¡ Z HTTP_IF_MATCHi r} ry r\ ) r r* r r© r r£ r r r] rg r )r4 rª r¦ r¥ rG Zis206r r# r# r$ Úmake_conditionalÅ s, -
|
|
|
üÿþzResponse.make_conditional)Ú overwriteÚweakr c C s& |sd| j kr"| t| ¡ |¡ dS )zÐAdd an etag for the current response if there is none yet.
|
|
.. versionchanged:: 2.0
|
SHA-1 is used to generate the value. MD5 may not be
|
available in some environments.
|
r N)r* Zset_etagr rS )r4 r¯ r° r# r# r$ rv s zResponse.add_etag)NNNNNF)N)F)F)F)F)..)..)FF)FN)FF)-rE Ú
|
__module__Ú __qualname__Ú__doc__rj r r] Ú__annotations__r/ r: rF Ú classmethodrM rP ÚtÚoverloadrS r3 Úpropertyr rg rU rk rB rC r> rl rq ru rw r r r r r r r r r r r¤ r© r® rv Ú __classcell__r# r# r5 r$ r ' s
|
M
|
÷ # ÿ, ÿ ý R 6 üIr c @ s e Zd ZdZdZddddZddd d
|
d Zd d dddZd dddZd dddZ ddddZ
|
ddddZ e ddd d Z d S ) r zµA file descriptor like object used by :meth:`Response.stream` to
|
represent the body of the stream. It directly pushes into the
|
response iterable of the response object.
|
zwb+r )r& c C s || _ d| _d S )NF)r& Úclosed)r4 r& r# r# r$ r/ ! s zResponseStream.__init__r1 r rZ c C sB | j rtd| jjdd | jj |¡ | jj dd ¡ t|S )Nú I/O operation on closed fileT)rh r\ )rº r r& rU r8 r* ÚpoprA r^ r# r# r$ Úwrite% s zResponseStream.writer r( )Úseqr c C s |D ]}| |¡ qd S r )r½ )r4 r¾ r" r# r# r$ Ú
|
writelines- s zResponseStream.writelinesr; c C s
|
d| _ d S )NT)rº rf r# r# r$ rl 1 s zResponseStream.closec C s | j rtdd S )Nr» ©rº r rf r# r# r$ Úflush4 s zResponseStream.flushr' c C s | j rtddS )Nr» FrÀ rf r# r# r$ Úisatty8 s zResponseStream.isattyc C s | j ¡ ttt| j j S r )r& rU r? r@ rA rf r# r# r$ Útell= s
|
zResponseStream.tellr c C s | j jS r )r& rX rf r# r# r$ ÚencodingA s zResponseStream.encodingN)rE r± r² r³ Úmoder/ r½ r¿ rl rÁ r rà r¸ rÄ r# r# r# r$ r s r )*Ú
|
__future__r r Útypingr¶ Úhttpr Ú urllib.parser Zdatastructuresr r Zsansio.responser Z_SansIOResponseÚurlsr r
|
Úutilsr Zwsgir r Zwerkzeug._internalr Z werkzeug.httpr r r r r Z werkzeug.wsgir Ú TYPE_CHECKINGZ_typeshed.wsgir r r Úrequestr r% r r# r# r# r$ Ú<module> s@ w
|
