U
|
Þ=®dN` ã @ sx d dl mZ d dlZd dlZd dlZd dlZd dlZd dlZd dlZ d dl
|
Z
|
d dl m Z d dl m Z d dl mZ d dlmZ d dlmZ dd lmZ dd
|
lmZ dd lmZ dd lmZ dd lmZ ddlmZ ddl m Z ddl m Z e j rd dl!m"Z" ddl#m$Z$ ddl%m&Z& e 'd¡Z(e )d¡Z*e )d¡Z+ddddhdd e,d D d d e,d D Z-G d d d e.e j/e( Z0G d!d" d"ee Z1G d#d$ d$ee Z2d%d&d'd(d)d*hZ3d+d+d+d,d-d.Z4d+d+d/d0d1Z5dXd+d3d4d5d6d7d8Z6dYd:d3d5d;d<d=Z7dZd@d:dAdBdAdBdCdDdEdBd4dFd5dG dHdIZ8dJdJd:dKd5dLdMdNZ9d[d+dBdKdOdPdQZ:d\d+dBdBdRdSdTdUZ;G dVdW dWe<Z=dS )]é )Ú annotationsN)Údatetime)Útime)Úquote)Úadler32)Úescapeé )Ú_DictAccessorProperty)Ú_missing)Ú_TAccessorValue)ÚHeaders)ÚNotFound)Ú RequestedRangeNotSatisfiable)Ú safe_join)Ú wrap_file)ÚWSGIEnvironment)ÚRequest©ÚResponseÚ_Tz &([^;]+);z[^A-Za-z0-9_.-]ÚCONÚPRNÚAUXÚNULc c s | ]}d | V qdS )ZCOMN© ©Ú.0Úir r úEd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\werkzeug/utils.pyÚ <genexpr>) s r é
|
c c s | ]}d | V qdS )ZLPTNr r r r r r * s c sd e Zd ZdZdddddd fdd Zd d
|
dd d d Zdd dd
|
dddZd ddddZ ZS )Úcached_propertyaz A :func:`property` that is only evaluated once. Subsequent access
|
returns the cached value. Setting the property sets the cached
|
value. Deleting the property clears the cached value, accessing it
|
again will evaluate it again.
|
|
.. code-block:: python
|
|
class Example:
|
@cached_property
|
def value(self):
|
# calculate something important here
|
return 42
|
|
e = Example()
|
e.value # evaluates
|
e.value # uses cache
|
e.value = 16 # sets cache
|
del e.value # clears cache
|
|
If the class defines ``__slots__``, it must add ``_cache_{name}`` as
|
a slot. Alternatively, it can add ``__dict__``, but that's usually
|
not desirable.
|
|
.. versionchanged:: 2.1
|
Works with ``__slots__``.
|
|
.. versionchanged:: 2.0
|
``del obj.name`` clears the cached value.
|
Nzt.Callable[[t.Any], _T]ú
|
str | NoneÚNone)ÚfgetÚnameÚdocÚreturnc s6 t j||d |p|j| _d| j | _|j| _d S )N)r& Z_cache_)ÚsuperÚ__init__Ú__name__Ú slot_nameÚ
|
__module__)Úselfr$ r% r& ©Ú __class__r r r) M s zcached_property.__init__Úobjectr )ÚobjÚvaluer' c C s* t |dr||j| j< nt|| j| d S ©NÚ__dict__)Úhasattrr4 r* Úsetattrr+ )r- r1 r2 r r r Ú__set__X s
|
zcached_property.__set__Útype)r1 r8 r' c C sx |d kr | S t |dd }|d k r0| | jt¡}nt || jt}|tkrt| |¡}|d k rf||j| j< nt|| j| |S r3 )ÚgetattrÚgetr* r
|
r+ r$ r4 r6 )r- r1 r8 Zobj_dictr2 r r r Ú__get__^ s
|
zcached_property.__get__©r1 r' c C s( t |dr|j| j= nt|| jt d S r3 )r5 r4 r* r6 r+ r
|
©r- r1 r r r Ú
|
__delete__s s
|
zcached_property.__delete__)NN)N) r* r, Ú __qualname__Ú__doc__r) r7 r; r> Ú __classcell__r r r. r r! . s ! ü r! c @ s$ e Zd ZdZdZdddddZdS ) Úenviron_propertyað Maps request attributes to environment variables. This works not only
|
for the Werkzeug request object, but also any other class with an
|
environ attribute:
|
|
>>> class Test(object):
|
... environ = {'key': 'value'}
|
... test = environ_property('key')
|
>>> var = Test()
|
>>> var.test
|
'value'
|
|
If you pass it a second value it's used as default if the key does not
|
exist, the third one can be a converter that takes a value and converts
|
it. If it raises :exc:`ValueError` or :exc:`TypeError` the default value
|
is used. If no default value is provided `None` is used.
|
|
Per default the property is read only. You have to explicitly enable it
|
by passing ``read_only=False`` to the constructor.
|
Tr r r< c C s |j S ©N)Úenvironr= r r r Úlookup s zenviron_property.lookupN)r* r, r? r@ Z read_onlyrE r r r r rB z s rB c @ s e Zd ZdZdddddZdS )Úheader_propertyz(Like `environ_property` but for headers.zRequest | Responser r< c C s |j S rC )Úheadersr= r r r rE s zheader_property.lookupN)r* r, r? r@ rE r r r r rF s rF zapplication/ecmascriptzapplication/javascriptzapplication/sqlzapplication/xmlzapplication/xml-dtdz&application/xml-external-parsed-entityÚstr)ÚmimetypeÚcharsetr' c C s. | d¡s | tks | d¡r*| d| 7 } | S )aL Returns the full content type string with charset for a mimetype.
|
|
If the mimetype represents text, the charset parameter will be
|
appended, otherwise the mimetype is returned unchanged.
|
|
:param mimetype: The mimetype to be used as content type.
|
:param charset: The charset to be appended for text mimetypes.
|
:return: The content type.
|
|
.. versionchanged:: 0.15
|
Any type that ends with ``+xml`` gets a charset, not just those
|
that start with ``application/``. Known text types such as
|
``application/javascript`` are also given charsets.
|
ztext/z+xmlz
|
; charset=)Ú
|
startswithÚ_charset_mimetypesÚendswith)rI rJ r r r Úget_content_type© s ÿþýrN )Úfilenamer' c C s t d| ¡} | dd¡ d¡} tjtjjfD ]}|r,| |d¡} q,t t
|
dd | ¡ ¡¡ d¡} tjdkr| r| d ¡d
|
¡ tkrd| } | S ) at Pass it a filename and it will return a secure version of it. This
|
filename can then safely be stored on a regular file system and passed
|
to :func:`os.path.join`. The filename returned is an ASCII only string
|
for maximum portability.
|
|
On windows systems the function also makes sure that the file is not
|
named after one of the special device files.
|
|
>>> secure_filename("My cool movie.mov")
|
'My_cool_movie.mov'
|
>>> secure_filename("../../../etc/passwd")
|
'etc_passwd'
|
>>> secure_filename('i contain cool \xfcml\xe4uts.txt')
|
'i_contain_cool_umlauts.txt'
|
|
The function might return an empty filename. It's your responsibility
|
to ensure that the filename is unique and that you abort or
|
generate a random filename if the function returned an empty one.
|
|
.. versionadded:: 0.5
|
|
:param filename: the filename to secure
|
ÚNFKDÚasciiÚignoreú Ú Ú_z._ÚntÚ.r )Ú unicodedataÚ normalizeÚencodeÚdecodeÚosÚsepÚpathÚaltsepÚreplacerH Ú_filename_ascii_strip_reÚsubÚjoinÚsplitÚstripr% ÚupperÚ_windows_device_files)rO r] r r r Úsecure_filename s ÿÿþý
|
rh é. Úintztype[Response] | Noner )ÚlocationÚcoder r' c C sF |dkrddl m} t| }|d| d| d|dd}| |jd < |S )
|
aa Returns a response object (a WSGI application) that, if called,
|
redirects the client to the target location. Supported codes are
|
301, 302, 303, 305, 307, and 308. 300 is not supported because
|
it's not a real redirect and 304 because it's the answer for a
|
request with a request with defined If-Modified-Since headers.
|
|
.. versionadded:: 0.6
|
The location can now be a unicode string that is encoded using
|
the :func:`iri_to_uri` function.
|
|
.. versionadded:: 0.10
|
The class used for the Response object can now be passed in.
|
|
:param location: the location the response should redirect to.
|
:param code: the redirect status code. defaults to 302.
|
:param class Response: a Response class to use when instantiating a
|
response. The default is :class:`werkzeug.wrappers.Response` if
|
unspecified.
|
Nr r z<!doctype html>
|
<html lang=en>
|
<title>Redirecting...</title>
|
<h1>Redirecting...</h1>
|
<p>You should be redirected automatically to the target URL: <a href="z">z </a>. If not, click the link.
|
z text/html)rI ZLocation)Úwrappersr r rG )rk rl r Z html_locationÚresponser r r Úredirectñ s ø
|
|
ro é4 r )rD rl r' c C sL | d d¡d }|s d}n
|
| d}| d¡}|rB| d| }t||S )aL Redirect to the current URL with a slash appended.
|
|
If the current URL is ``/user/42``, the redirect URL will be
|
``42/``. When joined to the current URL during response
|
processing or by the browser, this will produce ``/user/42/``.
|
|
The behavior is undefined if the path ends with a slash already. If
|
called unconditionally on a URL, it may produce a redirect loop.
|
|
:param environ: Use the path and query from this WSGI environment
|
to produce the redirect URL.
|
:param code: the status code for the redirect.
|
|
.. versionchanged:: 2.1
|
Produce a relative URL that only modifies the last segment.
|
Relevant when the current path has multiple segments.
|
|
.. versionchanged:: 2.1
|
The default status code is 308 instead of 301. This preserves
|
the request method and body.
|
Z PATH_INFOú/é z./Ú QUERY_STRINGú?)Ú
|
rpartitionr: ro )rD rl ÚtailÚnew_pathZ query_stringr r r Úappend_slash_redirect s
|
|
rx FTz os.PathLike | str | t.IO[bytes]r" Úboolz
|
bool | strz datetime | int | float | Nonez3None | (int | t.Callable[[str | None], int | None])zos.PathLike | str | None) Ú path_or_filerD rI Ú as_attachmentÚ download_nameÚ conditionalÚetagÚ last_modifiedÚmax_ageÚuse_x_sendfileÚresponse_classÚ
|
_root_pathr' c C sj |
|
dkrddl m} | }
|
d} d}d}d}t }t| tjtfsHt| drt tj
|
tjtf | ¡} | dk rxtj | | ¡} n tj | ¡} t | ¡}|j}|j}n| }|dkr¼| dk r¼tj | ¡}|dkr |dkrÖtdt |¡\}}|dkrðd}|dk r |s | d|¡ |dk rz| d¡ W nP tk
|
rt t d |¡}| dd
|
¡ d¡}t|d d }|d | d}Y n
|
X d|i}|rdnd}|jd|f| n|r¬td| rÊ| dk rÊ| |d< d}nP|dkràt | d}n0t|t j rú| ¡ j }nt|t j!rt"dt#||}|
|
|||dd}|dk r:||_$|dk rL||_%n|dk r\||_%d|j&_'t(|rv|| }|dk r²|dkrd|j&_'d|j&_)||j&_*t+t, | |_-t|trÊ| .|¡ n<|r| dk rt/| d¡d@ }| .| d | d | ¡ |rfz|j0|d|d }W n* t1k
|
rJ |dk rD| 2¡ Y nX |j3d krf|j4 5d d¡ |S ) a3 Send the contents of a file to the client.
|
|
The first argument can be a file path or a file-like object. Paths
|
are preferred in most cases because Werkzeug can manage the file and
|
get extra information from the path. Passing a file-like object
|
requires that the file is opened in binary mode, and is mostly
|
useful when building a file in memory with :class:`io.BytesIO`.
|
|
Never pass file paths provided by a user. The path is assumed to be
|
trusted, so a user could craft a path to access a file you didn't
|
intend. Use :func:`send_from_directory` to safely serve user-provided paths.
|
|
If the WSGI server sets a ``file_wrapper`` in ``environ``, it is
|
used, otherwise Werkzeug's built-in wrapper is used. Alternatively,
|
if the HTTP server supports ``X-Sendfile``, ``use_x_sendfile=True``
|
will tell the server to send the given path, which is much more
|
efficient than reading it in Python.
|
|
:param path_or_file: The path to the file to send, relative to the
|
current working directory if a relative path is given.
|
Alternatively, a file-like object opened in binary mode. Make
|
sure the file pointer is seeked to the start of the data.
|
:param environ: The WSGI environ for the current request.
|
:param mimetype: The MIME type to send for the file. If not
|
provided, it will try to detect it from the file name.
|
:param as_attachment: Indicate to a browser that it should offer to
|
save the file instead of displaying it.
|
:param download_name: The default name browsers will use when saving
|
the file. Defaults to the passed file name.
|
:param conditional: Enable conditional and range responses based on
|
request headers. Requires passing a file path and ``environ``.
|
:param etag: Calculate an ETag for the file, which requires passing
|
a file path. Can also be a string to use instead.
|
:param last_modified: The last modified time to send for the file,
|
in seconds. If not provided, it will try to detect it from the
|
file path.
|
:param max_age: How long the client should cache the file, in
|
seconds. If set, ``Cache-Control`` will be ``public``, otherwise
|
it will be ``no-cache`` to prefer conditional caching.
|
:param use_x_sendfile: Set the ``X-Sendfile`` header to let the
|
server to efficiently send the file. Requires support from the
|
HTTP server. Requires passing a file path.
|
:param response_class: Build the response using this class. Defaults
|
to :class:`~werkzeug.wrappers.Response`.
|
:param _root_path: Do not use. For internal use only. Use
|
:func:`send_from_directory` to safely send files under a path.
|
|
.. versionchanged:: 2.0.2
|
``send_file`` only sets a detected ``Content-Encoding`` if
|
``as_attachment`` is disabled.
|
|
.. versionadded:: 2.0
|
Adapted from Flask's implementation.
|
|
.. versionchanged:: 2.0
|
``download_name`` replaces Flask's ``attachment_filename``
|
parameter. If ``as_attachment=False``, it is passed with
|
``Content-Disposition: inline`` instead.
|
|
.. versionchanged:: 2.0
|
``max_age`` replaces Flask's ``cache_timeout`` parameter.
|
``conditional`` is enabled and ``max_age`` is not set by
|
default.
|
|
.. versionchanged:: 2.0
|
``etag`` replaces Flask's ``add_etags`` parameter. It can be a
|
string to use instead of generating one.
|
|
.. versionchanged:: 2.0
|
If an encoding is returned when guessing ``mimetype`` from
|
``download_name``, set the ``Content-Encoding`` header.
|
Nr r Ú
|
__fspath__zUnable to detect the MIME type because a file name is not available. Either set 'download_name', pass a path instead of a file, or set 'mimetype'.zapplication/octet-streamzContent-EncodingrQ rP rR z !#$&+-.^_`|~)ÚsafezUTF-8'')rO z filename*rO Ú
|
attachmentÚinlinezContent-Dispositionz]No name provided for attachment. Either set 'download_name' or pass a path instead of a file.z
|
X-SendfileÚrbz3Files must be opened in binary mode or use BytesIO.T)rI rG Zdirect_passthroughr zutf-8l ÿÿ ú-)Z accept_rangesZcomplete_lengthi0 z
|
x-sendfile)6rm r r Ú
|
isinstancer\ ÚPathLikerH r5 ÚtÚcastÚUnionr^ rc ÚabspathÚstatÚst_sizeÚst_mtimeÚbasenameÚ TypeErrorÚ mimetypesÚ
|
guess_typeÚsetrZ ÚUnicodeEncodeErrorrX rY r[ r ÚopenÚioÚBytesIOÚ getbufferÚnbytesÚ
|
TextIOBaseÚ
|
ValueErrorr Úcontent_lengthr Z cache_controlÚno_cacheÚcallableÚpublicr rj r ÚexpiresZset_etagr Zmake_conditionalr ÚcloseÚ status_coderG Úpop)rz rD rI r{ r| r} r~ r r r r r r r^ ÚfileÚsizeÚmtimerG r ÚencodingÚsimpleÚquotedÚnamesr2 ÚdataÚrvÚcheckr r r Ú send_file> sº V ÿ
|
|
ÿ
|
ÿ
|
|
ÿ
|
|
|
|
|
|
|
r² zos.PathLike | strzt.Any)Ú directoryr^ rD Úkwargsr' c K s^ t t | ¡t |¡}|dkr$t d|kr>tj |d |¡}tj |¡sPt t||f|S )aË Send a file from within a directory using :func:`send_file`.
|
|
This is a secure way to serve files from a folder, such as static
|
files or uploads. Uses :func:`~werkzeug.security.safe_join` to
|
ensure the path coming from the client is not maliciously crafted to
|
point outside the specified directory.
|
|
If the final path does not point to an existing regular file,
|
returns a 404 :exc:`~werkzeug.exceptions.NotFound` error.
|
|
:param directory: The directory that ``path`` must be located under. This *must not*
|
be a value provided by the client, otherwise it becomes insecure.
|
:param path: The path to the file to send, relative to ``directory``. This is the
|
part of the path provided by the client, which is checked for security.
|
:param environ: The WSGI environ for the current request.
|
:param kwargs: Arguments to pass to :func:`send_file`.
|
|
.. versionadded:: 2.0
|
Adapted from Flask's implementation.
|
Nr )r r\ Úfspathr r^ rc Úisfiler² )r³ r^ rD r´ r r r Úsend_from_directory s r· )Ú import_nameÚsilentr' c
|
C sî | dd¡} zz t| W n tk
|
r8 d| kr4 Y nX tj| W S | dd¡\}}t|t t |g}zt||W W S t k
|
r¤ } zt|dW 5 d}~X Y nX W n@ tk
|
rè } z"|sØt
|
| | t ¡ d ¡dW 5 d}~X Y nX dS )aC Imports an object based on a string. This is useful if you want to
|
use import paths as endpoints or something similar. An import path can
|
be specified either in dotted notation (``xml.sax.saxutils.escape``)
|
or with a colon as object delimiter (``xml.sax.saxutils:escape``).
|
|
If `silent` is True the return value will be `None` if the import fails.
|
|
:param import_name: the dotted name for the object to import.
|
:param silent: if set to `True` import errors are ignored and
|
`None` is returned instead.
|
:return: imported object
|
ú:rW r Nrr ) r` Ú
|
__import__Ú ImportErrorÚsysÚmodulesÚrsplitÚglobalsÚlocalsr9 ÚAttributeErrorÚImportStringErrorÚwith_tracebackÚexc_info)r¸ r¹ Ú module_nameZobj_nameÚmoduleÚer r r Ú import_stringC s,
|
|
ÿþrÉ zt.Iterator[str])Ú import_pathÚinclude_packagesÚ recursiver' c c s t | }t|dd}|dkr*t| d|j d}t |¡D ]>\}}}|| }|rx|r`|V |r~t||dE dH q@|V q@dS )a Finds all the modules below a package. This can be useful to
|
automatically import all views / controllers so that their metaclasses /
|
function decorators have a chance to register themselves on the
|
application.
|
|
Packages are not returned unless `include_packages` is `True`. This can
|
also recursively list modules but in that case it will import all the
|
packages to get the correct load path of that module.
|
|
:param import_path: the dotted name for the package to find child modules.
|
:param include_packages: set to `True` if packages should be returned, too.
|
:param recursive: set to `True` if recursion should happen.
|
:return: generator
|
Ú__path__Nz is not a packagerW T)rÉ r9 r r* ÚpkgutilÚ iter_modulesÚ find_modules) rÊ rË rÌ rÇ r^ r Ú _importerÚmodnameÚispkgr r r rÐ j s rÐ c sJ e Zd ZU dZded< ded< dddd fdd Zdd
|
d d Z ZS ) rà zBProvides information about a failed :func:`import_string` attempt.rH r¸ Ú BaseExceptionÚ exceptionr# )r¸ rÕ r' c
|
sÎ || _ || _|}d}g }| dd¡ d¡D ]}|r@| d| n|}t|dd}|rl| |t|dd f¡ q*dd |D }| d |d
|
¡ d |¡} d |d | dt|j d| } q¾q*t
|
|¡ d S )NrT rº rW T)r¹ Ú__file__c S s" g | ]\}}d |d|dqS )ú- z
|
found in rW r )r Únr r r r Ú
|
<listcomp> s z.ImportStringError.__init__.<locals>.<listcomp>r× z not found.Ú
|
zimport_string() failed for zõ. Possible reasons are:
|
|
- missing __init__.py in a package;
|
- package or module path not included in sys.path;
|
- duplicated package or module name taking precedence in sys.path;
|
- missing module, class, function or variable;
|
|
Debugged import:
|
|
z
|
|
Original exception:
|
|
z: ) r¸ rÕ r` rd rÉ Úappendr9 rc r8 r* r( r) )
|
r- r¸ rÕ Úmsgr% ZtrackedÚpartZimportedÚtrackZ track_strr. r r r) s"
|
ÿ zImportStringError.__init__)r' c C s" dt | j d| jd| jdS )Nú<ú(z, z)>)r8 r* r¸ rÕ )r- r r r Ú__repr__± s zImportStringError.__repr__)r* r, r? r@ Ú__annotations__r) rá rA r r r. r rà s
|
|
rà )ri N)rp )
|
NFNTTNNFNN)F)FF)>Ú
|
__future__r r r r\ rÎ Úrer½ Útypingr rX r r Ú urllib.parser Úzlibr Z
|
markupsafer Ú _internalr r
|
r Zdatastructuresr Ú
|
exceptionsr r Úsecurityr Zwsgir Ú TYPE_CHECKINGZ_typeshed.wsgir Zwrappers.requestr Zwrappers.responser ÚTypeVarr ÚcompileZ
|
_entity_rera Úrangerg ÚpropertyÚGenericr! rB rF rL rN rh ro rx r² r· rÉ rÐ r¼ rà r r r r Ú<module> s
|
|
|
üú
|
L ú
|
0 ÿ(( ô( \*( ÿ!
|
