U
|
ß=®dJO ã @ sp d dl Z d dlZd dlZd dlZd dlmZ d dlmZ d dlm Z ddl
|
m Z ddl
|
m Z ddl
|
m Z dd l
|
mZ dd
|
l
|
mZ dd l
|
mZ dd l
|
mZ dd l
|
mZ ddl
|
mZ ddl
|
mZ ddlmZ ejràd dlZe d¡Ze d¡Z e e dddZ dddddZ ej!e dd d Z"dFe e#e d d d!Z$G d"d# d#Z%G d$d% d%Z&dGej'ej! ej'ej(ej! e)e)ej'e) dd(d)d*Z*d+ej+dd,d-Z,dHd+ej'e ej'e ej-d/d0d1Z.dIe e ej'e ej'e e)e)ej(ej! d3d4d5Z/dJd6e)e d7d8d9Z0dKe e)e)e d:d;d<Z1G d=d> d>Z2dLej'e ej'e e d?d@dAZ3d&d&d&dBej4e e)e)e)ej5e dCdDdEZ6dS )Mé N)Úupdate_wrapper)Ú
|
ModuleType)Ú TracebackTypeé )Ú_default_text_stderr)Ú_default_text_stdout)Ú_find_binary_writer)Úauto_wrap_for_ansi)Úbinary_streams)Ú open_stream)Úshould_strip_ansi)Ú
|
strip_ansi)Ú text_streams)ÚWIN)Úresolve_color_defaultÚPÚR©ÚnameÚreturnc C s d | ¡ ¡ ¡ S )Nú-)ÚjoinÚsplitÚlower)r © r úBd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\click/utils.pyÚ _posixify s r zt.Callable[P, R]z t.Callable[P, t.Optional[R]])Úfuncr c s& ddt jt d fdd }t| S )z0Wraps a function so that it swallows exceptions.zP.argszP.kwargs)ÚargsÚkwargsr c s& z | |W S t k
|
r Y nX d S ©N)Ú Exception)r r ©r r r Úwrapper$ s
|
zsafecall.<locals>.wrapper)ÚtÚOptionalr r )r r# r r" r Úsafecall! s r& )Úvaluer c C sD t | tr<z| t ¡ ¡W S tk
|
r: | dd¡ Y S X t| S )z%Converts a value into a valid string.úutf-8Úreplace)Ú
|
isinstanceÚbytesÚdecodeÚsysÚgetfilesystemencodingÚ UnicodeErrorÚstr)r' r r r Úmake_str. s
|
r1 é- )ÚhelpÚ
|
max_lengthr c C s( | d¡}|dkr | d|
} | ¡ }|s.dS |d dkrF|dd
}d}t|d }t|D ]b\}}|t||dk 7 }||kr qÌ|d dkr¬d |d|d
¡ S ||kr^||kr^ qÌq^d |¡S |td
|
7 }|dkr|t|| |dk 8 }||krq|d8 }qØd |d|
¡d
|
S ) z+Returns a condensed version of help string.z
|
|
éÿÿÿÿNÚ r úr Ú.ú z...)Úfindr ÚlenÚ enumerater )r3 r4 Z paragraph_endÚwordsÚ total_lengthÚ
|
last_indexÚiÚwordr r r Úmake_default_short_help8 s4
|
|
|
|
|
rB c @ sà e Zd ZdZd ejedf eeje eje eddd Z eej
|
d
|
d d Z ed ddZ ej ej
|
d ddZdd ddZdd ddZd d ddZejeje eje eje ddddZejej d dd ZdS ) ÚLazyFilezîA lazy file works like a regular file but it does not fully open
|
the file but it does perform some basic checks early to see if the
|
filename parameter does make sense. This is useful for safely opening
|
files for writing.
|
ÚrNÚstrictFzos.PathLike[str])ÚfilenameÚmodeÚencodingÚerrorsÚatomicc C st t |¡| _|| _|| _|| _|| _| | | jdkrNt||||\| _| _ n"d|krdt
|
|| ¡ d | _d| _ d S )Nr rD T) ÚosÚfspathr rG rH rI rJ r Ú_fÚ should_closeÚopenÚclose)ÚselfrF rG rH rI rJ r r r Ú__init__q s
|
zLazyFile.__init__r c C s t | ¡ |S r )ÚgetattrrO ©rQ r r r r Ú __getattr__ s zLazyFile.__getattr__©r c C s. | j d k rt| j S dt| j d| j dS )Nz<unopened file 'z' ú>)rM ÚreprÚformat_filenamer rG ©rQ r r r Ú__repr__ s
|
|
zLazyFile.__repr__c
|
C s | j dk r| j S z&t| j| j| j| j| jd\}| _W n@ tk
|
rv } z"ddl m
|
} || j|j d|W 5 d}~X Y nX || _ |S )zOpens the file if it's not yet open. This call might fail with
|
a :exc:`FileError`. Not handling this error will produce an error
|
that Click shows.
|
N©rJ r )Ú FileError)Úhint) rM r r rG rH rI rJ rN ÚOSErrorÚ
|
exceptionsr] Ústrerror)rQ ÚrvÚer] r r r rO s
|
ÿ $z LazyFile.openc C s | j dk r| j ¡ dS )z+Closes the underlying file, no matter what.N)rM rP rZ r r r rP ¦ s
|
zLazyFile.closec C s | j r| ¡ dS )zThis function only closes the file if it was opened by the lazy
|
file wrapper. For instance this will never close stdin.
|
N)rN rP rZ r r r Úclose_intelligently« s z LazyFile.close_intelligentlyc C s | S r r rZ r r r Ú __enter__² s zLazyFile.__enter__©Úexc_typeÚ exc_valueÚtbr c C s | ¡ d S r )rd ©rQ rg rh ri r r r Ú__exit__µ s zLazyFile.__exit__c C s | ¡ t| jS r )rO ÚiterrM rZ r r r Ú__iter__½ s zLazyFile.__iter__)rD NrE F)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__r$ ÚUnionr0 r% ÚboolrR ÚAnyrU r[ ÚIOrO rP rd re ÚTypeÚ BaseExceptionr rk ÚIteratorÚAnyStrrm r r r r rC j s0 ú ú û rC c @ s e Zd Zejej ddddZeejdddZd dd d
|
Z ej
|
ej e ej
|
e ej
|
e dd d d ZedddZejej dddZdS )Ú KeepOpenFileN)Úfiler c C s
|
|| _ d S r )Ú_file)rQ r{ r r r rR Ã s zKeepOpenFile.__init__r c C s t | j|S r )rS r| rT r r r rU Æ s zKeepOpenFile.__getattr__rV c C s | S r r rZ r r r re É s zKeepOpenFile.__enter__rf c C s d S r r rj r r r rk Ì s zKeepOpenFile.__exit__c C s
|
t | jS r )rX r| rZ r r r r[ Ô s zKeepOpenFile.__repr__c C s
|
t | jS r )rl r| rZ r r r rm × s zKeepOpenFile.__iter__)rn ro rp r$ ru rt rR r0 rU re r% rv rw r rk r[ rx ry rm r r r r rz  s û rz TF)Úmessager{ ÚnlÚerrÚcolorr c C s |dkr&|rt }nt }|dkr&dS | dk rHt| tttfsHt| }n| }|rt|pVd}t|trl|d7 }n|d7 }|s| ¡ dS t|ttfrÂt|}|dk rÀ| ¡ | |¡ | ¡ dS nBt |}t
|
||rÞt |}n&t rt dk röt |}n|st |}| |¡ | ¡ dS )a Print a message and newline to stdout or a file. This should be
|
used instead of :func:`print` because it provides better support
|
for different data, files, and environments.
|
|
Compared to :func:`print`, this does the following:
|
|
- Ensures that the output encoding is not misconfigured on Linux.
|
- Supports Unicode in the Windows console.
|
- Supports writing to binary outputs, and supports writing bytes
|
to text outputs.
|
- Supports colors and styles on Windows.
|
- Removes ANSI color and style codes if the output does not look
|
like an interactive terminal.
|
- Always flushes the output.
|
|
:param message: The string or bytes to output. Other objects are
|
converted to strings.
|
:param file: The file to write to. Defaults to ``stdout``.
|
:param err: Write to ``stderr`` instead of ``stdout``.
|
:param nl: Print a newline after the message. Enabled by default.
|
:param color: Force showing or hiding colors and other styles. By
|
default Click will remove color if the output does not look like
|
an interactive terminal.
|
|
.. versionchanged:: 6.0
|
Support Unicode output on the Windows console. Click does not
|
modify ``sys.stdout``, so ``sys.stdout.write()`` and ``print()``
|
will still not support Unicode.
|
|
.. versionchanged:: 4.0
|
Added the ``color`` parameter.
|
|
.. versionadded:: 3.0
|
Added the ``err`` parameter.
|
|
.. versionchanged:: 2.0
|
Support colors on Windows if colorama is installed.
|
Nr6 Ú
|
ó
|
)r r r* r0 r+ Ú bytearrayÚflushr Úwriter r r r r )r} r{ r~ r r ÚoutÚ binary_filer r r ÚechoÛ sD -
|
|
|
|
|
|
|
|
r z'te.Literal['stdin', 'stdout', 'stderr']c C s( t | ¡}|dkr"td| d| S )z°Returns a system stream for byte processing.
|
|
:param name: the name of the stream to open. Valid names are ``'stdin'``,
|
``'stdout'`` and ``'stderr'``
|
NúUnknown standard stream 'ú')r
|
ÚgetÚ TypeError)r Úopenerr r r Úget_binary_streamB s
|
r rE )r rH rI r c C s, t | ¡}|dkr"td| d|||S )aÞ Returns a system stream for text processing. This usually returns
|
a wrapped stream around a binary stream returned from
|
:func:`get_binary_stream` but it also can take shortcuts for already
|
correctly configured streams.
|
|
:param name: the name of the stream to open. Valid names are ``'stdin'``,
|
``'stdout'`` and ``'stderr'``
|
:param encoding: overrides the detected default encoding.
|
:param errors: overrides the default error mode.
|
Nr r )r r r )r rH rI r r r r Úget_text_streamN s
|
r rD )rF rG rH rI ÚlazyrJ r c
|
C s\ |r&t t jt j t| ||||d¡S t| ||||d\}}|sXt t jt j t|¡}|S )aV Open a file, with extra behavior to handle ``'-'`` to indicate
|
a standard stream, lazy open on write, and atomic write. Similar to
|
the behavior of the :class:`~click.File` param type.
|
|
If ``'-'`` is given to open ``stdout`` or ``stdin``, the stream is
|
wrapped so that using it in a context manager will not close it.
|
This makes it possible to use the function without accidentally
|
closing a standard stream:
|
|
.. code-block:: python
|
|
with open_file(filename) as f:
|
...
|
|
:param filename: The name of the file to open, or ``'-'`` for
|
``stdin``/``stdout``.
|
:param mode: The mode in which to open the file.
|
:param encoding: The encoding to decode or encode a file opened in
|
text mode.
|
:param errors: The error handling mode.
|
:param lazy: Wait to open the file until it is accessed. For read
|
mode, the file is temporarily opened to raise access errors
|
early, then closed until it is read again.
|
:param atomic: Write to a temporary file and replace the given file
|
on close.
|
|
.. versionadded:: 3.0
|
r\ )r$ Úcastru rt rC r rz )rF rG rH rI r rJ ÚfrN r r r Ú open_filec s $
|
ÿr z9t.Union[str, bytes, os.PathLike[str], os.PathLike[bytes]])rF Úshortenr c C sP |rt j | ¡} n
|
t | ¡} t| tr8| t ¡ d¡} n| dd¡ dd¡} | S )u» Format a filename as a string for display. Ensures the filename can be
|
displayed by replacing any invalid bytes or surrogate escapes in the name
|
with the replacement character ``�``.
|
|
Invalid bytes or surrogate escapes will raise an error when written to a
|
stream with ``errors="strict". This will typically happen with ``stdout``
|
when the locale is something like ``en_GB.UTF-8``.
|
|
Many scenarios *are* safe to write surrogates though, due to PEP 538 and
|
PEP 540, including:
|
|
- Writing to ``stderr``, which uses ``errors="backslashreplace"``.
|
- The system has ``LANG=C.UTF-8``, ``C``, or ``POSIX``. Python opens
|
stdout and stderr with ``errors="surrogateescape"``.
|
- None of ``LANG/LC_*`` are set. Python assumes ``LANG=C.UTF-8``.
|
- Python is started in UTF-8 mode with ``PYTHONUTF8=1`` or ``-X utf8``.
|
Python opens stdout and stderr with ``errors="surrogateescape"``.
|
|
:param filename: formats a filename for UI display. This will also convert
|
the filename into unicode without failing.
|
:param shorten: this optionally shortens the filename to strip of the
|
path that leads up to it.
|
r) r( Úsurrogateescape)
|
rK ÚpathÚbasenamerL r* r+ r, r- r. Úencode)rF r r r r rY s
|
|
ÿrY )Úapp_nameÚroamingÚ force_posixr c C s¤ t r>|r dnd}tj |¡}|dkr0tj d¡}tj || ¡S |r`tj tj dt| ¡¡S tj dkrtj tj d¡| ¡S tj tj dtj d ¡¡t| ¡S )
|
a Returns the config folder for the application. The default behavior
|
is to return whatever is most appropriate for the operating system.
|
|
To give you an idea, for an app called ``"Foo Bar"``, something like
|
the following folders could be returned:
|
|
Mac OS X:
|
``~/Library/Application Support/Foo Bar``
|
Mac OS X (POSIX):
|
``~/.foo-bar``
|
Unix:
|
``~/.config/foo-bar``
|
Unix (POSIX):
|
``~/.foo-bar``
|
Windows (roaming):
|
``C:\Users\<user>\AppData\Roaming\Foo Bar``
|
Windows (not roaming):
|
``C:\Users\<user>\AppData\Local\Foo Bar``
|
|
.. versionadded:: 2.0
|
|
:param app_name: the application name. This should be properly capitalized
|
and can contain whitespace.
|
:param roaming: controls if the folder should be roaming or not on Windows.
|
Has no effect otherwise.
|
:param force_posix: if this is set to `True` then on any POSIX system the
|
folder will be stored in the home folder with a leading
|
dot instead of the XDG config home or darwin's
|
application support folder.
|
ÚAPPDATAÚ LOCALAPPDATANú~z~/.Údarwinz ~/Library/Application SupportÚXDG_CONFIG_HOMEz ~/.config)
|
r rK Úenvironr r Ú
|
expanduserr r r- Úplatform)r r r ÚkeyÚfolderr r r Ú get_app_dir¾ s"
|
|
ÿþr¦ c @ sH e Zd ZdZejej ddddZddddZe ejd d
|
d Z
|
dS ) ÚPacifyFlushWrappera« This wrapper is used to catch and suppress BrokenPipeErrors resulting
|
from ``.flush()`` being called on broken pipe during the shutdown/final-GC
|
of the Python interpreter. Notably ``.flush()`` is always called on
|
``sys.stdout`` and ``sys.stderr``. So as to have minimal impact on any
|
other cleanup code, and the case where the underlying file is not a broken
|
pipe, all calls and attributes are proxied.
|
N)Úwrappedr c C s
|
|| _ d S r )r¨ )rQ r¨ r r r rR ø s zPacifyFlushWrapper.__init__rV c
|
C sL z| j ¡ W n8 tk
|
rF } zdd l}|j|jkr6 W 5 d }~X Y nX d S )Nr )r¨ r r_ ÚerrnoÚEPIPE)rQ rc r© r r r r û s zPacifyFlushWrapper.flush)Úattrr c C s t | j|S r )rS r¨ )rQ r« r r r rU s z PacifyFlushWrapper.__getattr__) rn ro rp rq r$ ru rt rR r r0 rU r r r r r§ ï s r§ )r Ú_mainr c C sº |dkrt jd }| s t jd } t|dddksbtjdkrn|jdkrntj | ¡sntj | d¡rntj | ¡S t
|
t |j¡}tj tj | ¡¡d }|dkrª| d | }d
|
| d ¡ S ) a: Determine the command used to run the program, for use in help
|
text. If a file or entry point was executed, the file name is
|
returned. If ``python -m`` was used to execute a module or package,
|
``python -m name`` is returned.
|
|
This doesn't try to be too precise, the goal is to give a concise
|
name for help text. Files are only shown as their name without the
|
path. ``python`` is only shown for modules, and the full path to
|
``sys.executable`` is not shown.
|
|
:param path: The Python file being executed. Python puts this in
|
``sys.argv[0]``, which is used by default.
|
:param _main: The ``__main__`` module. This should only be passed
|
during internal testing.
|
|
.. versionadded:: 8.0
|
Based on command args detection in the Werkzeug reloader.
|
|
:meta private:
|
NÚ__main__r Ú __package__> Nr6 Úntr6 z.exer8 z
|
python -m )r- ÚmodulesÚargvrS rK r r® r Úexistsr r$ r r0 ÚsplitextÚlstrip)r r¬ Z py_moduler r r r Ú_detect_program_name s&
|
|
ÿþ
|
ýü rµ )ÚuserÚenvÚglob_recursive)r r¶ r· r¸ r c C s ddl m } g }| D ]j}|r(tj |¡}|r8tj |¡}z|||d}W n tjk
|
rb g }Y nX |st| |¡ q| |¡ q|S )a Simulate Unix shell expansion with Python functions.
|
|
See :func:`glob.glob`, :func:`os.path.expanduser`, and
|
:func:`os.path.expandvars`.
|
|
This is intended for use on Windows, where the shell does not do any
|
expansion. It may not exactly match what a Unix shell would do.
|
|
:param args: List of command line arguments to expand.
|
:param user: Expand user home directory.
|
:param env: Expand environment variables.
|
:param glob_recursive: ``**`` matches directories recursively.
|
|
.. versionchanged:: 8.1
|
Invalid glob patterns are treated as empty expansions rather
|
than raising an error.
|
|
.. versionadded:: 8.0
|
|
:meta private:
|
r )Úglob)Ú recursive) r¹ rK r r¢ Ú
|
expandvarsÚreÚerrorÚappendÚextend)r r¶ r· r¸ r¹ r ÚargÚmatchesr r r Ú _expand_args? s
|
r )r2 )NNTFN)NrE )rD NrE FF)F)TF)NN)7rK r¼ r- Útypingr$ Ú functoolsr Útypesr r Ú_compatr r r r r
|
r r r r r Úglobalsr Ú TYPE_CHECKINGZtyping_extensionsÚteZ ParamSpecr ÚTypeVarr r0 r r& rt r1 ÚintrB rC rz r% ru rs r ÚBinaryIOr ÚTextIOr r rY r¦ r§ rµ ÚIterableÚListr r r r r Ú<module> s°
|
|
|
2X û
|
ú g ýü ú
|
ù 3 þý *1 ÿ þ :ûú
|
