U
|
Þ=®dáq ã @ sè d dl mZ d dlZd dlZd dlZd dlZd dlmZ d dlm Z d dl
|
m Z ddl m Z ddl mZ dd l mZ dd
|
lmZ dd lmZ dd lmZ dd lmZ ejrÂd dlmZ d dlmZ dddddZ dMddddddddd Z dd d d d Z dNdddd!d"d#Z dd$d d%d&Z dOddd$d(d)d*d+Z!dPdd-d.dd/d0d1Z"G d2d3 d3Z#dQdd(d5d6d7d8d9Z$G d:d; d;Z%G d<d= d=Z&d>d$d5d?d@dAdBZ'dRd>d$d5dd?dDdEdFZ(dSd>dGd$d5dd?dHdIdJZ)G dKdL dLej*Z+dS )Té )Ú annotationsN)Úpartial©Úupdate_wrapper)Úchainé )Ú_make_encode_wrapper)Ú _to_bytes)Ú_to_str)ÚClientDisconnected)ÚRequestEntityTooLarge)Úutils)Úhost_is_trusted)ÚWSGIApplication)ÚWSGIEnvironmentz t.Callable[..., WSGIApplication]r )ÚfÚreturnc s t fdd S )a
|
Marks a function as responder. Decorate a function with it and it
|
will automatically call the return value as WSGI application.
|
|
Example::
|
|
@responder
|
def application(environ, start_response):
|
return Response('Hello World!')
|
c s | | dd
S )Néþÿÿÿ© )Úa©r r úDd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\werkzeug/wsgi.pyÚ<lambda>" ó zresponder.<locals>.<lambda>r r r r r Ú responder s
|
r Fr Úboolzt.Iterable[str] | NoneÚstr)ÚenvironÚ root_onlyÚstrip_querystringÚ host_onlyÚ trusted_hostsr c C sb | d t | |d}|sV| dd¡|d< |sV| dd¡|d< |sV| dd¡ d ¡|d
|
< tjf |S ) aX Recreate the URL for a request from the parts in a WSGI
|
environment.
|
|
The URL is an IRI, not a URI, so it may contain Unicode characters.
|
Use :func:`~werkzeug.urls.iri_to_uri` to convert it to ASCII.
|
|
:param environ: The WSGI environment to get the URL parts from.
|
:param root_only: Only build the root path, don't include the
|
remaining path or query string.
|
:param strip_querystring: Don't include the query string.
|
:param host_only: Only build the scheme and host.
|
:param trusted_hosts: A list of trusted host names to validate the
|
host against.
|
úwsgi.url_scheme)ÚschemeÚhostZ SCRIPT_NAMEÚ Ú root_pathÚ PATH_INFOÚpathÚ QUERY_STRINGÚlatin1Z query_string)Úget_hostÚgetÚencodeÚ _sansio_utilsÚget_current_url)r r r r r! Úpartsr r r r/ % s þr/ z tuple[str, int | None] | None)r r c C sP | d¡}|d krd S zt| dd ¡}W n ttfk
|
rF d }Y nX ||fS )NZ SERVER_NAMEZ SERVER_PORT)r, ÚintÚ TypeErrorÚ
|
ValueError)r ÚnameÚportr r r Ú _get_serverK s
|
|
r6 )r r! r c C s t | d | d¡t| |¡S )ar Return the host for the given WSGI environment.
|
|
The ``Host`` header is preferred, then ``SERVER_NAME`` if it's not
|
set. The returned host will only contain the port if it is different
|
than the standard port for the protocol.
|
|
Optionally, verify that the host is trusted using
|
:func:`host_is_trusted` and raise a
|
:exc:`~werkzeug.exceptions.SecurityError` if it is not.
|
|
:param environ: A WSGI environment dict.
|
:param trusted_hosts: A list of trusted host names.
|
|
:return: Host, with port if necessary.
|
:raise ~werkzeug.exceptions.SecurityError: If the host is not
|
trusted.
|
r" Z HTTP_HOST)r. r+ r, r6 )r r! r r r r+ \ s ür+ ú
|
int | Nonec C s t j| d¡| d¡dS )ad Return the ``Content-Length`` header value as an int. If the header is not given
|
or the ``Transfer-Encoding`` header is ``chunked``, ``None`` is returned to indicate
|
a streaming request. If the value is not an integer, or negative, 0 is returned.
|
|
:param environ: The WSGI environ to get the content length from.
|
|
.. versionadded:: 0.9
|
ÚCONTENT_LENGTHZHTTP_TRANSFER_ENCODING)Zhttp_content_lengthZhttp_transfer_encoding)r. Úget_content_lengthr, )r r r r r9 x s þr9 Tú t.IO[bytes])r Ú safe_fallbackÚmax_content_lengthr c C s t t jt | d ¡}t| }|dk r<|dk r<||kr<t d| krl|dk rht t jt t||dd¡S |S |dkr|rt ¡ S |S t t jt t||¡S )a¸ Return the WSGI input stream, wrapped so that it may be read safely without going
|
past the ``Content-Length`` header value or ``max_content_length``.
|
|
If ``Content-Length`` exceeds ``max_content_length``, a
|
:exc:`RequestEntityTooLarge`` ``413 Content Too Large`` error is raised.
|
|
If the WSGI server sets ``environ["wsgi.input_terminated"]``, it indicates that the
|
server handles terminating the stream, so it is safe to read directly. For example,
|
a server that knows how to handle chunked requests safely would set this.
|
|
If ``max_content_length`` is set, it can be enforced on streams if
|
``wsgi.input_terminated`` is set. Otherwise, an empty stream is returned unless the
|
user explicitly disables this safe fallback.
|
|
If the limit is reached before the underlying stream is exhausted (such as a file
|
that is too large, or an infinite stream), the remaining contents of the stream
|
cannot be read safely. Depending on how the server handles this, clients may show a
|
"connection reset" failure instead of seeing the 413 response.
|
|
:param environ: The WSGI environ containing the stream.
|
:param safe_fallback: Return an empty stream when ``Content-Length`` is not set.
|
Disabling this allows infinite streams, which can be a denial-of-service risk.
|
:param max_content_length: The maximum length that content-length or streaming
|
requests may not exceed.
|
|
.. versionchanged:: 2.3.2
|
``max_content_length`` is only applied to streaming requests if the server sets
|
``wsgi.input_terminated``.
|
|
.. versionchanged:: 2.3
|
Check ``max_content_length`` and raise an error if it is exceeded.
|
|
.. versionadded:: 0.9
|
z
|
wsgi.inputNzwsgi.input_terminatedT)Úis_max) ÚtÚcastÚIOÚbytesr9 r Ú LimitedStreamÚioÚBytesIO)r r; r< ÚstreamÚcontent_lengthr r r Úget_input_stream s ' ÿrG .út.Anyz
|
str | None)r ÚcharsetÚerrorsr c C sf |dk r&t jdtdd |dkr*d}nd}|dk rDt jdtdd nd}| d d
|
¡ d ¡}| ||¡S ) a Return ``PATH_INFO`` from the WSGI environment.
|
|
:param environ: WSGI environment to get the path from.
|
|
.. versionchanged:: 2.3
|
The ``charset`` and ``errors`` parameters are deprecated and will be removed in
|
Werkzeug 3.0.
|
|
.. versionadded:: 0.9
|
.zJThe 'charset' parameter is deprecated and will be removed in Werkzeug 3.0.é ©Ú
|
stacklevelNzutf-8zHThe 'errors' parameter is deprecated and will be removed in Werkzeug 3.0Úreplacer' r% r* )ÚwarningsÚwarnÚDeprecationWarningr, r- Údecode)r rI rJ r( r r r Ú get_path_infoË s$ üýrS c @ sN e Zd ZdZdddddddZd d d
|
d Zd d d dZdd ddZdS )ÚClosingIteratoraA The WSGI specification requires that all middlewares and gateways
|
respect the `close` callback of the iterable returned by the application.
|
Because it is useful to add another close action to a returned iterable
|
and adding a custom iterable is a boring task this class can be used for
|
that::
|
|
return ClosingIterator(app(environ, start_response), [cleanup_session,
|
cleanup_locals])
|
|
If there is just one close function it can be passed instead of the list.
|
|
A closing iterator is not needed if the application uses response objects
|
and finishes the processing if the response is started::
|
|
try:
|
return response(environ, start_response)
|
finally:
|
cleanup_session()
|
cleanup_locals()
|
Nút.Iterable[bytes]z@None | (t.Callable[[], None] | t.Iterable[t.Callable[[], None]])ÚNone)ÚiterableÚ callbacksr c C sr t |}t tjg tf tt|¡| _|d kr4g }nt|rD|g}nt |}t
|
|dd }|rh| d|¡ || _ d S )NÚcloser ) Úiterr> r? ÚCallablerA r ÚnextÚ_nextÚcallableÚlistÚgetattrÚinsertÚ
|
_callbacks)ÚselfrW rX ÚiteratorZiterable_closer r r Ú__init__
|
s zClosingIterator.__init__©r c C s | S ©Nr ©rc r r r Ú__iter__ s zClosingIterator.__iter__rA c C s | ¡ S rg )r] rh r r r Ú__next__ s zClosingIterator.__next__c C s | j D ]
|
}| qd S rg )rb )rc Úcallbackr r r rY # s
|
zClosingIterator.close)N)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__re ri rj rY r r r r rT ô s ürT é r1 rU )r ÚfileÚ buffer_sizer c C s | dt¡||S )a Wraps a file. This uses the WSGI server's file wrapper if available
|
or otherwise the generic :class:`FileWrapper`.
|
|
.. versionadded:: 0.5
|
|
If the file wrapper from the WSGI server is used it's important to not
|
iterate over it from inside the application but to pass it through
|
unchanged. If you want to pass out a file wrapper inside a response
|
object you have to set :attr:`Response.direct_passthrough` to `True`.
|
|
More information about file wrappers are available in :pep:`333`.
|
|
:param file: a :class:`file`-like object with a :meth:`~file.read` method.
|
:param buffer_size: number of bytes for one iteration.
|
zwsgi.file_wrapper)r, Ú FileWrapper)r rq rr r r r Ú wrap_file( s
|
ÿrt c @ sz e Zd ZdZd ddddddZdd d
|
d Zd d d dZdddddZdd ddZd d ddZ dd ddZ
|
dS ) rs a\ This class can be used to convert a :class:`file`-like object into
|
an iterable. It yields `buffer_size` blocks until the file is fully
|
read.
|
|
You should not use this class directly but rather use the
|
:func:`wrap_file` function that uses the WSGI server's file wrapper
|
support if it's available.
|
|
.. versionadded:: 0.5
|
|
If you're using this object together with a :class:`Response` you have
|
to use the `direct_passthrough` mode.
|
|
:param file: a :class:`file`-like object with a :meth:`~file.read` method.
|
:param buffer_size: number of bytes for one iteration.
|
rp r: r1 rV )rq rr r c C s || _ || _d S rg )rq rr )rc rq rr r r r re Q s zFileWrapper.__init__rf c C s t | jdr| j ¡ d S ©NrY )Úhasattrrq rY rh r r r rY U s zFileWrapper.closer c C s* t | jdr| j ¡ S t | jdr&dS dS )NÚseekableÚseekTF)rv rq rw rh r r r rw Y s
|
|
zFileWrapper.seekablerH )Úargsr c G s t | jdr| jj| d S )Nrx )rv rq rx )rc ry r r r rx ` s zFileWrapper.seekr7 c C s t | jdr| j ¡ S d S )NÚtell)rv rq rz rh r r r rz d s
|
zFileWrapper.tellc C s | S rg r rh r r r ri i s zFileWrapper.__iter__rA c C s | j | j¡}|r|S t d S rg )rq Úreadrr Ú StopIteration)rc Údatar r r rj l s zFileWrapper.__next__N)rp ) rl rm rn ro re rY rw rx rz ri rj r r r r rs ? s rs c @ sx e Zd ZdZddddddd Zd d
|
d d Zd d
|
ddZdd
|
ddZd d
|
ddZd d
|
ddZ dd
|
ddZ
|
dS )Ú _RangeWrapperas This class can be used to convert an iterable object into
|
an iterable that will only yield a piece of the underlying content.
|
It yields blocks until the underlying stream range is fully read.
|
The yielded blocks will have a size that can't exceed the original
|
iterator defined block size, but that can be smaller.
|
|
If you're using this object together with a :class:`Response` you have
|
to use the `direct_passthrough` mode.
|
|
:param iterable: an iterable object with a :meth:`__next__` method.
|
:param start_byte: byte from which read will start.
|
:param byte_range: how many bytes to read.
|
r Nú t.Iterable[bytes] | t.IO[bytes]r1 r7 )rW Ú
|
start_byteÚ
|
byte_rangec C sR t || _|| _|| _d | _|d k r.|| | _d| _t|doD| ¡ | _d| _d S )Nr rw F) rZ rW r r Úend_byteÚ read_lengthrv rw Ú end_reached)rc rW r r r r r re s
|
|
z_RangeWrapper.__init__rf c C s | S rg r rh r r r ri s z_RangeWrapper.__iter__rA c C sD z"t | j}| jt|7 _|W S tk
|
r> d| _ Y nX d S ©NT)r\ rW r Úlenr| r ©rc Úchunkr r r Ú _next_chunk s
|
z_RangeWrapper._next_chunkztuple[bytes | None, int]c C sl d }| j r,| j | j¡ | j ¡ | _| j}n8| j| jkrB| ¡ }q,|d k r^|| j| j d
}| j}||fS rg )rw rW rx r rz r r ©rc r Zcontextual_read_lengthr r r Ú_first_iteration¢ s
|
z _RangeWrapper._first_iterationc C sn | j r t d }| j}| jdkr,| ¡ \}}|d kr<| ¡ }| jd k rj| j| jkrjd| _ |d | j|
S |S )Nr T)r r| r r r r r r r r r] ° s
|
z_RangeWrapper._nextc C s | ¡ }|r|S d| _t d S r
)r] r r| r r r r rj ¾ s
|
z_RangeWrapper.__next__rV c C s t | jdr| j ¡ d S ru )rv rW rY rh r r r rY Å s z_RangeWrapper.close)r N) rl rm rn ro re ri r r r] rj rY r r r r r~ s s ü r~ r út.Iterator[bytes])rE Úlimitrr r c c s¦ t jdtdd t| tttfr(tdt| dsJ| D ]}|r6|V q6dS t
|
t j t | ¡} t| t s|dk rt
|
t j t t | |¡} | j }||}|sq¢|V qdS )z-Helper for the line and chunk iter functions.zE'_make_chunk_iter' is deprecated and will be removed in Werkzeug 3.0.rK rL zBPassed a string or byte object instead of true iterator or stream.r{ N)rO rP rQ Ú
|
isinstancerA Ú bytearrayr r2 rv r> r? r@ rB r{ )rE r rr ÚitemÚ_readr r r Ú_make_chunk_iterÊ s, ýÿ
|
r é ( )rE r rr Ú cap_at_bufferr c # sú t jdtdd t| | t d}|s.dS t|}t t|d¡t t|d¡}t t|d¡}t t|d¡t tj t t
|
|f ¡ d d
|
fd d }} | D ]6}
|
|
|
|krÜ| d d
|krÜ| |
|
7 } }
|
| ræ| V |
|
} q´| rö| V dS )aÓ Safely iterates line-based over an input stream. If the input stream
|
is not a :class:`LimitedStream` the `limit` parameter is mandatory.
|
|
This uses the stream's :meth:`~file.read` method internally as opposite
|
to the :meth:`~file.readline` method that is unsafe and can only be used
|
in violation of the WSGI specification. The same problem applies to the
|
`__iter__` function of the input stream which calls :meth:`~file.readline`
|
without arguments.
|
|
If you need line-by-line processing it's strongly recommended to iterate
|
over the input stream using this helper function.
|
|
.. deprecated:: 2.3
|
Will be removed in Werkzeug 3.0.
|
|
.. versionadded:: 0.11
|
added support for the `cap_at_buffer` parameter.
|
|
.. versionadded:: 0.9
|
added support for iterators as input stream.
|
|
.. versionchanged:: 0.8
|
This function now ensures that the limit was reached.
|
|
:param stream: the stream or iterate to iterate over.
|
:param limit: the limit in bytes for the stream. (Usually
|
content length. Not necessary if the `stream`
|
is a :class:`LimitedStream`.
|
:param buffer_size: The optional buffer size.
|
:param cap_at_buffer: if this is set chunks are split if they are longer
|
than the buffer size. Internally this is implemented
|
that the buffer size might be exhausted by a factor
|
of two however.
|
zC'make_line_iter' is deprecated and will be removed in Werkzeug 3.0.rK rL r% Nú Ú
|
z
|
r rf c 3 sÚ j } g }t d}|sqÈg }d}t tjt t|| d¡¡D ]}| |¡ |t |7 }|r~|dd
kr~| |V g }q@r@|kr@| |}t |krº|d
V |d
}q|g}q@|}q
|
|rÖ| |V d S )Nr% r Téÿÿÿÿ)
|
Újoinr\ r> r? ÚIteratorrA r Ú
|
splitlinesÚappendr )Ú_joinÚbufferÚnew_dataÚnew_bufÚbuf_sizer Úrv©Ú_iterrr r ZcrlfÚemptyr r Ú_iter_basic_lines& s2
|
ÿ
|
|
z)make_line_iter.<locals>._iter_basic_linesr ) rO rP rQ r r\ r r> r? rA r r ) rE r rr r Ú
|
first_itemÚsZcrÚlfr¥ Úpreviousr r r¢ r Úmake_line_iterê s4 (ý
|
|
rª rA )rE Ú separatorr rr r r c c st t jdtdd t| ||}t|d}|s.dS t tjt t |f|¡}t
|
|t r|t |}t dt |¡ d¡j}dj}n(t|}t d t |¡ d
|
¡j}dj}g } t|d}
|
|
|
sºq`||
|
} g } d } t | | D ]}||krô|| V g } d } qÔ| t|7 } | |¡ |rÔ| |krÔ|| }t||krJ|d|
V ||d
}q |g} t|} qÔ| } q¨| rp|| V dS ) aN Works like :func:`make_line_iter` but accepts a separator
|
which divides chunks. If you want newline based processing
|
you should use :func:`make_line_iter` instead as it
|
supports arbitrary newline markers.
|
|
.. deprecated:: 2.3
|
Will be removed in Werkzeug 3.0.
|
|
.. versionchanged:: 0.11
|
added support for the `cap_at_buffer` parameter.
|
|
.. versionchanged:: 0.9
|
added support for iterators as input stream.
|
|
.. versionadded:: 0.8
|
|
:param stream: the stream or iterate to iterate over.
|
:param separator: the separator that divides chunks.
|
:param limit: the limit in bytes for the stream. (Usually
|
content length. Not necessary if the `stream`
|
is otherwise already limited).
|
:param buffer_size: The optional buffer size.
|
:param cap_at_buffer: if this is set chunks are split if they are longer
|
than the buffer size. Internally this is implemented
|
that the buffer size might be exhausted by a factor
|
of two however.
|
zD'make_chunk_iter' is deprecated and will be removed in Werkzeug 3.0.rK rL r Nú(ú)r% ó (ó )r )rO rP rQ r r\ r> r? r rA r r r r
|
ÚreÚcompileÚescapeÚsplitr r r r )rE r« r rr r r£ r¦ Ú_splitr r r Úchunksr r r r¡ r r r Úmake_chunk_iterO sR "ý
|
|
|
|
|
|
r¶ c @ s e Zd ZdZd"ddddddd Zedd
|
d d Zdd
|
d dZd#dddddZdd
|
ddZ dddddZ
|
dd
|
d d Z dd
|
d d Z dd
|
d d!Z dS )$rB a: Wrap a stream so that it doesn't read more than a given limit. This is used to
|
limit ``wsgi.input`` to the ``Content-Length`` header value or
|
:attr:`.Request.max_content_length`.
|
|
When attempting to read after the limit has been reached, :meth:`on_exhausted` is
|
called. When the limit is a maximum, this raises :exc:`.RequestEntityTooLarge`.
|
|
If reading from the stream returns zero bytes or raises an error,
|
:meth:`on_disconnect` is called, which raises :exc:`.ClientDisconnected`. When the
|
limit is a maximum and zero bytes were read, no error is raised, since it may be the
|
end of the stream.
|
|
If the limit is reached before the underlying stream is exhausted (such as a file
|
that is too large, or an infinite stream), the remaining contents of the stream
|
cannot be read safely. Depending on how the server handles this, clients may show a
|
"connection reset" failure instead of seeing the 413 response.
|
|
:param stream: The stream to read from. Must be a readable binary IO object.
|
:param limit: The limit in bytes to not read past. Should be either the
|
``Content-Length`` header value or ``request.max_content_length``.
|
:param is_max: Whether the given ``limit`` is ``request.max_content_length`` instead
|
of the ``Content-Length`` header value. This changes how exhausted and
|
disconnect events are handled.
|
|
.. versionchanged:: 2.3
|
Handle ``max_content_length`` differently than ``Content-Length``.
|
|
.. versionchanged:: 2.3
|
Implements ``io.RawIOBase`` rather than ``io.IOBase``.
|
Fr: r1 r rV )rE r r= r c C s || _ d| _|| _|| _d S )Nr )Ú_streamÚ_posr Ú _limit_is_max)rc rE r r= r r r re Å s zLimitedStream.__init__rf c C s | j | jkS )z:Whether the current stream position has reached the limit.)r¸ r rh r r r Ú is_exhaustedË s zLimitedStream.is_exhaustedc C s | j r t dS )a Called when attempting to read after the limit has been reached.
|
|
The default behavior is to do nothing, unless the limit is a maximum, in which
|
case it raises :exc:`.RequestEntityTooLarge`.
|
|
.. versionchanged:: 2.3
|
Raises ``RequestEntityTooLarge`` if the limit is a maximum.
|
|
.. versionchanged:: 2.3
|
Any return value is ignored.
|
N)r¹ r rh r r r Ú on_exhaustedÐ s zLimitedStream.on_exhaustedNzException | None)Úerrorr c C s | j r|dk rt dS )a Called when an attempted read receives zero bytes before the limit was
|
reached. This indicates that the client disconnected before sending the full
|
request body.
|
|
The default behavior is to raise :exc:`.ClientDisconnected`, unless the limit is
|
a maximum and no error was raised.
|
|
.. versionchanged:: 2.3
|
Added the ``error`` parameter. Do nothing if the limit is a maximum and no
|
error was raised.
|
|
.. versionchanged:: 2.3
|
Any return value is ignored.
|
N)r¹ r )rc r¼ r r r Ú on_disconnectß s zLimitedStream.on_disconnectrA c C s | j s| ¡ S dS )a> Exhaust the stream by reading until the limit is reached or the client
|
disconnects, returning the remaining data.
|
|
.. versionchanged:: 2.3
|
Return the remaining data.
|
|
.. versionchanged:: 2.2.3
|
Handle case where wrapped stream returns fewer bytes than requested.
|
r )rº Úreadallrh r r r Úexhaustõ s
|
zLimitedStream.exhaustr r7 )Úbr c
|
C sv t |}| j| j }|dkr(| ¡ dS t| jdrì||krz| j |¡}W qê ttfk
|
r } z| j |d W Y ¢dS d }~X Y qêX nbt
|
|}z| j |¡}W n8 ttfk
|
rØ } z| j |d W Y ¢dS d }~X Y nX |rê||d |
< nfz| j t ||¡}W n: ttfk
|
r< } z| j |d W Y ¢dS d }~X Y nX t |}||d |
< |sd| ¡ dS | j|7 _|S )Nr Úreadinto)r¼ ) r r r¸ r» rv r· rÁ ÚOSErrorr3 r½ r r{ Úmin)rc rÀ ÚsizeÚ remainingZout_sizeÚeZtemp_br} r r r rÁ s@ zLimitedStream.readintoc C sB | j r| ¡ dS t }| j s:| d¡}|s.q:| |¡ qt|S )Nr i )rº r» r r{ ÚextendrA )rc Úoutr} r r r r¾ 4 s
|
zLimitedStream.readallc C s | j S )zKReturn the current stream position.
|
|
.. versionadded:: 0.9
|
)r¸ rh r r r rz G s zLimitedStream.tellc C s dS r
r rh r r r ÚreadableN s zLimitedStream.readable)F)N)rl rm rn ro re Úpropertyrº r» r½ r¿ rÁ r¾ rz rÉ r r r r rB ¥ s 0rB )FFFN)N)TN).N)rp )Nr F)Nr F),Ú
|
__future__r rC r° Útypingr> rO Ú functoolsr r Ú itertoolsr Ú _internalr r r
|
Ú
|
exceptionsr r Zsansior r. Z sansio.utilsr Ú TYPE_CHECKINGZ_typeshed.wsgir r r r/ r6 r+ r9 rG rS rT rt rs r~ r rª r¶ Ú RawIOBaserB r r r r Ú<module> s` û& ÿ ýF ý)5 ÿ4W" üh ûV
|
