Click-7.0/ 0000755 0001750 0001750 00000000000 13352517732 012615 5 ustar david david 0000000 0000000 Click-7.0/CHANGES.rst 0000644 0001750 0001750 00000066122 13352517662 014430 0 ustar david david 0000000 0000000 Click Changelog
===============
Version 7.0
-----------
Released 2018-09-25
- Drop support for Python 2.6 and 3.3. (`#967`_, `#976`_)
- Wrap ``click.Choice``'s missing message. (`#202`_, `#1000`_)
- Add native ZSH autocompletion support. (`#323`_, `#865`_)
- Document that ANSI color info isn't parsed from bytearrays in
Python 2. (`#334`_)
- Document byte-stripping behavior of ``CliRunner``. (`#334`_,
`#1010`_)
- Usage errors now hint at the ``--help`` option. (`#393`_, `#557`_)
- Implement streaming pager. (`#409`_, `#889`_)
- Extract bar formatting to its own method. (`#414`_)
- Add ``DateTime`` type for converting input in given date time
formats. (`#423`_)
- ``secho``'s first argument can now be ``None``, like in ``echo``.
(`#424`_)
- Fixes a ``ZeroDivisionError`` in ``ProgressBar.make_step``, when the
arg passed to the first call of ``ProgressBar.update`` is 0.
(`#447`_, `#1012`_)
- Show progressbar only if total execution time is visible. (`#487`_)
- Added the ability to hide commands and options from help. (`#500`_)
- Document that options can be ``required=True``. (`#514`_, `#1022`_)
- Non-standalone calls to ``Context.exit`` return the exit code,
rather than calling ``sys.exit``. (`#533`_, `#667`_, `#1098`_)
- ``click.getchar()`` returns Unicode in Python 3 on Windows,
consistent with other platforms. (`#537`_, `#821`_, `#822`_,
`#1088`_, `#1108`_)
- Added ``FloatRange`` type. (`#538`_, `#553`_)
- Added support for bash completion of ``type=click.Choice`` for
``Options`` and ``Arguments``. (`#535`_, `#681`_)
- Only allow one positional arg for ``Argument`` parameter
declaration. (`#568`_, `#574`_, `#1014`_)
- Add ``case_sensitive=False`` as an option to Choice. (`#569`_)
- ``click.getchar()`` correctly raises ``KeyboardInterrupt`` on "^C"
and ``EOFError`` on "^D" on Linux. (`#583`_, `#1115`_)
- Fix encoding issue with ``click.getchar(echo=True)`` on Linux.
(`#1115`_)
- ``param_hint`` in errors now derived from param itself. (`#598`_,
`#704`_, `#709`_)
- Add a test that ensures that when an argument is formatted into a
usage error, its metavar is used, not its name. (`#612`_)
- Allow setting ``prog_name`` as extra in ``CliRunner.invoke``.
(`#616`_, `#999`_)
- Help text taken from docstrings truncates at the ``\f`` form feed
character, useful for hiding Sphinx-style parameter documentation.
(`#629`_, `#1091`_)
- ``launch`` now works properly under Cygwin. (`#650`_)
- Update progress after iteration. (`#651`_, `#706`_)
- ``CliRunner.invoke`` now may receive ``args`` as a string
representing a Unix shell command. (`#664`_)
- Make ``Argument.make_metavar()`` default to type metavar. (`#675`_)
- Add documentation for ``ignore_unknown_options``. (`#684`_)
- Add bright colors support for ``click.style`` and fix the reset
option for parameters ``fg`` and ``bg``. (`#703`_, `#809`_)
- Add ``show_envvar`` for showing environment variables in help.
(`#710`_)
- Avoid ``BrokenPipeError`` during interpreter shutdown when stdout or
stderr is a closed pipe. (`#712`_, `#1106`_)
- Document customizing option names. (`#725`_, `#1016`_)
- Disable ``sys._getframes()`` on Python interpreters that don't
support it. (`#728`_)
- Fix bug in test runner when calling ``sys.exit`` with ``None``.
(`#739`_)
- Clarify documentation on command line options. (`#741`_, `#1003`_)
- Fix crash on Windows console. (`#744`_)
- Fix bug that caused bash completion to give improper completions on
chained commands. (`#754`_, `#774`_)
- Added support for dynamic bash completion from a user-supplied
callback. (`#755`_)
- Added support for bash completions containing spaces. (`#773`_)
- Allow autocompletion function to determine whether or not to return
completions that start with the incomplete argument. (`#790`_,
`#806`_)
- Fix option naming routine to match documentation and be
deterministic. (`#793`_, `#794`_)
- Fix path validation bug. (`#795`_, `#1020`_)
- Add test and documentation for ``Option`` naming: functionality.
(`#799`_)
- Update doc to match arg name for ``path_type``. (`#801`_)
- Raw strings added so correct escaping occurs. (`#807`_)
- Fix 16k character limit of ``click.echo`` on Windows. (`#816`_,
`#819`_)
- Overcome 64k character limit when writing to binary stream on
Windows 7. (`#825`_, `#830`_)
- Add bool conversion for "t" and "f". (`#842`_)
- ``NoSuchOption`` errors take ``ctx`` so that ``--help`` hint gets
printed in error output. (`#860`_)
- Fixed the behavior of Click error messages with regards to Unicode
on 2.x and 3.x. Message is now always Unicode and the str and
Unicode special methods work as you expect on that platform.
(`#862`_)
- Progress bar now uses stderr by default. (`#863`_)
- Add support for auto-completion documentation. (`#866`_, `#869`_)
- Allow ``CliRunner`` to separate stdout and stderr. (`#868`_)
- Fix variable precedence. (`#873`_, `#874`_)
- Fix invalid escape sequences. (`#877`_)
- Fix ``ResourceWarning`` that occurs during some tests. (`#878`_)
- When detecting a misconfigured locale, don't fail if the ``locale``
command fails. (`#880`_)
- Add ``case_sensitive=False`` as an option to ``Choice`` types.
(`#887`_)
- Force stdout/stderr writable. This works around issues with badly
patched standard streams like those from Jupyter. (`#918`_)
- Fix completion of subcommand options after last argument (`#919`_,
`#930`_)
- ``_AtomicFile`` now uses the ``realpath`` of the original filename
so that changing the working directory does not affect it.
(`#920`_)
- Fix incorrect completions when defaults are present (`#925`_,
`#930`_)
- Add copy option attrs so that custom classes can be re-used.
(`#926`_, `#994`_)
- "x" and "a" file modes now use stdout when file is ``"-"``.
(`#929`_)
- Fix missing comma in ``__all__`` list. (`#935`_)
- Clarify how parameters are named. (`#949`_, `#1009`_)
- Stdout is now automatically set to non blocking. (`#954`_)
- Do not set options twice. (`#962`_)
- Move ``fcntl`` import. (`#965`_)
- Fix Google App Engine ``ImportError``. (`#995`_)
- Better handling of help text for dynamic default option values.
(`#996`_)
- Fix ``get_winter_size()`` so it correctly returns ``(0,0)``.
(`#997`_)
- Add test case checking for custom param type. (`#1001`_)
- Allow short width to address cmd formatting. (`#1002`_)
- Add details about Python version support. (`#1004`_)
- Added deprecation flag to commands. (`#1005`_)
- Fixed issues where ``fd`` was undefined. (`#1007`_)
- Fix formatting for short help. (`#1008`_)
- Document how ``auto_envvar_prefix`` works with command groups.
(`#1011`_)
- Don't add newlines by default for progress bars. (`#1013`_)
- Use Python sorting order for ZSH completions. (`#1047`_, `#1059`_)
- Document that parameter names are converted to lowercase by default.
(`#1055`_)
- Subcommands that are named by the function now automatically have
the underscore replaced with a dash. If you register a function
named ``my_command`` it becomes ``my-command`` in the command line
interface.
- Hide hidden commands and options from completion. (`#1058`_,
`#1061`_)
- Fix absolute import blocking Click from being vendored into a
project on Windows. (`#1068`_, `#1069`_)
- Fix issue where a lowercase ``auto_envvar_prefix`` would not be
converted to uppercase. (`#1105`_)
.. _#202: https://github.com/pallets/click/issues/202
.. _#323: https://github.com/pallets/click/issues/323
.. _#334: https://github.com/pallets/click/issues/334
.. _#393: https://github.com/pallets/click/issues/393
.. _#409: https://github.com/pallets/click/issues/409
.. _#414: https://github.com/pallets/click/pull/414
.. _#423: https://github.com/pallets/click/pull/423
.. _#424: https://github.com/pallets/click/pull/424
.. _#447: https://github.com/pallets/click/issues/447
.. _#487: https://github.com/pallets/click/pull/487
.. _#500: https://github.com/pallets/click/pull/500
.. _#514: https://github.com/pallets/click/issues/514
.. _#533: https://github.com/pallets/click/pull/533
.. _#535: https://github.com/pallets/click/issues/535
.. _#537: https://github.com/pallets/click/issues/537
.. _#538: https://github.com/pallets/click/pull/538
.. _#553: https://github.com/pallets/click/pull/553
.. _#557: https://github.com/pallets/click/pull/557
.. _#568: https://github.com/pallets/click/issues/568
.. _#569: https://github.com/pallets/click/issues/569
.. _#574: https://github.com/pallets/click/issues/574
.. _#583: https://github.com/pallets/click/issues/583
.. _#598: https://github.com/pallets/click/issues/598
.. _#612: https://github.com/pallets/click/pull/612
.. _#616: https://github.com/pallets/click/issues/616
.. _#629: https://github.com/pallets/click/pull/629
.. _#650: https://github.com/pallets/click/pull/650
.. _#651: https://github.com/pallets/click/issues/651
.. _#664: https://github.com/pallets/click/pull/664
.. _#667: https://github.com/pallets/click/issues/667
.. _#675: https://github.com/pallets/click/pull/675
.. _#681: https://github.com/pallets/click/pull/681
.. _#684: https://github.com/pallets/click/pull/684
.. _#703: https://github.com/pallets/click/issues/703
.. _#704: https://github.com/pallets/click/issues/704
.. _#706: https://github.com/pallets/click/pull/706
.. _#709: https://github.com/pallets/click/pull/709
.. _#710: https://github.com/pallets/click/pull/710
.. _#712: https://github.com/pallets/click/pull/712
.. _#719: https://github.com/pallets/click/issues/719
.. _#725: https://github.com/pallets/click/issues/725
.. _#728: https://github.com/pallets/click/pull/728
.. _#739: https://github.com/pallets/click/pull/739
.. _#741: https://github.com/pallets/click/issues/741
.. _#744: https://github.com/pallets/click/issues/744
.. _#754: https://github.com/pallets/click/issues/754
.. _#755: https://github.com/pallets/click/pull/755
.. _#773: https://github.com/pallets/click/pull/773
.. _#774: https://github.com/pallets/click/pull/774
.. _#790: https://github.com/pallets/click/issues/790
.. _#793: https://github.com/pallets/click/issues/793
.. _#794: https://github.com/pallets/click/pull/794
.. _#795: https://github.com/pallets/click/issues/795
.. _#799: https://github.com/pallets/click/pull/799
.. _#801: https://github.com/pallets/click/pull/801
.. _#806: https://github.com/pallets/click/pull/806
.. _#807: https://github.com/pallets/click/pull/807
.. _#809: https://github.com/pallets/click/pull/809
.. _#816: https://github.com/pallets/click/pull/816
.. _#819: https://github.com/pallets/click/pull/819
.. _#821: https://github.com/pallets/click/issues/821
.. _#822: https://github.com/pallets/click/issues/822
.. _#825: https://github.com/pallets/click/issues/825
.. _#830: https://github.com/pallets/click/pull/830
.. _#842: https://github.com/pallets/click/pull/842
.. _#860: https://github.com/pallets/click/issues/860
.. _#862: https://github.com/pallets/click/issues/862
.. _#863: https://github.com/pallets/click/pull/863
.. _#865: https://github.com/pallets/click/pull/865
.. _#866: https://github.com/pallets/click/issues/866
.. _#868: https://github.com/pallets/click/pull/868
.. _#869: https://github.com/pallets/click/pull/869
.. _#873: https://github.com/pallets/click/issues/873
.. _#874: https://github.com/pallets/click/pull/874
.. _#877: https://github.com/pallets/click/pull/877
.. _#878: https://github.com/pallets/click/pull/878
.. _#880: https://github.com/pallets/click/pull/880
.. _#883: https://github.com/pallets/click/pull/883
.. _#887: https://github.com/pallets/click/pull/887
.. _#889: https://github.com/pallets/click/pull/889
.. _#918: https://github.com/pallets/click/pull/918
.. _#919: https://github.com/pallets/click/issues/919
.. _#920: https://github.com/pallets/click/pull/920
.. _#925: https://github.com/pallets/click/issues/925
.. _#926: https://github.com/pallets/click/issues/926
.. _#929: https://github.com/pallets/click/pull/929
.. _#930: https://github.com/pallets/click/pull/930
.. _#935: https://github.com/pallets/click/pull/935
.. _#949: https://github.com/pallets/click/issues/949
.. _#954: https://github.com/pallets/click/pull/954
.. _#962: https://github.com/pallets/click/pull/962
.. _#965: https://github.com/pallets/click/pull/965
.. _#967: https://github.com/pallets/click/pull/967
.. _#976: https://github.com/pallets/click/pull/976
.. _#990: https://github.com/pallets/click/pull/990
.. _#991: https://github.com/pallets/click/pull/991
.. _#993: https://github.com/pallets/click/pull/993
.. _#994: https://github.com/pallets/click/pull/994
.. _#995: https://github.com/pallets/click/pull/995
.. _#996: https://github.com/pallets/click/pull/996
.. _#997: https://github.com/pallets/click/pull/997
.. _#999: https://github.com/pallets/click/pull/999
.. _#1000: https://github.com/pallets/click/pull/1000
.. _#1001: https://github.com/pallets/click/pull/1001
.. _#1002: https://github.com/pallets/click/pull/1002
.. _#1003: https://github.com/pallets/click/pull/1003
.. _#1004: https://github.com/pallets/click/pull/1004
.. _#1005: https://github.com/pallets/click/pull/1005
.. _#1007: https://github.com/pallets/click/pull/1007
.. _#1008: https://github.com/pallets/click/pull/1008
.. _#1009: https://github.com/pallets/click/pull/1009
.. _#1010: https://github.com/pallets/click/pull/1010
.. _#1011: https://github.com/pallets/click/pull/1011
.. _#1012: https://github.com/pallets/click/pull/1012
.. _#1013: https://github.com/pallets/click/pull/1013
.. _#1014: https://github.com/pallets/click/pull/1014
.. _#1016: https://github.com/pallets/click/pull/1016
.. _#1020: https://github.com/pallets/click/pull/1020
.. _#1022: https://github.com/pallets/click/pull/1022
.. _#1027: https://github.com/pallets/click/pull/1027
.. _#1047: https://github.com/pallets/click/pull/1047
.. _#1055: https://github.com/pallets/click/pull/1055
.. _#1058: https://github.com/pallets/click/pull/1058
.. _#1059: https://github.com/pallets/click/pull/1059
.. _#1061: https://github.com/pallets/click/pull/1061
.. _#1068: https://github.com/pallets/click/issues/1068
.. _#1069: https://github.com/pallets/click/pull/1069
.. _#1088: https://github.com/pallets/click/issues/1088
.. _#1091: https://github.com/pallets/click/pull/1091
.. _#1098: https://github.com/pallets/click/pull/1098
.. _#1105: https://github.com/pallets/click/pull/1105
.. _#1106: https://github.com/pallets/click/pull/1106
.. _#1108: https://github.com/pallets/click/pull/1108
.. _#1115: https://github.com/pallets/click/pull/1115
Version 6.7
-----------
(bugfix release; released on January 6th 2017)
- Make ``click.progressbar`` work with ``codecs.open`` files. See #637.
- Fix bug in bash completion with nested subcommands. See #639.
- Fix test runner not saving caller env correctly. See #644.
- Fix handling of SIGPIPE. See #626
- Deal with broken Windows environments such as Google App Engine's. See #711.
Version 6.6
-----------
(bugfix release; released on April 4th 2016)
- Fix bug in ``click.Path`` where it would crash when passed a ``-``. See #551.
Version 6.4
-----------
(bugfix release; released on March 24th 2016)
- Fix bug in bash completion where click would discard one or more trailing
arguments. See #471.
Version 6.3
-----------
(bugfix release; released on February 22 2016)
- Fix argument checks for interpreter invoke with ``-m`` and ``-c``
on Windows.
- Fixed a bug that cased locale detection to error out on Python 3.
Version 6.2
-----------
(bugfix release, released on November 27th 2015)
- Correct fix for hidden progress bars.
Version 6.1
-----------
(bugfix release, released on November 27th 2015)
- Resolved an issue with invisible progress bars no longer rendering.
- Disable chain commands with subcommands as they were inherently broken.
- Fix ``MissingParameter`` not working without parameters passed.
Version 6.0
-----------
(codename "pow pow", released on November 24th 2015)
- Optimized the progressbar rendering to not render when it did not
actually change.
- Explicitly disallow ``nargs=-1`` with a set default.
- The context is now closed before it's popped from the stack.
- Added support for short aliases for the false flag on toggles.
- Click will now attempt to aid you with debugging locale errors
better by listing with the help of the OS what locales are
available.
- Click used to return byte strings on Python 2 in some unit-testing
situations. This has been fixed to correctly return unicode strings
now.
- For Windows users on Python 2, Click will now handle Unicode more
correctly handle Unicode coming in from the system. This also has
the disappointing side effect that filenames will now be always
unicode by default in the ``Path`` type which means that this can
introduce small bugs for code not aware of this.
- Added a ``type`` parameter to ``Path`` to force a specific string type
on the value.
- For users running Python on Windows the ``echo`` and ``prompt`` functions
now work with full unicode functionality in the Python windows console
by emulating an output stream. This also applies to getting the
virtual output and input streams via ``click.get_text_stream(...)``.
- Unittests now always force a certain virtual terminal width.
- Added support for allowing dashes to indicate standard streams to the
``Path`` type.
- Multi commands in chain mode no longer propagate arguments left over
from parsing to the callbacks. It's also now disallowed through an
exception when optional arguments are attached to multi commands if chain
mode is enabled.
- Relaxed restriction that disallowed chained commands to have other
chained commands as child commands.
- Arguments with positive nargs can now have defaults implemented.
Previously this configuration would often result in slightly unexpected
values be returned.
Version 5.1
-----------
(bugfix release, released on 17th August 2015)
- Fix a bug in ``pass_obj`` that would accidentally pass the context too.
Version 5.0
-----------
(codename "tok tok", released on 16th August 2015)
- Removed various deprecated functionality.
- Atomic files now only accept the ``w`` mode.
- Change the usage part of help output for very long commands to wrap
their arguments onto the next line, indented by 4 spaces.
- Fix a bug where return code and error messages were incorrect when
using ``CliRunner``.
- added ``get_current_context``.
- added a ``meta`` dictionary to the context which is shared across the
linked list of contexts to allow click utilities to place state there.
- introduced ``Context.scope``.
- The ``echo`` function is now threadsafe: It calls the ``write`` method of the
underlying object only once.
- ``prompt(hide_input=True)`` now prints a newline on ``^C``.
- Click will now warn if users are using ``unicode_literals``.
- Click will now ignore the ``PAGER`` environment variable if it is empty or
contains only whitespace.
- The ``click-contrib`` GitHub organization was created.
Version 4.1
-----------
(bugfix release, released on July 14th 2015)
- Fix a bug where error messages would include a trailing ``None`` string.
- Fix a bug where Click would crash on docstrings with trailing newlines.
- Support streams with encoding set to ``None`` on Python 3 by barfing with
a better error.
- Handle ^C in less-pager properly.
- Handle return value of ``None`` from ``sys.getfilesystemencoding``
- Fix crash when writing to unicode files with ``click.echo``.
- Fix type inference with multiple options.
Version 4.0
-----------
(codename "zoom zoom", released on March 31st 2015)
- Added ``color`` parameters to lots of interfaces that directly or indirectly
call into echoing. This previously was always autodetection (with the
exception of the ``echo_via_pager`` function). Now you can forcefully
enable or disable it, overriding the auto detection of Click.
- Added an ``UNPROCESSED`` type which does not perform any type changes which
simplifies text handling on 2.x / 3.x in some special advanced usecases.
- Added ``NoSuchOption`` and ``BadOptionUsage`` exceptions for more generic
handling of errors.
- Added support for handling of unprocessed options which can be useful in
situations where arguments are forwarded to underlying tools.
- Added ``max_content_width`` parameter to the context which can be used to
change the maximum width of help output. By default Click will not format
content for more than 80 characters width.
- Added support for writing prompts to stderr.
- Fix a bug when showing the default for multiple arguments.
- Added support for custom subclasses to ``option`` and ``argument``.
- Fix bug in ``clear()`` on Windows when colorama is installed.
- Reject ``nargs=-1`` for options properly. Options cannot be variadic.
- Fixed an issue with bash completion not working properly for commands with
non ASCII characters or dashes.
- Added a way to manually update the progressbar.
- Changed the formatting of missing arguments. Previously the internal
argument name was shown in error messages, now the metavar is shown if
passed. In case an automated metavar is selected, it's stripped of
extra formatting first.
Version 3.3
-----------
(bugfix release, released on September 8th 2014)
- Fixed an issue with error reporting on Python 3 for invalid forwarding
of commands.
Version 3.2
-----------
(bugfix release, released on August 22nd 2014)
- Added missing ``err`` parameter forwarding to the ``secho`` function.
- Fixed default parameters not being handled properly by the context
invoke method. This is a backwards incompatible change if the function
was used improperly. See :ref:`upgrade-to-3.2` for more information.
- Removed the `invoked_subcommands` attribute largely. It is not possible
to provide it to work error free due to how the parsing works so this
API has been deprecated. See :ref:`upgrade-to-3.2` for more information.
- Restored the functionality of `invoked_subcommand` which was broken as
a regression in 3.1.
Version 3.1
-----------
(bugfix release, released on August 13th 2014)
- Fixed a regression that caused contexts of subcommands to be
created before the parent command was invoked which was a
regression from earlier Click versions.
Version 3.0
-----------
(codename "clonk clonk", released on August 12th 2014)
- formatter now no longer attempts to accomodate for terminals
smaller than 50 characters. If that happens it just assumes
a minimal width.
- added a way to not swallow exceptions in the test system.
- added better support for colors with pagers and ways to
override the autodetection.
- the CLI runner's result object now has a traceback attached.
- improved automatic short help detection to work better with
dots that do not terminate sentences.
- when definining options without actual valid option strings
now, Click will give an error message instead of silently
passing. This should catch situations where users wanted to
created arguments instead of options.
- Restructured Click internally to support vendoring.
- Added support for multi command chaining.
- Added support for defaults on options with ``multiple`` and
options and arguments with ``nargs != 1``.
- label passed to ``progressbar`` is no longer rendered with
whitespace stripped.
- added a way to disable the standalone mode of the ``main``
method on a Click command to be able to handle errors better.
- added support for returning values from command callbacks.
- added simplifications for printing to stderr from ``echo``.
- added result callbacks for groups.
- entering a context multiple times defers the cleanup until
the last exit occurs.
- added ``open_file``.
Version 2.6
-----------
(bugfix release, released on August 11th 2014)
- Fixed an issue where the wrapped streams on Python 3 would be reporting
incorrect values for seekable.
Version 2.5
-----------
(bugfix release, released on July 28th 2014)
- Fixed a bug with text wrapping on Python 3.
Version 2.4
-----------
(bugfix release, released on July 4th 2014)
- Corrected a bug in the change of the help option in 2.3.
Version 2.3
-----------
(bugfix release, released on July 3rd 2014)
- Fixed an incorrectly formatted help record for count options.
- Add support for ansi code stripping on Windows if colorama
is not available.
- restored the Click 1.0 handling of the help parameter for certain
edge cases.
Version 2.2
-----------
(bugfix release, released on June 26th 2014)
- fixed tty detection on PyPy.
- fixed an issue that progress bars were not rendered when the
context manager was entered.
Version 2.1
-----------
(bugfix release, released on June 14th 2014)
- fixed the :func:`launch` function on windows.
- improved the colorama support on windows to try hard to not
screw up the console if the application is interrupted.
- fixed windows terminals incorrectly being reported to be 80
characters wide instead of 79
- use colorama win32 bindings if available to get the correct
dimensions of a windows terminal.
- fixed an issue with custom function types on Python 3.
- fixed an issue with unknown options being incorrectly reported
in error messages.
Version 2.0
-----------
(codename "tap tap tap", released on June 6th 2014)
- added support for opening stdin/stdout on Windows in
binary mode correctly.
- added support for atomic writes to files by going through
a temporary file.
- introduced :exc:`BadParameter` which can be used to easily perform
custom validation with the same error messages as in the type system.
- added :func:`progressbar`; a function to show progress bars.
- added :func:`get_app_dir`; a function to calculate the home folder
for configs.
- Added transparent handling for ANSI codes into the :func:`echo`
function through ``colorama``.
- Added :func:`clear` function.
- Breaking change: parameter callbacks now get the parameter object
passed as second argument. There is legacy support for old callbacks
which will warn but still execute the script.
- Added :func:`style`, :func:`unstyle` and :func:`secho` for ANSI
styles.
- Added an :func:`edit` function that invokes the default editor.
- Added an :func:`launch` function that launches browsers and applications.
- nargs of -1 for arguments can now be forced to be a single item through
the required flag. It defaults to not required.
- setting a default for arguments now implicitly makes it non required.
- changed "yN" / "Yn" to "y/N" and "Y/n" in confirmation prompts.
- added basic support for bash completion.
- added :func:`getchar` to fetch a single character from the terminal.
- errors now go to stderr as intended.
- fixed various issues with more exotic parameter formats like DOS/Windows
style arguments.
- added :func:`pause` which works similar to the Windows ``pause`` cmd
built-in but becomes an automatic noop if the application is not run
through a terminal.
- added a bit of extra information about missing choice parameters.
- changed how the help function is implemented to allow global overriding
of the help option.
- added support for token normalization to implement case insensitive handling.
- added support for providing defaults for context settings.
Version 1.1
-----------
(bugfix release, released on May 23rd 2014)
- fixed a bug that caused text files in Python 2 to not accept
native strings.
Version 1.0
-----------
(no codename, released on May 21st 2014)
- Initial release.
Click-7.0/CONTRIBUTING.rst 0000644 0001750 0001750 00000003555 13352517227 015265 0 ustar david david 0000000 0000000 ==========================
How to contribute to Click
==========================
Thanks for considering contributing to Click.
Support questions
=================
Please, don't use the issue tracker for this. Check whether the
``#pocoo`` IRC channel on Freenode can help with your issue. If your problem
is not strictly Click-specific, ``#python`` on Freenode is generally more
active. `StackOverflow `_ is also worth
considering.
Reporting issues
================
- Under which versions of Python does this happen? This is even more important
if your issue is encoding related.
- Under which versions of Click does this happen? Check if this issue is fixed
in the repository.
Submitting patches
==================
- Include tests if your patch is supposed to solve a bug, and explain clearly
under which circumstances the bug happens. Make sure the test fails without
your patch.
- Try to follow `PEP8 `_, but you
may ignore the line-length-limit if following it would make the code uglier.
- For features: Consider whether your feature would be a better fit for an
`external package `_
- For docs and bug fixes: Submit against the latest maintenance branch instead of master!
Running the testsuite
---------------------
You probably want to set up a `virtualenv
`_.
The minimal requirement for running the testsuite is ``py.test``. You can
install it with::
pip install pytest
Then you can run the testsuite with::
py.test
For a more isolated test environment, you can also install ``tox`` instead of
``pytest``. You can install it with::
pip install tox
The ``tox`` command will then run all tests against multiple combinations of
Python versions and dependency versions.
Click-7.0/Click.egg-info/ 0000755 0001750 0001750 00000000000 13352517732 015334 5 ustar david david 0000000 0000000 Click-7.0/Click.egg-info/PKG-INFO 0000644 0001750 0001750 00000010247 13352517732 016435 0 ustar david david 0000000 0000000 Metadata-Version: 1.2
Name: Click
Version: 7.0
Summary: Composable command line interface toolkit
Home-page: https://palletsprojects.com/p/click/
Author: Armin Ronacher
Author-email: armin.ronacher@active-4.com
Maintainer: Pallets Team
Maintainer-email: contact@palletsprojects.com
License: BSD
Project-URL: Documentation, https://click.palletsprojects.com/
Project-URL: Code, https://github.com/pallets/click
Project-URL: Issue tracker, https://github.com/pallets/click/issues
Description: \$ click\_
==========
Click is a Python package for creating beautiful command line interfaces
in a composable way with as little code as necessary. It's the "Command
Line Interface Creation Kit". It's highly configurable but comes with
sensible defaults out of the box.
It aims to make the process of writing command line tools quick and fun
while also preventing any frustration caused by the inability to
implement an intended CLI API.
Click in three points:
- Arbitrary nesting of commands
- Automatic help page generation
- Supports lazy loading of subcommands at runtime
Installing
----------
Install and update using `pip`_:
.. code-block:: text
$ pip install click
Click supports Python 3.4 and newer, Python 2.7, and PyPy.
.. _pip: https://pip.pypa.io/en/stable/quickstart/
A Simple Example
----------------
What does it look like? Here is an example of a simple Click program:
.. code-block:: python
import click
@click.command()
@click.option("--count", default=1, help="Number of greetings.")
@click.option("--name", prompt="Your name",
help="The person to greet.")
def hello(count, name):
"""Simple program that greets NAME for a total of COUNT times."""
for _ in range(count):
click.echo("Hello, %s!" % name)
if __name__ == '__main__':
hello()
And what it looks like when run:
.. code-block:: text
$ python hello.py --count=3
Your name: Click
Hello, Click!
Hello, Click!
Hello, Click!
Donate
------
The Pallets organization develops and supports Click and other popular
packages. In order to grow the community of contributors and users, and
allow the maintainers to devote more time to the projects, `please
donate today`_.
.. _please donate today: https://palletsprojects.com/donate
Links
-----
* Website: https://palletsprojects.com/p/click/
* Documentation: https://click.palletsprojects.com/
* License: `BSD `_
* Releases: https://pypi.org/project/click/
* Code: https://github.com/pallets/click
* Issue tracker: https://github.com/pallets/click/issues
* Test status:
* Linux, Mac: https://travis-ci.org/pallets/click
* Windows: https://ci.appveyor.com/project/pallets/click
* Test coverage: https://codecov.io/gh/pallets/click
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: BSD License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
Click-7.0/Click.egg-info/SOURCES.txt 0000644 0001750 0001750 00000005012 13352517732 017216 0 ustar david david 0000000 0000000 CHANGES.rst
CONTRIBUTING.rst
LICENSE.rst
MANIFEST.in
README.rst
setup.cfg
setup.py
tox.ini
Click.egg-info/PKG-INFO
Click.egg-info/SOURCES.txt
Click.egg-info/dependency_links.txt
Click.egg-info/top_level.txt
artwork/logo.svg
click/__init__.py
click/_bashcomplete.py
click/_compat.py
click/_termui_impl.py
click/_textwrap.py
click/_unicodefun.py
click/_winconsole.py
click/core.py
click/decorators.py
click/exceptions.py
click/formatting.py
click/globals.py
click/parser.py
click/termui.py
click/testing.py
click/types.py
click/utils.py
docs/Makefile
docs/advanced.rst
docs/api.rst
docs/arguments.rst
docs/bashcomplete.rst
docs/changelog.rst
docs/commands.rst
docs/complex.rst
docs/conf.py
docs/contrib.rst
docs/documentation.rst
docs/exceptions.rst
docs/index.rst
docs/license.rst
docs/make.bat
docs/options.rst
docs/parameters.rst
docs/prompts.rst
docs/python3.rst
docs/quickstart.rst
docs/requirements.txt
docs/setuptools.rst
docs/testing.rst
docs/upgrading.rst
docs/utils.rst
docs/why.rst
docs/wincmd.rst
docs/_static/click-icon.png
docs/_static/click-logo-sidebar.png
docs/_static/click-logo.png
examples/README
examples/aliases/README
examples/aliases/aliases.ini
examples/aliases/aliases.py
examples/aliases/setup.py
examples/bashcompletion/README
examples/bashcompletion/bashcompletion.py
examples/bashcompletion/setup.py
examples/colors/README
examples/colors/colors.py
examples/colors/setup.py
examples/complex/README
examples/complex/setup.py
examples/complex/complex/__init__.py
examples/complex/complex/cli.py
examples/complex/complex/commands/__init__.py
examples/complex/complex/commands/cmd_init.py
examples/complex/complex/commands/cmd_status.py
examples/imagepipe/.gitignore
examples/imagepipe/README
examples/imagepipe/example01.jpg
examples/imagepipe/example02.jpg
examples/imagepipe/imagepipe.py
examples/imagepipe/setup.py
examples/inout/README
examples/inout/inout.py
examples/inout/setup.py
examples/naval/README
examples/naval/naval.py
examples/naval/setup.py
examples/repo/README
examples/repo/repo.py
examples/repo/setup.py
examples/termui/README
examples/termui/setup.py
examples/termui/termui.py
examples/validation/README
examples/validation/setup.py
examples/validation/validation.py
tests/conftest.py
tests/test_arguments.py
tests/test_bashcomplete.py
tests/test_basic.py
tests/test_chain.py
tests/test_commands.py
tests/test_compat.py
tests/test_context.py
tests/test_defaults.py
tests/test_formatting.py
tests/test_imports.py
tests/test_normalization.py
tests/test_options.py
tests/test_termui.py
tests/test_testing.py
tests/test_utils.py Click-7.0/Click.egg-info/dependency_links.txt 0000644 0001750 0001750 00000000001 13352517732 021402 0 ustar david david 0000000 0000000
Click-7.0/Click.egg-info/top_level.txt 0000644 0001750 0001750 00000000006 13352517732 020062 0 ustar david david 0000000 0000000 click
Click-7.0/LICENSE.rst 0000644 0001750 0001750 00000003524 13352433170 014426 0 ustar david david 0000000 0000000 Copyright © 2014 by the Pallets team.
Some rights reserved.
Redistribution and use in source and binary forms of the software as
well as documentation, with or without modification, are permitted
provided that the following conditions are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE COPYRIGHT HOLDERS AND
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE AND DOCUMENTATION, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
----
Click uses parts of optparse written by Gregory P. Ward and maintained
by the Python Software Foundation. This is limited to code in parser.py.
Copyright © 2001-2006 Gregory P. Ward. All rights reserved.
Copyright © 2002-2006 Python Software Foundation. All rights reserved.
Click-7.0/MANIFEST.in 0000644 0001750 0001750 00000000314 13352433170 014342 0 ustar david david 0000000 0000000 include CHANGES.rst
include CONTRIBUTING.rst
include LICENSE.rst
include README.rst
include tox.ini
graft artwork
graft docs
prune docs/_build
graft examples
graft tests
global-exclude *.py[co] .DS_Store
Click-7.0/PKG-INFO 0000644 0001750 0001750 00000010247 13352517732 013716 0 ustar david david 0000000 0000000 Metadata-Version: 1.2
Name: Click
Version: 7.0
Summary: Composable command line interface toolkit
Home-page: https://palletsprojects.com/p/click/
Author: Armin Ronacher
Author-email: armin.ronacher@active-4.com
Maintainer: Pallets Team
Maintainer-email: contact@palletsprojects.com
License: BSD
Project-URL: Documentation, https://click.palletsprojects.com/
Project-URL: Code, https://github.com/pallets/click
Project-URL: Issue tracker, https://github.com/pallets/click/issues
Description: \$ click\_
==========
Click is a Python package for creating beautiful command line interfaces
in a composable way with as little code as necessary. It's the "Command
Line Interface Creation Kit". It's highly configurable but comes with
sensible defaults out of the box.
It aims to make the process of writing command line tools quick and fun
while also preventing any frustration caused by the inability to
implement an intended CLI API.
Click in three points:
- Arbitrary nesting of commands
- Automatic help page generation
- Supports lazy loading of subcommands at runtime
Installing
----------
Install and update using `pip`_:
.. code-block:: text
$ pip install click
Click supports Python 3.4 and newer, Python 2.7, and PyPy.
.. _pip: https://pip.pypa.io/en/stable/quickstart/
A Simple Example
----------------
What does it look like? Here is an example of a simple Click program:
.. code-block:: python
import click
@click.command()
@click.option("--count", default=1, help="Number of greetings.")
@click.option("--name", prompt="Your name",
help="The person to greet.")
def hello(count, name):
"""Simple program that greets NAME for a total of COUNT times."""
for _ in range(count):
click.echo("Hello, %s!" % name)
if __name__ == '__main__':
hello()
And what it looks like when run:
.. code-block:: text
$ python hello.py --count=3
Your name: Click
Hello, Click!
Hello, Click!
Hello, Click!
Donate
------
The Pallets organization develops and supports Click and other popular
packages. In order to grow the community of contributors and users, and
allow the maintainers to devote more time to the projects, `please
donate today`_.
.. _please donate today: https://palletsprojects.com/donate
Links
-----
* Website: https://palletsprojects.com/p/click/
* Documentation: https://click.palletsprojects.com/
* License: `BSD `_
* Releases: https://pypi.org/project/click/
* Code: https://github.com/pallets/click
* Issue tracker: https://github.com/pallets/click/issues
* Test status:
* Linux, Mac: https://travis-ci.org/pallets/click
* Windows: https://ci.appveyor.com/project/pallets/click
* Test coverage: https://codecov.io/gh/pallets/click
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: BSD License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
Click-7.0/README.rst 0000644 0001750 0001750 00000004513 13352433170 014300 0 ustar david david 0000000 0000000 \$ click\_
==========
Click is a Python package for creating beautiful command line interfaces
in a composable way with as little code as necessary. It's the "Command
Line Interface Creation Kit". It's highly configurable but comes with
sensible defaults out of the box.
It aims to make the process of writing command line tools quick and fun
while also preventing any frustration caused by the inability to
implement an intended CLI API.
Click in three points:
- Arbitrary nesting of commands
- Automatic help page generation
- Supports lazy loading of subcommands at runtime
Installing
----------
Install and update using `pip`_:
.. code-block:: text
$ pip install click
Click supports Python 3.4 and newer, Python 2.7, and PyPy.
.. _pip: https://pip.pypa.io/en/stable/quickstart/
A Simple Example
----------------
What does it look like? Here is an example of a simple Click program:
.. code-block:: python
import click
@click.command()
@click.option("--count", default=1, help="Number of greetings.")
@click.option("--name", prompt="Your name",
help="The person to greet.")
def hello(count, name):
"""Simple program that greets NAME for a total of COUNT times."""
for _ in range(count):
click.echo("Hello, %s!" % name)
if __name__ == '__main__':
hello()
And what it looks like when run:
.. code-block:: text
$ python hello.py --count=3
Your name: Click
Hello, Click!
Hello, Click!
Hello, Click!
Donate
------
The Pallets organization develops and supports Click and other popular
packages. In order to grow the community of contributors and users, and
allow the maintainers to devote more time to the projects, `please
donate today`_.
.. _please donate today: https://palletsprojects.com/donate
Links
-----
* Website: https://palletsprojects.com/p/click/
* Documentation: https://click.palletsprojects.com/
* License: `BSD `_
* Releases: https://pypi.org/project/click/
* Code: https://github.com/pallets/click
* Issue tracker: https://github.com/pallets/click/issues
* Test status:
* Linux, Mac: https://travis-ci.org/pallets/click
* Windows: https://ci.appveyor.com/project/pallets/click
* Test coverage: https://codecov.io/gh/pallets/click
Click-7.0/artwork/ 0000755 0001750 0001750 00000000000 13352517732 014306 5 ustar david david 0000000 0000000 Click-7.0/artwork/logo.svg 0000644 0001750 0001750 00000021001 13143622635 015756 0 ustar david david 0000000 0000000
Click-7.0/click/ 0000755 0001750 0001750 00000000000 13352517732 013702 5 ustar david david 0000000 0000000 Click-7.0/click/__init__.py 0000644 0001750 0001750 00000005345 13352517662 016024 0 ustar david david 0000000 0000000 # -*- coding: utf-8 -*-
"""
click
~~~~~
Click is a simple Python module inspired by the stdlib optparse to make
writing command line scripts fun. Unlike other modules, it's based
around a simple API that does not come with too much magic and is
composable.
:copyright: © 2014 by the Pallets team.
:license: BSD, see LICENSE.rst for more details.
"""
# Core classes
from .core import Context, BaseCommand, Command, MultiCommand, Group, \
CommandCollection, Parameter, Option, Argument
# Globals
from .globals import get_current_context
# Decorators
from .decorators import pass_context, pass_obj, make_pass_decorator, \
command, group, argument, option, confirmation_option, \
password_option, version_option, help_option
# Types
from .types import ParamType, File, Path, Choice, IntRange, Tuple, \
DateTime, STRING, INT, FLOAT, BOOL, UUID, UNPROCESSED, FloatRange
# Utilities
from .utils import echo, get_binary_stream, get_text_stream, open_file, \
format_filename, get_app_dir, get_os_args
# Terminal functions
from .termui import prompt, confirm, get_terminal_size, echo_via_pager, \
progressbar, clear, style, unstyle, secho, edit, launch, getchar, \
pause
# Exceptions
from .exceptions import ClickException, UsageError, BadParameter, \
FileError, Abort, NoSuchOption, BadOptionUsage, BadArgumentUsage, \
MissingParameter
# Formatting
from .formatting import HelpFormatter, wrap_text
# Parsing
from .parser import OptionParser
__all__ = [
# Core classes
'Context', 'BaseCommand', 'Command', 'MultiCommand', 'Group',
'CommandCollection', 'Parameter', 'Option', 'Argument',
# Globals
'get_current_context',
# Decorators
'pass_context', 'pass_obj', 'make_pass_decorator', 'command', 'group',
'argument', 'option', 'confirmation_option', 'password_option',
'version_option', 'help_option',
# Types
'ParamType', 'File', 'Path', 'Choice', 'IntRange', 'Tuple',
'DateTime', 'STRING', 'INT', 'FLOAT', 'BOOL', 'UUID', 'UNPROCESSED',
'FloatRange',
# Utilities
'echo', 'get_binary_stream', 'get_text_stream', 'open_file',
'format_filename', 'get_app_dir', 'get_os_args',
# Terminal functions
'prompt', 'confirm', 'get_terminal_size', 'echo_via_pager',
'progressbar', 'clear', 'style', 'unstyle', 'secho', 'edit', 'launch',
'getchar', 'pause',
# Exceptions
'ClickException', 'UsageError', 'BadParameter', 'FileError',
'Abort', 'NoSuchOption', 'BadOptionUsage', 'BadArgumentUsage',
'MissingParameter',
# Formatting
'HelpFormatter', 'wrap_text',
# Parsing
'OptionParser',
]
# Controls if click should emit the warning about the use of unicode
# literals.
disable_unicode_literals_warning = False
__version__ = '7.0'
Click-7.0/click/_bashcomplete.py 0000644 0001750 0001750 00000025406 13352433170 017061 0 ustar david david 0000000 0000000 import copy
import os
import re
from .utils import echo
from .parser import split_arg_string
from .core import MultiCommand, Option, Argument
from .types import Choice
try:
from collections import abc
except ImportError:
import collections as abc
WORDBREAK = '='
# Note, only BASH version 4.4 and later have the nosort option.
COMPLETION_SCRIPT_BASH = '''
%(complete_func)s() {
local IFS=$'\n'
COMPREPLY=( $( env COMP_WORDS="${COMP_WORDS[*]}" \\
COMP_CWORD=$COMP_CWORD \\
%(autocomplete_var)s=complete $1 ) )
return 0
}
%(complete_func)setup() {
local COMPLETION_OPTIONS=""
local BASH_VERSION_ARR=(${BASH_VERSION//./ })
# Only BASH version 4.4 and later have the nosort option.
if [ ${BASH_VERSION_ARR[0]} -gt 4 ] || ([ ${BASH_VERSION_ARR[0]} -eq 4 ] && [ ${BASH_VERSION_ARR[1]} -ge 4 ]); then
COMPLETION_OPTIONS="-o nosort"
fi
complete $COMPLETION_OPTIONS -F %(complete_func)s %(script_names)s
}
%(complete_func)setup
'''
COMPLETION_SCRIPT_ZSH = '''
%(complete_func)s() {
local -a completions
local -a completions_with_descriptions
local -a response
response=("${(@f)$( env COMP_WORDS=\"${words[*]}\" \\
COMP_CWORD=$((CURRENT-1)) \\
%(autocomplete_var)s=\"complete_zsh\" \\
%(script_names)s )}")
for key descr in ${(kv)response}; do
if [[ "$descr" == "_" ]]; then
completions+=("$key")
else
completions_with_descriptions+=("$key":"$descr")
fi
done
if [ -n "$completions_with_descriptions" ]; then
_describe -V unsorted completions_with_descriptions -U -Q
fi
if [ -n "$completions" ]; then
compadd -U -V unsorted -Q -a completions
fi
compstate[insert]="automenu"
}
compdef %(complete_func)s %(script_names)s
'''
_invalid_ident_char_re = re.compile(r'[^a-zA-Z0-9_]')
def get_completion_script(prog_name, complete_var, shell):
cf_name = _invalid_ident_char_re.sub('', prog_name.replace('-', '_'))
script = COMPLETION_SCRIPT_ZSH if shell == 'zsh' else COMPLETION_SCRIPT_BASH
return (script % {
'complete_func': '_%s_completion' % cf_name,
'script_names': prog_name,
'autocomplete_var': complete_var,
}).strip() + ';'
def resolve_ctx(cli, prog_name, args):
"""
Parse into a hierarchy of contexts. Contexts are connected through the parent variable.
:param cli: command definition
:param prog_name: the program that is running
:param args: full list of args
:return: the final context/command parsed
"""
ctx = cli.make_context(prog_name, args, resilient_parsing=True)
args = ctx.protected_args + ctx.args
while args:
if isinstance(ctx.command, MultiCommand):
if not ctx.command.chain:
cmd_name, cmd, args = ctx.command.resolve_command(ctx, args)
if cmd is None:
return ctx
ctx = cmd.make_context(cmd_name, args, parent=ctx,
resilient_parsing=True)
args = ctx.protected_args + ctx.args
else:
# Walk chained subcommand contexts saving the last one.
while args:
cmd_name, cmd, args = ctx.command.resolve_command(ctx, args)
if cmd is None:
return ctx
sub_ctx = cmd.make_context(cmd_name, args, parent=ctx,
allow_extra_args=True,
allow_interspersed_args=False,
resilient_parsing=True)
args = sub_ctx.args
ctx = sub_ctx
args = sub_ctx.protected_args + sub_ctx.args
else:
break
return ctx
def start_of_option(param_str):
"""
:param param_str: param_str to check
:return: whether or not this is the start of an option declaration (i.e. starts "-" or "--")
"""
return param_str and param_str[:1] == '-'
def is_incomplete_option(all_args, cmd_param):
"""
:param all_args: the full original list of args supplied
:param cmd_param: the current command paramter
:return: whether or not the last option declaration (i.e. starts "-" or "--") is incomplete and
corresponds to this cmd_param. In other words whether this cmd_param option can still accept
values
"""
if not isinstance(cmd_param, Option):
return False
if cmd_param.is_flag:
return False
last_option = None
for index, arg_str in enumerate(reversed([arg for arg in all_args if arg != WORDBREAK])):
if index + 1 > cmd_param.nargs:
break
if start_of_option(arg_str):
last_option = arg_str
return True if last_option and last_option in cmd_param.opts else False
def is_incomplete_argument(current_params, cmd_param):
"""
:param current_params: the current params and values for this argument as already entered
:param cmd_param: the current command parameter
:return: whether or not the last argument is incomplete and corresponds to this cmd_param. In
other words whether or not the this cmd_param argument can still accept values
"""
if not isinstance(cmd_param, Argument):
return False
current_param_values = current_params[cmd_param.name]
if current_param_values is None:
return True
if cmd_param.nargs == -1:
return True
if isinstance(current_param_values, abc.Iterable) \
and cmd_param.nargs > 1 and len(current_param_values) < cmd_param.nargs:
return True
return False
def get_user_autocompletions(ctx, args, incomplete, cmd_param):
"""
:param ctx: context associated with the parsed command
:param args: full list of args
:param incomplete: the incomplete text to autocomplete
:param cmd_param: command definition
:return: all the possible user-specified completions for the param
"""
results = []
if isinstance(cmd_param.type, Choice):
# Choices don't support descriptions.
results = [(c, None)
for c in cmd_param.type.choices if str(c).startswith(incomplete)]
elif cmd_param.autocompletion is not None:
dynamic_completions = cmd_param.autocompletion(ctx=ctx,
args=args,
incomplete=incomplete)
results = [c if isinstance(c, tuple) else (c, None)
for c in dynamic_completions]
return results
def get_visible_commands_starting_with(ctx, starts_with):
"""
:param ctx: context associated with the parsed command
:starts_with: string that visible commands must start with.
:return: all visible (not hidden) commands that start with starts_with.
"""
for c in ctx.command.list_commands(ctx):
if c.startswith(starts_with):
command = ctx.command.get_command(ctx, c)
if not command.hidden:
yield command
def add_subcommand_completions(ctx, incomplete, completions_out):
# Add subcommand completions.
if isinstance(ctx.command, MultiCommand):
completions_out.extend(
[(c.name, c.get_short_help_str()) for c in get_visible_commands_starting_with(ctx, incomplete)])
# Walk up the context list and add any other completion possibilities from chained commands
while ctx.parent is not None:
ctx = ctx.parent
if isinstance(ctx.command, MultiCommand) and ctx.command.chain:
remaining_commands = [c for c in get_visible_commands_starting_with(ctx, incomplete)
if c.name not in ctx.protected_args]
completions_out.extend([(c.name, c.get_short_help_str()) for c in remaining_commands])
def get_choices(cli, prog_name, args, incomplete):
"""
:param cli: command definition
:param prog_name: the program that is running
:param args: full list of args
:param incomplete: the incomplete text to autocomplete
:return: all the possible completions for the incomplete
"""
all_args = copy.deepcopy(args)
ctx = resolve_ctx(cli, prog_name, args)
if ctx is None:
return []
# In newer versions of bash long opts with '='s are partitioned, but it's easier to parse
# without the '='
if start_of_option(incomplete) and WORDBREAK in incomplete:
partition_incomplete = incomplete.partition(WORDBREAK)
all_args.append(partition_incomplete[0])
incomplete = partition_incomplete[2]
elif incomplete == WORDBREAK:
incomplete = ''
completions = []
if start_of_option(incomplete):
# completions for partial options
for param in ctx.command.params:
if isinstance(param, Option) and not param.hidden:
param_opts = [param_opt for param_opt in param.opts +
param.secondary_opts if param_opt not in all_args or param.multiple]
completions.extend([(o, param.help) for o in param_opts if o.startswith(incomplete)])
return completions
# completion for option values from user supplied values
for param in ctx.command.params:
if is_incomplete_option(all_args, param):
return get_user_autocompletions(ctx, all_args, incomplete, param)
# completion for argument values from user supplied values
for param in ctx.command.params:
if is_incomplete_argument(ctx.params, param):
return get_user_autocompletions(ctx, all_args, incomplete, param)
add_subcommand_completions(ctx, incomplete, completions)
# Sort before returning so that proper ordering can be enforced in custom types.
return sorted(completions)
def do_complete(cli, prog_name, include_descriptions):
cwords = split_arg_string(os.environ['COMP_WORDS'])
cword = int(os.environ['COMP_CWORD'])
args = cwords[1:cword]
try:
incomplete = cwords[cword]
except IndexError:
incomplete = ''
for item in get_choices(cli, prog_name, args, incomplete):
echo(item[0])
if include_descriptions:
# ZSH has trouble dealing with empty array parameters when returned from commands, so use a well defined character '_' to indicate no description is present.
echo(item[1] if item[1] else '_')
return True
def bashcomplete(cli, prog_name, complete_var, complete_instr):
if complete_instr.startswith('source'):
shell = 'zsh' if complete_instr == 'source_zsh' else 'bash'
echo(get_completion_script(prog_name, complete_var, shell))
return True
elif complete_instr == 'complete' or complete_instr == 'complete_zsh':
return do_complete(cli, prog_name, complete_instr == 'complete_zsh')
return False
Click-7.0/click/_compat.py 0000644 0001750 0001750 00000055547 13351570514 015712 0 ustar david david 0000000 0000000 import re
import io
import os
import sys
import codecs
from weakref import WeakKeyDictionary
PY2 = sys.version_info[0] == 2
CYGWIN = sys.platform.startswith('cygwin')
# Determine local App Engine environment, per Google's own suggestion
APP_ENGINE = ('APPENGINE_RUNTIME' in os.environ and
'Development/' in os.environ['SERVER_SOFTWARE'])
WIN = sys.platform.startswith('win') and not APP_ENGINE
DEFAULT_COLUMNS = 80
_ansi_re = re.compile(r'\033\[((?:\d|;)*)([a-zA-Z])')
def get_filesystem_encoding():
return sys.getfilesystemencoding() or sys.getdefaultencoding()
def _make_text_stream(stream, encoding, errors,
force_readable=False, force_writable=False):
if encoding is None:
encoding = get_best_encoding(stream)
if errors is None:
errors = 'replace'
return _NonClosingTextIOWrapper(stream, encoding, errors,
line_buffering=True,
force_readable=force_readable,
force_writable=force_writable)
def is_ascii_encoding(encoding):
"""Checks if a given encoding is ascii."""
try:
return codecs.lookup(encoding).name == 'ascii'
except LookupError:
return False
def get_best_encoding(stream):
"""Returns the default stream encoding if not found."""
rv = getattr(stream, 'encoding', None) or sys.getdefaultencoding()
if is_ascii_encoding(rv):
return 'utf-8'
return rv
class _NonClosingTextIOWrapper(io.TextIOWrapper):
def __init__(self, stream, encoding, errors,
force_readable=False, force_writable=False, **extra):
self._stream = stream = _FixupStream(stream, force_readable,
force_writable)
io.TextIOWrapper.__init__(self, stream, encoding, errors, **extra)
# The io module is a place where the Python 3 text behavior
# was forced upon Python 2, so we need to unbreak
# it to look like Python 2.
if PY2:
def write(self, x):
if isinstance(x, str) or is_bytes(x):
try:
self.flush()
except Exception:
pass
return self.buffer.write(str(x))
return io.TextIOWrapper.write(self, x)
def writelines(self, lines):
for line in lines:
self.write(line)
def __del__(self):
try:
self.detach()
except Exception:
pass
def isatty(self):
# https://bitbucket.org/pypy/pypy/issue/1803
return self._stream.isatty()
class _FixupStream(object):
"""The new io interface needs more from streams than streams
traditionally implement. As such, this fix-up code is necessary in
some circumstances.
The forcing of readable and writable flags are there because some tools
put badly patched objects on sys (one such offender are certain version
of jupyter notebook).
"""
def __init__(self, stream, force_readable=False, force_writable=False):
self._stream = stream
self._force_readable = force_readable
self._force_writable = force_writable
def __getattr__(self, name):
return getattr(self._stream, name)
def read1(self, size):
f = getattr(self._stream, 'read1', None)
if f is not None:
return f(size)
# We only dispatch to readline instead of read in Python 2 as we
# do not want cause problems with the different implementation
# of line buffering.
if PY2:
return self._stream.readline(size)
return self._stream.read(size)
def readable(self):
if self._force_readable:
return True
x = getattr(self._stream, 'readable', None)
if x is not None:
return x()
try:
self._stream.read(0)
except Exception:
return False
return True
def writable(self):
if self._force_writable:
return True
x = getattr(self._stream, 'writable', None)
if x is not None:
return x()
try:
self._stream.write('')
except Exception:
try:
self._stream.write(b'')
except Exception:
return False
return True
def seekable(self):
x = getattr(self._stream, 'seekable', None)
if x is not None:
return x()
try:
self._stream.seek(self._stream.tell())
except Exception:
return False
return True
if PY2:
text_type = unicode
bytes = str
raw_input = raw_input
string_types = (str, unicode)
int_types = (int, long)
iteritems = lambda x: x.iteritems()
range_type = xrange
def is_bytes(x):
return isinstance(x, (buffer, bytearray))
_identifier_re = re.compile(r'^[a-zA-Z_][a-zA-Z0-9_]*$')
# For Windows, we need to force stdout/stdin/stderr to binary if it's
# fetched for that. This obviously is not the most correct way to do
# it as it changes global state. Unfortunately, there does not seem to
# be a clear better way to do it as just reopening the file in binary
# mode does not change anything.
#
# An option would be to do what Python 3 does and to open the file as
# binary only, patch it back to the system, and then use a wrapper
# stream that converts newlines. It's not quite clear what's the
# correct option here.
#
# This code also lives in _winconsole for the fallback to the console
# emulation stream.
#
# There are also Windows environments where the `msvcrt` module is not
# available (which is why we use try-catch instead of the WIN variable
# here), such as the Google App Engine development server on Windows. In
# those cases there is just nothing we can do.
def set_binary_mode(f):
return f
try:
import msvcrt
except ImportError:
pass
else:
def set_binary_mode(f):
try:
fileno = f.fileno()
except Exception:
pass
else:
msvcrt.setmode(fileno, os.O_BINARY)
return f
try:
import fcntl
except ImportError:
pass
else:
def set_binary_mode(f):
try:
fileno = f.fileno()
except Exception:
pass
else:
flags = fcntl.fcntl(fileno, fcntl.F_GETFL)
fcntl.fcntl(fileno, fcntl.F_SETFL, flags & ~os.O_NONBLOCK)
return f
def isidentifier(x):
return _identifier_re.search(x) is not None
def get_binary_stdin():
return set_binary_mode(sys.stdin)
def get_binary_stdout():
_wrap_std_stream('stdout')
return set_binary_mode(sys.stdout)
def get_binary_stderr():
_wrap_std_stream('stderr')
return set_binary_mode(sys.stderr)
def get_text_stdin(encoding=None, errors=None):
rv = _get_windows_console_stream(sys.stdin, encoding, errors)
if rv is not None:
return rv
return _make_text_stream(sys.stdin, encoding, errors,
force_readable=True)
def get_text_stdout(encoding=None, errors=None):
_wrap_std_stream('stdout')
rv = _get_windows_console_stream(sys.stdout, encoding, errors)
if rv is not None:
return rv
return _make_text_stream(sys.stdout, encoding, errors,
force_writable=True)
def get_text_stderr(encoding=None, errors=None):
_wrap_std_stream('stderr')
rv = _get_windows_console_stream(sys.stderr, encoding, errors)
if rv is not None:
return rv
return _make_text_stream(sys.stderr, encoding, errors,
force_writable=True)
def filename_to_ui(value):
if isinstance(value, bytes):
value = value.decode(get_filesystem_encoding(), 'replace')
return value
else:
import io
text_type = str
raw_input = input
string_types = (str,)
int_types = (int,)
range_type = range
isidentifier = lambda x: x.isidentifier()
iteritems = lambda x: iter(x.items())
def is_bytes(x):
return isinstance(x, (bytes, memoryview, bytearray))
def _is_binary_reader(stream, default=False):
try:
return isinstance(stream.read(0), bytes)
except Exception:
return default
# This happens in some cases where the stream was already
# closed. In this case, we assume the default.
def _is_binary_writer(stream, default=False):
try:
stream.write(b'')
except Exception:
try:
stream.write('')
return False
except Exception:
pass
return default
return True
def _find_binary_reader(stream):
# We need to figure out if the given stream is already binary.
# This can happen because the official docs recommend detaching
# the streams to get binary streams. Some code might do this, so
# we need to deal with this case explicitly.
if _is_binary_reader(stream, False):
return stream
buf = getattr(stream, 'buffer', None)
# Same situation here; this time we assume that the buffer is
# actually binary in case it's closed.
if buf is not None and _is_binary_reader(buf, True):
return buf
def _find_binary_writer(stream):
# We need to figure out if the given stream is already binary.
# This can happen because the official docs recommend detatching
# the streams to get binary streams. Some code might do this, so
# we need to deal with this case explicitly.
if _is_binary_writer(stream, False):
return stream
buf = getattr(stream, 'buffer', None)
# Same situation here; this time we assume that the buffer is
# actually binary in case it's closed.
if buf is not None and _is_binary_writer(buf, True):
return buf
def _stream_is_misconfigured(stream):
"""A stream is misconfigured if its encoding is ASCII."""
# If the stream does not have an encoding set, we assume it's set
# to ASCII. This appears to happen in certain unittest
# environments. It's not quite clear what the correct behavior is
# but this at least will force Click to recover somehow.
return is_ascii_encoding(getattr(stream, 'encoding', None) or 'ascii')
def _is_compatible_text_stream(stream, encoding, errors):
stream_encoding = getattr(stream, 'encoding', None)
stream_errors = getattr(stream, 'errors', None)
# Perfect match.
if stream_encoding == encoding and stream_errors == errors:
return True
# Otherwise, it's only a compatible stream if we did not ask for
# an encoding.
if encoding is None:
return stream_encoding is not None
return False
def _force_correct_text_reader(text_reader, encoding, errors,
force_readable=False):
if _is_binary_reader(text_reader, False):
binary_reader = text_reader
else:
# If there is no target encoding set, we need to verify that the
# reader is not actually misconfigured.
if encoding is None and not _stream_is_misconfigured(text_reader):
return text_reader
if _is_compatible_text_stream(text_reader, encoding, errors):
return text_reader
# If the reader has no encoding, we try to find the underlying
# binary reader for it. If that fails because the environment is
# misconfigured, we silently go with the same reader because this
# is too common to happen. In that case, mojibake is better than
# exceptions.
binary_reader = _find_binary_reader(text_reader)
if binary_reader is None:
return text_reader
# At this point, we default the errors to replace instead of strict
# because nobody handles those errors anyways and at this point
# we're so fundamentally fucked that nothing can repair it.
if errors is None:
errors = 'replace'
return _make_text_stream(binary_reader, encoding, errors,
force_readable=force_readable)
def _force_correct_text_writer(text_writer, encoding, errors,
force_writable=False):
if _is_binary_writer(text_writer, False):
binary_writer = text_writer
else:
# If there is no target encoding set, we need to verify that the
# writer is not actually misconfigured.
if encoding is None and not _stream_is_misconfigured(text_writer):
return text_writer
if _is_compatible_text_stream(text_writer, encoding, errors):
return text_writer
# If the writer has no encoding, we try to find the underlying
# binary writer for it. If that fails because the environment is
# misconfigured, we silently go with the same writer because this
# is too common to happen. In that case, mojibake is better than
# exceptions.
binary_writer = _find_binary_writer(text_writer)
if binary_writer is None:
return text_writer
# At this point, we default the errors to replace instead of strict
# because nobody handles those errors anyways and at this point
# we're so fundamentally fucked that nothing can repair it.
if errors is None:
errors = 'replace'
return _make_text_stream(binary_writer, encoding, errors,
force_writable=force_writable)
def get_binary_stdin():
reader = _find_binary_reader(sys.stdin)
if reader is None:
raise RuntimeError('Was not able to determine binary '
'stream for sys.stdin.')
return reader
def get_binary_stdout():
writer = _find_binary_writer(sys.stdout)
if writer is None:
raise RuntimeError('Was not able to determine binary '
'stream for sys.stdout.')
return writer
def get_binary_stderr():
writer = _find_binary_writer(sys.stderr)
if writer is None:
raise RuntimeError('Was not able to determine binary '
'stream for sys.stderr.')
return writer
def get_text_stdin(encoding=None, errors=None):
rv = _get_windows_console_stream(sys.stdin, encoding, errors)
if rv is not None:
return rv
return _force_correct_text_reader(sys.stdin, encoding, errors,
force_readable=True)
def get_text_stdout(encoding=None, errors=None):
rv = _get_windows_console_stream(sys.stdout, encoding, errors)
if rv is not None:
return rv
return _force_correct_text_writer(sys.stdout, encoding, errors,
force_writable=True)
def get_text_stderr(encoding=None, errors=None):
rv = _get_windows_console_stream(sys.stderr, encoding, errors)
if rv is not None:
return rv
return _force_correct_text_writer(sys.stderr, encoding, errors,
force_writable=True)
def filename_to_ui(value):
if isinstance(value, bytes):
value = value.decode(get_filesystem_encoding(), 'replace')
else:
value = value.encode('utf-8', 'surrogateescape') \
.decode('utf-8', 'replace')
return value
def get_streerror(e, default=None):
if hasattr(e, 'strerror'):
msg = e.strerror
else:
if default is not None:
msg = default
else:
msg = str(e)
if isinstance(msg, bytes):
msg = msg.decode('utf-8', 'replace')
return msg
def open_stream(filename, mode='r', encoding=None, errors='strict',
atomic=False):
# Standard streams first. These are simple because they don't need
# special handling for the atomic flag. It's entirely ignored.
if filename == '-':
if any(m in mode for m in ['w', 'a', 'x']):
if 'b' in mode:
return get_binary_stdout(), False
return get_text_stdout(encoding=encoding, errors=errors), False
if 'b' in mode:
return get_binary_stdin(), False
return get_text_stdin(encoding=encoding, errors=errors), False
# Non-atomic writes directly go out through the regular open functions.
if not atomic:
if encoding is None:
return open(filename, mode), True
return io.open(filename, mode, encoding=encoding, errors=errors), True
# Some usability stuff for atomic writes
if 'a' in mode:
raise ValueError(
'Appending to an existing file is not supported, because that '
'would involve an expensive `copy`-operation to a temporary '
'file. Open the file in normal `w`-mode and copy explicitly '
'if that\'s what you\'re after.'
)
if 'x' in mode:
raise ValueError('Use the `overwrite`-parameter instead.')
if 'w' not in mode:
raise ValueError('Atomic writes only make sense with `w`-mode.')
# Atomic writes are more complicated. They work by opening a file
# as a proxy in the same folder and then using the fdopen
# functionality to wrap it in a Python file. Then we wrap it in an
# atomic file that moves the file over on close.
import tempfile
fd, tmp_filename = tempfile.mkstemp(dir=os.path.dirname(filename),
prefix='.__atomic-write')
if encoding is not None:
f = io.open(fd, mode, encoding=encoding, errors=errors)
else:
f = os.fdopen(fd, mode)
return _AtomicFile(f, tmp_filename, os.path.realpath(filename)), True
# Used in a destructor call, needs extra protection from interpreter cleanup.
if hasattr(os, 'replace'):
_replace = os.replace
_can_replace = True
else:
_replace = os.rename
_can_replace = not WIN
class _AtomicFile(object):
def __init__(self, f, tmp_filename, real_filename):
self._f = f
self._tmp_filename = tmp_filename
self._real_filename = real_filename
self.closed = False
@property
def name(self):
return self._real_filename
def close(self, delete=False):
if self.closed:
return
self._f.close()
if not _can_replace:
try:
os.remove(self._real_filename)
except OSError:
pass
_replace(self._tmp_filename, self._real_filename)
self.closed = True
def __getattr__(self, name):
return getattr(self._f, name)
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, tb):
self.close(delete=exc_type is not None)
def __repr__(self):
return repr(self._f)
auto_wrap_for_ansi = None
colorama = None
get_winterm_size = None
def strip_ansi(value):
return _ansi_re.sub('', value)
def should_strip_ansi(stream=None, color=None):
if color is None:
if stream is None:
stream = sys.stdin
return not isatty(stream)
return not color
# If we're on Windows, we provide transparent integration through
# colorama. This will make ANSI colors through the echo function
# work automatically.
if WIN:
# Windows has a smaller terminal
DEFAULT_COLUMNS = 79
from ._winconsole import _get_windows_console_stream, _wrap_std_stream
def _get_argv_encoding():
import locale
return locale.getpreferredencoding()
if PY2:
def raw_input(prompt=''):
sys.stderr.flush()
if prompt:
stdout = _default_text_stdout()
stdout.write(prompt)
stdin = _default_text_stdin()
return stdin.readline().rstrip('\r\n')
try:
import colorama
except ImportError:
pass
else:
_ansi_stream_wrappers = WeakKeyDictionary()
def auto_wrap_for_ansi(stream, color=None):
"""This function wraps a stream so that calls through colorama
are issued to the win32 console API to recolor on demand. It
also ensures to reset the colors if a write call is interrupted
to not destroy the console afterwards.
"""
try:
cached = _ansi_stream_wrappers.get(stream)
except Exception:
cached = None
if cached is not None:
return cached
strip = should_strip_ansi(stream, color)
ansi_wrapper = colorama.AnsiToWin32(stream, strip=strip)
rv = ansi_wrapper.stream
_write = rv.write
def _safe_write(s):
try:
return _write(s)
except:
ansi_wrapper.reset_all()
raise
rv.write = _safe_write
try:
_ansi_stream_wrappers[stream] = rv
except Exception:
pass
return rv
def get_winterm_size():
win = colorama.win32.GetConsoleScreenBufferInfo(
colorama.win32.STDOUT).srWindow
return win.Right - win.Left, win.Bottom - win.Top
else:
def _get_argv_encoding():
return getattr(sys.stdin, 'encoding', None) or get_filesystem_encoding()
_get_windows_console_stream = lambda *x: None
_wrap_std_stream = lambda *x: None
def term_len(x):
return len(strip_ansi(x))
def isatty(stream):
try:
return stream.isatty()
except Exception:
return False
def _make_cached_stream_func(src_func, wrapper_func):
cache = WeakKeyDictionary()
def func():
stream = src_func()
try:
rv = cache.get(stream)
except Exception:
rv = None
if rv is not None:
return rv
rv = wrapper_func()
try:
stream = src_func() # In case wrapper_func() modified the stream
cache[stream] = rv
except Exception:
pass
return rv
return func
_default_text_stdin = _make_cached_stream_func(
lambda: sys.stdin, get_text_stdin)
_default_text_stdout = _make_cached_stream_func(
lambda: sys.stdout, get_text_stdout)
_default_text_stderr = _make_cached_stream_func(
lambda: sys.stderr, get_text_stderr)
binary_streams = {
'stdin': get_binary_stdin,
'stdout': get_binary_stdout,
'stderr': get_binary_stderr,
}
text_streams = {
'stdin': get_text_stdin,
'stdout': get_text_stdout,
'stderr': get_text_stderr,
}
Click-7.0/click/_termui_impl.py 0000644 0001750 0001750 00000046233 13352433170 016742 0 ustar david david 0000000 0000000 # -*- coding: utf-8 -*-
"""
click._termui_impl
~~~~~~~~~~~~~~~~~~
This module contains implementations for the termui module. To keep the
import time of Click down, some infrequently used functionality is
placed in this module and only imported as needed.
:copyright: © 2014 by the Pallets team.
:license: BSD, see LICENSE.rst for more details.
"""
import os
import sys
import time
import math
import contextlib
from ._compat import _default_text_stdout, range_type, PY2, isatty, \
open_stream, strip_ansi, term_len, get_best_encoding, WIN, int_types, \
CYGWIN
from .utils import echo
from .exceptions import ClickException
if os.name == 'nt':
BEFORE_BAR = '\r'
AFTER_BAR = '\n'
else:
BEFORE_BAR = '\r\033[?25l'
AFTER_BAR = '\033[?25h\n'
def _length_hint(obj):
"""Returns the length hint of an object."""
try:
return len(obj)
except (AttributeError, TypeError):
try:
get_hint = type(obj).__length_hint__
except AttributeError:
return None
try:
hint = get_hint(obj)
except TypeError:
return None
if hint is NotImplemented or \
not isinstance(hint, int_types) or \
hint < 0:
return None
return hint
class ProgressBar(object):
def __init__(self, iterable, length=None, fill_char='#', empty_char=' ',
bar_template='%(bar)s', info_sep=' ', show_eta=True,
show_percent=None, show_pos=False, item_show_func=None,
label=None, file=None, color=None, width=30):
self.fill_char = fill_char
self.empty_char = empty_char
self.bar_template = bar_template
self.info_sep = info_sep
self.show_eta = show_eta
self.show_percent = show_percent
self.show_pos = show_pos
self.item_show_func = item_show_func
self.label = label or ''
if file is None:
file = _default_text_stdout()
self.file = file
self.color = color
self.width = width
self.autowidth = width == 0
if length is None:
length = _length_hint(iterable)
if iterable is None:
if length is None:
raise TypeError('iterable or length is required')
iterable = range_type(length)
self.iter = iter(iterable)
self.length = length
self.length_known = length is not None
self.pos = 0
self.avg = []
self.start = self.last_eta = time.time()
self.eta_known = False
self.finished = False
self.max_width = None
self.entered = False
self.current_item = None
self.is_hidden = not isatty(self.file)
self._last_line = None
self.short_limit = 0.5
def __enter__(self):
self.entered = True
self.render_progress()
return self
def __exit__(self, exc_type, exc_value, tb):
self.render_finish()
def __iter__(self):
if not self.entered:
raise RuntimeError('You need to use progress bars in a with block.')
self.render_progress()
return self.generator()
def is_fast(self):
return time.time() - self.start <= self.short_limit
def render_finish(self):
if self.is_hidden or self.is_fast():
return
self.file.write(AFTER_BAR)
self.file.flush()
@property
def pct(self):
if self.finished:
return 1.0
return min(self.pos / (float(self.length) or 1), 1.0)
@property
def time_per_iteration(self):
if not self.avg:
return 0.0
return sum(self.avg) / float(len(self.avg))
@property
def eta(self):
if self.length_known and not self.finished:
return self.time_per_iteration * (self.length - self.pos)
return 0.0
def format_eta(self):
if self.eta_known:
t = int(self.eta)
seconds = t % 60
t //= 60
minutes = t % 60
t //= 60
hours = t % 24
t //= 24
if t > 0:
days = t
return '%dd %02d:%02d:%02d' % (days, hours, minutes, seconds)
else:
return '%02d:%02d:%02d' % (hours, minutes, seconds)
return ''
def format_pos(self):
pos = str(self.pos)
if self.length_known:
pos += '/%s' % self.length
return pos
def format_pct(self):
return ('% 4d%%' % int(self.pct * 100))[1:]
def format_bar(self):
if self.length_known:
bar_length = int(self.pct * self.width)
bar = self.fill_char * bar_length
bar += self.empty_char * (self.width - bar_length)
elif self.finished:
bar = self.fill_char * self.width
else:
bar = list(self.empty_char * (self.width or 1))
if self.time_per_iteration != 0:
bar[int((math.cos(self.pos * self.time_per_iteration)
/ 2.0 + 0.5) * self.width)] = self.fill_char
bar = ''.join(bar)
return bar
def format_progress_line(self):
show_percent = self.show_percent
info_bits = []
if self.length_known and show_percent is None:
show_percent = not self.show_pos
if self.show_pos:
info_bits.append(self.format_pos())
if show_percent:
info_bits.append(self.format_pct())
if self.show_eta and self.eta_known and not self.finished:
info_bits.append(self.format_eta())
if self.item_show_func is not None:
item_info = self.item_show_func(self.current_item)
if item_info is not None:
info_bits.append(item_info)
return (self.bar_template % {
'label': self.label,
'bar': self.format_bar(),
'info': self.info_sep.join(info_bits)
}).rstrip()
def render_progress(self):
from .termui import get_terminal_size
if self.is_hidden:
return
buf = []
# Update width in case the terminal has been resized
if self.autowidth:
old_width = self.width
self.width = 0
clutter_length = term_len(self.format_progress_line())
new_width = max(0, get_terminal_size()[0] - clutter_length)
if new_width < old_width:
buf.append(BEFORE_BAR)
buf.append(' ' * self.max_width)
self.max_width = new_width
self.width = new_width
clear_width = self.width
if self.max_width is not None:
clear_width = self.max_width
buf.append(BEFORE_BAR)
line = self.format_progress_line()
line_len = term_len(line)
if self.max_width is None or self.max_width < line_len:
self.max_width = line_len
buf.append(line)
buf.append(' ' * (clear_width - line_len))
line = ''.join(buf)
# Render the line only if it changed.
if line != self._last_line and not self.is_fast():
self._last_line = line
echo(line, file=self.file, color=self.color, nl=False)
self.file.flush()
def make_step(self, n_steps):
self.pos += n_steps
if self.length_known and self.pos >= self.length:
self.finished = True
if (time.time() - self.last_eta) < 1.0:
return
self.last_eta = time.time()
# self.avg is a rolling list of length <= 7 of steps where steps are
# defined as time elapsed divided by the total progress through
# self.length.
if self.pos:
step = (time.time() - self.start) / self.pos
else:
step = time.time() - self.start
self.avg = self.avg[-6:] + [step]
self.eta_known = self.length_known
def update(self, n_steps):
self.make_step(n_steps)
self.render_progress()
def finish(self):
self.eta_known = 0
self.current_item = None
self.finished = True
def generator(self):
"""
Returns a generator which yields the items added to the bar during
construction, and updates the progress bar *after* the yielded block
returns.
"""
if not self.entered:
raise RuntimeError('You need to use progress bars in a with block.')
if self.is_hidden:
for rv in self.iter:
yield rv
else:
for rv in self.iter:
self.current_item = rv
yield rv
self.update(1)
self.finish()
self.render_progress()
def pager(generator, color=None):
"""Decide what method to use for paging through text."""
stdout = _default_text_stdout()
if not isatty(sys.stdin) or not isatty(stdout):
return _nullpager(stdout, generator, color)
pager_cmd = (os.environ.get('PAGER', None) or '').strip()
if pager_cmd:
if WIN:
return _tempfilepager(generator, pager_cmd, color)
return _pipepager(generator, pager_cmd, color)
if os.environ.get('TERM') in ('dumb', 'emacs'):
return _nullpager(stdout, generator, color)
if WIN or sys.platform.startswith('os2'):
return _tempfilepager(generator, 'more <', color)
if hasattr(os, 'system') and os.system('(less) 2>/dev/null') == 0:
return _pipepager(generator, 'less', color)
import tempfile
fd, filename = tempfile.mkstemp()
os.close(fd)
try:
if hasattr(os, 'system') and os.system('more "%s"' % filename) == 0:
return _pipepager(generator, 'more', color)
return _nullpager(stdout, generator, color)
finally:
os.unlink(filename)
def _pipepager(generator, cmd, color):
"""Page through text by feeding it to another program. Invoking a
pager through this might support colors.
"""
import subprocess
env = dict(os.environ)
# If we're piping to less we might support colors under the
# condition that
cmd_detail = cmd.rsplit('/', 1)[-1].split()
if color is None and cmd_detail[0] == 'less':
less_flags = os.environ.get('LESS', '') + ' '.join(cmd_detail[1:])
if not less_flags:
env['LESS'] = '-R'
color = True
elif 'r' in less_flags or 'R' in less_flags:
color = True
c = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE,
env=env)
encoding = get_best_encoding(c.stdin)
try:
for text in generator:
if not color:
text = strip_ansi(text)
c.stdin.write(text.encode(encoding, 'replace'))
except (IOError, KeyboardInterrupt):
pass
else:
c.stdin.close()
# Less doesn't respect ^C, but catches it for its own UI purposes (aborting
# search or other commands inside less).
#
# That means when the user hits ^C, the parent process (click) terminates,
# but less is still alive, paging the output and messing up the terminal.
#
# If the user wants to make the pager exit on ^C, they should set
# `LESS='-K'`. It's not our decision to make.
while True:
try:
c.wait()
except KeyboardInterrupt:
pass
else:
break
def _tempfilepager(generator, cmd, color):
"""Page through text by invoking a program on a temporary file."""
import tempfile
filename = tempfile.mktemp()
# TODO: This never terminates if the passed generator never terminates.
text = "".join(generator)
if not color:
text = strip_ansi(text)
encoding = get_best_encoding(sys.stdout)
with open_stream(filename, 'wb')[0] as f:
f.write(text.encode(encoding))
try:
os.system(cmd + ' "' + filename + '"')
finally:
os.unlink(filename)
def _nullpager(stream, generator, color):
"""Simply print unformatted text. This is the ultimate fallback."""
for text in generator:
if not color:
text = strip_ansi(text)
stream.write(text)
class Editor(object):
def __init__(self, editor=None, env=None, require_save=True,
extension='.txt'):
self.editor = editor
self.env = env
self.require_save = require_save
self.extension = extension
def get_editor(self):
if self.editor is not None:
return self.editor
for key in 'VISUAL', 'EDITOR':
rv = os.environ.get(key)
if rv:
return rv
if WIN:
return 'notepad'
for editor in 'vim', 'nano':
if os.system('which %s >/dev/null 2>&1' % editor) == 0:
return editor
return 'vi'
def edit_file(self, filename):
import subprocess
editor = self.get_editor()
if self.env:
environ = os.environ.copy()
environ.update(self.env)
else:
environ = None
try:
c = subprocess.Popen('%s "%s"' % (editor, filename),
env=environ, shell=True)
exit_code = c.wait()
if exit_code != 0:
raise ClickException('%s: Editing failed!' % editor)
except OSError as e:
raise ClickException('%s: Editing failed: %s' % (editor, e))
def edit(self, text):
import tempfile
text = text or ''
if text and not text.endswith('\n'):
text += '\n'
fd, name = tempfile.mkstemp(prefix='editor-', suffix=self.extension)
try:
if WIN:
encoding = 'utf-8-sig'
text = text.replace('\n', '\r\n')
else:
encoding = 'utf-8'
text = text.encode(encoding)
f = os.fdopen(fd, 'wb')
f.write(text)
f.close()
timestamp = os.path.getmtime(name)
self.edit_file(name)
if self.require_save \
and os.path.getmtime(name) == timestamp:
return None
f = open(name, 'rb')
try:
rv = f.read()
finally:
f.close()
return rv.decode('utf-8-sig').replace('\r\n', '\n')
finally:
os.unlink(name)
def open_url(url, wait=False, locate=False):
import subprocess
def _unquote_file(url):
try:
import urllib
except ImportError:
import urllib
if url.startswith('file://'):
url = urllib.unquote(url[7:])
return url
if sys.platform == 'darwin':
args = ['open']
if wait:
args.append('-W')
if locate:
args.append('-R')
args.append(_unquote_file(url))
null = open('/dev/null', 'w')
try:
return subprocess.Popen(args, stderr=null).wait()
finally:
null.close()
elif WIN:
if locate:
url = _unquote_file(url)
args = 'explorer /select,"%s"' % _unquote_file(
url.replace('"', ''))
else:
args = 'start %s "" "%s"' % (
wait and '/WAIT' or '', url.replace('"', ''))
return os.system(args)
elif CYGWIN:
if locate:
url = _unquote_file(url)
args = 'cygstart "%s"' % (os.path.dirname(url).replace('"', ''))
else:
args = 'cygstart %s "%s"' % (
wait and '-w' or '', url.replace('"', ''))
return os.system(args)
try:
if locate:
url = os.path.dirname(_unquote_file(url)) or '.'
else:
url = _unquote_file(url)
c = subprocess.Popen(['xdg-open', url])
if wait:
return c.wait()
return 0
except OSError:
if url.startswith(('http://', 'https://')) and not locate and not wait:
import webbrowser
webbrowser.open(url)
return 0
return 1
def _translate_ch_to_exc(ch):
if ch == u'\x03':
raise KeyboardInterrupt()
if ch == u'\x04' and not WIN: # Unix-like, Ctrl+D
raise EOFError()
if ch == u'\x1a' and WIN: # Windows, Ctrl+Z
raise EOFError()
if WIN:
import msvcrt
@contextlib.contextmanager
def raw_terminal():
yield
def getchar(echo):
# The function `getch` will return a bytes object corresponding to
# the pressed character. Since Windows 10 build 1803, it will also
# return \x00 when called a second time after pressing a regular key.
#
# `getwch` does not share this probably-bugged behavior. Moreover, it
# returns a Unicode object by default, which is what we want.
#
# Either of these functions will return \x00 or \xe0 to indicate
# a special key, and you need to call the same function again to get
# the "rest" of the code. The fun part is that \u00e0 is
# "latin small letter a with grave", so if you type that on a French
# keyboard, you _also_ get a \xe0.
# E.g., consider the Up arrow. This returns \xe0 and then \x48. The
# resulting Unicode string reads as "a with grave" + "capital H".
# This is indistinguishable from when the user actually types
# "a with grave" and then "capital H".
#
# When \xe0 is returned, we assume it's part of a special-key sequence
# and call `getwch` again, but that means that when the user types
# the \u00e0 character, `getchar` doesn't return until a second
# character is typed.
# The alternative is returning immediately, but that would mess up
# cross-platform handling of arrow keys and others that start with
# \xe0. Another option is using `getch`, but then we can't reliably
# read non-ASCII characters, because return values of `getch` are
# limited to the current 8-bit codepage.
#
# Anyway, Click doesn't claim to do this Right(tm), and using `getwch`
# is doing the right thing in more situations than with `getch`.
if echo:
func = msvcrt.getwche
else:
func = msvcrt.getwch
rv = func()
if rv in (u'\x00', u'\xe0'):
# \x00 and \xe0 are control characters that indicate special key,
# see above.
rv += func()
_translate_ch_to_exc(rv)
return rv
else:
import tty
import termios
@contextlib.contextmanager
def raw_terminal():
if not isatty(sys.stdin):
f = open('/dev/tty')
fd = f.fileno()
else:
fd = sys.stdin.fileno()
f = None
try:
old_settings = termios.tcgetattr(fd)
try:
tty.setraw(fd)
yield fd
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
sys.stdout.flush()
if f is not None:
f.close()
except termios.error:
pass
def getchar(echo):
with raw_terminal() as fd:
ch = os.read(fd, 32)
ch = ch.decode(get_best_encoding(sys.stdin), 'replace')
if echo and isatty(sys.stdout):
sys.stdout.write(ch)
_translate_ch_to_exc(ch)
return ch
Click-7.0/click/_textwrap.py 0000644 0001750 0001750 00000002256 13351553373 016276 0 ustar david david 0000000 0000000 import textwrap
from contextlib import contextmanager
class TextWrapper(textwrap.TextWrapper):
def _handle_long_word(self, reversed_chunks, cur_line, cur_len, width):
space_left = max(width - cur_len, 1)
if self.break_long_words:
last = reversed_chunks[-1]
cut = last[:space_left]
res = last[space_left:]
cur_line.append(cut)
reversed_chunks[-1] = res
elif not cur_line:
cur_line.append(reversed_chunks.pop())
@contextmanager
def extra_indent(self, indent):
old_initial_indent = self.initial_indent
old_subsequent_indent = self.subsequent_indent
self.initial_indent += indent
self.subsequent_indent += indent
try:
yield
finally:
self.initial_indent = old_initial_indent
self.subsequent_indent = old_subsequent_indent
def indent_only(self, text):
rv = []
for idx, line in enumerate(text.splitlines()):
indent = self.initial_indent
if idx > 0:
indent = self.subsequent_indent
rv.append(indent + line)
return '\n'.join(rv)
Click-7.0/click/_unicodefun.py 0000644 0001750 0001750 00000010414 13352517227 016551 0 ustar david david 0000000 0000000 import os
import sys
import codecs
from ._compat import PY2
# If someone wants to vendor click, we want to ensure the
# correct package is discovered. Ideally we could use a
# relative import here but unfortunately Python does not
# support that.
click = sys.modules[__name__.rsplit('.', 1)[0]]
def _find_unicode_literals_frame():
import __future__
if not hasattr(sys, '_getframe'): # not all Python implementations have it
return 0
frm = sys._getframe(1)
idx = 1
while frm is not None:
if frm.f_globals.get('__name__', '').startswith('click.'):
frm = frm.f_back
idx += 1
elif frm.f_code.co_flags & __future__.unicode_literals.compiler_flag:
return idx
else:
break
return 0
def _check_for_unicode_literals():
if not __debug__:
return
if not PY2 or click.disable_unicode_literals_warning:
return
bad_frame = _find_unicode_literals_frame()
if bad_frame <= 0:
return
from warnings import warn
warn(Warning('Click detected the use of the unicode_literals '
'__future__ import. This is heavily discouraged '
'because it can introduce subtle bugs in your '
'code. You should instead use explicit u"" literals '
'for your unicode strings. For more information see '
'https://click.palletsprojects.com/python3/'),
stacklevel=bad_frame)
def _verify_python3_env():
"""Ensures that the environment is good for unicode on Python 3."""
if PY2:
return
try:
import locale
fs_enc = codecs.lookup(locale.getpreferredencoding()).name
except Exception:
fs_enc = 'ascii'
if fs_enc != 'ascii':
return
extra = ''
if os.name == 'posix':
import subprocess
try:
rv = subprocess.Popen(['locale', '-a'], stdout=subprocess.PIPE,
stderr=subprocess.PIPE).communicate()[0]
except OSError:
rv = b''
good_locales = set()
has_c_utf8 = False
# Make sure we're operating on text here.
if isinstance(rv, bytes):
rv = rv.decode('ascii', 'replace')
for line in rv.splitlines():
locale = line.strip()
if locale.lower().endswith(('.utf-8', '.utf8')):
good_locales.add(locale)
if locale.lower() in ('c.utf8', 'c.utf-8'):
has_c_utf8 = True
extra += '\n\n'
if not good_locales:
extra += (
'Additional information: on this system no suitable UTF-8\n'
'locales were discovered. This most likely requires resolving\n'
'by reconfiguring the locale system.'
)
elif has_c_utf8:
extra += (
'This system supports the C.UTF-8 locale which is recommended.\n'
'You might be able to resolve your issue by exporting the\n'
'following environment variables:\n\n'
' export LC_ALL=C.UTF-8\n'
' export LANG=C.UTF-8'
)
else:
extra += (
'This system lists a couple of UTF-8 supporting locales that\n'
'you can pick from. The following suitable locales were\n'
'discovered: %s'
) % ', '.join(sorted(good_locales))
bad_locale = None
for locale in os.environ.get('LC_ALL'), os.environ.get('LANG'):
if locale and locale.lower().endswith(('.utf-8', '.utf8')):
bad_locale = locale
if locale is not None:
break
if bad_locale is not None:
extra += (
'\n\nClick discovered that you exported a UTF-8 locale\n'
'but the locale system could not pick up from it because\n'
'it does not exist. The exported locale is "%s" but it\n'
'is not supported'
) % bad_locale
raise RuntimeError(
'Click will abort further execution because Python 3 was'
' configured to use ASCII as encoding for the environment.'
' Consult https://click.palletsprojects.com/en/7.x/python3/ for'
' mitigation steps.' + extra
)
Click-7.0/click/_winconsole.py 0000644 0001750 0001750 00000021405 13351570514 016571 0 ustar david david 0000000 0000000 # -*- coding: utf-8 -*-
# This module is based on the excellent work by Adam Bartoš who
# provided a lot of what went into the implementation here in
# the discussion to issue1602 in the Python bug tracker.
#
# There are some general differences in regards to how this works
# compared to the original patches as we do not need to patch
# the entire interpreter but just work in our little world of
# echo and prmopt.
import io
import os
import sys
import zlib
import time
import ctypes
import msvcrt
from ._compat import _NonClosingTextIOWrapper, text_type, PY2
from ctypes import byref, POINTER, c_int, c_char, c_char_p, \
c_void_p, py_object, c_ssize_t, c_ulong, windll, WINFUNCTYPE
try:
from ctypes import pythonapi
PyObject_GetBuffer = pythonapi.PyObject_GetBuffer
PyBuffer_Release = pythonapi.PyBuffer_Release
except ImportError:
pythonapi = None
from ctypes.wintypes import LPWSTR, LPCWSTR
c_ssize_p = POINTER(c_ssize_t)
kernel32 = windll.kernel32
GetStdHandle = kernel32.GetStdHandle
ReadConsoleW = kernel32.ReadConsoleW
WriteConsoleW = kernel32.WriteConsoleW
GetLastError = kernel32.GetLastError
GetCommandLineW = WINFUNCTYPE(LPWSTR)(
('GetCommandLineW', windll.kernel32))
CommandLineToArgvW = WINFUNCTYPE(
POINTER(LPWSTR), LPCWSTR, POINTER(c_int))(
('CommandLineToArgvW', windll.shell32))
STDIN_HANDLE = GetStdHandle(-10)
STDOUT_HANDLE = GetStdHandle(-11)
STDERR_HANDLE = GetStdHandle(-12)
PyBUF_SIMPLE = 0
PyBUF_WRITABLE = 1
ERROR_SUCCESS = 0
ERROR_NOT_ENOUGH_MEMORY = 8
ERROR_OPERATION_ABORTED = 995
STDIN_FILENO = 0
STDOUT_FILENO = 1
STDERR_FILENO = 2
EOF = b'\x1a'
MAX_BYTES_WRITTEN = 32767
class Py_buffer(ctypes.Structure):
_fields_ = [
('buf', c_void_p),
('obj', py_object),
('len', c_ssize_t),
('itemsize', c_ssize_t),
('readonly', c_int),
('ndim', c_int),
('format', c_char_p),
('shape', c_ssize_p),
('strides', c_ssize_p),
('suboffsets', c_ssize_p),
('internal', c_void_p)
]
if PY2:
_fields_.insert(-1, ('smalltable', c_ssize_t * 2))
# On PyPy we cannot get buffers so our ability to operate here is
# serverly limited.
if pythonapi is None:
get_buffer = None
else:
def get_buffer(obj, writable=False):
buf = Py_buffer()
flags = PyBUF_WRITABLE if writable else PyBUF_SIMPLE
PyObject_GetBuffer(py_object(obj), byref(buf), flags)
try:
buffer_type = c_char * buf.len
return buffer_type.from_address(buf.buf)
finally:
PyBuffer_Release(byref(buf))
class _WindowsConsoleRawIOBase(io.RawIOBase):
def __init__(self, handle):
self.handle = handle
def isatty(self):
io.RawIOBase.isatty(self)
return True
class _WindowsConsoleReader(_WindowsConsoleRawIOBase):
def readable(self):
return True
def readinto(self, b):
bytes_to_be_read = len(b)
if not bytes_to_be_read:
return 0
elif bytes_to_be_read % 2:
raise ValueError('cannot read odd number of bytes from '
'UTF-16-LE encoded console')
buffer = get_buffer(b, writable=True)
code_units_to_be_read = bytes_to_be_read // 2
code_units_read = c_ulong()
rv = ReadConsoleW(self.handle, buffer, code_units_to_be_read,
byref(code_units_read), None)
if GetLastError() == ERROR_OPERATION_ABORTED:
# wait for KeyboardInterrupt
time.sleep(0.1)
if not rv:
raise OSError('Windows error: %s' % GetLastError())
if buffer[0] == EOF:
return 0
return 2 * code_units_read.value
class _WindowsConsoleWriter(_WindowsConsoleRawIOBase):
def writable(self):
return True
@staticmethod
def _get_error_message(errno):
if errno == ERROR_SUCCESS:
return 'ERROR_SUCCESS'
elif errno == ERROR_NOT_ENOUGH_MEMORY:
return 'ERROR_NOT_ENOUGH_MEMORY'
return 'Windows error %s' % errno
def write(self, b):
bytes_to_be_written = len(b)
buf = get_buffer(b)
code_units_to_be_written = min(bytes_to_be_written,
MAX_BYTES_WRITTEN) // 2
code_units_written = c_ulong()
WriteConsoleW(self.handle, buf, code_units_to_be_written,
byref(code_units_written), None)
bytes_written = 2 * code_units_written.value
if bytes_written == 0 and bytes_to_be_written > 0:
raise OSError(self._get_error_message(GetLastError()))
return bytes_written
class ConsoleStream(object):
def __init__(self, text_stream, byte_stream):
self._text_stream = text_stream
self.buffer = byte_stream
@property
def name(self):
return self.buffer.name
def write(self, x):
if isinstance(x, text_type):
return self._text_stream.write(x)
try:
self.flush()
except Exception:
pass
return self.buffer.write(x)
def writelines(self, lines):
for line in lines:
self.write(line)
def __getattr__(self, name):
return getattr(self._text_stream, name)
def isatty(self):
return self.buffer.isatty()
def __repr__(self):
return '' % (
self.name,
self.encoding,
)
class WindowsChunkedWriter(object):
"""
Wraps a stream (such as stdout), acting as a transparent proxy for all
attribute access apart from method 'write()' which we wrap to write in
limited chunks due to a Windows limitation on binary console streams.
"""
def __init__(self, wrapped):
# double-underscore everything to prevent clashes with names of
# attributes on the wrapped stream object.
self.__wrapped = wrapped
def __getattr__(self, name):
return getattr(self.__wrapped, name)
def write(self, text):
total_to_write = len(text)
written = 0
while written < total_to_write:
to_write = min(total_to_write - written, MAX_BYTES_WRITTEN)
self.__wrapped.write(text[written:written+to_write])
written += to_write
_wrapped_std_streams = set()
def _wrap_std_stream(name):
# Python 2 & Windows 7 and below
if PY2 and sys.getwindowsversion()[:2] <= (6, 1) and name not in _wrapped_std_streams:
setattr(sys, name, WindowsChunkedWriter(getattr(sys, name)))
_wrapped_std_streams.add(name)
def _get_text_stdin(buffer_stream):
text_stream = _NonClosingTextIOWrapper(
io.BufferedReader(_WindowsConsoleReader(STDIN_HANDLE)),
'utf-16-le', 'strict', line_buffering=True)
return ConsoleStream(text_stream, buffer_stream)
def _get_text_stdout(buffer_stream):
text_stream = _NonClosingTextIOWrapper(
io.BufferedWriter(_WindowsConsoleWriter(STDOUT_HANDLE)),
'utf-16-le', 'strict', line_buffering=True)
return ConsoleStream(text_stream, buffer_stream)
def _get_text_stderr(buffer_stream):
text_stream = _NonClosingTextIOWrapper(
io.BufferedWriter(_WindowsConsoleWriter(STDERR_HANDLE)),
'utf-16-le', 'strict', line_buffering=True)
return ConsoleStream(text_stream, buffer_stream)
if PY2:
def _hash_py_argv():
return zlib.crc32('\x00'.join(sys.argv[1:]))
_initial_argv_hash = _hash_py_argv()
def _get_windows_argv():
argc = c_int(0)
argv_unicode = CommandLineToArgvW(GetCommandLineW(), byref(argc))
argv = [argv_unicode[i] for i in range(0, argc.value)]
if not hasattr(sys, 'frozen'):
argv = argv[1:]
while len(argv) > 0:
arg = argv[0]
if not arg.startswith('-') or arg == '-':
break
argv = argv[1:]
if arg.startswith(('-c', '-m')):
break
return argv[1:]
_stream_factories = {
0: _get_text_stdin,
1: _get_text_stdout,
2: _get_text_stderr,
}
def _get_windows_console_stream(f, encoding, errors):
if get_buffer is not None and \
encoding in ('utf-16-le', None) \
and errors in ('strict', None) and \
hasattr(f, 'isatty') and f.isatty():
func = _stream_factories.get(f.fileno())
if func is not None:
if not PY2:
f = getattr(f, 'buffer', None)
if f is None:
return None
else:
# If we are on Python 2 we need to set the stream that we
# deal with to binary mode as otherwise the exercise if a
# bit moot. The same problems apply as for
# get_binary_stdin and friends from _compat.
msvcrt.setmode(f.fileno(), os.O_BINARY)
return func(f)
Click-7.0/click/core.py 0000644 0001750 0001750 00000223051 13351570514 015203 0 ustar david david 0000000 0000000 import errno
import inspect
import os
import sys
from contextlib import contextmanager
from itertools import repeat
from functools import update_wrapper
from .types import convert_type, IntRange, BOOL
from .utils import PacifyFlushWrapper, make_str, make_default_short_help, \
echo, get_os_args
from .exceptions import ClickException, UsageError, BadParameter, Abort, \
MissingParameter, Exit
from .termui import prompt, confirm, style
from .formatting import HelpFormatter, join_options
from .parser import OptionParser, split_opt
from .globals import push_context, pop_context
from ._compat import PY2, isidentifier, iteritems, string_types
from ._unicodefun import _check_for_unicode_literals, _verify_python3_env
_missing = object()
SUBCOMMAND_METAVAR = 'COMMAND [ARGS]...'
SUBCOMMANDS_METAVAR = 'COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]...'
DEPRECATED_HELP_NOTICE = ' (DEPRECATED)'
DEPRECATED_INVOKE_NOTICE = 'DeprecationWarning: ' + \
'The command %(name)s is deprecated.'
def _maybe_show_deprecated_notice(cmd):
if cmd.deprecated:
echo(style(DEPRECATED_INVOKE_NOTICE % {'name': cmd.name}, fg='red'), err=True)
def fast_exit(code):
"""Exit without garbage collection, this speeds up exit by about 10ms for
things like bash completion.
"""
sys.stdout.flush()
sys.stderr.flush()
os._exit(code)
def _bashcomplete(cmd, prog_name, complete_var=None):
"""Internal handler for the bash completion support."""
if complete_var is None:
complete_var = '_%s_COMPLETE' % (prog_name.replace('-', '_')).upper()
complete_instr = os.environ.get(complete_var)
if not complete_instr:
return
from ._bashcomplete import bashcomplete
if bashcomplete(cmd, prog_name, complete_var, complete_instr):
fast_exit(1)
def _check_multicommand(base_command, cmd_name, cmd, register=False):
if not base_command.chain or not isinstance(cmd, MultiCommand):
return
if register:
hint = 'It is not possible to add multi commands as children to ' \
'another multi command that is in chain mode'
else:
hint = 'Found a multi command as subcommand to a multi command ' \
'that is in chain mode. This is not supported'
raise RuntimeError('%s. Command "%s" is set to chain and "%s" was '
'added as subcommand but it in itself is a '
'multi command. ("%s" is a %s within a chained '
'%s named "%s").' % (
hint, base_command.name, cmd_name,
cmd_name, cmd.__class__.__name__,
base_command.__class__.__name__,
base_command.name))
def batch(iterable, batch_size):
return list(zip(*repeat(iter(iterable), batch_size)))
def invoke_param_callback(callback, ctx, param, value):
code = getattr(callback, '__code__', None)
args = getattr(code, 'co_argcount', 3)
if args < 3:
# This will become a warning in Click 3.0:
from warnings import warn
warn(Warning('Invoked legacy parameter callback "%s". The new '
'signature for such callbacks starting with '
'click 2.0 is (ctx, param, value).'
% callback), stacklevel=3)
return callback(ctx, value)
return callback(ctx, param, value)
@contextmanager
def augment_usage_errors(ctx, param=None):
"""Context manager that attaches extra information to exceptions that
fly.
"""
try:
yield
except BadParameter as e:
if e.ctx is None:
e.ctx = ctx
if param is not None and e.param is None:
e.param = param
raise
except UsageError as e:
if e.ctx is None:
e.ctx = ctx
raise
def iter_params_for_processing(invocation_order, declaration_order):
"""Given a sequence of parameters in the order as should be considered
for processing and an iterable of parameters that exist, this returns
a list in the correct order as they should be processed.
"""
def sort_key(item):
try:
idx = invocation_order.index(item)
except ValueError:
idx = float('inf')
return (not item.is_eager, idx)
return sorted(declaration_order, key=sort_key)
class Context(object):
"""The context is a special internal object that holds state relevant
for the script execution at every single level. It's normally invisible
to commands unless they opt-in to getting access to it.
The context is useful as it can pass internal objects around and can
control special execution features such as reading data from
environment variables.
A context can be used as context manager in which case it will call
:meth:`close` on teardown.
.. versionadded:: 2.0
Added the `resilient_parsing`, `help_option_names`,
`token_normalize_func` parameters.
.. versionadded:: 3.0
Added the `allow_extra_args` and `allow_interspersed_args`
parameters.
.. versionadded:: 4.0
Added the `color`, `ignore_unknown_options`, and
`max_content_width` parameters.
:param command: the command class for this context.
:param parent: the parent context.
:param info_name: the info name for this invocation. Generally this
is the most descriptive name for the script or
command. For the toplevel script it is usually
the name of the script, for commands below it it's
the name of the script.
:param obj: an arbitrary object of user data.
:param auto_envvar_prefix: the prefix to use for automatic environment
variables. If this is `None` then reading
from environment variables is disabled. This
does not affect manually set environment
variables which are always read.
:param default_map: a dictionary (like object) with default values
for parameters.
:param terminal_width: the width of the terminal. The default is
inherit from parent context. If no context
defines the terminal width then auto
detection will be applied.
:param max_content_width: the maximum width for content rendered by
Click (this currently only affects help
pages). This defaults to 80 characters if
not overridden. In other words: even if the
terminal is larger than that, Click will not
format things wider than 80 characters by
default. In addition to that, formatters might
add some safety mapping on the right.
:param resilient_parsing: if this flag is enabled then Click will
parse without any interactivity or callback
invocation. Default values will also be
ignored. This is useful for implementing
things such as completion support.
:param allow_extra_args: if this is set to `True` then extra arguments
at the end will not raise an error and will be
kept on the context. The default is to inherit
from the command.
:param allow_interspersed_args: if this is set to `False` then options
and arguments cannot be mixed. The
default is to inherit from the command.
:param ignore_unknown_options: instructs click to ignore options it does
not know and keeps them for later
processing.
:param help_option_names: optionally a list of strings that define how
the default help parameter is named. The
default is ``['--help']``.
:param token_normalize_func: an optional function that is used to
normalize tokens (options, choices,
etc.). This for instance can be used to
implement case insensitive behavior.
:param color: controls if the terminal supports ANSI colors or not. The
default is autodetection. This is only needed if ANSI
codes are used in texts that Click prints which is by
default not the case. This for instance would affect
help output.
"""
def __init__(self, command, parent=None, info_name=None, obj=None,
auto_envvar_prefix=None, default_map=None,
terminal_width=None, max_content_width=None,
resilient_parsing=False, allow_extra_args=None,
allow_interspersed_args=None,
ignore_unknown_options=None, help_option_names=None,
token_normalize_func=None, color=None):
#: the parent context or `None` if none exists.
self.parent = parent
#: the :class:`Command` for this context.
self.command = command
#: the descriptive information name
self.info_name = info_name
#: the parsed parameters except if the value is hidden in which
#: case it's not remembered.
self.params = {}
#: the leftover arguments.
self.args = []
#: protected arguments. These are arguments that are prepended
#: to `args` when certain parsing scenarios are encountered but
#: must be never propagated to another arguments. This is used
#: to implement nested parsing.
self.protected_args = []
if obj is None and parent is not None:
obj = parent.obj
#: the user object stored.
self.obj = obj
self._meta = getattr(parent, 'meta', {})
#: A dictionary (-like object) with defaults for parameters.
if default_map is None \
and parent is not None \
and parent.default_map is not None:
default_map = parent.default_map.get(info_name)
self.default_map = default_map
#: This flag indicates if a subcommand is going to be executed. A
#: group callback can use this information to figure out if it's
#: being executed directly or because the execution flow passes
#: onwards to a subcommand. By default it's None, but it can be
#: the name of the subcommand to execute.
#:
#: If chaining is enabled this will be set to ``'*'`` in case
#: any commands are executed. It is however not possible to
#: figure out which ones. If you require this knowledge you
#: should use a :func:`resultcallback`.
self.invoked_subcommand = None
if terminal_width is None and parent is not None:
terminal_width = parent.terminal_width
#: The width of the terminal (None is autodetection).
self.terminal_width = terminal_width
if max_content_width is None and parent is not None:
max_content_width = parent.max_content_width
#: The maximum width of formatted content (None implies a sensible
#: default which is 80 for most things).
self.max_content_width = max_content_width
if allow_extra_args is None:
allow_extra_args = command.allow_extra_args
#: Indicates if the context allows extra args or if it should
#: fail on parsing.
#:
#: .. versionadded:: 3.0
self.allow_extra_args = allow_extra_args
if allow_interspersed_args is None:
allow_interspersed_args = command.allow_interspersed_args
#: Indicates if the context allows mixing of arguments and
#: options or not.
#:
#: .. versionadded:: 3.0
self.allow_interspersed_args = allow_interspersed_args
if ignore_unknown_options is None:
ignore_unknown_options = command.ignore_unknown_options
#: Instructs click to ignore options that a command does not
#: understand and will store it on the context for later
#: processing. This is primarily useful for situations where you
#: want to call into external programs. Generally this pattern is
#: strongly discouraged because it's not possibly to losslessly
#: forward all arguments.
#:
#: .. versionadded:: 4.0
self.ignore_unknown_options = ignore_unknown_options
if help_option_names is None:
if parent is not None:
help_option_names = parent.help_option_names
else:
help_option_names = ['--help']
#: The names for the help options.
self.help_option_names = help_option_names
if token_normalize_func is None and parent is not None:
token_normalize_func = parent.token_normalize_func
#: An optional normalization function for tokens. This is
#: options, choices, commands etc.
self.token_normalize_func = token_normalize_func
#: Indicates if resilient parsing is enabled. In that case Click
#: will do its best to not cause any failures and default values
#: will be ignored. Useful for completion.
self.resilient_parsing = resilient_parsing
# If there is no envvar prefix yet, but the parent has one and
# the command on this level has a name, we can expand the envvar
# prefix automatically.
if auto_envvar_prefix is None:
if parent is not None \
and parent.auto_envvar_prefix is not None and \
self.info_name is not None:
auto_envvar_prefix = '%s_%s' % (parent.auto_envvar_prefix,
self.info_name.upper())
else:
auto_envvar_prefix = auto_envvar_prefix.upper()
self.auto_envvar_prefix = auto_envvar_prefix
if color is None and parent is not None:
color = parent.color
#: Controls if styling output is wanted or not.
self.color = color
self._close_callbacks = []
self._depth = 0
def __enter__(self):
self._depth += 1
push_context(self)
return self
def __exit__(self, exc_type, exc_value, tb):
self._depth -= 1
if self._depth == 0:
self.close()
pop_context()
@contextmanager
def scope(self, cleanup=True):
"""This helper method can be used with the context object to promote
it to the current thread local (see :func:`get_current_context`).
The default behavior of this is to invoke the cleanup functions which
can be disabled by setting `cleanup` to `False`. The cleanup
functions are typically used for things such as closing file handles.
If the cleanup is intended the context object can also be directly
used as a context manager.
Example usage::
with ctx.scope():
assert get_current_context() is ctx
This is equivalent::
with ctx:
assert get_current_context() is ctx
.. versionadded:: 5.0
:param cleanup: controls if the cleanup functions should be run or
not. The default is to run these functions. In
some situations the context only wants to be
temporarily pushed in which case this can be disabled.
Nested pushes automatically defer the cleanup.
"""
if not cleanup:
self._depth += 1
try:
with self as rv:
yield rv
finally:
if not cleanup:
self._depth -= 1
@property
def meta(self):
"""This is a dictionary which is shared with all the contexts
that are nested. It exists so that click utilities can store some
state here if they need to. It is however the responsibility of
that code to manage this dictionary well.
The keys are supposed to be unique dotted strings. For instance
module paths are a good choice for it. What is stored in there is
irrelevant for the operation of click. However what is important is
that code that places data here adheres to the general semantics of
the system.
Example usage::
LANG_KEY = __name__ + '.lang'
def set_language(value):
ctx = get_current_context()
ctx.meta[LANG_KEY] = value
def get_language():
return get_current_context().meta.get(LANG_KEY, 'en_US')
.. versionadded:: 5.0
"""
return self._meta
def make_formatter(self):
"""Creates the formatter for the help and usage output."""
return HelpFormatter(width=self.terminal_width,
max_width=self.max_content_width)
def call_on_close(self, f):
"""This decorator remembers a function as callback that should be
executed when the context tears down. This is most useful to bind
resource handling to the script execution. For instance, file objects
opened by the :class:`File` type will register their close callbacks
here.
:param f: the function to execute on teardown.
"""
self._close_callbacks.append(f)
return f
def close(self):
"""Invokes all close callbacks."""
for cb in self._close_callbacks:
cb()
self._close_callbacks = []
@property
def command_path(self):
"""The computed command path. This is used for the ``usage``
information on the help page. It's automatically created by
combining the info names of the chain of contexts to the root.
"""
rv = ''
if self.info_name is not None:
rv = self.info_name
if self.parent is not None:
rv = self.parent.command_path + ' ' + rv
return rv.lstrip()
def find_root(self):
"""Finds the outermost context."""
node = self
while node.parent is not None:
node = node.parent
return node
def find_object(self, object_type):
"""Finds the closest object of a given type."""
node = self
while node is not None:
if isinstance(node.obj, object_type):
return node.obj
node = node.parent
def ensure_object(self, object_type):
"""Like :meth:`find_object` but sets the innermost object to a
new instance of `object_type` if it does not exist.
"""
rv = self.find_object(object_type)
if rv is None:
self.obj = rv = object_type()
return rv
def lookup_default(self, name):
"""Looks up the default for a parameter name. This by default
looks into the :attr:`default_map` if available.
"""
if self.default_map is not None:
rv = self.default_map.get(name)
if callable(rv):
rv = rv()
return rv
def fail(self, message):
"""Aborts the execution of the program with a specific error
message.
:param message: the error message to fail with.
"""
raise UsageError(message, self)
def abort(self):
"""Aborts the script."""
raise Abort()
def exit(self, code=0):
"""Exits the application with a given exit code."""
raise Exit(code)
def get_usage(self):
"""Helper method to get formatted usage string for the current
context and command.
"""
return self.command.get_usage(self)
def get_help(self):
"""Helper method to get formatted help page for the current
context and command.
"""
return self.command.get_help(self)
def invoke(*args, **kwargs):
"""Invokes a command callback in exactly the way it expects. There
are two ways to invoke this method:
1. the first argument can be a callback and all other arguments and
keyword arguments are forwarded directly to the function.
2. the first argument is a click command object. In that case all
arguments are forwarded as well but proper click parameters
(options and click arguments) must be keyword arguments and Click
will fill in defaults.
Note that before Click 3.2 keyword arguments were not properly filled
in against the intention of this code and no context was created. For
more information about this change and why it was done in a bugfix
release see :ref:`upgrade-to-3.2`.
"""
self, callback = args[:2]
ctx = self
# It's also possible to invoke another command which might or
# might not have a callback. In that case we also fill
# in defaults and make a new context for this command.
if isinstance(callback, Command):
other_cmd = callback
callback = other_cmd.callback
ctx = Context(other_cmd, info_name=other_cmd.name, parent=self)
if callback is None:
raise TypeError('The given command does not have a '
'callback that can be invoked.')
for param in other_cmd.params:
if param.name not in kwargs and param.expose_value:
kwargs[param.name] = param.get_default(ctx)
args = args[2:]
with augment_usage_errors(self):
with ctx:
return callback(*args, **kwargs)
def forward(*args, **kwargs):
"""Similar to :meth:`invoke` but fills in default keyword
arguments from the current context if the other command expects
it. This cannot invoke callbacks directly, only other commands.
"""
self, cmd = args[:2]
# It's also possible to invoke another command which might or
# might not have a callback.
if not isinstance(cmd, Command):
raise TypeError('Callback is not a command.')
for param in self.params:
if param not in kwargs:
kwargs[param] = self.params[param]
return self.invoke(cmd, **kwargs)
class BaseCommand(object):
"""The base command implements the minimal API contract of commands.
Most code will never use this as it does not implement a lot of useful
functionality but it can act as the direct subclass of alternative
parsing methods that do not depend on the Click parser.
For instance, this can be used to bridge Click and other systems like
argparse or docopt.
Because base commands do not implement a lot of the API that other
parts of Click take for granted, they are not supported for all
operations. For instance, they cannot be used with the decorators
usually and they have no built-in callback system.
.. versionchanged:: 2.0
Added the `context_settings` parameter.
:param name: the name of the command to use unless a group overrides it.
:param context_settings: an optional dictionary with defaults that are
passed to the context object.
"""
#: the default for the :attr:`Context.allow_extra_args` flag.
allow_extra_args = False
#: the default for the :attr:`Context.allow_interspersed_args` flag.
allow_interspersed_args = True
#: the default for the :attr:`Context.ignore_unknown_options` flag.
ignore_unknown_options = False
def __init__(self, name, context_settings=None):
#: the name the command thinks it has. Upon registering a command
#: on a :class:`Group` the group will default the command name
#: with this information. You should instead use the
#: :class:`Context`\'s :attr:`~Context.info_name` attribute.
self.name = name
if context_settings is None:
context_settings = {}
#: an optional dictionary with defaults passed to the context.
self.context_settings = context_settings
def get_usage(self, ctx):
raise NotImplementedError('Base commands cannot get usage')
def get_help(self, ctx):
raise NotImplementedError('Base commands cannot get help')
def make_context(self, info_name, args, parent=None, **extra):
"""This function when given an info name and arguments will kick
off the parsing and create a new :class:`Context`. It does not
invoke the actual command callback though.
:param info_name: the info name for this invokation. Generally this
is the most descriptive name for the script or
command. For the toplevel script it's usually
the name of the script, for commands below it it's
the name of the script.
:param args: the arguments to parse as list of strings.
:param parent: the parent context if available.
:param extra: extra keyword arguments forwarded to the context
constructor.
"""
for key, value in iteritems(self.context_settings):
if key not in extra:
extra[key] = value
ctx = Context(self, info_name=info_name, parent=parent, **extra)
with ctx.scope(cleanup=False):
self.parse_args(ctx, args)
return ctx
def parse_args(self, ctx, args):
"""Given a context and a list of arguments this creates the parser
and parses the arguments, then modifies the context as necessary.
This is automatically invoked by :meth:`make_context`.
"""
raise NotImplementedError('Base commands do not know how to parse '
'arguments.')
def invoke(self, ctx):
"""Given a context, this invokes the command. The default
implementation is raising a not implemented error.
"""
raise NotImplementedError('Base commands are not invokable by default')
def main(self, args=None, prog_name=None, complete_var=None,
standalone_mode=True, **extra):
"""This is the way to invoke a script with all the bells and
whistles as a command line application. This will always terminate
the application after a call. If this is not wanted, ``SystemExit``
needs to be caught.
This method is also available by directly calling the instance of
a :class:`Command`.
.. versionadded:: 3.0
Added the `standalone_mode` flag to control the standalone mode.
:param args: the arguments that should be used for parsing. If not
provided, ``sys.argv[1:]`` is used.
:param prog_name: the program name that should be used. By default
the program name is constructed by taking the file
name from ``sys.argv[0]``.
:param complete_var: the environment variable that controls the
bash completion support. The default is
``"__COMPLETE"`` with prog_name in
uppercase.
:param standalone_mode: the default behavior is to invoke the script
in standalone mode. Click will then
handle exceptions and convert them into
error messages and the function will never
return but shut down the interpreter. If
this is set to `False` they will be
propagated to the caller and the return
value of this function is the return value
of :meth:`invoke`.
:param extra: extra keyword arguments are forwarded to the context
constructor. See :class:`Context` for more information.
"""
# If we are in Python 3, we will verify that the environment is
# sane at this point or reject further execution to avoid a
# broken script.
if not PY2:
_verify_python3_env()
else:
_check_for_unicode_literals()
if args is None:
args = get_os_args()
else:
args = list(args)
if prog_name is None:
prog_name = make_str(os.path.basename(
sys.argv and sys.argv[0] or __file__))
# Hook for the Bash completion. This only activates if the Bash
# completion is actually enabled, otherwise this is quite a fast
# noop.
_bashcomplete(self, prog_name, complete_var)
try:
try:
with self.make_context(prog_name, args, **extra) as ctx:
rv = self.invoke(ctx)
if not standalone_mode:
return rv
# it's not safe to `ctx.exit(rv)` here!
# note that `rv` may actually contain data like "1" which
# has obvious effects
# more subtle case: `rv=[None, None]` can come out of
# chained commands which all returned `None` -- so it's not
# even always obvious that `rv` indicates success/failure
# by its truthiness/falsiness
ctx.exit()
except (EOFError, KeyboardInterrupt):
echo(file=sys.stderr)
raise Abort()
except ClickException as e:
if not standalone_mode:
raise
e.show()
sys.exit(e.exit_code)
except IOError as e:
if e.errno == errno.EPIPE:
sys.stdout = PacifyFlushWrapper(sys.stdout)
sys.stderr = PacifyFlushWrapper(sys.stderr)
sys.exit(1)
else:
raise
except Exit as e:
if standalone_mode:
sys.exit(e.exit_code)
else:
# in non-standalone mode, return the exit code
# note that this is only reached if `self.invoke` above raises
# an Exit explicitly -- thus bypassing the check there which
# would return its result
# the results of non-standalone execution may therefore be
# somewhat ambiguous: if there are codepaths which lead to
# `ctx.exit(1)` and to `return 1`, the caller won't be able to
# tell the difference between the two
return e.exit_code
except Abort:
if not standalone_mode:
raise
echo('Aborted!', file=sys.stderr)
sys.exit(1)
def __call__(self, *args, **kwargs):
"""Alias for :meth:`main`."""
return self.main(*args, **kwargs)
class Command(BaseCommand):
"""Commands are the basic building block of command line interfaces in
Click. A basic command handles command line parsing and might dispatch
more parsing to commands nested below it.
.. versionchanged:: 2.0
Added the `context_settings` parameter.
:param name: the name of the command to use unless a group overrides it.
:param context_settings: an optional dictionary with defaults that are
passed to the context object.
:param callback: the callback to invoke. This is optional.
:param params: the parameters to register with this command. This can
be either :class:`Option` or :class:`Argument` objects.
:param help: the help string to use for this command.
:param epilog: like the help string but it's printed at the end of the
help page after everything else.
:param short_help: the short help to use for this command. This is
shown on the command listing of the parent command.
:param add_help_option: by default each command registers a ``--help``
option. This can be disabled by this parameter.
:param hidden: hide this command from help outputs.
:param deprecated: issues a message indicating that
the command is deprecated.
"""
def __init__(self, name, context_settings=None, callback=None,
params=None, help=None, epilog=None, short_help=None,
options_metavar='[OPTIONS]', add_help_option=True,
hidden=False, deprecated=False):
BaseCommand.__init__(self, name, context_settings)
#: the callback to execute when the command fires. This might be
#: `None` in which case nothing happens.
self.callback = callback
#: the list of parameters for this command in the order they
#: should show up in the help page and execute. Eager parameters
#: will automatically be handled before non eager ones.
self.params = params or []
# if a form feed (page break) is found in the help text, truncate help
# text to the content preceding the first form feed
if help and '\f' in help:
help = help.split('\f', 1)[0]
self.help = help
self.epilog = epilog
self.options_metavar = options_metavar
self.short_help = short_help
self.add_help_option = add_help_option
self.hidden = hidden
self.deprecated = deprecated
def get_usage(self, ctx):
formatter = ctx.make_formatter()
self.format_usage(ctx, formatter)
return formatter.getvalue().rstrip('\n')
def get_params(self, ctx):
rv = self.params
help_option = self.get_help_option(ctx)
if help_option is not None:
rv = rv + [help_option]
return rv
def format_usage(self, ctx, formatter):
"""Writes the usage line into the formatter."""
pieces = self.collect_usage_pieces(ctx)
formatter.write_usage(ctx.command_path, ' '.join(pieces))
def collect_usage_pieces(self, ctx):
"""Returns all the pieces that go into the usage line and returns
it as a list of strings.
"""
rv = [self.options_metavar]
for param in self.get_params(ctx):
rv.extend(param.get_usage_pieces(ctx))
return rv
def get_help_option_names(self, ctx):
"""Returns the names for the help option."""
all_names = set(ctx.help_option_names)
for param in self.params:
all_names.difference_update(param.opts)
all_names.difference_update(param.secondary_opts)
return all_names
def get_help_option(self, ctx):
"""Returns the help option object."""
help_options = self.get_help_option_names(ctx)
if not help_options or not self.add_help_option:
return
def show_help(ctx, param, value):
if value and not ctx.resilient_parsing:
echo(ctx.get_help(), color=ctx.color)
ctx.exit()
return Option(help_options, is_flag=True,
is_eager=True, expose_value=False,
callback=show_help,
help='Show this message and exit.')
def make_parser(self, ctx):
"""Creates the underlying option parser for this command."""
parser = OptionParser(ctx)
for param in self.get_params(ctx):
param.add_to_parser(parser, ctx)
return parser
def get_help(self, ctx):
"""Formats the help into a string and returns it. This creates a
formatter and will call into the following formatting methods:
"""
formatter = ctx.make_formatter()
self.format_help(ctx, formatter)
return formatter.getvalue().rstrip('\n')
def get_short_help_str(self, limit=45):
"""Gets short help for the command or makes it by shortening the long help string."""
return self.short_help or self.help and make_default_short_help(self.help, limit) or ''
def format_help(self, ctx, formatter):
"""Writes the help into the formatter if it exists.
This calls into the following methods:
- :meth:`format_usage`
- :meth:`format_help_text`
- :meth:`format_options`
- :meth:`format_epilog`
"""
self.format_usage(ctx, formatter)
self.format_help_text(ctx, formatter)
self.format_options(ctx, formatter)
self.format_epilog(ctx, formatter)
def format_help_text(self, ctx, formatter):
"""Writes the help text to the formatter if it exists."""
if self.help:
formatter.write_paragraph()
with formatter.indentation():
help_text = self.help
if self.deprecated:
help_text += DEPRECATED_HELP_NOTICE
formatter.write_text(help_text)
elif self.deprecated:
formatter.write_paragraph()
with formatter.indentation():
formatter.write_text(DEPRECATED_HELP_NOTICE)
def format_options(self, ctx, formatter):
"""Writes all the options into the formatter if they exist."""
opts = []
for param in self.get_params(ctx):
rv = param.get_help_record(ctx)
if rv is not None:
opts.append(rv)
if opts:
with formatter.section('Options'):
formatter.write_dl(opts)
def format_epilog(self, ctx, formatter):
"""Writes the epilog into the formatter if it exists."""
if self.epilog:
formatter.write_paragraph()
with formatter.indentation():
formatter.write_text(self.epilog)
def parse_args(self, ctx, args):
parser = self.make_parser(ctx)
opts, args, param_order = parser.parse_args(args=args)
for param in iter_params_for_processing(
param_order, self.get_params(ctx)):
value, args = param.handle_parse_result(ctx, opts, args)
if args and not ctx.allow_extra_args and not ctx.resilient_parsing:
ctx.fail('Got unexpected extra argument%s (%s)'
% (len(args) != 1 and 's' or '',
' '.join(map(make_str, args))))
ctx.args = args
return args
def invoke(self, ctx):
"""Given a context, this invokes the attached callback (if it exists)
in the right way.
"""
_maybe_show_deprecated_notice(self)
if self.callback is not None:
return ctx.invoke(self.callback, **ctx.params)
class MultiCommand(Command):
"""A multi command is the basic implementation of a command that
dispatches to subcommands. The most common version is the
:class:`Group`.
:param invoke_without_command: this controls how the multi command itself
is invoked. By default it's only invoked
if a subcommand is provided.
:param no_args_is_help: this controls what happens if no arguments are
provided. This option is enabled by default if
`invoke_without_command` is disabled or disabled
if it's enabled. If enabled this will add
``--help`` as argument if no arguments are
passed.
:param subcommand_metavar: the string that is used in the documentation
to indicate the subcommand place.
:param chain: if this is set to `True` chaining of multiple subcommands
is enabled. This restricts the form of commands in that
they cannot have optional arguments but it allows
multiple commands to be chained together.
:param result_callback: the result callback to attach to this multi
command.
"""
allow_extra_args = True
allow_interspersed_args = False
def __init__(self, name=None, invoke_without_command=False,
no_args_is_help=None, subcommand_metavar=None,
chain=False, result_callback=None, **attrs):
Command.__init__(self, name, **attrs)
if no_args_is_help is None:
no_args_is_help = not invoke_without_command
self.no_args_is_help = no_args_is_help
self.invoke_without_command = invoke_without_command
if subcommand_metavar is None:
if chain:
subcommand_metavar = SUBCOMMANDS_METAVAR
else:
subcommand_metavar = SUBCOMMAND_METAVAR
self.subcommand_metavar = subcommand_metavar
self.chain = chain
#: The result callback that is stored. This can be set or
#: overridden with the :func:`resultcallback` decorator.
self.result_callback = result_callback
if self.chain:
for param in self.params:
if isinstance(param, Argument) and not param.required:
raise RuntimeError('Multi commands in chain mode cannot '
'have optional arguments.')
def collect_usage_pieces(self, ctx):
rv = Command.collect_usage_pieces(self, ctx)
rv.append(self.subcommand_metavar)
return rv
def format_options(self, ctx, formatter):
Command.format_options(self, ctx, formatter)
self.format_commands(ctx, formatter)
def resultcallback(self, replace=False):
"""Adds a result callback to the chain command. By default if a
result callback is already registered this will chain them but
this can be disabled with the `replace` parameter. The result
callback is invoked with the return value of the subcommand
(or the list of return values from all subcommands if chaining
is enabled) as well as the parameters as they would be passed
to the main callback.
Example::
@click.group()
@click.option('-i', '--input', default=23)
def cli(input):
return 42
@cli.resultcallback()
def process_result(result, input):
return result + input
.. versionadded:: 3.0
:param replace: if set to `True` an already existing result
callback will be removed.
"""
def decorator(f):
old_callback = self.result_callback
if old_callback is None or replace:
self.result_callback = f
return f
def function(__value, *args, **kwargs):
return f(old_callback(__value, *args, **kwargs),
*args, **kwargs)
self.result_callback = rv = update_wrapper(function, f)
return rv
return decorator
def format_commands(self, ctx, formatter):
"""Extra format methods for multi methods that adds all the commands
after the options.
"""
commands = []
for subcommand in self.list_commands(ctx):
cmd = self.get_command(ctx, subcommand)
# What is this, the tool lied about a command. Ignore it
if cmd is None:
continue
if cmd.hidden:
continue
commands.append((subcommand, cmd))
# allow for 3 times the default spacing
if len(commands):
limit = formatter.width - 6 - max(len(cmd[0]) for cmd in commands)
rows = []
for subcommand, cmd in commands:
help = cmd.get_short_help_str(limit)
rows.append((subcommand, help))
if rows:
with formatter.section('Commands'):
formatter.write_dl(rows)
def parse_args(self, ctx, args):
if not args and self.no_args_is_help and not ctx.resilient_parsing:
echo(ctx.get_help(), color=ctx.color)
ctx.exit()
rest = Command.parse_args(self, ctx, args)
if self.chain:
ctx.protected_args = rest
ctx.args = []
elif rest:
ctx.protected_args, ctx.args = rest[:1], rest[1:]
return ctx.args
def invoke(self, ctx):
def _process_result(value):
if self.result_callback is not None:
value = ctx.invoke(self.result_callback, value,
**ctx.params)
return value
if not ctx.protected_args:
# If we are invoked without command the chain flag controls
# how this happens. If we are not in chain mode, the return
# value here is the return value of the command.
# If however we are in chain mode, the return value is the
# return value of the result processor invoked with an empty
# list (which means that no subcommand actually was executed).
if self.invoke_without_command:
if not self.chain:
return Command.invoke(self, ctx)
with ctx:
Command.invoke(self, ctx)
return _process_result([])
ctx.fail('Missing command.')
# Fetch args back out
args = ctx.protected_args + ctx.args
ctx.args = []
ctx.protected_args = []
# If we're not in chain mode, we only allow the invocation of a
# single command but we also inform the current context about the
# name of the command to invoke.
if not self.chain:
# Make sure the context is entered so we do not clean up
# resources until the result processor has worked.
with ctx:
cmd_name, cmd, args = self.resolve_command(ctx, args)
ctx.invoked_subcommand = cmd_name
Command.invoke(self, ctx)
sub_ctx = cmd.make_context(cmd_name, args, parent=ctx)
with sub_ctx:
return _process_result(sub_ctx.command.invoke(sub_ctx))
# In chain mode we create the contexts step by step, but after the
# base command has been invoked. Because at that point we do not
# know the subcommands yet, the invoked subcommand attribute is
# set to ``*`` to inform the command that subcommands are executed
# but nothing else.
with ctx:
ctx.invoked_subcommand = args and '*' or None
Command.invoke(self, ctx)
# Otherwise we make every single context and invoke them in a
# chain. In that case the return value to the result processor
# is the list of all invoked subcommand's results.
contexts = []
while args:
cmd_name, cmd, args = self.resolve_command(ctx, args)
sub_ctx = cmd.make_context(cmd_name, args, parent=ctx,
allow_extra_args=True,
allow_interspersed_args=False)
contexts.append(sub_ctx)
args, sub_ctx.args = sub_ctx.args, []
rv = []
for sub_ctx in contexts:
with sub_ctx:
rv.append(sub_ctx.command.invoke(sub_ctx))
return _process_result(rv)
def resolve_command(self, ctx, args):
cmd_name = make_str(args[0])
original_cmd_name = cmd_name
# Get the command
cmd = self.get_command(ctx, cmd_name)
# If we can't find the command but there is a normalization
# function available, we try with that one.
if cmd is None and ctx.token_normalize_func is not None:
cmd_name = ctx.token_normalize_func(cmd_name)
cmd = self.get_command(ctx, cmd_name)
# If we don't find the command we want to show an error message
# to the user that it was not provided. However, there is
# something else we should do: if the first argument looks like
# an option we want to kick off parsing again for arguments to
# resolve things like --help which now should go to the main
# place.
if cmd is None and not ctx.resilient_parsing:
if split_opt(cmd_name)[0]:
self.parse_args(ctx, ctx.args)
ctx.fail('No such command "%s".' % original_cmd_name)
return cmd_name, cmd, args[1:]
def get_command(self, ctx, cmd_name):
"""Given a context and a command name, this returns a
:class:`Command` object if it exists or returns `None`.
"""
raise NotImplementedError()
def list_commands(self, ctx):
"""Returns a list of subcommand names in the order they should
appear.
"""
return []
class Group(MultiCommand):
"""A group allows a command to have subcommands attached. This is the
most common way to implement nesting in Click.
:param commands: a dictionary of commands.
"""
def __init__(self, name=None, commands=None, **attrs):
MultiCommand.__init__(self, name, **attrs)
#: the registered subcommands by their exported names.
self.commands = commands or {}
def add_command(self, cmd, name=None):
"""Registers another :class:`Command` with this group. If the name
is not provided, the name of the command is used.
"""
name = name or cmd.name
if name is None:
raise TypeError('Command has no name.')
_check_multicommand(self, name, cmd, register=True)
self.commands[name] = cmd
def command(self, *args, **kwargs):
"""A shortcut decorator for declaring and attaching a command to
the group. This takes the same arguments as :func:`command` but
immediately registers the created command with this instance by
calling into :meth:`add_command`.
"""
def decorator(f):
cmd = command(*args, **kwargs)(f)
self.add_command(cmd)
return cmd
return decorator
def group(self, *args, **kwargs):
"""A shortcut decorator for declaring and attaching a group to
the group. This takes the same arguments as :func:`group` but
immediately registers the created command with this instance by
calling into :meth:`add_command`.
"""
def decorator(f):
cmd = group(*args, **kwargs)(f)
self.add_command(cmd)
return cmd
return decorator
def get_command(self, ctx, cmd_name):
return self.commands.get(cmd_name)
def list_commands(self, ctx):
return sorted(self.commands)
class CommandCollection(MultiCommand):
"""A command collection is a multi command that merges multiple multi
commands together into one. This is a straightforward implementation
that accepts a list of different multi commands as sources and
provides all the commands for each of them.
"""
def __init__(self, name=None, sources=None, **attrs):
MultiCommand.__init__(self, name, **attrs)
#: The list of registered multi commands.
self.sources = sources or []
def add_source(self, multi_cmd):
"""Adds a new multi command to the chain dispatcher."""
self.sources.append(multi_cmd)
def get_command(self, ctx, cmd_name):
for source in self.sources:
rv = source.get_command(ctx, cmd_name)
if rv is not None:
if self.chain:
_check_multicommand(self, cmd_name, rv)
return rv
def list_commands(self, ctx):
rv = set()
for source in self.sources:
rv.update(source.list_commands(ctx))
return sorted(rv)
class Parameter(object):
r"""A parameter to a command comes in two versions: they are either
:class:`Option`\s or :class:`Argument`\s. Other subclasses are currently
not supported by design as some of the internals for parsing are
intentionally not finalized.
Some settings are supported by both options and arguments.
.. versionchanged:: 2.0
Changed signature for parameter callback to also be passed the
parameter. In Click 2.0, the old callback format will still work,
but it will raise a warning to give you change to migrate the
code easier.
:param param_decls: the parameter declarations for this option or
argument. This is a list of flags or argument
names.
:param type: the type that should be used. Either a :class:`ParamType`
or a Python type. The later is converted into the former
automatically if supported.
:param required: controls if this is optional or not.
:param default: the default value if omitted. This can also be a callable,
in which case it's invoked when the default is needed
without any arguments.
:param callback: a callback that should be executed after the parameter
was matched. This is called as ``fn(ctx, param,
value)`` and needs to return the value. Before Click
2.0, the signature was ``(ctx, value)``.
:param nargs: the number of arguments to match. If not ``1`` the return
value is a tuple instead of single value. The default for
nargs is ``1`` (except if the type is a tuple, then it's
the arity of the tuple).
:param metavar: how the value is represented in the help page.
:param expose_value: if this is `True` then the value is passed onwards
to the command callback and stored on the context,
otherwise it's skipped.
:param is_eager: eager values are processed before non eager ones. This
should not be set for arguments or it will inverse the
order of processing.
:param envvar: a string or list of strings that are environment variables
that should be checked.
"""
param_type_name = 'parameter'
def __init__(self, param_decls=None, type=None, required=False,
default=None, callback=None, nargs=None, metavar=None,
expose_value=True, is_eager=False, envvar=None,
autocompletion=None):
self.name, self.opts, self.secondary_opts = \
self._parse_decls(param_decls or (), expose_value)
self.type = convert_type(type, default)
# Default nargs to what the type tells us if we have that
# information available.
if nargs is None:
if self.type.is_composite:
nargs = self.type.arity
else:
nargs = 1
self.required = required
self.callback = callback
self.nargs = nargs
self.multiple = False
self.expose_value = expose_value
self.default = default
self.is_eager = is_eager
self.metavar = metavar
self.envvar = envvar
self.autocompletion = autocompletion
@property
def human_readable_name(self):
"""Returns the human readable name of this parameter. This is the
same as the name for options, but the metavar for arguments.
"""
return self.name
def make_metavar(self):
if self.metavar is not None:
return self.metavar
metavar = self.type.get_metavar(self)
if metavar is None:
metavar = self.type.name.upper()
if self.nargs != 1:
metavar += '...'
return metavar
def get_default(self, ctx):
"""Given a context variable this calculates the default value."""
# Otherwise go with the regular default.
if callable(self.default):
rv = self.default()
else:
rv = self.default
return self.type_cast_value(ctx, rv)
def add_to_parser(self, parser, ctx):
pass
def consume_value(self, ctx, opts):
value = opts.get(self.name)
if value is None:
value = self.value_from_envvar(ctx)
if value is None:
value = ctx.lookup_default(self.name)
return value
def type_cast_value(self, ctx, value):
"""Given a value this runs it properly through the type system.
This automatically handles things like `nargs` and `multiple` as
well as composite types.
"""
if self.type.is_composite:
if self.nargs <= 1:
raise TypeError('Attempted to invoke composite type '
'but nargs has been set to %s. This is '
'not supported; nargs needs to be set to '
'a fixed value > 1.' % self.nargs)
if self.multiple:
return tuple(self.type(x or (), self, ctx) for x in value or ())
return self.type(value or (), self, ctx)
def _convert(value, level):
if level == 0:
return self.type(value, self, ctx)
return tuple(_convert(x, level - 1) for x in value or ())
return _convert(value, (self.nargs != 1) + bool(self.multiple))
def process_value(self, ctx, value):
"""Given a value and context this runs the logic to convert the
value as necessary.
"""
# If the value we were given is None we do nothing. This way
# code that calls this can easily figure out if something was
# not provided. Otherwise it would be converted into an empty
# tuple for multiple invocations which is inconvenient.
if value is not None:
return self.type_cast_value(ctx, value)
def value_is_missing(self, value):
if value is None:
return True
if (self.nargs != 1 or self.multiple) and value == ():
return True
return False
def full_process_value(self, ctx, value):
value = self.process_value(ctx, value)
if value is None and not ctx.resilient_parsing:
value = self.get_default(ctx)
if self.required and self.value_is_missing(value):
raise MissingParameter(ctx=ctx, param=self)
return value
def resolve_envvar_value(self, ctx):
if self.envvar is None:
return
if isinstance(self.envvar, (tuple, list)):
for envvar in self.envvar:
rv = os.environ.get(envvar)
if rv is not None:
return rv
else:
return os.environ.get(self.envvar)
def value_from_envvar(self, ctx):
rv = self.resolve_envvar_value(ctx)
if rv is not None and self.nargs != 1:
rv = self.type.split_envvar_value(rv)
return rv
def handle_parse_result(self, ctx, opts, args):
with augment_usage_errors(ctx, param=self):
value = self.consume_value(ctx, opts)
try:
value = self.full_process_value(ctx, value)
except Exception:
if not ctx.resilient_parsing:
raise
value = None
if self.callback is not None:
try:
value = invoke_param_callback(
self.callback, ctx, self, value)
except Exception:
if not ctx.resilient_parsing:
raise
if self.expose_value:
ctx.params[self.name] = value
return value, args
def get_help_record(self, ctx):
pass
def get_usage_pieces(self, ctx):
return []
def get_error_hint(self, ctx):
"""Get a stringified version of the param for use in error messages to
indicate which param caused the error.
"""
hint_list = self.opts or [self.human_readable_name]
return ' / '.join('"%s"' % x for x in hint_list)
class Option(Parameter):
"""Options are usually optional values on the command line and
have some extra features that arguments don't have.
All other parameters are passed onwards to the parameter constructor.
:param show_default: controls if the default value should be shown on the
help page. Normally, defaults are not shown. If this
value is a string, it shows the string instead of the
value. This is particularly useful for dynamic options.
:param show_envvar: controls if an environment variable should be shown on
the help page. Normally, environment variables
are not shown.
:param prompt: if set to `True` or a non empty string then the user will be
prompted for input. If set to `True` the prompt will be the
option name capitalized.
:param confirmation_prompt: if set then the value will need to be confirmed
if it was prompted for.
:param hide_input: if this is `True` then the input on the prompt will be
hidden from the user. This is useful for password
input.
:param is_flag: forces this option to act as a flag. The default is
auto detection.
:param flag_value: which value should be used for this flag if it's
enabled. This is set to a boolean automatically if
the option string contains a slash to mark two options.
:param multiple: if this is set to `True` then the argument is accepted
multiple times and recorded. This is similar to ``nargs``
in how it works but supports arbitrary number of
arguments.
:param count: this flag makes an option increment an integer.
:param allow_from_autoenv: if this is enabled then the value of this
parameter will be pulled from an environment
variable in case a prefix is defined on the
context.
:param help: the help string.
:param hidden: hide this option from help outputs.
"""
param_type_name = 'option'
def __init__(self, param_decls=None, show_default=False,
prompt=False, confirmation_prompt=False,
hide_input=False, is_flag=None, flag_value=None,
multiple=False, count=False, allow_from_autoenv=True,
type=None, help=None, hidden=False, show_choices=True,
show_envvar=False, **attrs):
default_is_missing = attrs.get('default', _missing) is _missing
Parameter.__init__(self, param_decls, type=type, **attrs)
if prompt is True:
prompt_text = self.name.replace('_', ' ').capitalize()
elif prompt is False:
prompt_text = None
else:
prompt_text = prompt
self.prompt = prompt_text
self.confirmation_prompt = confirmation_prompt
self.hide_input = hide_input
self.hidden = hidden
# Flags
if is_flag is None:
if flag_value is not None:
is_flag = True
else:
is_flag = bool(self.secondary_opts)
if is_flag and default_is_missing:
self.default = False
if flag_value is None:
flag_value = not self.default
self.is_flag = is_flag
self.flag_value = flag_value
if self.is_flag and isinstance(self.flag_value, bool) \
and type is None:
self.type = BOOL
self.is_bool_flag = True
else:
self.is_bool_flag = False
# Counting
self.count = count
if count:
if type is None:
self.type = IntRange(min=0)
if default_is_missing:
self.default = 0
self.multiple = multiple
self.allow_from_autoenv = allow_from_autoenv
self.help = help
self.show_default = show_default
self.show_choices = show_choices
self.show_envvar = show_envvar
# Sanity check for stuff we don't support
if __debug__:
if self.nargs < 0:
raise TypeError('Options cannot have nargs < 0')
if self.prompt and self.is_flag and not self.is_bool_flag:
raise TypeError('Cannot prompt for flags that are not bools.')
if not self.is_bool_flag and self.secondary_opts:
raise TypeError('Got secondary option for non boolean flag.')
if self.is_bool_flag and self.hide_input \
and self.prompt is not None:
raise TypeError('Hidden input does not work with boolean '
'flag prompts.')
if self.count:
if self.multiple:
raise TypeError('Options cannot be multiple and count '
'at the same time.')
elif self.is_flag:
raise TypeError('Options cannot be count and flags at '
'the same time.')
def _parse_decls(self, decls, expose_value):
opts = []
secondary_opts = []
name = None
possible_names = []
for decl in decls:
if isidentifier(decl):
if name is not None:
raise TypeError('Name defined twice')
name = decl
else:
split_char = decl[:1] == '/' and ';' or '/'
if split_char in decl:
first, second = decl.split(split_char, 1)
first = first.rstrip()
if first:
possible_names.append(split_opt(first))
opts.append(first)
second = second.lstrip()
if second:
secondary_opts.append(second.lstrip())
else:
possible_names.append(split_opt(decl))
opts.append(decl)
if name is None and possible_names:
possible_names.sort(key=lambda x: -len(x[0])) # group long options first
name = possible_names[0][1].replace('-', '_').lower()
if not isidentifier(name):
name = None
if name is None:
if not expose_value:
return None, opts, secondary_opts
raise TypeError('Could not determine name for option')
if not opts and not secondary_opts:
raise TypeError('No options defined but a name was passed (%s). '
'Did you mean to declare an argument instead '
'of an option?' % name)
return name, opts, secondary_opts
def add_to_parser(self, parser, ctx):
kwargs = {
'dest': self.name,
'nargs': self.nargs,
'obj': self,
}
if self.multiple:
action = 'append'
elif self.count:
action = 'count'
else:
action = 'store'
if self.is_flag:
kwargs.pop('nargs', None)
if self.is_bool_flag and self.secondary_opts:
parser.add_option(self.opts, action=action + '_const',
const=True, **kwargs)
parser.add_option(self.secondary_opts, action=action +
'_const', const=False, **kwargs)
else:
parser.add_option(self.opts, action=action + '_const',
const=self.flag_value,
**kwargs)
else:
kwargs['action'] = action
parser.add_option(self.opts, **kwargs)
def get_help_record(self, ctx):
if self.hidden:
return
any_prefix_is_slash = []
def _write_opts(opts):
rv, any_slashes = join_options(opts)
if any_slashes:
any_prefix_is_slash[:] = [True]
if not self.is_flag and not self.count:
rv += ' ' + self.make_metavar()
return rv
rv = [_write_opts(self.opts)]
if self.secondary_opts:
rv.append(_write_opts(self.secondary_opts))
help = self.help or ''
extra = []
if self.show_envvar:
envvar = self.envvar
if envvar is None:
if self.allow_from_autoenv and \
ctx.auto_envvar_prefix is not None:
envvar = '%s_%s' % (ctx.auto_envvar_prefix, self.name.upper())
if envvar is not None:
extra.append('env var: %s' % (
', '.join('%s' % d for d in envvar)
if isinstance(envvar, (list, tuple))
else envvar, ))
if self.default is not None and self.show_default:
if isinstance(self.show_default, string_types):
default_string = '({})'.format(self.show_default)
elif isinstance(self.default, (list, tuple)):
default_string = ', '.join('%s' % d for d in self.default)
elif inspect.isfunction(self.default):
default_string = "(dynamic)"
else:
default_string = self.default
extra.append('default: {}'.format(default_string))
if self.required:
extra.append('required')
if extra:
help = '%s[%s]' % (help and help + ' ' or '', '; '.join(extra))
return ((any_prefix_is_slash and '; ' or ' / ').join(rv), help)
def get_default(self, ctx):
# If we're a non boolean flag out default is more complex because
# we need to look at all flags in the same group to figure out
# if we're the the default one in which case we return the flag
# value as default.
if self.is_flag and not self.is_bool_flag:
for param in ctx.command.params:
if param.name == self.name and param.default:
return param.flag_value
return None
return Parameter.get_default(self, ctx)
def prompt_for_value(self, ctx):
"""This is an alternative flow that can be activated in the full
value processing if a value does not exist. It will prompt the
user until a valid value exists and then returns the processed
value as result.
"""
# Calculate the default before prompting anything to be stable.
default = self.get_default(ctx)
# If this is a prompt for a flag we need to handle this
# differently.
if self.is_bool_flag:
return confirm(self.prompt, default)
return prompt(self.prompt, default=default, type=self.type,
hide_input=self.hide_input, show_choices=self.show_choices,
confirmation_prompt=self.confirmation_prompt,
value_proc=lambda x: self.process_value(ctx, x))
def resolve_envvar_value(self, ctx):
rv = Parameter.resolve_envvar_value(self, ctx)
if rv is not None:
return rv
if self.allow_from_autoenv and \
ctx.auto_envvar_prefix is not None:
envvar = '%s_%s' % (ctx.auto_envvar_prefix, self.name.upper())
return os.environ.get(envvar)
def value_from_envvar(self, ctx):
rv = self.resolve_envvar_value(ctx)
if rv is None:
return None
value_depth = (self.nargs != 1) + bool(self.multiple)
if value_depth > 0 and rv is not None:
rv = self.type.split_envvar_value(rv)
if self.multiple and self.nargs != 1:
rv = batch(rv, self.nargs)
return rv
def full_process_value(self, ctx, value):
if value is None and self.prompt is not None \
and not ctx.resilient_parsing:
return self.prompt_for_value(ctx)
return Parameter.full_process_value(self, ctx, value)
class Argument(Parameter):
"""Arguments are positional parameters to a command. They generally
provide fewer features than options but can have infinite ``nargs``
and are required by default.
All parameters are passed onwards to the parameter constructor.
"""
param_type_name = 'argument'
def __init__(self, param_decls, required=None, **attrs):
if required is None:
if attrs.get('default') is not None:
required = False
else:
required = attrs.get('nargs', 1) > 0
Parameter.__init__(self, param_decls, required=required, **attrs)
if self.default is not None and self.nargs < 0:
raise TypeError('nargs=-1 in combination with a default value '
'is not supported.')
@property
def human_readable_name(self):
if self.metavar is not None:
return self.metavar
return self.name.upper()
def make_metavar(self):
if self.metavar is not None:
return self.metavar
var = self.type.get_metavar(self)
if not var:
var = self.name.upper()
if not self.required:
var = '[%s]' % var
if self.nargs != 1:
var += '...'
return var
def _parse_decls(self, decls, expose_value):
if not decls:
if not expose_value:
return None, [], []
raise TypeError('Could not determine name for argument')
if len(decls) == 1:
name = arg = decls[0]
name = name.replace('-', '_').lower()
else:
raise TypeError('Arguments take exactly one '
'parameter declaration, got %d' % len(decls))
return name, [arg], []
def get_usage_pieces(self, ctx):
return [self.make_metavar()]
def get_error_hint(self, ctx):
return '"%s"' % self.make_metavar()
def add_to_parser(self, parser, ctx):
parser.add_argument(dest=self.name, nargs=self.nargs,
obj=self)
# Circular dependency between decorators and core
from .decorators import command, group
Click-7.0/click/decorators.py 0000644 0001750 0001750 00000025732 13351570514 016426 0 ustar david david 0000000 0000000 import sys
import inspect
from functools import update_wrapper
from ._compat import iteritems
from ._unicodefun import _check_for_unicode_literals
from .utils import echo
from .globals import get_current_context
def pass_context(f):
"""Marks a callback as wanting to receive the current context
object as first argument.
"""
def new_func(*args, **kwargs):
return f(get_current_context(), *args, **kwargs)
return update_wrapper(new_func, f)
def pass_obj(f):
"""Similar to :func:`pass_context`, but only pass the object on the
context onwards (:attr:`Context.obj`). This is useful if that object
represents the state of a nested system.
"""
def new_func(*args, **kwargs):
return f(get_current_context().obj, *args, **kwargs)
return update_wrapper(new_func, f)
def make_pass_decorator(object_type, ensure=False):
"""Given an object type this creates a decorator that will work
similar to :func:`pass_obj` but instead of passing the object of the
current context, it will find the innermost context of type
:func:`object_type`.
This generates a decorator that works roughly like this::
from functools import update_wrapper
def decorator(f):
@pass_context
def new_func(ctx, *args, **kwargs):
obj = ctx.find_object(object_type)
return ctx.invoke(f, obj, *args, **kwargs)
return update_wrapper(new_func, f)
return decorator
:param object_type: the type of the object to pass.
:param ensure: if set to `True`, a new object will be created and
remembered on the context if it's not there yet.
"""
def decorator(f):
def new_func(*args, **kwargs):
ctx = get_current_context()
if ensure:
obj = ctx.ensure_object(object_type)
else:
obj = ctx.find_object(object_type)
if obj is None:
raise RuntimeError('Managed to invoke callback without a '
'context object of type %r existing'
% object_type.__name__)
return ctx.invoke(f, obj, *args, **kwargs)
return update_wrapper(new_func, f)
return decorator
def _make_command(f, name, attrs, cls):
if isinstance(f, Command):
raise TypeError('Attempted to convert a callback into a '
'command twice.')
try:
params = f.__click_params__
params.reverse()
del f.__click_params__
except AttributeError:
params = []
help = attrs.get('help')
if help is None:
help = inspect.getdoc(f)
if isinstance(help, bytes):
help = help.decode('utf-8')
else:
help = inspect.cleandoc(help)
attrs['help'] = help
_check_for_unicode_literals()
return cls(name=name or f.__name__.lower().replace('_', '-'),
callback=f, params=params, **attrs)
def command(name=None, cls=None, **attrs):
r"""Creates a new :class:`Command` and uses the decorated function as
callback. This will also automatically attach all decorated
:func:`option`\s and :func:`argument`\s as parameters to the command.
The name of the command defaults to the name of the function. If you
want to change that, you can pass the intended name as the first
argument.
All keyword arguments are forwarded to the underlying command class.
Once decorated the function turns into a :class:`Command` instance
that can be invoked as a command line utility or be attached to a
command :class:`Group`.
:param name: the name of the command. This defaults to the function
name with underscores replaced by dashes.
:param cls: the command class to instantiate. This defaults to
:class:`Command`.
"""
if cls is None:
cls = Command
def decorator(f):
cmd = _make_command(f, name, attrs, cls)
cmd.__doc__ = f.__doc__
return cmd
return decorator
def group(name=None, **attrs):
"""Creates a new :class:`Group` with a function as callback. This
works otherwise the same as :func:`command` just that the `cls`
parameter is set to :class:`Group`.
"""
attrs.setdefault('cls', Group)
return command(name, **attrs)
def _param_memo(f, param):
if isinstance(f, Command):
f.params.append(param)
else:
if not hasattr(f, '__click_params__'):
f.__click_params__ = []
f.__click_params__.append(param)
def argument(*param_decls, **attrs):
"""Attaches an argument to the command. All positional arguments are
passed as parameter declarations to :class:`Argument`; all keyword
arguments are forwarded unchanged (except ``cls``).
This is equivalent to creating an :class:`Argument` instance manually
and attaching it to the :attr:`Command.params` list.
:param cls: the argument class to instantiate. This defaults to
:class:`Argument`.
"""
def decorator(f):
ArgumentClass = attrs.pop('cls', Argument)
_param_memo(f, ArgumentClass(param_decls, **attrs))
return f
return decorator
def option(*param_decls, **attrs):
"""Attaches an option to the command. All positional arguments are
passed as parameter declarations to :class:`Option`; all keyword
arguments are forwarded unchanged (except ``cls``).
This is equivalent to creating an :class:`Option` instance manually
and attaching it to the :attr:`Command.params` list.
:param cls: the option class to instantiate. This defaults to
:class:`Option`.
"""
def decorator(f):
# Issue 926, copy attrs, so pre-defined options can re-use the same cls=
option_attrs = attrs.copy()
if 'help' in option_attrs:
option_attrs['help'] = inspect.cleandoc(option_attrs['help'])
OptionClass = option_attrs.pop('cls', Option)
_param_memo(f, OptionClass(param_decls, **option_attrs))
return f
return decorator
def confirmation_option(*param_decls, **attrs):
"""Shortcut for confirmation prompts that can be ignored by passing
``--yes`` as parameter.
This is equivalent to decorating a function with :func:`option` with
the following parameters::
def callback(ctx, param, value):
if not value:
ctx.abort()
@click.command()
@click.option('--yes', is_flag=True, callback=callback,
expose_value=False, prompt='Do you want to continue?')
def dropdb():
pass
"""
def decorator(f):
def callback(ctx, param, value):
if not value:
ctx.abort()
attrs.setdefault('is_flag', True)
attrs.setdefault('callback', callback)
attrs.setdefault('expose_value', False)
attrs.setdefault('prompt', 'Do you want to continue?')
attrs.setdefault('help', 'Confirm the action without prompting.')
return option(*(param_decls or ('--yes',)), **attrs)(f)
return decorator
def password_option(*param_decls, **attrs):
"""Shortcut for password prompts.
This is equivalent to decorating a function with :func:`option` with
the following parameters::
@click.command()
@click.option('--password', prompt=True, confirmation_prompt=True,
hide_input=True)
def changeadmin(password):
pass
"""
def decorator(f):
attrs.setdefault('prompt', True)
attrs.setdefault('confirmation_prompt', True)
attrs.setdefault('hide_input', True)
return option(*(param_decls or ('--password',)), **attrs)(f)
return decorator
def version_option(version=None, *param_decls, **attrs):
"""Adds a ``--version`` option which immediately ends the program
printing out the version number. This is implemented as an eager
option that prints the version and exits the program in the callback.
:param version: the version number to show. If not provided Click
attempts an auto discovery via setuptools.
:param prog_name: the name of the program (defaults to autodetection)
:param message: custom message to show instead of the default
(``'%(prog)s, version %(version)s'``)
:param others: everything else is forwarded to :func:`option`.
"""
if version is None:
if hasattr(sys, '_getframe'):
module = sys._getframe(1).f_globals.get('__name__')
else:
module = ''
def decorator(f):
prog_name = attrs.pop('prog_name', None)
message = attrs.pop('message', '%(prog)s, version %(version)s')
def callback(ctx, param, value):
if not value or ctx.resilient_parsing:
return
prog = prog_name
if prog is None:
prog = ctx.find_root().info_name
ver = version
if ver is None:
try:
import pkg_resources
except ImportError:
pass
else:
for dist in pkg_resources.working_set:
scripts = dist.get_entry_map().get('console_scripts') or {}
for script_name, entry_point in iteritems(scripts):
if entry_point.module_name == module:
ver = dist.version
break
if ver is None:
raise RuntimeError('Could not determine version')
echo(message % {
'prog': prog,
'version': ver,
}, color=ctx.color)
ctx.exit()
attrs.setdefault('is_flag', True)
attrs.setdefault('expose_value', False)
attrs.setdefault('is_eager', True)
attrs.setdefault('help', 'Show the version and exit.')
attrs['callback'] = callback
return option(*(param_decls or ('--version',)), **attrs)(f)
return decorator
def help_option(*param_decls, **attrs):
"""Adds a ``--help`` option which immediately ends the program
printing out the help page. This is usually unnecessary to add as
this is added by default to all commands unless suppressed.
Like :func:`version_option`, this is implemented as eager option that
prints in the callback and exits.
All arguments are forwarded to :func:`option`.
"""
def decorator(f):
def callback(ctx, param, value):
if value and not ctx.resilient_parsing:
echo(ctx.get_help(), color=ctx.color)
ctx.exit()
attrs.setdefault('is_flag', True)
attrs.setdefault('expose_value', False)
attrs.setdefault('help', 'Show this message and exit.')
attrs.setdefault('is_eager', True)
attrs['callback'] = callback
return option(*(param_decls or ('--help',)), **attrs)(f)
return decorator
# Circular dependencies between core and decorators
from .core import Command, Group, Argument, Option
Click-7.0/click/exceptions.py 0000644 0001750 0001750 00000016757 13351570514 016451 0 ustar david david 0000000 0000000 from ._compat import PY2, filename_to_ui, get_text_stderr
from .utils import echo
def _join_param_hints(param_hint):
if isinstance(param_hint, (tuple, list)):
return ' / '.join('"%s"' % x for x in param_hint)
return param_hint
class ClickException(Exception):
"""An exception that Click can handle and show to the user."""
#: The exit code for this exception
exit_code = 1
def __init__(self, message):
ctor_msg = message
if PY2:
if ctor_msg is not None:
ctor_msg = ctor_msg.encode('utf-8')
Exception.__init__(self, ctor_msg)
self.message = message
def format_message(self):
return self.message
def __str__(self):
return self.message
if PY2:
__unicode__ = __str__
def __str__(self):
return self.message.encode('utf-8')
def show(self, file=None):
if file is None:
file = get_text_stderr()
echo('Error: %s' % self.format_message(), file=file)
class UsageError(ClickException):
"""An internal exception that signals a usage error. This typically
aborts any further handling.
:param message: the error message to display.
:param ctx: optionally the context that caused this error. Click will
fill in the context automatically in some situations.
"""
exit_code = 2
def __init__(self, message, ctx=None):
ClickException.__init__(self, message)
self.ctx = ctx
self.cmd = self.ctx and self.ctx.command or None
def show(self, file=None):
if file is None:
file = get_text_stderr()
color = None
hint = ''
if (self.cmd is not None and
self.cmd.get_help_option(self.ctx) is not None):
hint = ('Try "%s %s" for help.\n'
% (self.ctx.command_path, self.ctx.help_option_names[0]))
if self.ctx is not None:
color = self.ctx.color
echo(self.ctx.get_usage() + '\n%s' % hint, file=file, color=color)
echo('Error: %s' % self.format_message(), file=file, color=color)
class BadParameter(UsageError):
"""An exception that formats out a standardized error message for a
bad parameter. This is useful when thrown from a callback or type as
Click will attach contextual information to it (for instance, which
parameter it is).
.. versionadded:: 2.0
:param param: the parameter object that caused this error. This can
be left out, and Click will attach this info itself
if possible.
:param param_hint: a string that shows up as parameter name. This
can be used as alternative to `param` in cases
where custom validation should happen. If it is
a string it's used as such, if it's a list then
each item is quoted and separated.
"""
def __init__(self, message, ctx=None, param=None,
param_hint=None):
UsageError.__init__(self, message, ctx)
self.param = param
self.param_hint = param_hint
def format_message(self):
if self.param_hint is not None:
param_hint = self.param_hint
elif self.param is not None:
param_hint = self.param.get_error_hint(self.ctx)
else:
return 'Invalid value: %s' % self.message
param_hint = _join_param_hints(param_hint)
return 'Invalid value for %s: %s' % (param_hint, self.message)
class MissingParameter(BadParameter):
"""Raised if click required an option or argument but it was not
provided when invoking the script.
.. versionadded:: 4.0
:param param_type: a string that indicates the type of the parameter.
The default is to inherit the parameter type from
the given `param`. Valid values are ``'parameter'``,
``'option'`` or ``'argument'``.
"""
def __init__(self, message=None, ctx=None, param=None,
param_hint=None, param_type=None):
BadParameter.__init__(self, message, ctx, param, param_hint)
self.param_type = param_type
def format_message(self):
if self.param_hint is not None:
param_hint = self.param_hint
elif self.param is not None:
param_hint = self.param.get_error_hint(self.ctx)
else:
param_hint = None
param_hint = _join_param_hints(param_hint)
param_type = self.param_type
if param_type is None and self.param is not None:
param_type = self.param.param_type_name
msg = self.message
if self.param is not None:
msg_extra = self.param.type.get_missing_message(self.param)
if msg_extra:
if msg:
msg += '. ' + msg_extra
else:
msg = msg_extra
return 'Missing %s%s%s%s' % (
param_type,
param_hint and ' %s' % param_hint or '',
msg and '. ' or '.',
msg or '',
)
class NoSuchOption(UsageError):
"""Raised if click attempted to handle an option that does not
exist.
.. versionadded:: 4.0
"""
def __init__(self, option_name, message=None, possibilities=None,
ctx=None):
if message is None:
message = 'no such option: %s' % option_name
UsageError.__init__(self, message, ctx)
self.option_name = option_name
self.possibilities = possibilities
def format_message(self):
bits = [self.message]
if self.possibilities:
if len(self.possibilities) == 1:
bits.append('Did you mean %s?' % self.possibilities[0])
else:
possibilities = sorted(self.possibilities)
bits.append('(Possible options: %s)' % ', '.join(possibilities))
return ' '.join(bits)
class BadOptionUsage(UsageError):
"""Raised if an option is generally supplied but the use of the option
was incorrect. This is for instance raised if the number of arguments
for an option is not correct.
.. versionadded:: 4.0
:param option_name: the name of the option being used incorrectly.
"""
def __init__(self, option_name, message, ctx=None):
UsageError.__init__(self, message, ctx)
self.option_name = option_name
class BadArgumentUsage(UsageError):
"""Raised if an argument is generally supplied but the use of the argument
was incorrect. This is for instance raised if the number of values
for an argument is not correct.
.. versionadded:: 6.0
"""
def __init__(self, message, ctx=None):
UsageError.__init__(self, message, ctx)
class FileError(ClickException):
"""Raised if a file cannot be opened."""
def __init__(self, filename, hint=None):
ui_filename = filename_to_ui(filename)
if hint is None:
hint = 'unknown error'
ClickException.__init__(self, hint)
self.ui_filename = ui_filename
self.filename = filename
def format_message(self):
return 'Could not open file %s: %s' % (self.ui_filename, self.message)
class Abort(RuntimeError):
"""An internal signalling exception that signals Click to abort."""
class Exit(RuntimeError):
"""An exception that indicates that the application should exit with some
status code.
:param code: the status code to exit with.
"""
def __init__(self, code=0):
self.exit_code = code
Click-7.0/click/formatting.py 0000644 0001750 0001750 00000021271 13351553412 016423 0 ustar david david 0000000 0000000 from contextlib import contextmanager
from .termui import get_terminal_size
from .parser import split_opt
from ._compat import term_len
# Can force a width. This is used by the test system
FORCED_WIDTH = None
def measure_table(rows):
widths = {}
for row in rows:
for idx, col in enumerate(row):
widths[idx] = max(widths.get(idx, 0), term_len(col))
return tuple(y for x, y in sorted(widths.items()))
def iter_rows(rows, col_count):
for row in rows:
row = tuple(row)
yield row + ('',) * (col_count - len(row))
def wrap_text(text, width=78, initial_indent='', subsequent_indent='',
preserve_paragraphs=False):
"""A helper function that intelligently wraps text. By default, it
assumes that it operates on a single paragraph of text but if the
`preserve_paragraphs` parameter is provided it will intelligently
handle paragraphs (defined by two empty lines).
If paragraphs are handled, a paragraph can be prefixed with an empty
line containing the ``\\b`` character (``\\x08``) to indicate that
no rewrapping should happen in that block.
:param text: the text that should be rewrapped.
:param width: the maximum width for the text.
:param initial_indent: the initial indent that should be placed on the
first line as a string.
:param subsequent_indent: the indent string that should be placed on
each consecutive line.
:param preserve_paragraphs: if this flag is set then the wrapping will
intelligently handle paragraphs.
"""
from ._textwrap import TextWrapper
text = text.expandtabs()
wrapper = TextWrapper(width, initial_indent=initial_indent,
subsequent_indent=subsequent_indent,
replace_whitespace=False)
if not preserve_paragraphs:
return wrapper.fill(text)
p = []
buf = []
indent = None
def _flush_par():
if not buf:
return
if buf[0].strip() == '\b':
p.append((indent or 0, True, '\n'.join(buf[1:])))
else:
p.append((indent or 0, False, ' '.join(buf)))
del buf[:]
for line in text.splitlines():
if not line:
_flush_par()
indent = None
else:
if indent is None:
orig_len = term_len(line)
line = line.lstrip()
indent = orig_len - term_len(line)
buf.append(line)
_flush_par()
rv = []
for indent, raw, text in p:
with wrapper.extra_indent(' ' * indent):
if raw:
rv.append(wrapper.indent_only(text))
else:
rv.append(wrapper.fill(text))
return '\n\n'.join(rv)
class HelpFormatter(object):
"""This class helps with formatting text-based help pages. It's
usually just needed for very special internal cases, but it's also
exposed so that developers can write their own fancy outputs.
At present, it always writes into memory.
:param indent_increment: the additional increment for each level.
:param width: the width for the text. This defaults to the terminal
width clamped to a maximum of 78.
"""
def __init__(self, indent_increment=2, width=None, max_width=None):
self.indent_increment = indent_increment
if max_width is None:
max_width = 80
if width is None:
width = FORCED_WIDTH
if width is None:
width = max(min(get_terminal_size()[0], max_width) - 2, 50)
self.width = width
self.current_indent = 0
self.buffer = []
def write(self, string):
"""Writes a unicode string into the internal buffer."""
self.buffer.append(string)
def indent(self):
"""Increases the indentation."""
self.current_indent += self.indent_increment
def dedent(self):
"""Decreases the indentation."""
self.current_indent -= self.indent_increment
def write_usage(self, prog, args='', prefix='Usage: '):
"""Writes a usage line into the buffer.
:param prog: the program name.
:param args: whitespace separated list of arguments.
:param prefix: the prefix for the first line.
"""
usage_prefix = '%*s%s ' % (self.current_indent, prefix, prog)
text_width = self.width - self.current_indent
if text_width >= (term_len(usage_prefix) + 20):
# The arguments will fit to the right of the prefix.
indent = ' ' * term_len(usage_prefix)
self.write(wrap_text(args, text_width,
initial_indent=usage_prefix,
subsequent_indent=indent))
else:
# The prefix is too long, put the arguments on the next line.
self.write(usage_prefix)
self.write('\n')
indent = ' ' * (max(self.current_indent, term_len(prefix)) + 4)
self.write(wrap_text(args, text_width,
initial_indent=indent,
subsequent_indent=indent))
self.write('\n')
def write_heading(self, heading):
"""Writes a heading into the buffer."""
self.write('%*s%s:\n' % (self.current_indent, '', heading))
def write_paragraph(self):
"""Writes a paragraph into the buffer."""
if self.buffer:
self.write('\n')
def write_text(self, text):
"""Writes re-indented text into the buffer. This rewraps and
preserves paragraphs.
"""
text_width = max(self.width - self.current_indent, 11)
indent = ' ' * self.current_indent
self.write(wrap_text(text, text_width,
initial_indent=indent,
subsequent_indent=indent,
preserve_paragraphs=True))
self.write('\n')
def write_dl(self, rows, col_max=30, col_spacing=2):
"""Writes a definition list into the buffer. This is how options
and commands are usually formatted.
:param rows: a list of two item tuples for the terms and values.
:param col_max: the maximum width of the first column.
:param col_spacing: the number of spaces between the first and
second column.
"""
rows = list(rows)
widths = measure_table(rows)
if len(widths) != 2:
raise TypeError('Expected two columns for definition list')
first_col = min(widths[0], col_max) + col_spacing
for first, second in iter_rows(rows, len(widths)):
self.write('%*s%s' % (self.current_indent, '', first))
if not second:
self.write('\n')
continue
if term_len(first) <= first_col - col_spacing:
self.write(' ' * (first_col - term_len(first)))
else:
self.write('\n')
self.write(' ' * (first_col + self.current_indent))
text_width = max(self.width - first_col - 2, 10)
lines = iter(wrap_text(second, text_width).splitlines())
if lines:
self.write(next(lines) + '\n')
for line in lines:
self.write('%*s%s\n' % (
first_col + self.current_indent, '', line))
else:
self.write('\n')
@contextmanager
def section(self, name):
"""Helpful context manager that writes a paragraph, a heading,
and the indents.
:param name: the section name that is written as heading.
"""
self.write_paragraph()
self.write_heading(name)
self.indent()
try:
yield
finally:
self.dedent()
@contextmanager
def indentation(self):
"""A context manager that increases the indentation."""
self.indent()
try:
yield
finally:
self.dedent()
def getvalue(self):
"""Returns the buffer contents."""
return ''.join(self.buffer)
def join_options(options):
"""Given a list of option strings this joins them in the most appropriate
way and returns them in the form ``(formatted_string,
any_prefix_is_slash)`` where the second item in the tuple is a flag that
indicates if any of the option prefixes was a slash.
"""
rv = []
any_prefix_is_slash = False
for opt in options:
prefix = split_opt(opt)[0]
if prefix == '/':
any_prefix_is_slash = True
rv.append((len(prefix), opt))
rv.sort(key=lambda x: x[0])
rv = ', '.join(x[1] for x in rv)
return rv, any_prefix_is_slash
Click-7.0/click/globals.py 0000644 0001750 0001750 00000002752 13351570514 015701 0 ustar david david 0000000 0000000 from threading import local
_local = local()
def get_current_context(silent=False):
"""Returns the current click context. This can be used as a way to
access the current context object from anywhere. This is a more implicit
alternative to the :func:`pass_context` decorator. This function is
primarily useful for helpers such as :func:`echo` which might be
interested in changing its behavior based on the current context.
To push the current context, :meth:`Context.scope` can be used.
.. versionadded:: 5.0
:param silent: is set to `True` the return value is `None` if no context
is available. The default behavior is to raise a
:exc:`RuntimeError`.
"""
try:
return getattr(_local, 'stack')[-1]
except (AttributeError, IndexError):
if not silent:
raise RuntimeError('There is no active click context.')
def push_context(ctx):
"""Pushes a new context to the current stack."""
_local.__dict__.setdefault('stack', []).append(ctx)
def pop_context():
"""Removes the top level from the stack."""
_local.stack.pop()
def resolve_color_default(color=None):
""""Internal helper to get the default value of the color flag. If a
value is passed it's returned unchanged, otherwise it's looked up from
the current context.
"""
if color is not None:
return color
ctx = get_current_context(silent=True)
if ctx is not None:
return ctx.color
Click-7.0/click/parser.py 0000644 0001750 0001750 00000036226 13352433170 015552 0 ustar david david 0000000 0000000 # -*- coding: utf-8 -*-
"""
click.parser
~~~~~~~~~~~~
This module started out as largely a copy paste from the stdlib's
optparse module with the features removed that we do not need from
optparse because we implement them in Click on a higher level (for
instance type handling, help formatting and a lot more).
The plan is to remove more and more from here over time.
The reason this is a different module and not optparse from the stdlib
is that there are differences in 2.x and 3.x about the error messages
generated and optparse in the stdlib uses gettext for no good reason
and might cause us issues.
"""
import re
from collections import deque
from .exceptions import UsageError, NoSuchOption, BadOptionUsage, \
BadArgumentUsage
def _unpack_args(args, nargs_spec):
"""Given an iterable of arguments and an iterable of nargs specifications,
it returns a tuple with all the unpacked arguments at the first index
and all remaining arguments as the second.
The nargs specification is the number of arguments that should be consumed
or `-1` to indicate that this position should eat up all the remainders.
Missing items are filled with `None`.
"""
args = deque(args)
nargs_spec = deque(nargs_spec)
rv = []
spos = None
def _fetch(c):
try:
if spos is None:
return c.popleft()
else:
return c.pop()
except IndexError:
return None
while nargs_spec:
nargs = _fetch(nargs_spec)
if nargs == 1:
rv.append(_fetch(args))
elif nargs > 1:
x = [_fetch(args) for _ in range(nargs)]
# If we're reversed, we're pulling in the arguments in reverse,
# so we need to turn them around.
if spos is not None:
x.reverse()
rv.append(tuple(x))
elif nargs < 0:
if spos is not None:
raise TypeError('Cannot have two nargs < 0')
spos = len(rv)
rv.append(None)
# spos is the position of the wildcard (star). If it's not `None`,
# we fill it with the remainder.
if spos is not None:
rv[spos] = tuple(args)
args = []
rv[spos + 1:] = reversed(rv[spos + 1:])
return tuple(rv), list(args)
def _error_opt_args(nargs, opt):
if nargs == 1:
raise BadOptionUsage(opt, '%s option requires an argument' % opt)
raise BadOptionUsage(opt, '%s option requires %d arguments' % (opt, nargs))
def split_opt(opt):
first = opt[:1]
if first.isalnum():
return '', opt
if opt[1:2] == first:
return opt[:2], opt[2:]
return first, opt[1:]
def normalize_opt(opt, ctx):
if ctx is None or ctx.token_normalize_func is None:
return opt
prefix, opt = split_opt(opt)
return prefix + ctx.token_normalize_func(opt)
def split_arg_string(string):
"""Given an argument string this attempts to split it into small parts."""
rv = []
for match in re.finditer(r"('([^'\\]*(?:\\.[^'\\]*)*)'"
r'|"([^"\\]*(?:\\.[^"\\]*)*)"'
r'|\S+)\s*', string, re.S):
arg = match.group().strip()
if arg[:1] == arg[-1:] and arg[:1] in '"\'':
arg = arg[1:-1].encode('ascii', 'backslashreplace') \
.decode('unicode-escape')
try:
arg = type(string)(arg)
except UnicodeError:
pass
rv.append(arg)
return rv
class Option(object):
def __init__(self, opts, dest, action=None, nargs=1, const=None, obj=None):
self._short_opts = []
self._long_opts = []
self.prefixes = set()
for opt in opts:
prefix, value = split_opt(opt)
if not prefix:
raise ValueError('Invalid start character for option (%s)'
% opt)
self.prefixes.add(prefix[0])
if len(prefix) == 1 and len(value) == 1:
self._short_opts.append(opt)
else:
self._long_opts.append(opt)
self.prefixes.add(prefix)
if action is None:
action = 'store'
self.dest = dest
self.action = action
self.nargs = nargs
self.const = const
self.obj = obj
@property
def takes_value(self):
return self.action in ('store', 'append')
def process(self, value, state):
if self.action == 'store':
state.opts[self.dest] = value
elif self.action == 'store_const':
state.opts[self.dest] = self.const
elif self.action == 'append':
state.opts.setdefault(self.dest, []).append(value)
elif self.action == 'append_const':
state.opts.setdefault(self.dest, []).append(self.const)
elif self.action == 'count':
state.opts[self.dest] = state.opts.get(self.dest, 0) + 1
else:
raise ValueError('unknown action %r' % self.action)
state.order.append(self.obj)
class Argument(object):
def __init__(self, dest, nargs=1, obj=None):
self.dest = dest
self.nargs = nargs
self.obj = obj
def process(self, value, state):
if self.nargs > 1:
holes = sum(1 for x in value if x is None)
if holes == len(value):
value = None
elif holes != 0:
raise BadArgumentUsage('argument %s takes %d values'
% (self.dest, self.nargs))
state.opts[self.dest] = value
state.order.append(self.obj)
class ParsingState(object):
def __init__(self, rargs):
self.opts = {}
self.largs = []
self.rargs = rargs
self.order = []
class OptionParser(object):
"""The option parser is an internal class that is ultimately used to
parse options and arguments. It's modelled after optparse and brings
a similar but vastly simplified API. It should generally not be used
directly as the high level Click classes wrap it for you.
It's not nearly as extensible as optparse or argparse as it does not
implement features that are implemented on a higher level (such as
types or defaults).
:param ctx: optionally the :class:`~click.Context` where this parser
should go with.
"""
def __init__(self, ctx=None):
#: The :class:`~click.Context` for this parser. This might be
#: `None` for some advanced use cases.
self.ctx = ctx
#: This controls how the parser deals with interspersed arguments.
#: If this is set to `False`, the parser will stop on the first
#: non-option. Click uses this to implement nested subcommands
#: safely.
self.allow_interspersed_args = True
#: This tells the parser how to deal with unknown options. By
#: default it will error out (which is sensible), but there is a
#: second mode where it will ignore it and continue processing
#: after shifting all the unknown options into the resulting args.
self.ignore_unknown_options = False
if ctx is not None:
self.allow_interspersed_args = ctx.allow_interspersed_args
self.ignore_unknown_options = ctx.ignore_unknown_options
self._short_opt = {}
self._long_opt = {}
self._opt_prefixes = set(['-', '--'])
self._args = []
def add_option(self, opts, dest, action=None, nargs=1, const=None,
obj=None):
"""Adds a new option named `dest` to the parser. The destination
is not inferred (unlike with optparse) and needs to be explicitly
provided. Action can be any of ``store``, ``store_const``,
``append``, ``appnd_const`` or ``count``.
The `obj` can be used to identify the option in the order list
that is returned from the parser.
"""
if obj is None:
obj = dest
opts = [normalize_opt(opt, self.ctx) for opt in opts]
option = Option(opts, dest, action=action, nargs=nargs,
const=const, obj=obj)
self._opt_prefixes.update(option.prefixes)
for opt in option._short_opts:
self._short_opt[opt] = option
for opt in option._long_opts:
self._long_opt[opt] = option
def add_argument(self, dest, nargs=1, obj=None):
"""Adds a positional argument named `dest` to the parser.
The `obj` can be used to identify the option in the order list
that is returned from the parser.
"""
if obj is None:
obj = dest
self._args.append(Argument(dest=dest, nargs=nargs, obj=obj))
def parse_args(self, args):
"""Parses positional arguments and returns ``(values, args, order)``
for the parsed options and arguments as well as the leftover
arguments if there are any. The order is a list of objects as they
appear on the command line. If arguments appear multiple times they
will be memorized multiple times as well.
"""
state = ParsingState(args)
try:
self._process_args_for_options(state)
self._process_args_for_args(state)
except UsageError:
if self.ctx is None or not self.ctx.resilient_parsing:
raise
return state.opts, state.largs, state.order
def _process_args_for_args(self, state):
pargs, args = _unpack_args(state.largs + state.rargs,
[x.nargs for x in self._args])
for idx, arg in enumerate(self._args):
arg.process(pargs[idx], state)
state.largs = args
state.rargs = []
def _process_args_for_options(self, state):
while state.rargs:
arg = state.rargs.pop(0)
arglen = len(arg)
# Double dashes always handled explicitly regardless of what
# prefixes are valid.
if arg == '--':
return
elif arg[:1] in self._opt_prefixes and arglen > 1:
self._process_opts(arg, state)
elif self.allow_interspersed_args:
state.largs.append(arg)
else:
state.rargs.insert(0, arg)
return
# Say this is the original argument list:
# [arg0, arg1, ..., arg(i-1), arg(i), arg(i+1), ..., arg(N-1)]
# ^
# (we are about to process arg(i)).
#
# Then rargs is [arg(i), ..., arg(N-1)] and largs is a *subset* of
# [arg0, ..., arg(i-1)] (any options and their arguments will have
# been removed from largs).
#
# The while loop will usually consume 1 or more arguments per pass.
# If it consumes 1 (eg. arg is an option that takes no arguments),
# then after _process_arg() is done the situation is:
#
# largs = subset of [arg0, ..., arg(i)]
# rargs = [arg(i+1), ..., arg(N-1)]
#
# If allow_interspersed_args is false, largs will always be
# *empty* -- still a subset of [arg0, ..., arg(i-1)], but
# not a very interesting subset!
def _match_long_opt(self, opt, explicit_value, state):
if opt not in self._long_opt:
possibilities = [word for word in self._long_opt
if word.startswith(opt)]
raise NoSuchOption(opt, possibilities=possibilities, ctx=self.ctx)
option = self._long_opt[opt]
if option.takes_value:
# At this point it's safe to modify rargs by injecting the
# explicit value, because no exception is raised in this
# branch. This means that the inserted value will be fully
# consumed.
if explicit_value is not None:
state.rargs.insert(0, explicit_value)
nargs = option.nargs
if len(state.rargs) < nargs:
_error_opt_args(nargs, opt)
elif nargs == 1:
value = state.rargs.pop(0)
else:
value = tuple(state.rargs[:nargs])
del state.rargs[:nargs]
elif explicit_value is not None:
raise BadOptionUsage(opt, '%s option does not take a value' % opt)
else:
value = None
option.process(value, state)
def _match_short_opt(self, arg, state):
stop = False
i = 1
prefix = arg[0]
unknown_options = []
for ch in arg[1:]:
opt = normalize_opt(prefix + ch, self.ctx)
option = self._short_opt.get(opt)
i += 1
if not option:
if self.ignore_unknown_options:
unknown_options.append(ch)
continue
raise NoSuchOption(opt, ctx=self.ctx)
if option.takes_value:
# Any characters left in arg? Pretend they're the
# next arg, and stop consuming characters of arg.
if i < len(arg):
state.rargs.insert(0, arg[i:])
stop = True
nargs = option.nargs
if len(state.rargs) < nargs:
_error_opt_args(nargs, opt)
elif nargs == 1:
value = state.rargs.pop(0)
else:
value = tuple(state.rargs[:nargs])
del state.rargs[:nargs]
else:
value = None
option.process(value, state)
if stop:
break
# If we got any unknown options we re-combinate the string of the
# remaining options and re-attach the prefix, then report that
# to the state as new larg. This way there is basic combinatorics
# that can be achieved while still ignoring unknown arguments.
if self.ignore_unknown_options and unknown_options:
state.largs.append(prefix + ''.join(unknown_options))
def _process_opts(self, arg, state):
explicit_value = None
# Long option handling happens in two parts. The first part is
# supporting explicitly attached values. In any case, we will try
# to long match the option first.
if '=' in arg:
long_opt, explicit_value = arg.split('=', 1)
else:
long_opt = arg
norm_long_opt = normalize_opt(long_opt, self.ctx)
# At this point we will match the (assumed) long option through
# the long option matching code. Note that this allows options
# like "-foo" to be matched as long options.
try:
self._match_long_opt(norm_long_opt, explicit_value, state)
except NoSuchOption:
# At this point the long option matching failed, and we need
# to try with short options. However there is a special rule
# which says, that if we have a two character options prefix
# (applies to "--foo" for instance), we do not dispatch to the
# short option code and will instead raise the no option
# error.
if arg[:2] not in self._opt_prefixes:
return self._match_short_opt(arg, state)
if not self.ignore_unknown_options:
raise
state.largs.append(arg)
Click-7.0/click/termui.py 0000644 0001750 0001750 00000055247 13352517576 015604 0 ustar david david 0000000 0000000 import os
import sys
import struct
import inspect
import itertools
from ._compat import raw_input, text_type, string_types, \
isatty, strip_ansi, get_winterm_size, DEFAULT_COLUMNS, WIN
from .utils import echo
from .exceptions import Abort, UsageError
from .types import convert_type, Choice, Path
from .globals import resolve_color_default
# The prompt functions to use. The doc tools currently override these
# functions to customize how they work.
visible_prompt_func = raw_input
_ansi_colors = {
'black': 30,
'red': 31,
'green': 32,
'yellow': 33,
'blue': 34,
'magenta': 35,
'cyan': 36,
'white': 37,
'reset': 39,
'bright_black': 90,
'bright_red': 91,
'bright_green': 92,
'bright_yellow': 93,
'bright_blue': 94,
'bright_magenta': 95,
'bright_cyan': 96,
'bright_white': 97,
}
_ansi_reset_all = '\033[0m'
def hidden_prompt_func(prompt):
import getpass
return getpass.getpass(prompt)
def _build_prompt(text, suffix, show_default=False, default=None, show_choices=True, type=None):
prompt = text
if type is not None and show_choices and isinstance(type, Choice):
prompt += ' (' + ", ".join(map(str, type.choices)) + ')'
if default is not None and show_default:
prompt = '%s [%s]' % (prompt, default)
return prompt + suffix
def prompt(text, default=None, hide_input=False, confirmation_prompt=False,
type=None, value_proc=None, prompt_suffix=': ', show_default=True,
err=False, show_choices=True):
"""Prompts a user for input. This is a convenience function that can
be used to prompt a user for input later.
If the user aborts the input by sending a interrupt signal, this
function will catch it and raise a :exc:`Abort` exception.
.. versionadded:: 7.0
Added the show_choices parameter.
.. versionadded:: 6.0
Added unicode support for cmd.exe on Windows.
.. versionadded:: 4.0
Added the `err` parameter.
:param text: the text to show for the prompt.
:param default: the default value to use if no input happens. If this
is not given it will prompt until it's aborted.
:param hide_input: if this is set to true then the input value will
be hidden.
:param confirmation_prompt: asks for confirmation for the value.
:param type: the type to use to check the value against.
:param value_proc: if this parameter is provided it's a function that
is invoked instead of the type conversion to
convert a value.
:param prompt_suffix: a suffix that should be added to the prompt.
:param show_default: shows or hides the default value in the prompt.
:param err: if set to true the file defaults to ``stderr`` instead of
``stdout``, the same as with echo.
:param show_choices: Show or hide choices if the passed type is a Choice.
For example if type is a Choice of either day or week,
show_choices is true and text is "Group by" then the
prompt will be "Group by (day, week): ".
"""
result = None
def prompt_func(text):
f = hide_input and hidden_prompt_func or visible_prompt_func
try:
# Write the prompt separately so that we get nice
# coloring through colorama on Windows
echo(text, nl=False, err=err)
return f('')
except (KeyboardInterrupt, EOFError):
# getpass doesn't print a newline if the user aborts input with ^C.
# Allegedly this behavior is inherited from getpass(3).
# A doc bug has been filed at https://bugs.python.org/issue24711
if hide_input:
echo(None, err=err)
raise Abort()
if value_proc is None:
value_proc = convert_type(type, default)
prompt = _build_prompt(text, prompt_suffix, show_default, default, show_choices, type)
while 1:
while 1:
value = prompt_func(prompt)
if value:
break
elif default is not None:
if isinstance(value_proc, Path):
# validate Path default value(exists, dir_okay etc.)
value = default
break
return default
try:
result = value_proc(value)
except UsageError as e:
echo('Error: %s' % e.message, err=err)
continue
if not confirmation_prompt:
return result
while 1:
value2 = prompt_func('Repeat for confirmation: ')
if value2:
break
if value == value2:
return result
echo('Error: the two entered values do not match', err=err)
def confirm(text, default=False, abort=False, prompt_suffix=': ',
show_default=True, err=False):
"""Prompts for confirmation (yes/no question).
If the user aborts the input by sending a interrupt signal this
function will catch it and raise a :exc:`Abort` exception.
.. versionadded:: 4.0
Added the `err` parameter.
:param text: the question to ask.
:param default: the default for the prompt.
:param abort: if this is set to `True` a negative answer aborts the
exception by raising :exc:`Abort`.
:param prompt_suffix: a suffix that should be added to the prompt.
:param show_default: shows or hides the default value in the prompt.
:param err: if set to true the file defaults to ``stderr`` instead of
``stdout``, the same as with echo.
"""
prompt = _build_prompt(text, prompt_suffix, show_default,
default and 'Y/n' or 'y/N')
while 1:
try:
# Write the prompt separately so that we get nice
# coloring through colorama on Windows
echo(prompt, nl=False, err=err)
value = visible_prompt_func('').lower().strip()
except (KeyboardInterrupt, EOFError):
raise Abort()
if value in ('y', 'yes'):
rv = True
elif value in ('n', 'no'):
rv = False
elif value == '':
rv = default
else:
echo('Error: invalid input', err=err)
continue
break
if abort and not rv:
raise Abort()
return rv
def get_terminal_size():
"""Returns the current size of the terminal as tuple in the form
``(width, height)`` in columns and rows.
"""
# If shutil has get_terminal_size() (Python 3.3 and later) use that
if sys.version_info >= (3, 3):
import shutil
shutil_get_terminal_size = getattr(shutil, 'get_terminal_size', None)
if shutil_get_terminal_size:
sz = shutil_get_terminal_size()
return sz.columns, sz.lines
# We provide a sensible default for get_winterm_size() when being invoked
# inside a subprocess. Without this, it would not provide a useful input.
if get_winterm_size is not None:
size = get_winterm_size()
if size == (0, 0):
return (79, 24)
else:
return size
def ioctl_gwinsz(fd):
try:
import fcntl
import termios
cr = struct.unpack(
'hh', fcntl.ioctl(fd, termios.TIOCGWINSZ, '1234'))
except Exception:
return
return cr
cr = ioctl_gwinsz(0) or ioctl_gwinsz(1) or ioctl_gwinsz(2)
if not cr:
try:
fd = os.open(os.ctermid(), os.O_RDONLY)
try:
cr = ioctl_gwinsz(fd)
finally:
os.close(fd)
except Exception:
pass
if not cr or not cr[0] or not cr[1]:
cr = (os.environ.get('LINES', 25),
os.environ.get('COLUMNS', DEFAULT_COLUMNS))
return int(cr[1]), int(cr[0])
def echo_via_pager(text_or_generator, color=None):
"""This function takes a text and shows it via an environment specific
pager on stdout.
.. versionchanged:: 3.0
Added the `color` flag.
:param text_or_generator: the text to page, or alternatively, a
generator emitting the text to page.
:param color: controls if the pager supports ANSI colors or not. The
default is autodetection.
"""
color = resolve_color_default(color)
if inspect.isgeneratorfunction(text_or_generator):
i = text_or_generator()
elif isinstance(text_or_generator, string_types):
i = [text_or_generator]
else:
i = iter(text_or_generator)
# convert every element of i to a text type if necessary
text_generator = (el if isinstance(el, string_types) else text_type(el)
for el in i)
from ._termui_impl import pager
return pager(itertools.chain(text_generator, "\n"), color)
def progressbar(iterable=None, length=None, label=None, show_eta=True,
show_percent=None, show_pos=False,
item_show_func=None, fill_char='#', empty_char='-',
bar_template='%(label)s [%(bar)s] %(info)s',
info_sep=' ', width=36, file=None, color=None):
"""This function creates an iterable context manager that can be used
to iterate over something while showing a progress bar. It will
either iterate over the `iterable` or `length` items (that are counted
up). While iteration happens, this function will print a rendered
progress bar to the given `file` (defaults to stdout) and will attempt
to calculate remaining time and more. By default, this progress bar
will not be rendered if the file is not a terminal.
The context manager creates the progress bar. When the context
manager is entered the progress bar is already displayed. With every
iteration over the progress bar, the iterable passed to the bar is
advanced and the bar is updated. When the context manager exits,
a newline is printed and the progress bar is finalized on screen.
No printing must happen or the progress bar will be unintentionally
destroyed.
Example usage::
with progressbar(items) as bar:
for item in bar:
do_something_with(item)
Alternatively, if no iterable is specified, one can manually update the
progress bar through the `update()` method instead of directly
iterating over the progress bar. The update method accepts the number
of steps to increment the bar with::
with progressbar(length=chunks.total_bytes) as bar:
for chunk in chunks:
process_chunk(chunk)
bar.update(chunks.bytes)
.. versionadded:: 2.0
.. versionadded:: 4.0
Added the `color` parameter. Added a `update` method to the
progressbar object.
:param iterable: an iterable to iterate over. If not provided the length
is required.
:param length: the number of items to iterate over. By default the
progressbar will attempt to ask the iterator about its
length, which might or might not work. If an iterable is
also provided this parameter can be used to override the
length. If an iterable is not provided the progress bar
will iterate over a range of that length.
:param label: the label to show next to the progress bar.
:param show_eta: enables or disables the estimated time display. This is
automatically disabled if the length cannot be
determined.
:param show_percent: enables or disables the percentage display. The
default is `True` if the iterable has a length or
`False` if not.
:param show_pos: enables or disables the absolute position display. The
default is `False`.
:param item_show_func: a function called with the current item which
can return a string to show the current item
next to the progress bar. Note that the current
item can be `None`!
:param fill_char: the character to use to show the filled part of the
progress bar.
:param empty_char: the character to use to show the non-filled part of
the progress bar.
:param bar_template: the format string to use as template for the bar.
The parameters in it are ``label`` for the label,
``bar`` for the progress bar and ``info`` for the
info section.
:param info_sep: the separator between multiple info items (eta etc.)
:param width: the width of the progress bar in characters, 0 means full
terminal width
:param file: the file to write to. If this is not a terminal then
only the label is printed.
:param color: controls if the terminal supports ANSI colors or not. The
default is autodetection. This is only needed if ANSI
codes are included anywhere in the progress bar output
which is not the case by default.
"""
from ._termui_impl import ProgressBar
color = resolve_color_default(color)
return ProgressBar(iterable=iterable, length=length, show_eta=show_eta,
show_percent=show_percent, show_pos=show_pos,
item_show_func=item_show_func, fill_char=fill_char,
empty_char=empty_char, bar_template=bar_template,
info_sep=info_sep, file=file, label=label,
width=width, color=color)
def clear():
"""Clears the terminal screen. This will have the effect of clearing
the whole visible space of the terminal and moving the cursor to the
top left. This does not do anything if not connected to a terminal.
.. versionadded:: 2.0
"""
if not isatty(sys.stdout):
return
# If we're on Windows and we don't have colorama available, then we
# clear the screen by shelling out. Otherwise we can use an escape
# sequence.
if WIN:
os.system('cls')
else:
sys.stdout.write('\033[2J\033[1;1H')
def style(text, fg=None, bg=None, bold=None, dim=None, underline=None,
blink=None, reverse=None, reset=True):
"""Styles a text with ANSI styles and returns the new string. By
default the styling is self contained which means that at the end
of the string a reset code is issued. This can be prevented by
passing ``reset=False``.
Examples::
click.echo(click.style('Hello World!', fg='green'))
click.echo(click.style('ATTENTION!', blink=True))
click.echo(click.style('Some things', reverse=True, fg='cyan'))
Supported color names:
* ``black`` (might be a gray)
* ``red``
* ``green``
* ``yellow`` (might be an orange)
* ``blue``
* ``magenta``
* ``cyan``
* ``white`` (might be light gray)
* ``bright_black``
* ``bright_red``
* ``bright_green``
* ``bright_yellow``
* ``bright_blue``
* ``bright_magenta``
* ``bright_cyan``
* ``bright_white``
* ``reset`` (reset the color code only)
.. versionadded:: 2.0
.. versionadded:: 7.0
Added support for bright colors.
:param text: the string to style with ansi codes.
:param fg: if provided this will become the foreground color.
:param bg: if provided this will become the background color.
:param bold: if provided this will enable or disable bold mode.
:param dim: if provided this will enable or disable dim mode. This is
badly supported.
:param underline: if provided this will enable or disable underline.
:param blink: if provided this will enable or disable blinking.
:param reverse: if provided this will enable or disable inverse
rendering (foreground becomes background and the
other way round).
:param reset: by default a reset-all code is added at the end of the
string which means that styles do not carry over. This
can be disabled to compose styles.
"""
bits = []
if fg:
try:
bits.append('\033[%dm' % (_ansi_colors[fg]))
except KeyError:
raise TypeError('Unknown color %r' % fg)
if bg:
try:
bits.append('\033[%dm' % (_ansi_colors[bg] + 10))
except KeyError:
raise TypeError('Unknown color %r' % bg)
if bold is not None:
bits.append('\033[%dm' % (1 if bold else 22))
if dim is not None:
bits.append('\033[%dm' % (2 if dim else 22))
if underline is not None:
bits.append('\033[%dm' % (4 if underline else 24))
if blink is not None:
bits.append('\033[%dm' % (5 if blink else 25))
if reverse is not None:
bits.append('\033[%dm' % (7 if reverse else 27))
bits.append(text)
if reset:
bits.append(_ansi_reset_all)
return ''.join(bits)
def unstyle(text):
"""Removes ANSI styling information from a string. Usually it's not
necessary to use this function as Click's echo function will
automatically remove styling if necessary.
.. versionadded:: 2.0
:param text: the text to remove style information from.
"""
return strip_ansi(text)
def secho(message=None, file=None, nl=True, err=False, color=None, **styles):
"""This function combines :func:`echo` and :func:`style` into one
call. As such the following two calls are the same::
click.secho('Hello World!', fg='green')
click.echo(click.style('Hello World!', fg='green'))
All keyword arguments are forwarded to the underlying functions
depending on which one they go with.
.. versionadded:: 2.0
"""
if message is not None:
message = style(message, **styles)
return echo(message, file=file, nl=nl, err=err, color=color)
def edit(text=None, editor=None, env=None, require_save=True,
extension='.txt', filename=None):
r"""Edits the given text in the defined editor. If an editor is given
(should be the full path to the executable but the regular operating
system search path is used for finding the executable) it overrides
the detected editor. Optionally, some environment variables can be
used. If the editor is closed without changes, `None` is returned. In
case a file is edited directly the return value is always `None` and
`require_save` and `extension` are ignored.
If the editor cannot be opened a :exc:`UsageError` is raised.
Note for Windows: to simplify cross-platform usage, the newlines are
automatically converted from POSIX to Windows and vice versa. As such,
the message here will have ``\n`` as newline markers.
:param text: the text to edit.
:param editor: optionally the editor to use. Defaults to automatic
detection.
:param env: environment variables to forward to the editor.
:param require_save: if this is true, then not saving in the editor
will make the return value become `None`.
:param extension: the extension to tell the editor about. This defaults
to `.txt` but changing this might change syntax
highlighting.
:param filename: if provided it will edit this file instead of the
provided text contents. It will not use a temporary
file as an indirection in that case.
"""
from ._termui_impl import Editor
editor = Editor(editor=editor, env=env, require_save=require_save,
extension=extension)
if filename is None:
return editor.edit(text)
editor.edit_file(filename)
def launch(url, wait=False, locate=False):
"""This function launches the given URL (or filename) in the default
viewer application for this file type. If this is an executable, it
might launch the executable in a new session. The return value is
the exit code of the launched application. Usually, ``0`` indicates
success.
Examples::
click.launch('https://click.palletsprojects.com/')
click.launch('/my/downloaded/file', locate=True)
.. versionadded:: 2.0
:param url: URL or filename of the thing to launch.
:param wait: waits for the program to stop.
:param locate: if this is set to `True` then instead of launching the
application associated with the URL it will attempt to
launch a file manager with the file located. This
might have weird effects if the URL does not point to
the filesystem.
"""
from ._termui_impl import open_url
return open_url(url, wait=wait, locate=locate)
# If this is provided, getchar() calls into this instead. This is used
# for unittesting purposes.
_getchar = None
def getchar(echo=False):
"""Fetches a single character from the terminal and returns it. This
will always return a unicode character and under certain rare
circumstances this might return more than one character. The
situations which more than one character is returned is when for
whatever reason multiple characters end up in the terminal buffer or
standard input was not actually a terminal.
Note that this will always read from the terminal, even if something
is piped into the standard input.
Note for Windows: in rare cases when typing non-ASCII characters, this
function might wait for a second character and then return both at once.
This is because certain Unicode characters look like special-key markers.
.. versionadded:: 2.0
:param echo: if set to `True`, the character read will also show up on
the terminal. The default is to not show it.
"""
f = _getchar
if f is None:
from ._termui_impl import getchar as f
return f(echo)
def raw_terminal():
from ._termui_impl import raw_terminal as f
return f()
def pause(info='Press any key to continue ...', err=False):
"""This command stops execution and waits for the user to press any
key to continue. This is similar to the Windows batch "pause"
command. If the program is not run through a terminal, this command
will instead do nothing.
.. versionadded:: 2.0
.. versionadded:: 4.0
Added the `err` parameter.
:param info: the info string to print before pausing.
:param err: if set to message goes to ``stderr`` instead of
``stdout``, the same as with echo.
"""
if not isatty(sys.stdin) or not isatty(sys.stdout):
return
try:
if info:
echo(info, nl=False, err=err)
try:
getchar()
except (KeyboardInterrupt, EOFError):
pass
finally:
if info:
echo(err=err)
Click-7.0/click/testing.py 0000644 0001750 0001750 00000031406 13351570514 015731 0 ustar david david 0000000 0000000 import os
import sys
import shutil
import tempfile
import contextlib
import shlex
from ._compat import iteritems, PY2, string_types
# If someone wants to vendor click, we want to ensure the
# correct package is discovered. Ideally we could use a
# relative import here but unfortunately Python does not
# support that.
clickpkg = sys.modules[__name__.rsplit('.', 1)[0]]
if PY2:
from cStringIO import StringIO
else:
import io
from ._compat import _find_binary_reader
class EchoingStdin(object):
def __init__(self, input, output):
self._input = input
self._output = output
def __getattr__(self, x):
return getattr(self._input, x)
def _echo(self, rv):
self._output.write(rv)
return rv
def read(self, n=-1):
return self._echo(self._input.read(n))
def readline(self, n=-1):
return self._echo(self._input.readline(n))
def readlines(self):
return [self._echo(x) for x in self._input.readlines()]
def __iter__(self):
return iter(self._echo(x) for x in self._input)
def __repr__(self):
return repr(self._input)
def make_input_stream(input, charset):
# Is already an input stream.
if hasattr(input, 'read'):
if PY2:
return input
rv = _find_binary_reader(input)
if rv is not None:
return rv
raise TypeError('Could not find binary reader for input stream.')
if input is None:
input = b''
elif not isinstance(input, bytes):
input = input.encode(charset)
if PY2:
return StringIO(input)
return io.BytesIO(input)
class Result(object):
"""Holds the captured result of an invoked CLI script."""
def __init__(self, runner, stdout_bytes, stderr_bytes, exit_code,
exception, exc_info=None):
#: The runner that created the result
self.runner = runner
#: The standard output as bytes.
self.stdout_bytes = stdout_bytes
#: The standard error as bytes, or False(y) if not available
self.stderr_bytes = stderr_bytes
#: The exit code as integer.
self.exit_code = exit_code
#: The exception that happened if one did.
self.exception = exception
#: The traceback
self.exc_info = exc_info
@property
def output(self):
"""The (standard) output as unicode string."""
return self.stdout
@property
def stdout(self):
"""The standard output as unicode string."""
return self.stdout_bytes.decode(self.runner.charset, 'replace') \
.replace('\r\n', '\n')
@property
def stderr(self):
"""The standard error as unicode string."""
if not self.stderr_bytes:
raise ValueError("stderr not separately captured")
return self.stderr_bytes.decode(self.runner.charset, 'replace') \
.replace('\r\n', '\n')
def __repr__(self):
return '<%s %s>' % (
type(self).__name__,
self.exception and repr(self.exception) or 'okay',
)
class CliRunner(object):
"""The CLI runner provides functionality to invoke a Click command line
script for unittesting purposes in a isolated environment. This only
works in single-threaded systems without any concurrency as it changes the
global interpreter state.
:param charset: the character set for the input and output data. This is
UTF-8 by default and should not be changed currently as
the reporting to Click only works in Python 2 properly.
:param env: a dictionary with environment variables for overriding.
:param echo_stdin: if this is set to `True`, then reading from stdin writes
to stdout. This is useful for showing examples in
some circumstances. Note that regular prompts
will automatically echo the input.
:param mix_stderr: if this is set to `False`, then stdout and stderr are
preserved as independent streams. This is useful for
Unix-philosophy apps that have predictable stdout and
noisy stderr, such that each may be measured
independently
"""
def __init__(self, charset=None, env=None, echo_stdin=False,
mix_stderr=True):
if charset is None:
charset = 'utf-8'
self.charset = charset
self.env = env or {}
self.echo_stdin = echo_stdin
self.mix_stderr = mix_stderr
def get_default_prog_name(self, cli):
"""Given a command object it will return the default program name
for it. The default is the `name` attribute or ``"root"`` if not
set.
"""
return cli.name or 'root'
def make_env(self, overrides=None):
"""Returns the environment overrides for invoking a script."""
rv = dict(self.env)
if overrides:
rv.update(overrides)
return rv
@contextlib.contextmanager
def isolation(self, input=None, env=None, color=False):
"""A context manager that sets up the isolation for invoking of a
command line tool. This sets up stdin with the given input data
and `os.environ` with the overrides from the given dictionary.
This also rebinds some internals in Click to be mocked (like the
prompt functionality).
This is automatically done in the :meth:`invoke` method.
.. versionadded:: 4.0
The ``color`` parameter was added.
:param input: the input stream to put into sys.stdin.
:param env: the environment overrides as dictionary.
:param color: whether the output should contain color codes. The
application can still override this explicitly.
"""
input = make_input_stream(input, self.charset)
old_stdin = sys.stdin
old_stdout = sys.stdout
old_stderr = sys.stderr
old_forced_width = clickpkg.formatting.FORCED_WIDTH
clickpkg.formatting.FORCED_WIDTH = 80
env = self.make_env(env)
if PY2:
bytes_output = StringIO()
if self.echo_stdin:
input = EchoingStdin(input, bytes_output)
sys.stdout = bytes_output
if not self.mix_stderr:
bytes_error = StringIO()
sys.stderr = bytes_error
else:
bytes_output = io.BytesIO()
if self.echo_stdin:
input = EchoingStdin(input, bytes_output)
input = io.TextIOWrapper(input, encoding=self.charset)
sys.stdout = io.TextIOWrapper(
bytes_output, encoding=self.charset)
if not self.mix_stderr:
bytes_error = io.BytesIO()
sys.stderr = io.TextIOWrapper(
bytes_error, encoding=self.charset)
if self.mix_stderr:
sys.stderr = sys.stdout
sys.stdin = input
def visible_input(prompt=None):
sys.stdout.write(prompt or '')
val = input.readline().rstrip('\r\n')
sys.stdout.write(val + '\n')
sys.stdout.flush()
return val
def hidden_input(prompt=None):
sys.stdout.write((prompt or '') + '\n')
sys.stdout.flush()
return input.readline().rstrip('\r\n')
def _getchar(echo):
char = sys.stdin.read(1)
if echo:
sys.stdout.write(char)
sys.stdout.flush()
return char
default_color = color
def should_strip_ansi(stream=None, color=None):
if color is None:
return not default_color
return not color
old_visible_prompt_func = clickpkg.termui.visible_prompt_func
old_hidden_prompt_func = clickpkg.termui.hidden_prompt_func
old__getchar_func = clickpkg.termui._getchar
old_should_strip_ansi = clickpkg.utils.should_strip_ansi
clickpkg.termui.visible_prompt_func = visible_input
clickpkg.termui.hidden_prompt_func = hidden_input
clickpkg.termui._getchar = _getchar
clickpkg.utils.should_strip_ansi = should_strip_ansi
old_env = {}
try:
for key, value in iteritems(env):
old_env[key] = os.environ.get(key)
if value is None:
try:
del os.environ[key]
except Exception:
pass
else:
os.environ[key] = value
yield (bytes_output, not self.mix_stderr and bytes_error)
finally:
for key, value in iteritems(old_env):
if value is None:
try:
del os.environ[key]
except Exception:
pass
else:
os.environ[key] = value
sys.stdout = old_stdout
sys.stderr = old_stderr
sys.stdin = old_stdin
clickpkg.termui.visible_prompt_func = old_visible_prompt_func
clickpkg.termui.hidden_prompt_func = old_hidden_prompt_func
clickpkg.termui._getchar = old__getchar_func
clickpkg.utils.should_strip_ansi = old_should_strip_ansi
clickpkg.formatting.FORCED_WIDTH = old_forced_width
def invoke(self, cli, args=None, input=None, env=None,
catch_exceptions=True, color=False, mix_stderr=False, **extra):
"""Invokes a command in an isolated environment. The arguments are
forwarded directly to the command line script, the `extra` keyword
arguments are passed to the :meth:`~clickpkg.Command.main` function of
the command.
This returns a :class:`Result` object.
.. versionadded:: 3.0
The ``catch_exceptions`` parameter was added.
.. versionchanged:: 3.0
The result object now has an `exc_info` attribute with the
traceback if available.
.. versionadded:: 4.0
The ``color`` parameter was added.
:param cli: the command to invoke
:param args: the arguments to invoke. It may be given as an iterable
or a string. When given as string it will be interpreted
as a Unix shell command. More details at
:func:`shlex.split`.
:param input: the input data for `sys.stdin`.
:param env: the environment overrides.
:param catch_exceptions: Whether to catch any other exceptions than
``SystemExit``.
:param extra: the keyword arguments to pass to :meth:`main`.
:param color: whether the output should contain color codes. The
application can still override this explicitly.
"""
exc_info = None
with self.isolation(input=input, env=env, color=color) as outstreams:
exception = None
exit_code = 0
if isinstance(args, string_types):
args = shlex.split(args)
try:
prog_name = extra.pop("prog_name")
except KeyError:
prog_name = self.get_default_prog_name(cli)
try:
cli.main(args=args or (), prog_name=prog_name, **extra)
except SystemExit as e:
exc_info = sys.exc_info()
exit_code = e.code
if exit_code is None:
exit_code = 0
if exit_code != 0:
exception = e
if not isinstance(exit_code, int):
sys.stdout.write(str(exit_code))
sys.stdout.write('\n')
exit_code = 1
except Exception as e:
if not catch_exceptions:
raise
exception = e
exit_code = 1
exc_info = sys.exc_info()
finally:
sys.stdout.flush()
stdout = outstreams[0].getvalue()
stderr = outstreams[1] and outstreams[1].getvalue()
return Result(runner=self,
stdout_bytes=stdout,
stderr_bytes=stderr,
exit_code=exit_code,
exception=exception,
exc_info=exc_info)
@contextlib.contextmanager
def isolated_filesystem(self):
"""A context manager that creates a temporary folder and changes
the current working directory to it for isolated filesystem tests.
"""
cwd = os.getcwd()
t = tempfile.mkdtemp()
os.chdir(t)
try:
yield t
finally:
os.chdir(cwd)
try:
shutil.rmtree(t)
except (OSError, IOError):
pass
Click-7.0/click/types.py 0000644 0001750 0001750 00000055367 13351570514 015434 0 ustar david david 0000000 0000000 import os
import stat
from datetime import datetime
from ._compat import open_stream, text_type, filename_to_ui, \
get_filesystem_encoding, get_streerror, _get_argv_encoding, PY2
from .exceptions import BadParameter
from .utils import safecall, LazyFile
class ParamType(object):
"""Helper for converting values through types. The following is
necessary for a valid type:
* it needs a name
* it needs to pass through None unchanged
* it needs to convert from a string
* it needs to convert its result type through unchanged
(eg: needs to be idempotent)
* it needs to be able to deal with param and context being `None`.
This can be the case when the object is used with prompt
inputs.
"""
is_composite = False
#: the descriptive name of this type
name = None
#: if a list of this type is expected and the value is pulled from a
#: string environment variable, this is what splits it up. `None`
#: means any whitespace. For all parameters the general rule is that
#: whitespace splits them up. The exception are paths and files which
#: are split by ``os.path.pathsep`` by default (":" on Unix and ";" on
#: Windows).
envvar_list_splitter = None
def __call__(self, value, param=None, ctx=None):
if value is not None:
return self.convert(value, param, ctx)
def get_metavar(self, param):
"""Returns the metavar default for this param if it provides one."""
def get_missing_message(self, param):
"""Optionally might return extra information about a missing
parameter.
.. versionadded:: 2.0
"""
def convert(self, value, param, ctx):
"""Converts the value. This is not invoked for values that are
`None` (the missing value).
"""
return value
def split_envvar_value(self, rv):
"""Given a value from an environment variable this splits it up
into small chunks depending on the defined envvar list splitter.
If the splitter is set to `None`, which means that whitespace splits,
then leading and trailing whitespace is ignored. Otherwise, leading
and trailing splitters usually lead to empty items being included.
"""
return (rv or '').split(self.envvar_list_splitter)
def fail(self, message, param=None, ctx=None):
"""Helper method to fail with an invalid value message."""
raise BadParameter(message, ctx=ctx, param=param)
class CompositeParamType(ParamType):
is_composite = True
@property
def arity(self):
raise NotImplementedError()
class FuncParamType(ParamType):
def __init__(self, func):
self.name = func.__name__
self.func = func
def convert(self, value, param, ctx):
try:
return self.func(value)
except ValueError:
try:
value = text_type(value)
except UnicodeError:
value = str(value).decode('utf-8', 'replace')
self.fail(value, param, ctx)
class UnprocessedParamType(ParamType):
name = 'text'
def convert(self, value, param, ctx):
return value
def __repr__(self):
return 'UNPROCESSED'
class StringParamType(ParamType):
name = 'text'
def convert(self, value, param, ctx):
if isinstance(value, bytes):
enc = _get_argv_encoding()
try:
value = value.decode(enc)
except UnicodeError:
fs_enc = get_filesystem_encoding()
if fs_enc != enc:
try:
value = value.decode(fs_enc)
except UnicodeError:
value = value.decode('utf-8', 'replace')
return value
return value
def __repr__(self):
return 'STRING'
class Choice(ParamType):
"""The choice type allows a value to be checked against a fixed set
of supported values. All of these values have to be strings.
You should only pass a list or tuple of choices. Other iterables
(like generators) may lead to surprising results.
See :ref:`choice-opts` for an example.
:param case_sensitive: Set to false to make choices case
insensitive. Defaults to true.
"""
name = 'choice'
def __init__(self, choices, case_sensitive=True):
self.choices = choices
self.case_sensitive = case_sensitive
def get_metavar(self, param):
return '[%s]' % '|'.join(self.choices)
def get_missing_message(self, param):
return 'Choose from:\n\t%s.' % ',\n\t'.join(self.choices)
def convert(self, value, param, ctx):
# Exact match
if value in self.choices:
return value
# Match through normalization and case sensitivity
# first do token_normalize_func, then lowercase
# preserve original `value` to produce an accurate message in
# `self.fail`
normed_value = value
normed_choices = self.choices
if ctx is not None and \
ctx.token_normalize_func is not None:
normed_value = ctx.token_normalize_func(value)
normed_choices = [ctx.token_normalize_func(choice) for choice in
self.choices]
if not self.case_sensitive:
normed_value = normed_value.lower()
normed_choices = [choice.lower() for choice in normed_choices]
if normed_value in normed_choices:
return normed_value
self.fail('invalid choice: %s. (choose from %s)' %
(value, ', '.join(self.choices)), param, ctx)
def __repr__(self):
return 'Choice(%r)' % list(self.choices)
class DateTime(ParamType):
"""The DateTime type converts date strings into `datetime` objects.
The format strings which are checked are configurable, but default to some
common (non-timezone aware) ISO 8601 formats.
When specifying *DateTime* formats, you should only pass a list or a tuple.
Other iterables, like generators, may lead to surprising results.
The format strings are processed using ``datetime.strptime``, and this
consequently defines the format strings which are allowed.
Parsing is tried using each format, in order, and the first format which
parses successfully is used.
:param formats: A list or tuple of date format strings, in the order in
which they should be tried. Defaults to
``'%Y-%m-%d'``, ``'%Y-%m-%dT%H:%M:%S'``,
``'%Y-%m-%d %H:%M:%S'``.
"""
name = 'datetime'
def __init__(self, formats=None):
self.formats = formats or [
'%Y-%m-%d',
'%Y-%m-%dT%H:%M:%S',
'%Y-%m-%d %H:%M:%S'
]
def get_metavar(self, param):
return '[{}]'.format('|'.join(self.formats))
def _try_to_convert_date(self, value, format):
try:
return datetime.strptime(value, format)
except ValueError:
return None
def convert(self, value, param, ctx):
# Exact match
for format in self.formats:
dtime = self._try_to_convert_date(value, format)
if dtime:
return dtime
self.fail(
'invalid datetime format: {}. (choose from {})'.format(
value, ', '.join(self.formats)))
def __repr__(self):
return 'DateTime'
class IntParamType(ParamType):
name = 'integer'
def convert(self, value, param, ctx):
try:
return int(value)
except (ValueError, UnicodeError):
self.fail('%s is not a valid integer' % value, param, ctx)
def __repr__(self):
return 'INT'
class IntRange(IntParamType):
"""A parameter that works similar to :data:`click.INT` but restricts
the value to fit into a range. The default behavior is to fail if the
value falls outside the range, but it can also be silently clamped
between the two edges.
See :ref:`ranges` for an example.
"""
name = 'integer range'
def __init__(self, min=None, max=None, clamp=False):
self.min = min
self.max = max
self.clamp = clamp
def convert(self, value, param, ctx):
rv = IntParamType.convert(self, value, param, ctx)
if self.clamp:
if self.min is not None and rv < self.min:
return self.min
if self.max is not None and rv > self.max:
return self.max
if self.min is not None and rv < self.min or \
self.max is not None and rv > self.max:
if self.min is None:
self.fail('%s is bigger than the maximum valid value '
'%s.' % (rv, self.max), param, ctx)
elif self.max is None:
self.fail('%s is smaller than the minimum valid value '
'%s.' % (rv, self.min), param, ctx)
else:
self.fail('%s is not in the valid range of %s to %s.'
% (rv, self.min, self.max), param, ctx)
return rv
def __repr__(self):
return 'IntRange(%r, %r)' % (self.min, self.max)
class FloatParamType(ParamType):
name = 'float'
def convert(self, value, param, ctx):
try:
return float(value)
except (UnicodeError, ValueError):
self.fail('%s is not a valid floating point value' %
value, param, ctx)
def __repr__(self):
return 'FLOAT'
class FloatRange(FloatParamType):
"""A parameter that works similar to :data:`click.FLOAT` but restricts
the value to fit into a range. The default behavior is to fail if the
value falls outside the range, but it can also be silently clamped
between the two edges.
See :ref:`ranges` for an example.
"""
name = 'float range'
def __init__(self, min=None, max=None, clamp=False):
self.min = min
self.max = max
self.clamp = clamp
def convert(self, value, param, ctx):
rv = FloatParamType.convert(self, value, param, ctx)
if self.clamp:
if self.min is not None and rv < self.min:
return self.min
if self.max is not None and rv > self.max:
return self.max
if self.min is not None and rv < self.min or \
self.max is not None and rv > self.max:
if self.min is None:
self.fail('%s is bigger than the maximum valid value '
'%s.' % (rv, self.max), param, ctx)
elif self.max is None:
self.fail('%s is smaller than the minimum valid value '
'%s.' % (rv, self.min), param, ctx)
else:
self.fail('%s is not in the valid range of %s to %s.'
% (rv, self.min, self.max), param, ctx)
return rv
def __repr__(self):
return 'FloatRange(%r, %r)' % (self.min, self.max)
class BoolParamType(ParamType):
name = 'boolean'
def convert(self, value, param, ctx):
if isinstance(value, bool):
return bool(value)
value = value.lower()
if value in ('true', 't', '1', 'yes', 'y'):
return True
elif value in ('false', 'f', '0', 'no', 'n'):
return False
self.fail('%s is not a valid boolean' % value, param, ctx)
def __repr__(self):
return 'BOOL'
class UUIDParameterType(ParamType):
name = 'uuid'
def convert(self, value, param, ctx):
import uuid
try:
if PY2 and isinstance(value, text_type):
value = value.encode('ascii')
return uuid.UUID(value)
except (UnicodeError, ValueError):
self.fail('%s is not a valid UUID value' % value, param, ctx)
def __repr__(self):
return 'UUID'
class File(ParamType):
"""Declares a parameter to be a file for reading or writing. The file
is automatically closed once the context tears down (after the command
finished working).
Files can be opened for reading or writing. The special value ``-``
indicates stdin or stdout depending on the mode.
By default, the file is opened for reading text data, but it can also be
opened in binary mode or for writing. The encoding parameter can be used
to force a specific encoding.
The `lazy` flag controls if the file should be opened immediately or upon
first IO. The default is to be non-lazy for standard input and output
streams as well as files opened for reading, `lazy` otherwise. When opening a
file lazily for reading, it is still opened temporarily for validation, but
will not be held open until first IO. lazy is mainly useful when opening
for writing to avoid creating the file until it is needed.
Starting with Click 2.0, files can also be opened atomically in which
case all writes go into a separate file in the same folder and upon
completion the file will be moved over to the original location. This
is useful if a file regularly read by other users is modified.
See :ref:`file-args` for more information.
"""
name = 'filename'
envvar_list_splitter = os.path.pathsep
def __init__(self, mode='r', encoding=None, errors='strict', lazy=None,
atomic=False):
self.mode = mode
self.encoding = encoding
self.errors = errors
self.lazy = lazy
self.atomic = atomic
def resolve_lazy_flag(self, value):
if self.lazy is not None:
return self.lazy
if value == '-':
return False
elif 'w' in self.mode:
return True
return False
def convert(self, value, param, ctx):
try:
if hasattr(value, 'read') or hasattr(value, 'write'):
return value
lazy = self.resolve_lazy_flag(value)
if lazy:
f = LazyFile(value, self.mode, self.encoding, self.errors,
atomic=self.atomic)
if ctx is not None:
ctx.call_on_close(f.close_intelligently)
return f
f, should_close = open_stream(value, self.mode,
self.encoding, self.errors,
atomic=self.atomic)
# If a context is provided, we automatically close the file
# at the end of the context execution (or flush out). If a
# context does not exist, it's the caller's responsibility to
# properly close the file. This for instance happens when the
# type is used with prompts.
if ctx is not None:
if should_close:
ctx.call_on_close(safecall(f.close))
else:
ctx.call_on_close(safecall(f.flush))
return f
except (IOError, OSError) as e:
self.fail('Could not open file: %s: %s' % (
filename_to_ui(value),
get_streerror(e),
), param, ctx)
class Path(ParamType):
"""The path type is similar to the :class:`File` type but it performs
different checks. First of all, instead of returning an open file
handle it returns just the filename. Secondly, it can perform various
basic checks about what the file or directory should be.
.. versionchanged:: 6.0
`allow_dash` was added.
:param exists: if set to true, the file or directory needs to exist for
this value to be valid. If this is not required and a
file does indeed not exist, then all further checks are
silently skipped.
:param file_okay: controls if a file is a possible value.
:param dir_okay: controls if a directory is a possible value.
:param writable: if true, a writable check is performed.
:param readable: if true, a readable check is performed.
:param resolve_path: if this is true, then the path is fully resolved
before the value is passed onwards. This means
that it's absolute and symlinks are resolved. It
will not expand a tilde-prefix, as this is
supposed to be done by the shell only.
:param allow_dash: If this is set to `True`, a single dash to indicate
standard streams is permitted.
:param path_type: optionally a string type that should be used to
represent the path. The default is `None` which
means the return value will be either bytes or
unicode depending on what makes most sense given the
input data Click deals with.
"""
envvar_list_splitter = os.path.pathsep
def __init__(self, exists=False, file_okay=True, dir_okay=True,
writable=False, readable=True, resolve_path=False,
allow_dash=False, path_type=None):
self.exists = exists
self.file_okay = file_okay
self.dir_okay = dir_okay
self.writable = writable
self.readable = readable
self.resolve_path = resolve_path
self.allow_dash = allow_dash
self.type = path_type
if self.file_okay and not self.dir_okay:
self.name = 'file'
self.path_type = 'File'
elif self.dir_okay and not self.file_okay:
self.name = 'directory'
self.path_type = 'Directory'
else:
self.name = 'path'
self.path_type = 'Path'
def coerce_path_result(self, rv):
if self.type is not None and not isinstance(rv, self.type):
if self.type is text_type:
rv = rv.decode(get_filesystem_encoding())
else:
rv = rv.encode(get_filesystem_encoding())
return rv
def convert(self, value, param, ctx):
rv = value
is_dash = self.file_okay and self.allow_dash and rv in (b'-', '-')
if not is_dash:
if self.resolve_path:
rv = os.path.realpath(rv)
try:
st = os.stat(rv)
except OSError:
if not self.exists:
return self.coerce_path_result(rv)
self.fail('%s "%s" does not exist.' % (
self.path_type,
filename_to_ui(value)
), param, ctx)
if not self.file_okay and stat.S_ISREG(st.st_mode):
self.fail('%s "%s" is a file.' % (
self.path_type,
filename_to_ui(value)
), param, ctx)
if not self.dir_okay and stat.S_ISDIR(st.st_mode):
self.fail('%s "%s" is a directory.' % (
self.path_type,
filename_to_ui(value)
), param, ctx)
if self.writable and not os.access(value, os.W_OK):
self.fail('%s "%s" is not writable.' % (
self.path_type,
filename_to_ui(value)
), param, ctx)
if self.readable and not os.access(value, os.R_OK):
self.fail('%s "%s" is not readable.' % (
self.path_type,
filename_to_ui(value)
), param, ctx)
return self.coerce_path_result(rv)
class Tuple(CompositeParamType):
"""The default behavior of Click is to apply a type on a value directly.
This works well in most cases, except for when `nargs` is set to a fixed
count and different types should be used for different items. In this
case the :class:`Tuple` type can be used. This type can only be used
if `nargs` is set to a fixed number.
For more information see :ref:`tuple-type`.
This can be selected by using a Python tuple literal as a type.
:param types: a list of types that should be used for the tuple items.
"""
def __init__(self, types):
self.types = [convert_type(ty) for ty in types]
@property
def name(self):
return "<" + " ".join(ty.name for ty in self.types) + ">"
@property
def arity(self):
return len(self.types)
def convert(self, value, param, ctx):
if len(value) != len(self.types):
raise TypeError('It would appear that nargs is set to conflict '
'with the composite type arity.')
return tuple(ty(x, param, ctx) for ty, x in zip(self.types, value))
def convert_type(ty, default=None):
"""Converts a callable or python ty into the most appropriate param
ty.
"""
guessed_type = False
if ty is None and default is not None:
if isinstance(default, tuple):
ty = tuple(map(type, default))
else:
ty = type(default)
guessed_type = True
if isinstance(ty, tuple):
return Tuple(ty)
if isinstance(ty, ParamType):
return ty
if ty is text_type or ty is str or ty is None:
return STRING
if ty is int:
return INT
# Booleans are only okay if not guessed. This is done because for
# flags the default value is actually a bit of a lie in that it
# indicates which of the flags is the one we want. See get_default()
# for more information.
if ty is bool and not guessed_type:
return BOOL
if ty is float:
return FLOAT
if guessed_type:
return STRING
# Catch a common mistake
if __debug__:
try:
if issubclass(ty, ParamType):
raise AssertionError('Attempted to use an uninstantiated '
'parameter type (%s).' % ty)
except TypeError:
pass
return FuncParamType(ty)
#: A dummy parameter type that just does nothing. From a user's
#: perspective this appears to just be the same as `STRING` but internally
#: no string conversion takes place. This is necessary to achieve the
#: same bytes/unicode behavior on Python 2/3 in situations where you want
#: to not convert argument types. This is usually useful when working
#: with file paths as they can appear in bytes and unicode.
#:
#: For path related uses the :class:`Path` type is a better choice but
#: there are situations where an unprocessed type is useful which is why
#: it is is provided.
#:
#: .. versionadded:: 4.0
UNPROCESSED = UnprocessedParamType()
#: A unicode string parameter type which is the implicit default. This
#: can also be selected by using ``str`` as type.
STRING = StringParamType()
#: An integer parameter. This can also be selected by using ``int`` as
#: type.
INT = IntParamType()
#: A floating point value parameter. This can also be selected by using
#: ``float`` as type.
FLOAT = FloatParamType()
#: A boolean parameter. This is the default for boolean flags. This can
#: also be selected by using ``bool`` as a type.
BOOL = BoolParamType()
#: A UUID parameter.
UUID = UUIDParameterType()
Click-7.0/click/utils.py 0000644 0001750 0001750 00000036623 13351570514 015422 0 ustar david david 0000000 0000000 import os
import sys
from .globals import resolve_color_default
from ._compat import text_type, open_stream, get_filesystem_encoding, \
get_streerror, string_types, PY2, binary_streams, text_streams, \
filename_to_ui, auto_wrap_for_ansi, strip_ansi, should_strip_ansi, \
_default_text_stdout, _default_text_stderr, is_bytes, WIN
if not PY2:
from ._compat import _find_binary_writer
elif WIN:
from ._winconsole import _get_windows_argv, \
_hash_py_argv, _initial_argv_hash
echo_native_types = string_types + (bytes, bytearray)
def _posixify(name):
return '-'.join(name.split()).lower()
def safecall(func):
"""Wraps a function so that it swallows exceptions."""
def wrapper(*args, **kwargs):
try:
return func(*args, **kwargs)
except Exception:
pass
return wrapper
def make_str(value):
"""Converts a value into a valid string."""
if isinstance(value, bytes):
try:
return value.decode(get_filesystem_encoding())
except UnicodeError:
return value.decode('utf-8', 'replace')
return text_type(value)
def make_default_short_help(help, max_length=45):
"""Return a condensed version of help string."""
words = help.split()
total_length = 0
result = []
done = False
for word in words:
if word[-1:] == '.':
done = True
new_length = result and 1 + len(word) or len(word)
if total_length + new_length > max_length:
result.append('...')
done = True
else:
if result:
result.append(' ')
result.append(word)
if done:
break
total_length += new_length
return ''.join(result)
class LazyFile(object):
"""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.
"""
def __init__(self, filename, mode='r', encoding=None, errors='strict',
atomic=False):
self.name = filename
self.mode = mode
self.encoding = encoding
self.errors = errors
self.atomic = atomic
if filename == '-':
self._f, self.should_close = open_stream(filename, mode,
encoding, errors)
else:
if 'r' in mode:
# Open and close the file in case we're opening it for
# reading so that we can catch at least some errors in
# some cases early.
open(filename, mode).close()
self._f = None
self.should_close = True
def __getattr__(self, name):
return getattr(self.open(), name)
def __repr__(self):
if self._f is not None:
return repr(self._f)
return '' % (self.name, self.mode)
def open(self):
"""Opens 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.
"""
if self._f is not None:
return self._f
try:
rv, self.should_close = open_stream(self.name, self.mode,
self.encoding,
self.errors,
atomic=self.atomic)
except (IOError, OSError) as e:
from .exceptions import FileError
raise FileError(self.name, hint=get_streerror(e))
self._f = rv
return rv
def close(self):
"""Closes the underlying file, no matter what."""
if self._f is not None:
self._f.close()
def close_intelligently(self):
"""This function only closes the file if it was opened by the lazy
file wrapper. For instance this will never close stdin.
"""
if self.should_close:
self.close()
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, tb):
self.close_intelligently()
def __iter__(self):
self.open()
return iter(self._f)
class KeepOpenFile(object):
def __init__(self, file):
self._file = file
def __getattr__(self, name):
return getattr(self._file, name)
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, tb):
pass
def __repr__(self):
return repr(self._file)
def __iter__(self):
return iter(self._file)
def echo(message=None, file=None, nl=True, err=False, color=None):
"""Prints a message plus a newline to the given file or stdout. On
first sight, this looks like the print function, but it has improved
support for handling Unicode and binary data that does not fail no
matter how badly configured the system is.
Primarily it means that you can print binary data as well as Unicode
data on both 2.x and 3.x to the given file in the most appropriate way
possible. This is a very carefree function in that it will try its
best to not fail. As of Click 6.0 this includes support for unicode
output on the Windows console.
In addition to that, if `colorama`_ is installed, the echo function will
also support clever handling of ANSI codes. Essentially it will then
do the following:
- add transparent handling of ANSI color codes on Windows.
- hide ANSI codes automatically if the destination file is not a
terminal.
.. _colorama: https://pypi.org/project/colorama/
.. versionchanged:: 6.0
As of Click 6.0 the echo function will properly support unicode
output on the windows console. Not that click does not modify
the interpreter in any way which means that `sys.stdout` or the
print statement or function will still not provide unicode support.
.. versionchanged:: 2.0
Starting with version 2.0 of Click, the echo function will work
with colorama if it's installed.
.. versionadded:: 3.0
The `err` parameter was added.
.. versionchanged:: 4.0
Added the `color` flag.
:param message: the message to print
:param file: the file to write to (defaults to ``stdout``)
:param err: if set to true the file defaults to ``stderr`` instead of
``stdout``. This is faster and easier than calling
:func:`get_text_stderr` yourself.
:param nl: if set to `True` (the default) a newline is printed afterwards.
:param color: controls if the terminal supports ANSI colors or not. The
default is autodetection.
"""
if file is None:
if err:
file = _default_text_stderr()
else:
file = _default_text_stdout()
# Convert non bytes/text into the native string type.
if message is not None and not isinstance(message, echo_native_types):
message = text_type(message)
if nl:
message = message or u''
if isinstance(message, text_type):
message += u'\n'
else:
message += b'\n'
# If there is a message, and we're in Python 3, and the value looks
# like bytes, we manually need to find the binary stream and write the
# message in there. This is done separately so that most stream
# types will work as you would expect. Eg: you can write to StringIO
# for other cases.
if message and not PY2 and is_bytes(message):
binary_file = _find_binary_writer(file)
if binary_file is not None:
file.flush()
binary_file.write(message)
binary_file.flush()
return
# ANSI-style support. If there is no message or we are dealing with
# bytes nothing is happening. If we are connected to a file we want
# to strip colors. If we are on windows we either wrap the stream
# to strip the color or we use the colorama support to translate the
# ansi codes to API calls.
if message and not is_bytes(message):
color = resolve_color_default(color)
if should_strip_ansi(file, color):
message = strip_ansi(message)
elif WIN:
if auto_wrap_for_ansi is not None:
file = auto_wrap_for_ansi(file)
elif not color:
message = strip_ansi(message)
if message:
file.write(message)
file.flush()
def get_binary_stream(name):
"""Returns a system stream for byte processing. This essentially
returns the stream from the sys module with the given name but it
solves some compatibility issues between different Python versions.
Primarily this function is necessary for getting binary streams on
Python 3.
:param name: the name of the stream to open. Valid names are ``'stdin'``,
``'stdout'`` and ``'stderr'``
"""
opener = binary_streams.get(name)
if opener is None:
raise TypeError('Unknown standard stream %r' % name)
return opener()
def get_text_stream(name, encoding=None, errors='strict'):
"""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 on Python 3
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.
"""
opener = text_streams.get(name)
if opener is None:
raise TypeError('Unknown standard stream %r' % name)
return opener(encoding, errors)
def open_file(filename, mode='r', encoding=None, errors='strict',
lazy=False, atomic=False):
"""This is similar to how the :class:`File` works but for manual
usage. Files are opened non lazy by default. This can open regular
files as well as stdin/stdout if ``'-'`` is passed.
If stdin/stdout is returned the stream is wrapped so that the context
manager will not close the stream accidentally. This makes it possible
to always use the function like this without having to worry to
accidentally close a standard stream::
with open_file(filename) as f:
...
.. versionadded:: 3.0
: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 use.
:param errors: the error handling for this file.
:param lazy: can be flipped to true to open the file lazily.
:param atomic: in atomic mode writes go into a temporary file and it's
moved on close.
"""
if lazy:
return LazyFile(filename, mode, encoding, errors, atomic=atomic)
f, should_close = open_stream(filename, mode, encoding, errors,
atomic=atomic)
if not should_close:
f = KeepOpenFile(f)
return f
def get_os_args():
"""This returns the argument part of sys.argv in the most appropriate
form for processing. What this means is that this return value is in
a format that works for Click to process but does not necessarily
correspond well to what's actually standard for the interpreter.
On most environments the return value is ``sys.argv[:1]`` unchanged.
However if you are on Windows and running Python 2 the return value
will actually be a list of unicode strings instead because the
default behavior on that platform otherwise will not be able to
carry all possible values that sys.argv can have.
.. versionadded:: 6.0
"""
# We can only extract the unicode argv if sys.argv has not been
# changed since the startup of the application.
if PY2 and WIN and _initial_argv_hash == _hash_py_argv():
return _get_windows_argv()
return sys.argv[1:]
def format_filename(filename, shorten=False):
"""Formats a filename for user display. The main purpose of this
function is to ensure that the filename can be displayed at all. This
will decode the filename to unicode if necessary in a way that it will
not fail. Optionally, it can shorten the filename to not include the
full path to the filename.
: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.
"""
if shorten:
filename = os.path.basename(filename)
return filename_to_ui(filename)
def get_app_dir(app_name, roaming=True, force_posix=False):
r"""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``
Win XP (roaming):
``C:\Documents and Settings\\Local Settings\Application Data\Foo Bar``
Win XP (not roaming):
``C:\Documents and Settings\\Application Data\Foo Bar``
Win 7 (roaming):
``C:\Users\\AppData\Roaming\Foo Bar``
Win 7 (not roaming):
``C:\Users\\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 affect 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.
"""
if WIN:
key = roaming and 'APPDATA' or 'LOCALAPPDATA'
folder = os.environ.get(key)
if folder is None:
folder = os.path.expanduser('~')
return os.path.join(folder, app_name)
if force_posix:
return os.path.join(os.path.expanduser('~/.' + _posixify(app_name)))
if sys.platform == 'darwin':
return os.path.join(os.path.expanduser(
'~/Library/Application Support'), app_name)
return os.path.join(
os.environ.get('XDG_CONFIG_HOME', os.path.expanduser('~/.config')),
_posixify(app_name))
class PacifyFlushWrapper(object):
"""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.
"""
def __init__(self, wrapped):
self.wrapped = wrapped
def flush(self):
try:
self.wrapped.flush()
except IOError as e:
import errno
if e.errno != errno.EPIPE:
raise
def __getattr__(self, attr):
return getattr(self.wrapped, attr)
Click-7.0/docs/ 0000755 0001750 0001750 00000000000 13352517732 013545 5 ustar david david 0000000 0000000 Click-7.0/docs/Makefile 0000644 0001750 0001750 00000001133 13351570514 015177 0 ustar david david 0000000 0000000 # Minimal makefile for Sphinx documentation
#
# You can set these variables from the command line.
SPHINXOPTS =
SPHINXBUILD = sphinx-build
SPHINXPROJ = Jinja
SOURCEDIR = .
BUILDDIR = _build
# Put it first so that "make" without argument is like "make help".
help:
@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
.PHONY: help Makefile
# Catch-all target: route all unknown targets to Sphinx using the new
# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS).
%: Makefile
@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
Click-7.0/docs/_static/ 0000755 0001750 0001750 00000000000 13352517732 015173 5 ustar david david 0000000 0000000 Click-7.0/docs/_static/click-icon.png 0000644 0001750 0001750 00000001161 13351570514 017707 0 ustar david david 0000000 0000000 PNG
IHDR @ @ iq sBIT|d pHYs d tEXtSoftware www.inkscape.org< IDATxٻkQ/F41 (B; @H;ml+;
bk'h`ccPR AQDc 7a1ua;s KJ)RJ)RJ)RJ)%4:DyZL oburgCMFaSmoqaZ0/܆6ۍʛ F31\UFK8;S5Q,ćUѫqU~UgYFzJ3c,4'l%L)RZw {- IENDB` Click-7.0/docs/_static/click-logo-sidebar.png 0000644 0001750 0001750 00000010226 13351570514 021330 0 ustar david david 0000000 0000000 PNG
IHDR d ]IDATx] ]VIHD}B%tt2#QjiE
NJ=fR(ziRP%(J*D4!F]>}>|w _^{>Ru郬{Ջuъx;H4vjpwlQh]Sc+mZ'f fՁG+A@Y^8ZY_"쐖,x}kهYtA (% ϛ \ŷ^H?m pN*/TN Vp?B^ԍ^NVq]RbzFƋ2`p7 N C?har) #̊H+:i@?KmG1Jen4"oX1T9v ·): |~>s Nk 5>^O8p+``4PFZRKȀu-F~ g\^H2 x+lfne ;yw_ x hG4 e-j9]E2< t
)4}R"fRӤ58Yf+̟]5Boλ3|L oD |0m7T]^ԋ 1 o͝
\ ] >/ |ukJȝ`{xfe[ XPn= LD!uK2\Kr7Q!)Yת'\D(V[Q*i qope?K%OA;aĴ' {o
K8߁oMxLX#,Gjeс̘:d7 J͎ց ̭ oT &3 Vw BNWI+cp6:xq
6@yaxri(] wpAqI迥'
OFp8l/o" r%D
2LTį6-PMN 1J{5Փڎ ^wv'7Ύf
w fWؠ00ur}h'B.jU #GU+`u Y g<6l,rv88 B8G:_[,/`v|8; ? ~Owuݗa=79IiDg|2xc H HJ5.1HviThs? 龵aJJ:Li':ۜpK $%`kPA T2Y<p:l
}#)/ᶈjdro˔:áнMJ7 gB譶o/ohQ|)2.9W~ ٽ;5c6y늸|F`_;/9RoVpJaZdz,G3 9TB4QhՁ >j 9"ye9S~q xsOv`k7%_|hx
U)511kȑH!/鮎Cʗ L8RHw|ßp6F;= _a \ o
x & J/ |Nugrˆ,/r4<{F 9µ8\9SR O<3^ lYpDFyv9ٙ}vy٥^.EΥU?_@z8.&m
_?F.n%Y]'ga69vo Gp
- Ͼӭ 06p, DB\A8~8&}Pvn~yv<x3ء
y@R'GC GHR&B 6szˎ808P`W</V@sZs5l »a(s::@ n Մ)V("}8-
v>\ #@(0 9
6F]cڒ;hH6jR1ː p@RMv*qYބE~Z ӀCj \u{|2v`-sI Chg,tRI$ }e@"ڙuF V]\fܖ $b
5nś #HĀ( H^ i|FzHT( yMJoJ1P iFME1P СW!a.`Mz'Th18~(&M[ʑ`myɄFR\r;Qt([E@SD )4nKhA ΟVRM՞Н|hhuK%T΅VmC6{%gj
=؞ B "
D 5jdkƚBǝ剁t t#:pnp3}bl;ẂAP` `:08Lԁ3R ,ƽ{/{2ų!1||Uc10M[|kZ,g mZ^o|rZ5cGyb i ru@1[ZPkTȌҞ 51 \{W۞F`0&20)} b#IDk$,ȏy z\[*+g`1Lnl 8l ?A?JĀ@QkЭfqMCF2.y ib ̄g> :7E0*ߝ4z:THbCN}jE 4lHc`2zgF`F(' fqDs:pȈb\ L;o p|:ѢP M^5pk4y).nP(@ '{]ݴFrmnhYKo l1<ԁǵj3)t`2ڼ ucM*(r> $bAW:;BgL"ց]+P1P7wxq4bHb6 @ m ȜCvw\!勁
~| (,h tU5OШlIm@=!_<>
iv+ i
2 ?% &:pnp7fUmk ߁YZgͨuWƣa33 }^zF`GT1PQ1k:k9./q(Q_ﴚB Kb :`t;?ֹ q@LB&( ) NM>r?NO
^
zS 1 b\uvzޮ
+b7{A|+> ~] @VA?/htD~htmҝ9T3Py1u҉:pN *՝ZMSS@ H@)[@9#
?#`#r
zW?@KĀ(CD'J\S\q1 ߏ^U,O?ؐގ IENDB` Click-7.0/docs/_static/click-logo.png 0000644 0001750 0001750 00000062741 13351570514 017732 0 ustar david david 0000000 0000000 PNG
IHDR H ^ ?t
AiCCPICC Profile H
wTSϽ7" %z ;HQIP&vDF)VdTG"cE b PQDEk 5ޚYg} PtX4X\XffGD=HƳ.d,P&s"7C$
E6<~&S2)212 "įl+ɘ&Y4Pޚ%ᣌ\%g|eTI (L 0_&l2E 9r9h xgIbטifSb1+MxL 0oE%Ymh Yh ~S=zU&ϞAYl/ $Z U m@O ޜ l^ ' lsk.+7oʿ9V;?#I3eE妧KD d9i,UQ h
A1vjp ԁzN6p\W
p G@
K0ށiABZyCAP8C@&*CP=#t] 4}a
ٰ; GDxJ> ,_@FXDBX$!k"EHqaYbVabJ0cVL6f3bձX'?v 6-V``[a; p~\2n5
&x*sb|!
ߏ ƿ' Zk! $l$T4QOt"y\b)AI &NI$R$)TIj"]&=&!:dGrY@^O$ _%?P(&OJ EBN9J@y@yCR
nXZOD}J}/G3ɭk{%Oחw_.'_!JQ@SVF=IEbbbb5Q%O@%!BӥyҸM:e0 G7ӓ e%e[( R0`3R46i^)*n*|"fLUo՝mO0j&jajj.ϧwϝ_4갺zj=U45nɚ4ǴhZ ZZ^0Tf%9->ݫ=cXgN].[7A\SwBOK/X/_Q>QG[ `Aaac#*Z;8cq>[&IIMST`ϴ kh&45ǢYYF֠9<|y+ =X_,,S-, Y)YXmĚk]c}džjcΦ浭-v};]N"&1=xtv(}'{'IߝY)
Σ -rq r.d._xpUەZMvm=+KGǔ ^WWbj>:>>>v}/avO8
FV> 2 u /_$\BCv< 5 ]s.,4&yUx~xw-bEDCĻHGKwFGEGME{EEKX,YFZ = {$vrK
.3\rϮ_Yq* ©L_wד+]eD]cIIIOAu_䩔)3ѩiB%a+]3='/40CiU@ёL(sYfLH$%Y jgGeQn ~5f5wugv5k֮\۹Nw]m mHFˍenQQ`hBBQ-[lllfjۗ"^bO%ܒY}WwvwXbY^Ю]WVa[q`id2JjGէ{m> PkAma꺿g_DHGGu;776ƱqoC{P38!9 ҝˁ^r۽Ug9];}} _~imp㭎}]/}.{^=}^?z8hc'
O*?f`ϳgC/Oϩ+FFGGόzˌㅿ)ѫ~wgbk?Jި9mdwi獵ޫ?cǑOO?w| x&mf2:Y~ pHYs iTXtXML:com.adobe.xmp
1
2
1
9tj @ IDATx%E&0C
""*Y1Ō]u
kZi꪿"AP% " 07wws ]}}ƭ5<<&z6SSSװ7**G`dtttO]~ u %M6b ، eˑysF}W
t_$0ґS=v~K` ȵ5-n:\MF\ߜwm>{$P 6LvBFBQy^%hH\% >~ʜ0w% H?*R4[dMdA%k\$P>i]EQkd ͨ aL %0:CgJ@@ut@QSwmQFMC$6i۔*"TmԿY ѦMuK!Y<7`v n% H:f _
S䕕@0?)mu+Wý)9(U/:{K|} pNRCDZ
1PzNk +Q'793@Bi:V/*juQe;M.qh]`X p>=Y* sfD38K@(1n{po rRv:Mm)q@ l͵ sF/c/t\GϤsUKa!?JpT.d/i% 9u T|\Y`iH@ H@$0
X0:]IQA#&䲨ݨӬ(
Cfv6*2H-BsښRΏnm&& @jDSv8zmBt> 3$ 4%u L;0&tM lLcMX$ HB6֥r O =lCSH+Z9ٸ+ TR
t ]V©P `]sΥ{^3f( H3E L91S|d4$60 N_hIG3 S H 0MΗxI' H@"P7)}wM: 8iċ349 H` sV
H$AD15QזB EH[b 7F \t)JG@~mWN+ yuG+5Lƫ·2-QK# H :10Vhoq}(?ԠbhN@Xݪ$ (ρKFo!QF$ T@/ " %e$ - 2쓢Oώ`JˉqNY H@< RFPI@( 77W(9zOJ e% wiFJL V_4PRF@LOyeR ً1ޝIX! 6>%]fcIy]}=nc&6|ZlX s ;( s/@M\f2Rs6|$ C9nUSdߎY啓@Dd ىΜ;K3s7zz
e܈lL%=J'RoRd5*ώ=y\Ib[%9u wv[S_ ÐmnG&ͫ8'Y|,>%qqU@ fԋPxN3-El/NNi~D`OM)3#|d7}i#G㧿tJ_ xNԍn qh y@q=Y1cR_lg]*Rՙu Kd L M_Qlu4wI*K^ (oXB v(s
ci 5$d$0(F!,p` 8x'|&i4r>wEi} A~G w:] Kbs 3BF3.rX(mu( uAquqИgwnJ2i7 &1Ѩh/ H`ҐMdTN"@k_:D .[:Љ8w舽/2qN_ta ӛ P%w⺈kY\EEDD^4͗͑RH /dV /_ H@G`F,erfm2lHg
9O%s0t`{
W
kq < (ܿ>t/t]ԡaL9o ✖b q_.2i H@!#H
$n;# uZh lBcFνt_lFDJ_UZt>FeQڌQWO+*Y41>]@z^+a~̢ 0w sW@7xC'n8. }8e7S'ʳzn;h+T 4(e\ė8ZM?Z PN'#K5&||)MI8m'7
h_3 itjEJY$S
&[Kt@90:kH|Ct% EROocԺ O@t]"=輾 1B ^5G7D2LDRԩSS
l.6)FΕB #EEgpk /Fٓ >5#l: H@C ]0ݏ MVa$Ў O@_KC; NBCU]iLOF3:cȰ4* FO<usĎzFHm m}78a<ԉ!: H@G FΜܘCpCY"(#&6 Oq-0]iQw#2ob*9~k?rSL Zd-lH'?c[:lO F2F6qs;OĊY9}t}\>>F>+qM>9M\u8{mNeC "3{Xp< }
q|xWC7x$ HO#t7 G@,d$ Hq h$gJ ܘOS| 7X p V;8G:E)@ZB$E;&X"tЌ HLLxl{I7H3ϡxB??ϵiU1Md 98ȦQR
AbiU AZ4 Wb! w֡ ~ x D$9$ H!i:c;[
S,p1#0.¡0ڑTbETWϢ}R`Jó_w'54q xO wĴqtQƑ$
d|LLwyV{<
WH%2s7fQǃӚ伊i?$f3 gŪ3#OH'fnvϤi6kōY
9Mk M'TchG'0
q;Iĸ}! )#1dm(S)5MY{gq~tJg)q,
$ڵ(q6>l H@hMFN۷x>
vSI4&G]ܺ8 - :ܻKҨu?eѿz
Xw}$Alks.
:*YrO _8~-8-`ԟ+% H@0fFsqEin_Hڧ
LӤDs!iٌHK b "==?yx+t=U,ҰtLڱ#߽)go#13$ H ynܧ9o =F :d$ŒNL?U|c%:]q $ui@ $kTΏۊ;5kR.
#'}m9M2(@#4Hwl\7 мo6/$EVRmK }H1'o# <{)% =QnȪr@ +0>=?O]zYEV Kt t0:mqx6t#@ AJ[=1AZcTg5ֻ)"H ' ! L_XLG*B$1^c$ S;NX{x)
74$
E)#Hʮ1`Ģ; ~;*@)]q}$2D=]q4S$Myn؝s>Fғ?'wМc$.S<Jw :\ h6/ɖRs$8'^wcr&}z.BZ)FDo%m?c 0{C$ Hzm M<~{H}'c$})O# K~T d U\@U
a H1h+*% H@EA
#:f{b(=m Ǵ:"FQNFnDF¨fT=|2 U52
ƴza =?go$ t@?
r1OJa$ A@GI&Wuiw@']Q.ұ#,HSId\/Pkqe^ajTrx** H@"wi`1 ;iL"-$#I0Fz\MrUVg`Rӭx \[V
6l >xXdڇҦ#)>$ (4]\[zrbrwAG1U}AKujѵ KENU/K[U)eDcA?)?M0˛6Ioi+$ B &_H Wڋ61ف$D:Hm'5mǙi %Nޙ ^p Ë^oSkGf 1~ꖺ0S)/ H@h E)Vb$#EG 0f1RY?T (8FZ\/H{[)ZGcT_&\m'F'h^KR+&Nu1[SI@@rVYz4&oAhmcݻxK h{ImOyyM|T>/Ei V"? #H\h>ùj5>A f6=$Pŷ^Q.$j# H>Jo jx5x}}:%큉&p|%GDZcH:d a8Tu{x'tЍ:2"1Fb1VOsI/$ J%1y!5'Sr7/Y3YkO I ۧZ_ $ EYHŌGG^w
Hv(6.>Յ_H6N' H@p=s}^2~hxF Q?:u|nt'Hln;O]owԤke_R{oH/1Nm̬@I+qN8; }%[I?@,FFRLWI@@N4@'}6H9ON؟H}](% ҅CʾSӼTG.OƈY;ksm~x d5)rߌgWD L$ 1:]"lbe/H5tkVZd ُA)7FSK(n :ߟIT3H
#'\1#n-"|zzrjD% H˶h$Ms?L9ܓPmO?W>[9SC
/uHWp> ˾F
|N%^sīKxu;'rw,?k H@M#H4
S--٧r#;V}#G ¹nJI,OW`(Tو yoz$
yQ #ds ͽI(@ $:#/Hy}OI;5\31TI E"➀Tw=V t~9Mi1.#*s==ɐ)o| hgV9uϳBά8ibu9YIk H@Ij҃h$ޓXS_E8O&wLvSSm@ԔX\_P681\0
)qJ&;y:tʳtuL^^2u[xI@nQ wF$0p*c ٕFЦ)O+=9>=sEӰ~)ө:R UoH$Isn$5N9O~qю|M]@'O~eb 0#w}4 z yq|s\:{ M@ ĿF_U icxW%N٫!S Mb4w7.&@E6O&{k7|%5ĹA l~cqV<& Yin_ Oy3 b4AW
nZ
ukIGut4>\GbZihP tg̾Ri9zQ{e]=S:ܓxJTٽmgE9.r^9 UbH@(/0bۓ˫b[bJsi^6-]S Kʌњ%q7t)}sCY
c47a ^Ͻu_;yv#?hV##oE*=s> _kp_1\I@x97ױ'h |M@,yD# J__rŇgF\rF
. .>_Y w\މn C e` -|1mg^P_!wgĺsp: #/BM 1{$ K>ω?;#ev}v>QVOGlD] sφ5 o$; F];vSyy5[9Ţ,q
5r7h%~v!FrI @\Wc/Jn ~TGӿ@ΜO~?KEUo|@E] ?AS_
faWy
eJ}1`v8 F0ص2hw_֗>N}Ĵզ㱔v_cD}y`%ތDa[}p2Ӱ
*@ePx^]&9bùޏ Z'8e*y HN8B #wGI|<*"V8
wlGRQB Ǩ>}wut{9[Z_q0=Z08id}0yi(F9qQz |:]HKY: tD`4%D$pcG9M?ȅ#zx+҄5tHLoWѫNi;ǠΜ1UYG~b u':5O>gvLZM&]HFn(G9?<91
q7gQ/go@n@O\բ{~K)+RvB=<>7+zoyLS~Η2t6h74!> 7OwǏq
u0O*?^Tx" 'tF^_z8Z QS.p'p 4˔0'p~4:U.~/̾IZe5Z p\1ziֈ Loq_8i="hרLk_R0t G?FCS@q_ GĵUe>mM-0x^8O4v^tM4?cIE [(|Hr?\$ЌZ4q>
cFZW gnGq(2|SPǓS%?}45~ (wg^f/ O ĪZUvѾ̵Pʶe3+P7٤ x9FQ?FcR- .HD>V Maes*߆n!^eZ|-gUKkANR+1ΖmHs \hqs} ț87ħ07C%@`3m/Zh,nx<}c麙u{ ~ tq0ۄK_ [Ed_ t?.106įWpFU0;ڍJRFnks KZ
k41S!VӺ Fgk7pm^̱eqR ,C n-}<?f 漌8}k?J.(Тu_ .0~y %9p q^̹{TJe%0@'ܴ Ϛ!Gwߨ$ T&)7H-:]ؼf9UL J> 1âf# 5b 6 Qƍ0`6-im~^-_A2VXU1.#<Ԩ"8AN#fMYe$ H@@'C=àz JcG+S#'ܵ)82E^Y H@$ $0B~if XC| $MϜ$ H@hL` ޭ!C@ $^o)J@$ HSL۬4_/4n愋8u/n+$ H@% 7$@7
xcsjև=* H@$ j+hW t`U j92GY% H@$ИP`C@W
$N!l7rwN8pWI@$ H &_4V:Gsg }Ysݗ$ H@@'m^a>!-9I{=K)nQ+]Ժ2K@$ H:C+7^H.8d[ H@$ 3}?k|yw}]F$ H@'A'C+G$ H@&1b XG|,*v a㕐X}6*| 25]ɶ٢c I@$ H@"cS* N'$ /2XE 8Ů$ H@ 3bNYM!mY"(SMHլ7$ H@@Gg%&U G
@Pe$ H@@KMo'mG@N]$ H@@,z1~@w
$ H@@? juI$IĪ%lVV$ HXw%u5%TӊX$ H@$ j *2
R@
$ H@G @bk&m¦/ H@$PZOB2Uޤ3FםO9|
ə$ H@$ vGG-F}ń6~#UJU0; H@$ 3t=>HH@@&% H@$ VZ#G\lD@)&$ H@$9FfMiIVY#T KS$ H@@;)XNc)cN$ H@# ]+P
@qTQ$ H@&0]|IcH=nv$ H@M`"X] h I@$ .^=kYayVY#T KS$ H@@K=Ws+uG4zl$ H@$҉), ?3b-0-$ H@Z Q|4v1>-bAq [? ~߆oB~ ),(=$ H@$ 29?)s:
ß; N0?Z$ H@JH`ttt_FiR=,~|)'8I@$ H0^1Ō"=2bMh 5c$ H@@ i= hH
$ H@$ fgcjIVY@jP H@$ }Pb,AYE@j H@$ zؿO6_\_$ H@%!wb)MZ
d5@1H$ H@%! MqH)j 5b$ H@@EFXayHU=u$ H@5 $ WH
f! H@$ R-m|,
YIDAT6C`T$ H@@i lfMV1
o#M?Fp Lk@@$ H@$PSuFGGUt_X<'0/Ŀ<~2j
) H@$ ~##Ko8jTI w[o ;H$ H@ g,Һ###(;bHQR$ H`0z2L V\H$ H@h@`IfAK p
Au, H@$Pw# LMHHլ7$ H@@sCIk
4\ɡy>Tt$ H@H`jQ,ŷt34<$ H@$P?>.ۨ)*LVia$ H@$0M`ydk/T*$ H@F ]^Uv4-$ H@@F'g,(;bQJ ) H@$ "099?ÛP1B ] gBx
$O H@$ ԏ
Rccc0
~ "wuHZ & H@$ $|`\-~,@&l5)Ő$ H@`J[O3´gJh UTZ$ H@`
^YSdiU@Z$ H@@)tfMٍVMNj5$ H@u]+ARH.$ H@@L1ٌICL $ H@7RdR@
$ H@$P nDC>TS{ H@$ E`yBB) _Tu$ H@;&)Y,RYjB=$ H@$G,}rWNLL:l4*We*, H@$ #_H}ż bQe_e,$ H@$J`>\ 㨶2P58# H@$ UlFԎ###[]o$Q5Έ-]_'
$jK' H@$ "Bhz0QF2e ՈH@$ H"0~8WCFGGVʿH$ H@@%<,,kV~i yK@$ HBq$MToX$ H@'VB d&7f, H@$ J(A%lJ( ]Q H@$ Hw,>M%4[]n% H@$ Tw&D+AoH}Co$ H@66k Rd
9
nP5M H@$ V;%c1P/2UL\$ H@%ddJd9a?9n$ H@$PV+߄rŲ#)gS TRS H@$ 8::%OK**Fat]u!=@1p$ H@bxx$ ` -@a##Q] .6y H@$ H 9{B 죛
.5Y H@$ H`!Fv[8E HB5֔% H@$ y06&vR7$ H@$Ќ@tեfMRK< $ H@
&bjw=u)T13$ H@jI`"T j D$ H@$ (b) 6@j#$ H@@XڬIfMR;B $ H@
#*v?˘߉EF4
CiB$ H@@;|蓌 tGZɱ9v|OhOs33 H@$ H` *uGSq
|ߜRЛ$ H@@Ew&Pntt~0-!je]&Ƅj 5b$ H@$P" >ChWjEH 8^@ !w`)* H@$ 8jsL{1#LkyX% J@$ H@&q{V Xb4Q1L$ H@(
mLd5 1@$ H@(}J] $ H@@d[x_)l2vQI@$ H@(dxgF_$ H@@?H] vY
ҊJ@$ H@}!p]B&.@Z H@$ HLXb/26@j@ H@$ H,0z>.PT9v/6 ӈ$ H@zC`ġd>l#0gt4:gl H@$ H 5!mFGGD~ LaT
͏WΏp
t/ H@$ ԁ&###S=0Z!Ajʃ$ H@@ נ k S^$ H@(=l; &''ˮ! jժixNi[ H@$ tdq
~O_IGf/G}8JPN)4H@$ H FёxclD0B%
D ҄$ H@$И =rt !_#|4W'j$ H@$ `4hT-Mzxj z#H=l&$ H@N`3 '57G@]Z H@$ 2nyO+1ޮJ%HT
$ H@'ߝ'NO@ROH$ H@I`2GɑM(UHJ+N% H@$ 4i'!L<r@*w$ H@@=$/48Bng*^磁k' H@$0pXW 8-1NoC{Y@5q$ H@8V:iio05
%3V:dB$ H@@St$ï 6~ .dX7"ӑO:݄ GH}4SD$ H/3;;kQT/Ç1ׅ!#퇒vSx.wI&B_:D0:t
* H@$ IwvO%CL{FGG?n+2w; }}^MH yyGU?dߗ'^Ǚr{I@$ H0ȨP>Fڹ%&}- 6:N>6
o͎R6NJI@$ H` 쑈Åg6+9 Q$ H@ S6Q gw4O$H@$ HfF(Vccc^ æ`#HNNN;r_ 3rs?Gc;G8v &%o5/@Z H@$ "0::1 WR3mKt V/3um !6Eyi W)$ H@!GoL,
yPl^3v% H@$P GHUt=1M)r
@* IH@$ T &94CXY R
Am* H@$0@B -RhF$ H@
ԒvO $ZS4R5@j` H@$ `&Ϣ Xn(F@\$ H@@QXF{ybZ!߫;u^jUK\Z$ H@&1K;_0
`Md51X$ H0*X%w"~+W$$XD51\$ H&&&@!.0
v_%^,!?G`5@jFp H@$ A p=FG)hd.@,pf/0?71O
Z
:1 H@$ 11bC 7DS81e-j\ l=66v/Y~-lߎۘr=E{߉t +ޥ?$ʱ+D(_XDY>&x>wEa+bo mLB?$ H@@H.H 6+;
>K"/I@$ @| qQ@*O]$ H@@o 5::[o4@*{
$ H@@^O$$jH@$ u
p<$ H@$P{k_iH㥴$ H@@ٛzgǥ@ H@$ H@u!T $ H@@4:Fh$ H@@]h ե&-$ H@$1
$ H@$Pu)吀$ H@>z9SK444tS0j@V}$ H@鸞u)I@$ H@e&TQ7 H@$ H4z$ H@$ 2@*s$ H@$SH=mf$ H@@ h vM$ H@)
63 H@$ H4\;& H@$ ROq$ H@$PfHe u$ H@zJ@L$ H@(32+n$ H@@:ECMMMݐ%3rd;%NNz3Șu
*,%$ H@*K`xxJ-U |g/*]Et$ H@$ @|Z H@$ H(HE4 H@$ H4*_@$ H@(RQ$MG$ H@<
W$ H@"TIӑ$ H@*O@Uh$ H@$ h Et$ H@$ @|Z H@$ H(HE4 H@$ HF+_ H@$ tL`hhҩ '< *ϑdk+( IENDB` Click-7.0/docs/advanced.rst 0000644 0001750 0001750 00000033612 13351570514 016045 0 ustar david david 0000000 0000000 Advanced Patterns
=================
.. currentmodule:: click
In addition to common functionality that is implemented in the library
itself, there are countless patterns that can be implemented by extending
Click. This page should give some insight into what can be accomplished.
.. _aliases:
Command Aliases
---------------
Many tools support aliases for commands. For instance, you can configure
``git`` to accept ``git ci`` as alias for ``git commit``. Other tools
also support auto-discovery for aliases by automatically shortening them.
Click does not support this out of the box, but it's very easy to customize
the :class:`Group` or any other :class:`MultiCommand` to provide this
functionality.
As explained in :ref:`custom-multi-commands`, a multi command can provide
two methods: :meth:`~MultiCommand.list_commands` and
:meth:`~MultiCommand.get_command`. In this particular case, you only need
to override the latter as you generally don't want to enumerate the
aliases on the help page in order to avoid confusion.
This following example implements a subclass of :class:`Group` that
accepts a prefix for a command. If there were a command called ``push``,
it would accept ``pus`` as an alias (so long as it was unique):
.. click:example::
class AliasedGroup(click.Group):
def get_command(self, ctx, cmd_name):
rv = click.Group.get_command(self, ctx, cmd_name)
if rv is not None:
return rv
matches = [x for x in self.list_commands(ctx)
if x.startswith(cmd_name)]
if not matches:
return None
elif len(matches) == 1:
return click.Group.get_command(self, ctx, matches[0])
ctx.fail('Too many matches: %s' % ', '.join(sorted(matches)))
And it can then be used like this:
.. click:example::
@click.command(cls=AliasedGroup)
def cli():
pass
@cli.command()
def push():
pass
@cli.command()
def pop():
pass
Parameter Modifications
-----------------------
Parameters (options and arguments) are forwarded to the command callbacks
as you have seen. One common way to prevent a parameter from being passed
to the callback is the `expose_value` argument to a parameter which hides
the parameter entirely. The way this works is that the :class:`Context`
object has a :attr:`~Context.params` attribute which is a dictionary of
all parameters. Whatever is in that dictionary is being passed to the
callbacks.
This can be used to make up addition parameters. Generally this pattern
is not recommended but in some cases it can be useful. At the very least
it's good to know that the system works this way.
.. click:example::
import urllib
def open_url(ctx, param, value):
if value is not None:
ctx.params['fp'] = urllib.urlopen(value)
return value
@click.command()
@click.option('--url', callback=open_url)
def cli(url, fp=None):
if fp is not None:
click.echo('%s: %s' % (url, fp.code))
In this case the callback returns the URL unchanged but also passes a
second ``fp`` value to the callback. What's more recommended is to pass
the information in a wrapper however:
.. click:example::
import urllib
class URL(object):
def __init__(self, url, fp):
self.url = url
self.fp = fp
def open_url(ctx, param, value):
if value is not None:
return URL(value, urllib.urlopen(value))
@click.command()
@click.option('--url', callback=open_url)
def cli(url):
if url is not None:
click.echo('%s: %s' % (url.url, url.fp.code))
Token Normalization
-------------------
.. versionadded:: 2.0
Starting with Click 2.0, it's possible to provide a function that is used
for normalizing tokens. Tokens are option names, choice values, or command
values. This can be used to implement case insensitive options, for
instance.
In order to use this feature, the context needs to be passed a function that
performs the normalization of the token. For instance, you could have a
function that converts the token to lowercase:
.. click:example::
CONTEXT_SETTINGS = dict(token_normalize_func=lambda x: x.lower())
@click.command(context_settings=CONTEXT_SETTINGS)
@click.option('--name', default='Pete')
def cli(name):
click.echo('Name: %s' % name)
And how it works on the command line:
.. click:run::
invoke(cli, prog_name='cli', args=['--NAME=Pete'])
Invoking Other Commands
-----------------------
Sometimes, it might be interesting to invoke one command from another
command. This is a pattern that is generally discouraged with Click, but
possible nonetheless. For this, you can use the :func:`Context.invoke`
or :func:`Context.forward` methods.
They work similarly, but the difference is that :func:`Context.invoke` merely
invokes another command with the arguments you provide as a caller,
whereas :func:`Context.forward` fills in the arguments from the current
command. Both accept the command as the first argument and everything else
is passed onwards as you would expect.
Example:
.. click:example::
cli = click.Group()
@cli.command()
@click.option('--count', default=1)
def test(count):
click.echo('Count: %d' % count)
@cli.command()
@click.option('--count', default=1)
@click.pass_context
def dist(ctx, count):
ctx.forward(test)
ctx.invoke(test, count=42)
And what it looks like:
.. click:run::
invoke(cli, prog_name='cli', args=['dist'])
.. _callback-evaluation-order:
Callback Evaluation Order
-------------------------
Click works a bit differently than some other command line parsers in that
it attempts to reconcile the order of arguments as defined by the
programmer with the order of arguments as defined by the user before
invoking any callbacks.
This is an important concept to understand when porting complex
patterns to Click from optparse or other systems. A parameter
callback invocation in optparse happens as part of the parsing step,
whereas a callback invocation in Click happens after the parsing.
The main difference is that in optparse, callbacks are invoked with the raw
value as it happens, whereas a callback in Click is invoked after the
value has been fully converted.
Generally, the order of invocation is driven by the order in which the user
provides the arguments to the script; if there is an option called ``--foo``
and an option called ``--bar`` and the user calls it as ``--bar
--foo``, then the callback for ``bar`` will fire before the one for ``foo``.
There are three exceptions to this rule which are important to know:
Eagerness:
An option can be set to be "eager". All eager parameters are
evaluated before all non-eager parameters, but again in the order as
they were provided on the command line by the user.
This is important for parameters that execute and exit like ``--help``
and ``--version``. Both are eager parameters, but whatever parameter
comes first on the command line will win and exit the program.
Repeated parameters:
If an option or argument is split up on the command line into multiple
places because it is repeated -- for instance, ``--exclude foo --include
baz --exclude bar`` -- the callback will fire based on the position of
the first option. In this case, the callback will fire for
``exclude`` and it will be passed both options (``foo`` and
``bar``), then the callback for ``include`` will fire with ``baz``
only.
Note that even if a parameter does not allow multiple versions, Click
will still accept the position of the first, but it will ignore every
value except the last. The reason for this is to allow composability
through shell aliases that set defaults.
Missing parameters:
If a parameter is not defined on the command line, the callback will
still fire. This is different from how it works in optparse where
undefined values do not fire the callback. Missing parameters fire
their callbacks at the very end which makes it possible for them to
default to values from a parameter that came before.
Most of the time you do not need to be concerned about any of this,
but it is important to know how it works for some advanced cases.
.. _forwarding-unknown-options:
Forwarding Unknown Options
--------------------------
In some situations it is interesting to be able to accept all unknown
options for further manual processing. Click can generally do that as of
Click 4.0, but it has some limitations that lie in the nature of the
problem. The support for this is provided through a parser flag called
``ignore_unknown_options`` which will instruct the parser to collect all
unknown options and to put them to the leftover argument instead of
triggering a parsing error.
This can generally be activated in two different ways:
1. It can be enabled on custom :class:`Command` subclasses by changing
the :attr:`~BaseCommand.ignore_unknown_options` attribute.
2. It can be enabled by changing the attribute of the same name on the
context class (:attr:`Context.ignore_unknown_options`). This is best
changed through the ``context_settings`` dictionary on the command.
For most situations the easiest solution is the second. Once the behavior
is changed something needs to pick up those leftover options (which at
this point are considered arguments). For this again you have two
options:
1. You can use :func:`pass_context` to get the context passed. This will
only work if in addition to :attr:`~Context.ignore_unknown_options`
you also set :attr:`~Context.allow_extra_args` as otherwise the
command will abort with an error that there are leftover arguments.
If you go with this solution, the extra arguments will be collected in
:attr:`Context.args`.
2. You can attach a :func:`argument` with ``nargs`` set to `-1` which
will eat up all leftover arguments. In this case it's recommended to
set the `type` to :data:`UNPROCESSED` to avoid any string processing
on those arguments as otherwise they are forced into unicode strings
automatically which is often not what you want.
In the end you end up with something like this:
.. click:example::
import sys
from subprocess import call
@click.command(context_settings=dict(
ignore_unknown_options=True,
))
@click.option('-v', '--verbose', is_flag=True, help='Enables verbose mode')
@click.argument('timeit_args', nargs=-1, type=click.UNPROCESSED)
def cli(verbose, timeit_args):
"""A fake wrapper around Python's timeit."""
cmdline = ['echo', 'python', '-mtimeit'] + list(timeit_args)
if verbose:
click.echo('Invoking: %s' % ' '.join(cmdline))
call(cmdline)
And what it looks like:
.. click:run::
invoke(cli, prog_name='cli', args=['--help'])
println()
invoke(cli, prog_name='cli', args=['-n', '100', 'a = 1; b = 2; a * b'])
println()
invoke(cli, prog_name='cli', args=['-v', 'a = 1; b = 2; a * b'])
As you can see the verbosity flag is handled by Click, everything else
ends up in the `timeit_args` variable for further processing which then
for instance, allows invoking a subprocess. There are a few things that
are important to know about how this ignoring of unhandled flag happens:
* Unknown long options are generally ignored and not processed at all.
So for instance if ``--foo=bar`` or ``--foo bar`` are passed they
generally end up like that. Note that because the parser cannot know
if an option will accept an argument or not, the ``bar`` part might be
handled as an argument.
* Unknown short options might be partially handled and reassembled if
necessary. For instance in the above example there is an option
called ``-v`` which enables verbose mode. If the command would be
ignored with ``-va`` then the ``-v`` part would be handled by Click
(as it is known) and ``-a`` would end up in the leftover parameters
for further processing.
* Depending on what you plan on doing you might have some success by
disabling interspersed arguments
(:attr:`~Context.allow_interspersed_args`) which instructs the parser
to not allow arguments and options to be mixed. Depending on your
situation this might improve your results.
Generally though the combinated handling of options and arguments from
your own commands and commands from another application are discouraged
and if you can avoid it, you should. It's a much better idea to have
everything below a subcommand be forwarded to another application than to
handle some arguments yourself.
Global Context Access
---------------------
.. versionadded:: 5.0
Starting with Click 5.0 it is possible to access the current context from
anywhere within the same thread through the use of the
:func:`get_current_context` function which returns it. This is primarily
useful for accessing the context bound object as well as some flags that
are stored on it to customize the runtime behavior. For instance the
:func:`echo` function does this to infer the default value of the `color`
flag.
Example usage::
def get_current_command_name():
return click.get_current_context().info_name
It should be noted that this only works within the current thread. If you
spawn additional threads then those threads will not have the ability to
refer to the current context. If you want to give another thread the
ability to refer to this context you need to use the context within the
thread as a context manager::
def spawn_thread(ctx, func):
def wrapper():
with ctx:
func()
t = threading.Thread(target=wrapper)
t.start()
return t
Now the thread function can access the context like the main thread would
do. However if you do use this for threading you need to be very careful
as the vast majority of the context is not thread safe! You are only
allowed to read from the context, but not to perform any modifications on
it.
Click-7.0/docs/api.rst 0000644 0001750 0001750 00000004447 13351553412 015053 0 ustar david david 0000000 0000000 API
===
.. module:: click
This part of the documentation lists the full API reference of all public
classes and functions.
Decorators
----------
.. autofunction:: command
.. autofunction:: group
.. autofunction:: argument
.. autofunction:: option
.. autofunction:: password_option
.. autofunction:: confirmation_option
.. autofunction:: version_option
.. autofunction:: help_option
.. autofunction:: pass_context
.. autofunction:: pass_obj
.. autofunction:: make_pass_decorator
Utilities
---------
.. autofunction:: echo
.. autofunction:: echo_via_pager
.. autofunction:: prompt
.. autofunction:: confirm
.. autofunction:: progressbar
.. autofunction:: clear
.. autofunction:: style
.. autofunction:: unstyle
.. autofunction:: secho
.. autofunction:: edit
.. autofunction:: launch
.. autofunction:: getchar
.. autofunction:: pause
.. autofunction:: get_terminal_size
.. autofunction:: get_binary_stream
.. autofunction:: get_text_stream
.. autofunction:: open_file
.. autofunction:: get_app_dir
.. autofunction:: format_filename
Commands
--------
.. autoclass:: BaseCommand
:members:
.. autoclass:: Command
:members:
.. autoclass:: MultiCommand
:members:
.. autoclass:: Group
:members:
.. autoclass:: CommandCollection
:members:
Parameters
----------
.. autoclass:: Parameter
:members:
.. autoclass:: Option
.. autoclass:: Argument
Context
-------
.. autoclass:: Context
:members:
.. autofunction:: get_current_context
Types
-----
.. autodata:: STRING
.. autodata:: INT
.. autodata:: FLOAT
.. autodata:: BOOL
.. autodata:: UUID
.. autodata:: UNPROCESSED
.. autoclass:: File
.. autoclass:: Path
.. autoclass:: Choice
.. autoclass:: IntRange
.. autoclass:: Tuple
.. autoclass:: ParamType
:members:
Exceptions
----------
.. autoexception:: ClickException
.. autoexception:: Abort
.. autoexception:: UsageError
.. autoexception:: BadParameter
.. autoexception:: FileError
.. autoexception:: NoSuchOption
.. autoexception:: BadOptionUsage
.. autoexception:: BadArgumentUsage
Formatting
----------
.. autoclass:: HelpFormatter
:members:
.. autofunction:: wrap_text
Parsing
-------
.. autoclass:: OptionParser
:members:
Testing
-------
.. currentmodule:: click.testing
.. autoclass:: CliRunner
:members:
.. autoclass:: Result
:members:
Click-7.0/docs/arguments.rst 0000644 0001750 0001750 00000020170 13351570514 016300 0 ustar david david 0000000 0000000 .. _arguments:
Arguments
=========
.. currentmodule:: click
Arguments work similarly to :ref:`options ` but are positional.
They also only support a subset of the features of options due to their
syntactical nature. Click will also not attempt to document arguments for
you and wants you to document them manually in order to avoid ugly help
pages.
Basic Arguments
---------------
The most basic option is a simple string argument of one value. If no
type is provided, the type of the default value is used, and if no default
value is provided, the type is assumed to be :data:`STRING`.
Example:
.. click:example::
@click.command()
@click.argument('filename')
def touch(filename):
click.echo(filename)
And what it looks like:
.. click:run::
invoke(touch, args=['foo.txt'])
Variadic Arguments
------------------
The second most common version is variadic arguments where a specific (or
unlimited) number of arguments is accepted. This can be controlled with
the ``nargs`` parameter. If it is set to ``-1``, then an unlimited number
of arguments is accepted.
The value is then passed as a tuple. Note that only one argument can be
set to ``nargs=-1``, as it will eat up all arguments.
Example:
.. click:example::
@click.command()
@click.argument('src', nargs=-1)
@click.argument('dst', nargs=1)
def copy(src, dst):
for fn in src:
click.echo('move %s to folder %s' % (fn, dst))
And what it looks like:
.. click:run::
invoke(copy, args=['foo.txt', 'bar.txt', 'my_folder'])
Note that this is not how you would write this application. The reason
for this is that in this particular example the arguments are defined as
strings. Filenames, however, are not strings! They might be on certain
operating systems, but not necessarily on all. For better ways to write
this, see the next sections.
.. admonition:: Note on Non-Empty Variadic Arguments
If you come from ``argparse``, you might be missing support for setting
``nargs`` to ``+`` to indicate that at least one argument is required.
This is supported by setting ``required=True``. However, this should
not be used if you can avoid it as we believe scripts should gracefully
degrade into becoming noops if a variadic argument is empty. The
reason for this is that very often, scripts are invoked with wildcard
inputs from the command line and they should not error out if the
wildcard is empty.
.. _file-args:
File Arguments
--------------
Since all the examples have already worked with filenames, it makes sense
to explain how to deal with files properly. Command line tools are more
fun if they work with files the Unix way, which is to accept ``-`` as a
special file that refers to stdin/stdout.
Click supports this through the :class:`click.File` type which
intelligently handles files for you. It also deals with Unicode and bytes
correctly for all versions of Python so your script stays very portable.
Example:
.. click:example::
@click.command()
@click.argument('input', type=click.File('rb'))
@click.argument('output', type=click.File('wb'))
def inout(input, output):
while True:
chunk = input.read(1024)
if not chunk:
break
output.write(chunk)
And what it does:
.. click:run::
with isolated_filesystem():
invoke(inout, args=['-', 'hello.txt'], input=['hello'],
terminate_input=True)
invoke(inout, args=['hello.txt', '-'])
File Path Arguments
-------------------
In the previous example, the files were opened immediately. But what if
we just want the filename? The naïve way is to use the default string
argument type. However, remember that Click is Unicode-based, so the string
will always be a Unicode value. Unfortunately, filenames can be Unicode or
bytes depending on which operating system is being used. As such, the type
is insufficient.
Instead, you should be using the :class:`Path` type, which automatically
handles this ambiguity. Not only will it return either bytes or Unicode
depending on what makes more sense, but it will also be able to do some
basic checks for you such as existence checks.
Example:
.. click:example::
@click.command()
@click.argument('f', type=click.Path(exists=True))
def touch(f):
click.echo(click.format_filename(f))
And what it does:
.. click:run::
with isolated_filesystem():
with open('hello.txt', 'w') as f:
f.write('Hello World!\n')
invoke(touch, args=['hello.txt'])
println()
invoke(touch, args=['missing.txt'])
File Opening Safety
-------------------
The :class:`FileType` type has one problem it needs to deal with, and that
is to decide when to open a file. The default behavior is to be
"intelligent" about it. What this means is that it will open stdin/stdout
and files opened for reading immediately. This will give the user direct
feedback when a file cannot be opened, but it will only open files
for writing the first time an IO operation is performed by automatically
wrapping the file in a special wrapper.
This behavior can be forced by passing ``lazy=True`` or ``lazy=False`` to
the constructor. If the file is opened lazily, it will fail its first IO
operation by raising an :exc:`FileError`.
Since files opened for writing will typically immediately empty the file,
the lazy mode should only be disabled if the developer is absolutely sure
that this is intended behavior.
Forcing lazy mode is also very useful to avoid resource handling
confusion. If a file is opened in lazy mode, it will receive a
``close_intelligently`` method that can help figure out if the file
needs closing or not. This is not needed for parameters, but is
necessary for manually prompting with the :func:`prompt` function as you
do not know if a stream like stdout was opened (which was already open
before) or a real file that needs closing.
Starting with Click 2.0, it is also possible to open files in atomic mode by
passing ``atomic=True``. In atomic mode, all writes go into a separate
file in the same folder, and upon completion, the file will be moved over to
the original location. This is useful if a file regularly read by other
users is modified.
Environment Variables
---------------------
Like options, arguments can also grab values from an environment variable.
Unlike options, however, this is only supported for explicitly named
environment variables.
Example usage:
.. click:example::
@click.command()
@click.argument('src', envvar='SRC', type=click.File('r'))
def echo(src):
click.echo(src.read())
And from the command line:
.. click:run::
with isolated_filesystem():
with open('hello.txt', 'w') as f:
f.write('Hello World!')
invoke(echo, env={'SRC': 'hello.txt'})
In that case, it can also be a list of different environment variables
where the first one is picked.
Generally, this feature is not recommended because it can cause the user
a lot of confusion.
Option-Like Arguments
---------------------
Sometimes, you want to process arguments that look like options. For
instance, imagine you have a file named ``-foo.txt``. If you pass this as
an argument in this manner, Click will treat it as an option.
To solve this, Click does what any POSIX style command line script does,
and that is to accept the string ``--`` as a separator for options and
arguments. After the ``--`` marker, all further parameters are accepted as
arguments.
Example usage:
.. click:example::
@click.command()
@click.argument('files', nargs=-1, type=click.Path())
def touch(files):
for filename in files:
click.echo(filename)
And from the command line:
.. click:run::
invoke(touch, ['--', '-foo.txt', 'bar.txt'])
If you don't like the ``--`` marker, you can set ignore_unknown_options to
True to avoid checking unknown options:
.. click:example::
@click.command(context_settings={"ignore_unknown_options": True})
@click.argument('files', nargs=-1, type=click.Path())
def touch(files):
for filename in files:
click.echo(filename)
And from the command line:
.. click:run::
invoke(touch, ['-foo.txt', 'bar.txt'])
Click-7.0/docs/bashcomplete.rst 0000644 0001750 0001750 00000010752 13351570514 016746 0 ustar david david 0000000 0000000 Bash Complete
=============
.. versionadded:: 2.0
As of Click 2.0, there is built-in support for Bash completion for
any Click script. There are certain restrictions on when this completion
is available, but for the most part it should just work.
Limitations
-----------
Bash completion is only available if a script has been installed properly,
and not executed through the ``python`` command. For information about
how to do that, see :ref:`setuptools-integration`. Click currently
only supports completion for Bash and Zsh.
What it Completes
-----------------
Generally, the Bash completion support will complete subcommands, options
and any option or argument values where the type is click.Choice.
Subcommands and choices are always listed whereas options only if at
least a dash has been provided. Example::
$ repo
clone commit copy delete setuser
$ repo clone -
--deep --help --rev --shallow -r
Additionally, custom suggestions can be provided for arguments and options with
the ``autocompletion`` parameter. ``autocompletion`` should a callback function
that returns a list of strings. This is useful when the suggestions need to be
dynamically generated at bash completion time. The callback function will be
passed 3 keyword arguments:
- ``ctx`` - The current click context.
- ``args`` - The list of arguments passed in.
- ``incomplete`` - The partial word that is being completed, as a string. May
be an empty string ``''`` if no characters have been entered yet.
Here is an example of using a callback function to generate dynamic suggestions:
.. click:example::
import os
def get_env_vars(ctx, args, incomplete):
return [k for k in os.environ.keys() if incomplete in k]
@click.command()
@click.argument("envvar", type=click.STRING, autocompletion=get_env_vars)
def cmd1(envvar):
click.echo('Environment variable: %s' % envvar)
click.echo('Value: %s' % os.environ[envvar])
Completion help strings (ZSH only)
----------------------------------
ZSH supports showing documentation strings for completions. These are taken
from the help parameters of options and subcommands. For dynamically generated
completions a help string can be provided by returning a tuple instead of a
string. The first element of the tuple is the completion and the second is the
help string to display.
Here is an example of using a callback function to generate dynamic suggestions with help strings:
.. click:example::
import os
def get_colors(ctx, args, incomplete):
colors = [('red', 'help string for the color red'),
('blue', 'help string for the color blue'),
('green', 'help string for the color green')]
return [c for c in colors if incomplete in c[0]]
@click.command()
@click.argument("color", type=click.STRING, autocompletion=get_colors)
def cmd1(color):
click.echo('Chosen color is %s' % color)
Activation
----------
In order to activate Bash completion, you need to inform Bash that
completion is available for your script, and how. Any Click application
automatically provides support for that. The general way this works is
through a magic environment variable called ``__COMPLETE``,
where ```` is your application executable name in uppercase
with dashes replaced by underscores.
If your tool is called ``foo-bar``, then the magic variable is called
``_FOO_BAR_COMPLETE``. By exporting it with the ``source`` value it will
spit out the activation script which can be trivially activated.
For instance, to enable Bash completion for your ``foo-bar`` script, this
is what you would need to put into your ``.bashrc``::
eval "$(_FOO_BAR_COMPLETE=source foo-bar)"
For zsh users add this to your ``.zshrc``::
eval "$(_FOO_BAR_COMPLETE=source_zsh foo-bar)"
From this point onwards, your script will have autocompletion enabled.
Activation Script
-----------------
The above activation example will always invoke your application on
startup. This might be slowing down the shell activation time
significantly if you have many applications. Alternatively, you could also
ship a file with the contents of that, which is what Git and other systems
are doing.
This can be easily accomplished::
_FOO_BAR_COMPLETE=source foo-bar > foo-bar-complete.sh
For zsh:
_FOO_BAR_COMPLETE=source_zsh foo-bar > foo-bar-complete.sh
And then you would put this into your .bashrc or .zshrc instead::
. /path/to/foo-bar-complete.sh
Click-7.0/docs/changelog.rst 0000644 0001750 0001750 00000000066 13351570514 016224 0 ustar david david 0000000 0000000 .. currentmodule:: click
.. include:: ../CHANGES.rst
Click-7.0/docs/commands.rst 0000644 0001750 0001750 00000044243 13351570514 016103 0 ustar david david 0000000 0000000 Commands and Groups
===================
.. currentmodule:: click
The most important feature of Click is the concept of arbitrarily nesting
command line utilities. This is implemented through the :class:`Command`
and :class:`Group` (actually :class:`MultiCommand`).
Callback Invocation
-------------------
For a regular command, the callback is executed whenever the command runs.
If the script is the only command, it will always fire (unless a parameter
callback prevents it. This for instance happens if someone passes
``--help`` to the script).
For groups and multi commands, the situation looks different. In this case,
the callback fires whenever a subcommand fires (unless this behavior is
changed). What this means in practice is that an outer command runs
when an inner command runs:
.. click:example::
@click.group()
@click.option('--debug/--no-debug', default=False)
def cli(debug):
click.echo('Debug mode is %s' % ('on' if debug else 'off'))
@cli.command()
def sync():
click.echo('Syncing')
Here is what this looks like:
.. click:run::
invoke(cli, prog_name='tool.py')
println()
invoke(cli, prog_name='tool.py', args=['--debug', 'sync'])
Passing Parameters
------------------
Click strictly separates parameters between commands and subcommands. What this
means is that options and arguments for a specific command have to be specified
*after* the command name itself, but *before* any other command names.
This behavior is already observable with the predefined ``--help`` option.
Suppose we have a program called ``tool.py``, containing a subcommand called
``sub``.
- ``tool.py --help`` will return the help for the whole program (listing
subcommands).
- ``tool.py sub --help`` will return the help for the ``sub`` subcommand.
- But ``tool.py --help sub`` will treat ``--help`` as an argument for the main
program. Click then invokes the callback for ``--help``, which prints the
help and aborts the program before click can process the subcommand.
Nested Handling and Contexts
----------------------------
As you can see from the earlier example, the basic command group accepts a
debug argument which is passed to its callback, but not to the sync
command itself. The sync command only accepts its own arguments.
This allows tools to act completely independent of each other, but how
does one command talk to a nested one? The answer to this is the
:class:`Context`.
Each time a command is invoked, a new context is created and linked with the
parent context. Normally, you can't see these contexts, but they are
there. Contexts are passed to parameter callbacks together with the
value automatically. Commands can also ask for the context to be passed
by marking themselves with the :func:`pass_context` decorator. In that
case, the context is passed as first argument.
The context can also carry a program specified object that can be
used for the program's purposes. What this means is that you can build a
script like this:
.. click:example::
@click.group()
@click.option('--debug/--no-debug', default=False)
@click.pass_context
def cli(ctx, debug):
# ensure that ctx.obj exists and is a dict (in case `cli()` is called
# by means other than the `if` block below
ctx.ensure_object(dict)
ctx.obj['DEBUG'] = debug
@cli.command()
@click.pass_context
def sync(ctx):
click.echo('Debug is %s' % (ctx.obj['DEBUG'] and 'on' or 'off'))
if __name__ == '__main__':
cli(obj={})
If the object is provided, each context will pass the object onwards to
its children, but at any level a context's object can be overridden. To
reach to a parent, ``context.parent`` can be used.
In addition to that, instead of passing an object down, nothing stops the
application from modifying global state. For instance, you could just flip
a global ``DEBUG`` variable and be done with it.
Decorating Commands
-------------------
As you have seen in the earlier example, a decorator can change how a
command is invoked. What actually happens behind the scenes is that
callbacks are always invoked through the :meth:`Context.invoke` method
which automatically invokes a command correctly (by either passing the
context or not).
This is very useful when you want to write custom decorators. For
instance, a common pattern would be to configure an object representing
state and then storing it on the context and then to use a custom
decorator to find the most recent object of this sort and pass it as first
argument.
For instance, the :func:`pass_obj` decorator can be implemented like this:
.. click:example::
from functools import update_wrapper
def pass_obj(f):
@click.pass_context
def new_func(ctx, *args, **kwargs):
return ctx.invoke(f, ctx.obj, *args, **kwargs)
return update_wrapper(new_func, f)
The :meth:`Context.invoke` command will automatically invoke the function
in the correct way, so the function will either be called with ``f(ctx,
obj)`` or ``f(obj)`` depending on whether or not it itself is decorated with
:func:`pass_context`.
This is a very powerful concept that can be used to build very complex
nested applications; see :ref:`complex-guide` for more information.
Group Invocation Without Command
--------------------------------
By default, a group or multi command is not invoked unless a subcommand is
passed. In fact, not providing a command automatically passes ``--help``
by default. This behavior can be changed by passing
``invoke_without_command=True`` to a group. In that case, the callback is
always invoked instead of showing the help page. The context object also
includes information about whether or not the invocation would go to a
subcommand.
Example:
.. click:example::
@click.group(invoke_without_command=True)
@click.pass_context
def cli(ctx):
if ctx.invoked_subcommand is None:
click.echo('I was invoked without subcommand')
else:
click.echo('I am about to invoke %s' % ctx.invoked_subcommand)
@cli.command()
def sync():
click.echo('The subcommand')
And how it works in practice:
.. click:run::
invoke(cli, prog_name='tool', args=[])
invoke(cli, prog_name='tool', args=['sync'])
.. _custom-multi-commands:
Custom Multi Commands
---------------------
In addition to using :func:`click.group`, you can also build your own
custom multi commands. This is useful when you want to support commands
being loaded lazily from plugins.
A custom multi command just needs to implement a list and load method:
.. click:example::
import click
import os
plugin_folder = os.path.join(os.path.dirname(__file__), 'commands')
class MyCLI(click.MultiCommand):
def list_commands(self, ctx):
rv = []
for filename in os.listdir(plugin_folder):
if filename.endswith('.py'):
rv.append(filename[:-3])
rv.sort()
return rv
def get_command(self, ctx, name):
ns = {}
fn = os.path.join(plugin_folder, name + '.py')
with open(fn) as f:
code = compile(f.read(), fn, 'exec')
eval(code, ns, ns)
return ns['cli']
cli = MyCLI(help='This tool\'s subcommands are loaded from a '
'plugin folder dynamically.')
if __name__ == '__main__':
cli()
These custom classes can also be used with decorators:
.. click:example::
@click.command(cls=MyCLI)
def cli():
pass
Merging Multi Commands
----------------------
In addition to implementing custom multi commands, it can also be
interesting to merge multiple together into one script. While this is
generally not as recommended as it nests one below the other, the merging
approach can be useful in some circumstances for a nicer shell experience.
The default implementation for such a merging system is the
:class:`CommandCollection` class. It accepts a list of other multi
commands and makes the commands available on the same level.
Example usage:
.. click:example::
import click
@click.group()
def cli1():
pass
@cli1.command()
def cmd1():
"""Command on cli1"""
@click.group()
def cli2():
pass
@cli2.command()
def cmd2():
"""Command on cli2"""
cli = click.CommandCollection(sources=[cli1, cli2])
if __name__ == '__main__':
cli()
And what it looks like:
.. click:run::
invoke(cli, prog_name='cli', args=['--help'])
In case a command exists in more than one source, the first source wins.
.. _multi-command-chaining:
Multi Command Chaining
----------------------
.. versionadded:: 3.0
Sometimes it is useful to be allowed to invoke more than one subcommand in
one go. For instance if you have installed a setuptools package before
you might be familiar with the ``setup.py sdist bdist_wheel upload``
command chain which invokes ``dist`` before ``bdist_wheel`` before
``upload``. Starting with Click 3.0 this is very simple to implement.
All you have to do is to pass ``chain=True`` to your multicommand:
.. click:example::
@click.group(chain=True)
def cli():
pass
@cli.command('sdist')
def sdist():
click.echo('sdist called')
@cli.command('bdist_wheel')
def bdist_wheel():
click.echo('bdist_wheel called')
Now you can invoke it like this:
.. click:run::
invoke(cli, prog_name='setup.py', args=['sdist', 'bdist_wheel'])
When using multi command chaining you can only have one command (the last)
use ``nargs=-1`` on an argument. It is also not possible to nest multi
commands below chained multicommands. Other than that there are no
restrictions on how they work. They can accept options and arguments as
normal.
Another note: the :attr:`Context.invoked_subcommand` attribute is a bit
useless for multi commands as it will give ``'*'`` as value if more than
one command is invoked. This is necessary because the handling of
subcommands happens one after another so the exact subcommands that will
be handled are not yet available when the callback fires.
.. note::
It is currently not possible for chain commands to be nested. This
will be fixed in future versions of Click.
Multi Command Pipelines
-----------------------
.. versionadded:: 3.0
A very common usecase of multi command chaining is to have one command
process the result of the previous command. There are various ways in
which this can be facilitated. The most obvious way is to store a value
on the context object and process it from function to function. This
works by decorating a function with :func:`pass_context` after which the
context object is provided and a subcommand can store its data there.
Another way to accomplish this is to setup pipelines by returning
processing functions. Think of it like this: when a subcommand gets
invoked it processes all of its parameters and comes up with a plan of
how to do its processing. At that point it then returns a processing
function and returns.
Where do the returned functions go? The chained multicommand can register
a callback with :meth:`MultiCommand.resultcallback` that goes over all
these functions and then invoke them.
To make this a bit more concrete consider this example:
.. click:example::
@click.group(chain=True, invoke_without_command=True)
@click.option('-i', '--input', type=click.File('r'))
def cli(input):
pass
@cli.resultcallback()
def process_pipeline(processors, input):
iterator = (x.rstrip('\r\n') for x in input)
for processor in processors:
iterator = processor(iterator)
for item in iterator:
click.echo(item)
@cli.command('uppercase')
def make_uppercase():
def processor(iterator):
for line in iterator:
yield line.upper()
return processor
@cli.command('lowercase')
def make_lowercase():
def processor(iterator):
for line in iterator:
yield line.lower()
return processor
@cli.command('strip')
def make_strip():
def processor(iterator):
for line in iterator:
yield line.strip()
return processor
That's a lot in one go, so let's go through it step by step.
1. The first thing is to make a :func:`group` that is chainable. In
addition to that we also instruct Click to invoke even if no
subcommand is defined. If this would not be done, then invoking an
empty pipeline would produce the help page instead of running the
result callbacks.
2. The next thing we do is to register a result callback on our group.
This callback will be invoked with an argument which is the list of
all return values of all subcommands and then the same keyword
parameters as our group itself. This means we can access the input
file easily there without having to use the context object.
3. In this result callback we create an iterator of all the lines in the
input file and then pass this iterator through all the returned
callbacks from all subcommands and finally we print all lines to
stdout.
After that point we can register as many subcommands as we want and each
subcommand can return a processor function to modify the stream of lines.
One important thing of note is that Click shuts down the context after
each callback has been run. This means that for instance file types
cannot be accessed in the `processor` functions as the files will already
be closed there. This limitation is unlikely to change because it would
make resource handling much more complicated. For such it's recommended
to not use the file type and manually open the file through
:func:`open_file`.
For a more complex example that also improves upon handling of the
pipelines have a look at the `imagepipe multi command chaining demo
`__ in
the Click repository. It implements a pipeline based image editing tool
that has a nice internal structure for the pipelines.
Overriding Defaults
-------------------
By default, the default value for a parameter is pulled from the
``default`` flag that is provided when it's defined, but that's not the
only place defaults can be loaded from. The other place is the
:attr:`Context.default_map` (a dictionary) on the context. This allows
defaults to be loaded from a configuration file to override the regular
defaults.
This is useful if you plug in some commands from another package but
you're not satisfied with the defaults.
The default map can be nested arbitrarily for each subcommand and
provided when the script is invoked. Alternatively, it can also be
overridden at any point by commands. For instance, a top-level command could
load the defaults from a configuration file.
Example usage:
.. click:example::
import click
@click.group()
def cli():
pass
@cli.command()
@click.option('--port', default=8000)
def runserver(port):
click.echo('Serving on http://127.0.0.1:%d/' % port)
if __name__ == '__main__':
cli(default_map={
'runserver': {
'port': 5000
}
})
And in action:
.. click:run::
invoke(cli, prog_name='cli', args=['runserver'], default_map={
'runserver': {
'port': 5000
}
})
Context Defaults
----------------
.. versionadded:: 2.0
Starting with Click 2.0 you can override defaults for contexts not just
when calling your script, but also in the decorator that declares a
command. For instance given the previous example which defines a custom
``default_map`` this can also be accomplished in the decorator now.
This example does the same as the previous example:
.. click:example::
import click
CONTEXT_SETTINGS = dict(
default_map={'runserver': {'port': 5000}}
)
@click.group(context_settings=CONTEXT_SETTINGS)
def cli():
pass
@cli.command()
@click.option('--port', default=8000)
def runserver(port):
click.echo('Serving on http://127.0.0.1:%d/' % port)
if __name__ == '__main__':
cli()
And again the example in action:
.. click:run::
invoke(cli, prog_name='cli', args=['runserver'])
Command Return Values
---------------------
.. versionadded:: 3.0
One of the new introductions in Click 3.0 is the full support for return
values from command callbacks. This enables a whole range of features
that were previously hard to implement.
In essence any command callback can now return a value. This return value
is bubbled to certain receivers. One usecase for this has already been
show in the example of :ref:`multi-command-chaining` where it has been
demonstrated that chained multi commands can have callbacks that process
all return values.
When working with command return values in Click, this is what you need to
know:
- The return value of a command callback is generally returned from the
:meth:`BaseCommand.invoke` method. The exception to this rule has to
do with :class:`Group`\s:
* In a group the return value is generally the return value of the
subcommand invoked. The only exception to this rule is that the
return value is the return value of the group callback if it's
invoked without arguments and `invoke_without_command` is enabled.
* If a group is set up for chaining then the return value is a list
of all subcommands' results.
* Return values of groups can be processed through a
:attr:`MultiCommand.result_callback`. This is invoked with the
list of all return values in chain mode, or the single return
value in case of non chained commands.
- The return value is bubbled through from the :meth:`Context.invoke`
and :meth:`Context.forward` methods. This is useful in situations
where you internally want to call into another command.
- Click does not have any hard requirements for the return values and
does not use them itself. This allows return values to be used for
custom decorators or workflows (like in the multi command chaining
example).
- When a Click script is invoked as command line application (through
:meth:`BaseCommand.main`) the return value is ignored unless the
`standalone_mode` is disabled in which case it's bubbled through.
Click-7.0/docs/complex.rst 0000644 0001750 0001750 00000017224 13351570514 015750 0 ustar david david 0000000 0000000 .. _complex-guide:
Complex Applications
====================
.. currentmodule:: click
Click is designed to assist with the creation of complex and simple CLI tools
alike. However, the power of its design is the ability to arbitrarily nest
systems together. For instance, if you have ever used Django, you will
have realized that it provides a command line utility, but so does Celery.
When using Celery with Django, there are two tools that need to interact with
each other and be cross-configured.
In a theoretical world of two separate Click command line utilities, they
could solve this problem by nesting one inside the other. For instance, the
web framework could also load the commands for the message queue framework.
Basic Concepts
--------------
To understand how this works, you need to understand two concepts: contexts
and the calling convention.
Contexts
````````
Whenever a Click command is executed, a :class:`Context` object is created
which holds state for this particular invocation. It remembers parsed
parameters, what command created it, which resources need to be cleaned up
at the end of the function, and so forth. It can also optionally hold an
application-defined object.
Context objects build a linked list until they hit the top one. Each context
is linked to a parent context. This allows a command to work below
another command and store its own information there without having to be
afraid of altering up the state of the parent command.
Because the parent data is available, however, it is possible to navigate to
it if needed.
Most of the time, you do not see the context object, but when writing more
complex applications it comes in handy. This brings us to the next point.
Calling Convention
``````````````````
When a Click command callback is executed, it's passed all the non-hidden
parameters as keyword arguments. Notably absent is the context. However,
a callback can opt into being passed to the context object by marking itself
with :func:`pass_context`.
So how do you invoke a command callback if you don't know if it should
receive the context or not? The answer is that the context itself
provides a helper function (:meth:`Context.invoke`) which can do this for
you. It accepts the callback as first argument and then invokes the
function correctly.
Building a Git Clone
--------------------
In this example, we want to build a command line tool that resembles a
version control system. Systems like Git usually provide one
over-arching command that already accepts some parameters and
configuration, and then have extra subcommands that do other things.
The Root Command
````````````````
At the top level, we need a group that can hold all our commands. In this
case, we use the basic :func:`click.group` which allows us to register
other Click commands below it.
For this command, we also want to accept some parameters that configure the
state of our tool:
.. click:example::
import os
import click
class Repo(object):
def __init__(self, home=None, debug=False):
self.home = os.path.abspath(home or '.')
self.debug = debug
@click.group()
@click.option('--repo-home', envvar='REPO_HOME', default='.repo')
@click.option('--debug/--no-debug', default=False,
envvar='REPO_DEBUG')
@click.pass_context
def cli(ctx, repo_home, debug):
ctx.obj = Repo(repo_home, debug)
Let's understand what this does. We create a group command which can
have subcommands. When it is invoked, it will create an instance of a
``Repo`` class. This holds the state for our command line tool. In this
case, it just remembers some parameters, but at this point it could also
start loading configuration files and so on.
This state object is then remembered by the context as :attr:`~Context.obj`.
This is a special attribute where commands are supposed to remember what
they need to pass on to their children.
In order for this to work, we need to mark our function with
:func:`pass_context`, because otherwise, the context object would be
entirely hidden from us.
The First Child Command
```````````````````````
Let's add our first child command to it, the clone command:
.. click:example::
@cli.command()
@click.argument('src')
@click.argument('dest', required=False)
def clone(src, dest):
pass
So now we have a clone command, but how do we get access to the repo? As
you can imagine, one way is to use the :func:`pass_context` function which
again will make our callback also get the context passed on which we
memorized the repo. However, there is a second version of this decorator
called :func:`pass_obj` which will just pass the stored object, (in our case
the repo):
.. click:example::
@cli.command()
@click.argument('src')
@click.argument('dest', required=False)
@click.pass_obj
def clone(repo, src, dest):
pass
Interleaved Commands
````````````````````
While not relevant for the particular program we want to build, there is
also quite good support for interleaving systems. Imagine for instance that
there was a super cool plugin for our version control system that needed a
lot of configuration and wanted to store its own configuration as
:attr:`~Context.obj`. If we would then attach another command below that,
we would all of a sudden get the plugin configuration instead of our repo
object.
One obvious way to remedy this is to store a reference to the repo in the
plugin, but then a command needs to be aware that it's attached below such a
plugin.
There is a much better system that can be built by taking advantage of the
linked nature of contexts. We know that the plugin context is linked to the
context that created our repo. Because of that, we can start a search for
the last level where the object stored by the context was a repo.
Built-in support for this is provided by the :func:`make_pass_decorator`
factory, which will create decorators for us that find objects (it
internally calls into :meth:`Context.find_object`). In our case, we
know that we want to find the closest ``Repo`` object, so let's make a
decorator for this:
.. click:example::
pass_repo = click.make_pass_decorator(Repo)
If we now use ``pass_repo`` instead of ``pass_obj``, we will always get a
repo instead of something else:
.. click:example::
@cli.command()
@click.argument('src')
@click.argument('dest', required=False)
@pass_repo
def clone(repo, src, dest):
pass
Ensuring Object Creation
````````````````````````
The above example only works if there was an outer command that created a
``Repo`` object and stored it in the context. For some more advanced use
cases, this might become a problem. The default behavior of
:func:`make_pass_decorator` is to call :meth:`Context.find_object`
which will find the object. If it can't find the object,
:meth:`make_pass_decorator` will raise an error.
The alternative behavior is to use :meth:`Context.ensure_object`
which will find the object, and if it cannot find it, will create one and
store it in the innermost context. This behavior can also be enabled for
:func:`make_pass_decorator` by passing ``ensure=True``:
.. click:example::
pass_repo = click.make_pass_decorator(Repo, ensure=True)
In this case, the innermost context gets an object created if it is
missing. This might replace objects being placed there earlier. In this
case, the command stays executable, even if the outer command does not run.
For this to work, the object type needs to have a constructor that accepts
no arguments.
As such it runs standalone:
.. click:example::
@click.command()
@pass_repo
def cp(repo):
click.echo(isinstance(repo, Repo))
As you can see:
.. click:run::
invoke(cp, [])
Click-7.0/docs/conf.py 0000644 0001750 0001750 00000003404 13352233342 015035 0 ustar david david 0000000 0000000 from pallets_sphinx_themes import ProjectLink, get_version
# Project --------------------------------------------------------------
project = "Click"
copyright = "2014 Pallets Team"
author = "Pallets Team"
release, version = get_version("Click", version_length=1)
# General --------------------------------------------------------------
master_doc = "index"
extensions = ["sphinx.ext.autodoc", "sphinx.ext.intersphinx", "pallets_sphinx_themes"]
intersphinx_mapping = {"python": ("https://docs.python.org/3/", None)}
# HTML -----------------------------------------------------------------
html_theme = "click"
html_theme_options = {"index_sidebar_logo": False}
html_context = {
"project_links": [
ProjectLink("Donate to Pallets", "https://palletsprojects.com/donate"),
ProjectLink("Click Website", "https://palletsprojects.com/p/click/"),
ProjectLink("PyPI releases", "https://pypi.org/project/Click/"),
ProjectLink("Source Code", "https://github.com/pallets/click/"),
ProjectLink("Issue Tracker", "https://github.com/pallets/click/issues/"),
]
}
html_sidebars = {
"index": ["project.html", "versions.html", "searchbox.html"],
"**": ["localtoc.html", "relations.html", "versions.html", "searchbox.html"],
}
singlehtml_sidebars = {"index": ["project.html", "versions.html", "localtoc.html"]}
html_static_path = ["_static"]
html_favicon = "_static/click-icon.png"
html_logo = "_static/click-logo-sidebar.png"
html_title = "Click Documentation ({})".format(version)
html_show_sourcelink = False
html_domain_indices = False
html_experimental_html5_writer = True
# LaTeX ----------------------------------------------------------------
latex_documents = [
(master_doc, "Click-{}.tex".format(version), html_title, author, "manual")
]
Click-7.0/docs/contrib.rst 0000644 0001750 0001750 00000002251 13351553406 015734 0 ustar david david 0000000 0000000 .. _contrib:
=============
click-contrib
=============
As the userbase of Click grows, more and more major feature requests pop up in
Click's bugtracker. As reasonable as it may be for those features to be bundled
with Click instead of being a standalone project, many of those requested
features are either highly experimental or have unproven practical use, while
potentially being a burden to maintain.
This is why click-contrib_ exists. The GitHub organization is a collection of
possibly experimental third-party packages whose featureset does not belong
into Click, but also a playground for major features that may be added to Click
in the future. It is also meant to coordinate and concentrate effort on writing
third-party extensions for Click, and to ease the effort of searching for such
extensions. In that sense it could be described as a low-maintenance
alternative to extension repositories of other frameworks.
Please note that the quality and stability of those packages may be different
than what you expect from Click itself. While published under a common
organization, they are still projects separate from Click.
.. _click-contrib: https://github.com/click-contrib/
Click-7.0/docs/documentation.rst 0000644 0001750 0001750 00000011703 13351570514 017146 0 ustar david david 0000000 0000000 Documenting Scripts
===================
.. currentmodule:: click
Click makes it very easy to document your command line tools. First of
all, it automatically generates help pages for you. While these are
currently not customizable in terms of their layout, all of the text
can be changed.
Help Texts
----------
Commands and options accept help arguments. In the case of commands, the
docstring of the function is automatically used if provided.
Simple example:
.. click:example::
@click.command()
@click.option('--count', default=1, help='number of greetings')
@click.argument('name')
def hello(count, name):
"""This script prints hello NAME COUNT times."""
for x in range(count):
click.echo('Hello %s!' % name)
And what it looks like:
.. click:run::
invoke(hello, args=['--help'])
Arguments cannot be documented this way. This is to follow the general
convention of Unix tools of using arguments for only the most necessary
things and to document them in the introduction text by referring to them
by name.
Preventing Rewrapping
---------------------
The default behavior of Click is to rewrap text based on the width of the
terminal. In some circumstances, this can become a problem. The main issue
is when showing code examples, where newlines are significant.
Rewrapping can be disabled on a per-paragraph basis by adding a line with
solely the ``\b`` escape marker in it. This line will be removed from the
help text and rewrapping will be disabled.
Example:
.. click:example::
@click.command()
def cli():
"""First paragraph.
This is a very long second paragraph and as you
can see wrapped very early in the source text
but will be rewrapped to the terminal width in
the final output.
\b
This is
a paragraph
without rewrapping.
And this is a paragraph
that will be rewrapped again.
"""
And what it looks like:
.. click:run::
invoke(cli, args=['--help'])
.. _doc-meta-variables:
Truncating Help Texts
---------------------
Click gets command help text from function docstrings. However if you
already use docstrings to document function arguments you may not want
to see :param: and :return: lines in your help text.
You can use the ``\f`` escape marker to have Click truncate the help text
after the marker.
Example:
.. click:example::
@click.command()
@click.pass_context
def cli(ctx):
"""First paragraph.
This is a very long second
paragraph and not correctly
wrapped but it will be rewrapped.
\f
:param click.core.Context ctx: Click context.
"""
And what it looks like:
.. click:run::
invoke(cli, args=['--help'])
Meta Variables
--------------
Options and parameters accept a ``metavar`` argument that can change the
meta variable in the help page. The default version is the parameter name
in uppercase with underscores, but can be annotated differently if
desired. This can be customized at all levels:
.. click:example::
@click.command(options_metavar='')
@click.option('--count', default=1, help='number of greetings',
metavar='')
@click.argument('name', metavar='')
def hello(count, name):
"""This script prints hello times."""
for x in range(count):
click.echo('Hello %s!' % name)
Example:
.. click:run::
invoke(hello, args=['--help'])
Command Short Help
------------------
For commands, a short help snippet is generated. By default, it's the first
sentence of the help message of the command, unless it's too long. This can
also be overridden:
.. click:example::
@click.group()
def cli():
"""A simple command line tool."""
@cli.command('init', short_help='init the repo')
def init():
"""Initializes the repository."""
@cli.command('delete', short_help='delete the repo')
def delete():
"""Deletes the repository."""
And what it looks like:
.. click:run::
invoke(cli, prog_name='repo.py')
Help Parameter Customization
----------------------------
.. versionadded:: 2.0
The help parameter is implemented in Click in a very special manner.
Unlike regular parameters it's automatically added by Click for any
command and it performs automatic conflict resolution. By default it's
called ``--help``, but this can be changed. If a command itself implements
a parameter with the same name, the default help parameter stops accepting
it. There is a context setting that can be used to override the names of
the help parameters called :attr:`~Context.help_option_names`.
This example changes the default parameters to ``-h`` and ``--help``
instead of just ``--help``:
.. click:example::
CONTEXT_SETTINGS = dict(help_option_names=['-h', '--help'])
@click.command(context_settings=CONTEXT_SETTINGS)
def cli():
pass
And what it looks like:
.. click:run::
invoke(cli, ['-h'])
Click-7.0/docs/exceptions.rst 0000644 0001750 0001750 00000005554 13351553373 016471 0 ustar david david 0000000 0000000 Exception Handling
==================
.. currentmodule:: click
Click internally uses exceptions to signal various error conditions that
the user of the application might have caused. Primarily this is things
like incorrect usage.
Where are Errors Handled?
-------------------------
Click's main error handling is happening in :meth:`BaseCommand.main`. In
there it handles all subclasses of :exc:`ClickException` as well as the
standard :exc:`EOFError` and :exc:`KeyboardInterrupt` exceptions. The
latter are internally translated into a :exc:`Abort`.
The logic applied is the following:
1. If an :exc:`EOFError` or :exc:`KeyboardInterrupt` happens, reraise it
as :exc:`Abort`.
2. If an :exc:`ClickException` is raised, invoke the
:meth:`ClickException.show` method on it to display it and then exit
the program with :attr:`ClickException.exit_code`.
3. If an :exc:`Abort` exception is raised print the string ``Aborted!``
to standard error and exit the program with exit code ``1``.
4. if it goes through well, exit the program with exit code ``0``.
What if I don't want that?
--------------------------
Generally you always have the option to invoke the :meth:`invoke` method
yourself. For instance if you have a :class:`Command` you can invoke it
manually like this::
ctx = command.make_context('command-name', ['args', 'go', 'here'])
with ctx:
result = command.invoke(ctx)
In this case exceptions will not be handled at all and bubbled up as you
would expect.
Starting with Click 3.0 you can also use the :meth:`Command.main` method
but disable the standalone mode which will do two things: disable
exception handling and disable the implicit :meth:`sys.exit` at the end.
So you can do something like this::
command.main(['command-name', 'args', 'go', 'here'],
standalone_mode=False)
Which Exceptions Exist?
-----------------------
Click has two exception bases: :exc:`ClickException` which is raised for
all exceptions that Click wants to signal to the user and :exc:`Abort`
which is used to instruct Click to abort the execution.
A :exc:`ClickException` has a :meth:`~ClickException.show` method which
can render an error message to stderr or the given file object. If you
want to use the exception yourself for doing something check the API docs
about what else they provide.
The following common subclasses exist:
* :exc:`UsageError` to inform the user that something went wrong.
* :exc:`BadParameter` to inform the user that something went wrong with
a specific parameter. These are often handled internally in Click and
augmented with extra information if possible. For instance if those
are raised from a callback Click will automatically augment it with
the parameter name if possible.
* :exc:`FileError` this is an error that is raised by the
:exc:`FileType` if Click encounters issues opening the file.
Click-7.0/docs/index.rst 0000644 0001750 0001750 00000004327 13351570514 015410 0 ustar david david 0000000 0000000 .. rst-class:: hide-header
Welcome to Click
================
.. image:: _static/click-logo.png
:align: center
:scale: 50%
:target: https://palletsprojects.com/p/click/
Click is a Python package for creating beautiful command line interfaces
in a composable way with as little code as necessary. It's the "Command
Line Interface Creation Kit". It's highly configurable but comes with
sensible defaults out of the box.
It aims to make the process of writing command line tools quick and fun
while also preventing any frustration caused by the inability to implement
an intended CLI API.
Click in three points:
- arbitrary nesting of commands
- automatic help page generation
- supports lazy loading of subcommands at runtime
What does it look like? Here is an example of a simple Click program:
.. click:example::
import click
@click.command()
@click.option('--count', default=1, help='Number of greetings.')
@click.option('--name', prompt='Your name',
help='The person to greet.')
def hello(count, name):
"""Simple program that greets NAME for a total of COUNT times."""
for x in range(count):
click.echo('Hello %s!' % name)
if __name__ == '__main__':
hello()
And what it looks like when run:
.. click:run::
invoke(hello, ['--count=3'], prog_name='python hello.py', input='John\n')
It automatically generates nicely formatted help pages:
.. click:run::
invoke(hello, ['--help'], prog_name='python hello.py')
You can get the library directly from PyPI::
pip install click
Documentation
-------------
This part of the documentation guides you through all of the library's
usage patterns.
.. toctree::
:maxdepth: 2
why
quickstart
setuptools
parameters
options
arguments
commands
prompts
documentation
complex
advanced
testing
utils
bashcomplete
exceptions
python3
wincmd
API Reference
-------------
If you are looking for information on a specific function, class, or
method, this part of the documentation is for you.
.. toctree::
:maxdepth: 2
api
Miscellaneous Pages
-------------------
.. toctree::
:maxdepth: 2
contrib
changelog
upgrading
license
Click-7.0/docs/license.rst 0000644 0001750 0001750 00000000627 13352433170 015717 0 ustar david david 0000000 0000000 License
=======
Click is licensed under a three-clause BSD License. It basically means:
do whatever you want with it as long as the copyright in Click sticks
around, the conditions are not modified and the disclaimer is present.
Furthermore, you must not use the names of the authors to promote derivatives
of the software without written consent.
License Text
------------
.. include:: ../LICENSE.rst
Click-7.0/docs/make.bat 0000644 0001750 0001750 00000001405 13351570514 015146 0 ustar david david 0000000 0000000 @ECHO OFF
pushd %~dp0
REM Command file for Sphinx documentation
if "%SPHINXBUILD%" == "" (
set SPHINXBUILD=sphinx-build
)
set SOURCEDIR=.
set BUILDDIR=_build
set SPHINXPROJ=Jinja
if "%1" == "" goto help
%SPHINXBUILD% >NUL 2>NUL
if errorlevel 9009 (
echo.
echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
echo.installed, then set the SPHINXBUILD environment variable to point
echo.to the full path of the 'sphinx-build' executable. Alternatively you
echo.may add the Sphinx directory to PATH.
echo.
echo.If you don't have Sphinx installed, grab it from
echo.http://sphinx-doc.org/
exit /b 1
)
%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
goto end
:help
%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
:end
popd
Click-7.0/docs/options.rst 0000644 0001750 0001750 00000053175 13351570514 016001 0 ustar david david 0000000 0000000 .. _options:
Options
=======
.. currentmodule:: click
Adding options to commands can be accomplished by the :func:`option`
decorator. Since options can come in various different versions, there
are a ton of parameters to configure their behavior. Options in click are
distinct from :ref:`positional arguments `.
Name Your Options
-----------------
The naming rules can be found in :ref:`parameter_names`. In short, you
can refer the option **implicitly** by the longest dash-prefixed argument:
.. click:example::
@click.command()
@click.option('-s', '--string-to-echo')
def echo(string_to_echo):
click.echo(string_to_echo)
Or, **explicitly**, by giving one non-dash-prefixed argument:
.. click:example::
@click.command()
@click.option('-s', '--string-to-echo', 'string')
def echo(string):
click.echo(string)
Basic Value Options
-------------------
The most basic option is a value option. These options accept one
argument which is a value. If no type is provided, the type of the default
value is used. If no default value is provided, the type is assumed to be
:data:`STRING`. Unless a name is explicitly specified, the name of the
parameter is the first long option defined; otherwise the first short one is
used. By default, options are not required, however to make an option required,
simply pass in `required=True` as an argument to the decorator.
.. click:example::
@click.command()
@click.option('--n', default=1)
def dots(n):
click.echo('.' * n)
.. click:example::
# How to make an option required
@click.command()
@click.option('--n', required=True, type=int)
def dots(n):
click.echo('.' * n)
.. click:example::
# How to use a Python reserved word such as `from` as a parameter
@click.command()
@click.option('--from', '-f', 'from_')
@click.option('--to', '-t')
def reserved_param_name(from_, to):
click.echo('from %s to %s' % (from_, to))
And on the command line:
.. click:run::
invoke(dots, args=['--n=2'])
In this case the option is of type :data:`INT` because the default value
is an integer.
To show the default values when showing command help, use ``show_default=True``
.. click:example::
@click.command()
@click.option('--n', default=1, show_default=True)
def dots(n):
click.echo('.' * n)
.. click:run::
invoke(dots, args=['--help'])
Multi Value Options
-------------------
Sometimes, you have options that take more than one argument. For options,
only a fixed number of arguments is supported. This can be configured by
the ``nargs`` parameter. The values are then stored as a tuple.
.. click:example::
@click.command()
@click.option('--pos', nargs=2, type=float)
def findme(pos):
click.echo('%s / %s' % pos)
And on the command line:
.. click:run::
invoke(findme, args=['--pos', '2.0', '3.0'])
.. _tuple-type:
Tuples as Multi Value Options
-----------------------------
.. versionadded:: 4.0
As you can see that by using `nargs` set to a specific number each item in
the resulting tuple is of the same type. This might not be what you want.
Commonly you might want to use different types for different indexes in
the tuple. For this you can directly specify a tuple as type:
.. click:example::
@click.command()
@click.option('--item', type=(str, int))
def putitem(item):
click.echo('name=%s id=%d' % item)
And on the command line:
.. click:run::
invoke(putitem, args=['--item', 'peter', '1338'])
By using a tuple literal as type, `nargs` gets automatically set to the
length of the tuple and the :class:`click.Tuple` type is automatically
used. The above example is thus equivalent to this:
.. click:example::
@click.command()
@click.option('--item', nargs=2, type=click.Tuple([str, int]))
def putitem(item):
click.echo('name=%s id=%d' % item)
Multiple Options
----------------
Similarly to ``nargs``, there is also the case of wanting to support a
parameter being provided multiple times to and have all values recorded --
not just the last one. For instance, ``git commit -m foo -m bar`` would
record two lines for the commit message: ``foo`` and ``bar``. This can be
accomplished with the ``multiple`` flag:
Example:
.. click:example::
@click.command()
@click.option('--message', '-m', multiple=True)
def commit(message):
click.echo('\n'.join(message))
And on the command line:
.. click:run::
invoke(commit, args=['-m', 'foo', '-m', 'bar'])
Counting
--------
In some very rare circumstances, it is interesting to use the repetition
of options to count an integer up. This can be used for verbosity flags,
for instance:
.. click:example::
@click.command()
@click.option('-v', '--verbose', count=True)
def log(verbose):
click.echo('Verbosity: %s' % verbose)
And on the command line:
.. click:run::
invoke(log, args=['-vvv'])
Boolean Flags
-------------
Boolean flags are options that can be enabled or disabled. This can be
accomplished by defining two flags in one go separated by a slash (``/``)
for enabling or disabling the option. (If a slash is in an option string,
Click automatically knows that it's a boolean flag and will pass
``is_flag=True`` implicitly.) Click always wants you to provide an enable
and disable flag so that you can change the default later.
Example:
.. click:example::
import sys
@click.command()
@click.option('--shout/--no-shout', default=False)
def info(shout):
rv = sys.platform
if shout:
rv = rv.upper() + '!!!!111'
click.echo(rv)
And on the command line:
.. click:run::
invoke(info, args=['--shout'])
invoke(info, args=['--no-shout'])
If you really don't want an off-switch, you can just define one and
manually inform Click that something is a flag:
.. click:example::
import sys
@click.command()
@click.option('--shout', is_flag=True)
def info(shout):
rv = sys.platform
if shout:
rv = rv.upper() + '!!!!111'
click.echo(rv)
And on the command line:
.. click:run::
invoke(info, args=['--shout'])
Note that if a slash is contained in your option already (for instance, if
you use Windows-style parameters where ``/`` is the prefix character), you
can alternatively split the parameters through ``;`` instead:
.. click:example::
@click.command()
@click.option('/debug;/no-debug')
def log(debug):
click.echo('debug=%s' % debug)
if __name__ == '__main__':
log()
.. versionchanged:: 6.0
If you want to define an alias for the second option only, then you will
need to use leading whitespace to disambiguate the format string:
Example:
.. click:example::
import sys
@click.command()
@click.option('--shout/--no-shout', ' /-S', default=False)
def info(shout):
rv = sys.platform
if shout:
rv = rv.upper() + '!!!!111'
click.echo(rv)
.. click:run::
invoke(info, args=['--help'])
Feature Switches
----------------
In addition to boolean flags, there are also feature switches. These are
implemented by setting multiple options to the same parameter name and
defining a flag value. Note that by providing the ``flag_value`` parameter,
Click will implicitly set ``is_flag=True``.
To set a default flag, assign a value of `True` to the flag that should be
the default.
.. click:example::
import sys
@click.command()
@click.option('--upper', 'transformation', flag_value='upper',
default=True)
@click.option('--lower', 'transformation', flag_value='lower')
def info(transformation):
click.echo(getattr(sys.platform, transformation)())
And on the command line:
.. click:run::
invoke(info, args=['--upper'])
invoke(info, args=['--lower'])
invoke(info)
.. _choice-opts:
Choice Options
--------------
Sometimes, you want to have a parameter be a choice of a list of values.
In that case you can use :class:`Choice` type. It can be instantiated
with a list of valid values.
Example:
.. click:example::
@click.command()
@click.option('--hash-type', type=click.Choice(['md5', 'sha1']))
def digest(hash_type):
click.echo(hash_type)
What it looks like:
.. click:run::
invoke(digest, args=['--hash-type=md5'])
println()
invoke(digest, args=['--hash-type=foo'])
println()
invoke(digest, args=['--help'])
.. note::
You should only pass the choices as list or tuple. Other iterables (like
generators) may lead to surprising results.
.. _option-prompting:
Prompting
---------
In some cases, you want parameters that can be provided from the command line,
but if not provided, ask for user input instead. This can be implemented with
Click by defining a prompt string.
Example:
.. click:example::
@click.command()
@click.option('--name', prompt=True)
def hello(name):
click.echo('Hello %s!' % name)
And what it looks like:
.. click:run::
invoke(hello, args=['--name=John'])
invoke(hello, input=['John'])
If you are not happy with the default prompt string, you can ask for
a different one:
.. click:example::
@click.command()
@click.option('--name', prompt='Your name please')
def hello(name):
click.echo('Hello %s!' % name)
What it looks like:
.. click:run::
invoke(hello, input=['John'])
Password Prompts
----------------
Click also supports hidden prompts and asking for confirmation. This is
useful for password input:
.. click:example::
@click.command()
@click.option('--password', prompt=True, hide_input=True,
confirmation_prompt=True)
def encrypt(password):
click.echo('Encrypting password to %s' % password.encode('rot13'))
What it looks like:
.. click:run::
invoke(encrypt, input=['secret', 'secret'])
Because this combination of parameters is quite common, this can also be
replaced with the :func:`password_option` decorator:
.. click:example::
@click.command()
@click.password_option()
def encrypt(password):
click.echo('Encrypting password to %s' % password.encode('rot13'))
Dynamic Defaults for Prompts
----------------------------
The ``auto_envvar_prefix`` and ``default_map`` options for the context
allow the program to read option values from the environment or a
configuration file. However, this overrides the prompting mechanism, so
that the user does not get the option to change the value interactively.
If you want to let the user configure the default value, but still be
prompted if the option isn't specified on the command line, you can do so
by supplying a callable as the default value. For example, to get a default
from the environment:
.. click:example::
@click.command()
@click.option('--username', prompt=True,
default=lambda: os.environ.get('USER', ''))
def hello(username):
print("Hello,", username)
To describe what the default value will be, set it in ``show_default``.
.. click:example::
@click.command()
@click.option('--username', prompt=True,
default=lambda: os.environ.get('USER', ''),
show_default='current user')
def hello(username):
print("Hello,", username)
.. click:run::
invoke(hello, args=['--help'])
Callbacks and Eager Options
---------------------------
Sometimes, you want a parameter to completely change the execution flow.
For instance, this is the case when you want to have a ``--version``
parameter that prints out the version and then exits the application.
Note: an actual implementation of a ``--version`` parameter that is
reusable is available in Click as :func:`click.version_option`. The code
here is merely an example of how to implement such a flag.
In such cases, you need two concepts: eager parameters and a callback. An
eager parameter is a parameter that is handled before others, and a
callback is what executes after the parameter is handled. The eagerness
is necessary so that an earlier required parameter does not produce an
error message. For instance, if ``--version`` was not eager and a
parameter ``--foo`` was required and defined before, you would need to
specify it for ``--version`` to work. For more information, see
:ref:`callback-evaluation-order`.
A callback is a function that is invoked with two parameters: the current
:class:`Context` and the value. The context provides some useful features
such as quitting the application and gives access to other already
processed parameters.
Here an example for a ``--version`` flag:
.. click:example::
def print_version(ctx, param, value):
if not value or ctx.resilient_parsing:
return
click.echo('Version 1.0')
ctx.exit()
@click.command()
@click.option('--version', is_flag=True, callback=print_version,
expose_value=False, is_eager=True)
def hello():
click.echo('Hello World!')
The `expose_value` parameter prevents the pretty pointless ``version``
parameter from being passed to the callback. If that was not specified, a
boolean would be passed to the `hello` script. The `resilient_parsing`
flag is applied to the context if Click wants to parse the command line
without any destructive behavior that would change the execution flow. In
this case, because we would exit the program, we instead do nothing.
What it looks like:
.. click:run::
invoke(hello)
invoke(hello, args=['--version'])
.. admonition:: Callback Signature Changes
In Click 2.0 the signature for callbacks changed. For more
information about these changes see :ref:`upgrade-to-2.0`.
Yes Parameters
--------------
For dangerous operations, it's very useful to be able to ask a user for
confirmation. This can be done by adding a boolean ``--yes`` flag and
asking for confirmation if the user did not provide it and to fail in a
callback:
.. click:example::
def abort_if_false(ctx, param, value):
if not value:
ctx.abort()
@click.command()
@click.option('--yes', is_flag=True, callback=abort_if_false,
expose_value=False,
prompt='Are you sure you want to drop the db?')
def dropdb():
click.echo('Dropped all tables!')
And what it looks like on the command line:
.. click:run::
invoke(dropdb, input=['n'])
invoke(dropdb, args=['--yes'])
Because this combination of parameters is quite common, this can also be
replaced with the :func:`confirmation_option` decorator:
.. click:example::
@click.command()
@click.confirmation_option(prompt='Are you sure you want to drop the db?')
def dropdb():
click.echo('Dropped all tables!')
.. admonition:: Callback Signature Changes
In Click 2.0 the signature for callbacks changed. For more
information about these changes see :ref:`upgrade-to-2.0`.
Values from Environment Variables
---------------------------------
A very useful feature of Click is the ability to accept parameters from
environment variables in addition to regular parameters. This allows
tools to be automated much easier. For instance, you might want to pass
a configuration file with a ``--config`` parameter but also support exporting
a ``TOOL_CONFIG=hello.cfg`` key-value pair for a nicer development
experience.
This is supported by Click in two ways. One is to automatically build
environment variables which is supported for options only. To enable this
feature, the ``auto_envvar_prefix`` parameter needs to be passed to the
script that is invoked. Each command and parameter is then added as an
uppercase underscore-separated variable. If you have a subcommand
called ``foo`` taking an option called ``bar`` and the prefix is
``MY_TOOL``, then the variable is ``MY_TOOL_FOO_BAR``.
Example usage:
.. click:example::
@click.command()
@click.option('--username')
def greet(username):
click.echo('Hello %s!' % username)
if __name__ == '__main__':
greet(auto_envvar_prefix='GREETER')
And from the command line:
.. click:run::
invoke(greet, env={'GREETER_USERNAME': 'john'},
auto_envvar_prefix='GREETER')
When using ``auto_envvar_prefix`` with command groups, the command name needs
to be included in the environment variable, between the prefix and the parameter name, *i.e.* *PREFIX_COMMAND_VARIABLE*.
Example:
.. click:example::
@click.group()
@click.option('--debug/--no-debug')
def cli(debug):
click.echo('Debug mode is %s' % ('on' if debug else 'off'))
@cli.command()
@click.option('--username')
def greet(username):
click.echo('Hello %s!' % username)
if __name__ == '__main__':
cli(auto_envvar_prefix='GREETER')
.. click:run::
invoke(cli, args=['greet',],
env={'GREETER_GREET_USERNAME': 'John', 'GREETER_DEBUG': 'false'},
auto_envvar_prefix='GREETER')
The second option is to manually pull values in from specific environment
variables by defining the name of the environment variable on the option.
Example usage:
.. click:example::
@click.command()
@click.option('--username', envvar='USERNAME')
def greet(username):
click.echo('Hello %s!' % username)
if __name__ == '__main__':
greet()
And from the command line:
.. click:run::
invoke(greet, env={'USERNAME': 'john'})
In that case it can also be a list of different environment variables
where the first one is picked.
Multiple Values from Environment Values
---------------------------------------
As options can accept multiple values, pulling in such values from
environment variables (which are strings) is a bit more complex. The way
Click solves this is by leaving it up to the type to customize this
behavior. For both ``multiple`` and ``nargs`` with values other than
``1``, Click will invoke the :meth:`ParamType.split_envvar_value` method to
perform the splitting.
The default implementation for all types is to split on whitespace. The
exceptions to this rule are the :class:`File` and :class:`Path` types
which both split according to the operating system's path splitting rules.
On Unix systems like Linux and OS X, the splitting happens for those on
every colon (``:``), and for Windows, on every semicolon (``;``).
Example usage:
.. click:example::
@click.command()
@click.option('paths', '--path', envvar='PATHS', multiple=True,
type=click.Path())
def perform(paths):
for path in paths:
click.echo(path)
if __name__ == '__main__':
perform()
And from the command line:
.. click:run::
import os
invoke(perform, env={'PATHS': './foo/bar%s./test' % os.path.pathsep})
Other Prefix Characters
-----------------------
Click can deal with alternative prefix characters other than ``-`` for
options. This is for instance useful if you want to handle slashes as
parameters ``/`` or something similar. Note that this is strongly
discouraged in general because Click wants developers to stay close to
POSIX semantics. However in certain situations this can be useful:
.. click:example::
@click.command()
@click.option('+w/-w')
def chmod(w):
click.echo('writable=%s' % w)
if __name__ == '__main__':
chmod()
And from the command line:
.. click:run::
invoke(chmod, args=['+w'])
invoke(chmod, args=['-w'])
Note that if you are using ``/`` as prefix character and you want to use a
boolean flag you need to separate it with ``;`` instead of ``/``:
.. click:example::
@click.command()
@click.option('/debug;/no-debug')
def log(debug):
click.echo('debug=%s' % debug)
if __name__ == '__main__':
log()
.. _ranges:
Range Options
-------------
A special mention should go to the :class:`IntRange` type, which works very
similarly to the :data:`INT` type, but restricts the value to fall into a
specific range (inclusive on both edges). It has two modes:
- the default mode (non-clamping mode) where a value that falls outside
of the range will cause an error.
- an optional clamping mode where a value that falls outside of the
range will be clamped. This means that a range of ``0-5`` would
return ``5`` for the value ``10`` or ``0`` for the value ``-1`` (for
example).
Example:
.. click:example::
@click.command()
@click.option('--count', type=click.IntRange(0, 20, clamp=True))
@click.option('--digit', type=click.IntRange(0, 10))
def repeat(count, digit):
click.echo(str(digit) * count)
if __name__ == '__main__':
repeat()
And from the command line:
.. click:run::
invoke(repeat, args=['--count=1000', '--digit=5'])
invoke(repeat, args=['--count=1000', '--digit=12'])
If you pass ``None`` for any of the edges, it means that the range is open
at that side.
Callbacks for Validation
------------------------
.. versionchanged:: 2.0
If you want to apply custom validation logic, you can do this in the
parameter callbacks. These callbacks can both modify values as well as
raise errors if the validation does not work.
In Click 1.0, you can only raise the :exc:`UsageError` but starting with
Click 2.0, you can also raise the :exc:`BadParameter` error, which has the
added advantage that it will automatically format the error message to
also contain the parameter name.
Example:
.. click:example::
def validate_rolls(ctx, param, value):
try:
rolls, dice = map(int, value.split('d', 2))
return (dice, rolls)
except ValueError:
raise click.BadParameter('rolls need to be in format NdM')
@click.command()
@click.option('--rolls', callback=validate_rolls, default='1d6')
def roll(rolls):
click.echo('Rolling a %d-sided dice %d time(s)' % rolls)
if __name__ == '__main__':
roll()
And what it looks like:
.. click:run::
invoke(roll, args=['--rolls=42'])
println()
invoke(roll, args=['--rolls=2d12'])
Click-7.0/docs/parameters.rst 0000644 0001750 0001750 00000011256 13351570514 016443 0 ustar david david 0000000 0000000 Parameters
==========
.. currentmodule:: click
Click supports two types of parameters for scripts: options and arguments.
There is generally some confusion among authors of command line scripts of
when to use which, so here is a quick overview of the differences. As its
name indicates, an option is optional. While arguments can be optional
within reason, they are much more restricted in how optional they can be.
To help you decide between options and arguments, the recommendation is
to use arguments exclusively for things like going to subcommands or input
filenames / URLs, and have everything else be an option instead.
Differences
-----------
Arguments can do less than options. The following features are only
available for options:
* automatic prompting for missing input
* act as flags (boolean or otherwise)
* option values can be pulled from environment variables, arguments can not
* options are fully documented in the help page, arguments are not
(this is intentional as arguments might be too specific to be
automatically documented)
On the other hand arguments, unlike options, can accept an arbitrary number
of arguments. Options can strictly ever only accept a fixed number of
arguments (defaults to 1).
Parameter Types
---------------
Parameters can be of different types. Types can be implemented with
different behavior and some are supported out of the box:
``str`` / :data:`click.STRING`:
The default parameter type which indicates unicode strings.
``int`` / :data:`click.INT`:
A parameter that only accepts integers.
``float`` / :data:`click.FLOAT`:
A parameter that only accepts floating point values.
``bool`` / :data:`click.BOOL`:
A parameter that accepts boolean values. This is automatically used
for boolean flags. If used with string values ``1``, ``yes``, ``y``, ``t``
and ``true`` convert to `True` and ``0``, ``no``, ``n``, ``f`` and ``false``
convert to `False`.
:data:`click.UUID`:
A parameter that accepts UUID values. This is not automatically
guessed but represented as :class:`uuid.UUID`.
.. autoclass:: File
:noindex:
.. autoclass:: Path
:noindex:
.. autoclass:: Choice
:noindex:
.. autoclass:: IntRange
:noindex:
.. autoclass:: FloatRange
:noindex:
.. autoclass:: DateTime
:noindex:
Custom parameter types can be implemented by subclassing
:class:`click.ParamType`. For simple cases, passing a Python function that
fails with a `ValueError` is also supported, though discouraged.
.. _parameter_names:
Parameter Names
---------------
Parameters (both options and arguments) accept a number of positional arguments
which are passed to the command function as parameters. Each string with a
single dash is added as a short argument; each string starting with a double
dash as a long one.
If a string is added without any dashes, it becomes the internal parameter name
which is also used as variable name.
If all names for a parameter contain dashes, the internal name is generated
automatically by taking the longest argument and converting all dashes to
underscores.
The internal name is converted to lowercase.
Examples:
* For an option with ``('-f', '--foo-bar')``, the parameter name is `foo_bar`.
* For an option with ``('-x',)``, the parameter is `x`.
* For an option with ``('-f', '--filename', 'dest')``, the parameter name is `dest`.
* For an option with ``('--CamelCaseOption',)``, the parameter is `camelcaseoption`.
* For an arguments with ``(`foogle`)``, the parameter name is `foogle`. To
provide a different human readable name for use in help text, see the section
about :ref:`doc-meta-variables`.
Implementing Custom Types
-------------------------
To implement a custom type, you need to subclass the :class:`ParamType`
class. Types can be invoked with or without context and parameter object,
which is why they need to be able to deal with this.
The following code implements an integer type that accepts hex and octal
numbers in addition to normal integers, and converts them into regular
integers::
import click
class BasedIntParamType(click.ParamType):
name = 'integer'
def convert(self, value, param, ctx):
try:
if value[:2].lower() == '0x':
return int(value[2:], 16)
elif value[:1] == '0':
return int(value, 8)
return int(value, 10)
except ValueError:
self.fail('%s is not a valid integer' % value, param, ctx)
BASED_INT = BasedIntParamType()
As you can see, a subclass needs to implement the :meth:`ParamType.convert`
method and optionally provide the :attr:`ParamType.name` attribute. The
latter can be used for documentation purposes.
Click-7.0/docs/prompts.rst 0000644 0001750 0001750 00000003163 13351553367 016011 0 ustar david david 0000000 0000000 User Input Prompts
==================
.. currentmodule:: click
Click supports prompts in two different places. The first is automated
prompts when the parameter handling happens, and the second is to ask for
prompts at a later point independently.
This can be accomplished with the :func:`prompt` function, which asks for
valid input according to a type, or the :func:`confirm` function, which asks
for confirmation (yes/no).
Option Prompts
--------------
Option prompts are integrated into the option interface. See
:ref:`option-prompting` for more information. Internally, it
automatically calls either :func:`prompt` or :func:`confirm` as necessary.
Input Prompts
-------------
To manually ask for user input, you can use the :func:`prompt` function.
By default, it accepts any Unicode string, but you can ask for any other
type. For instance, you can ask for a valid integer::
value = click.prompt('Please enter a valid integer', type=int)
Additionally, the type will be determined automatically if a default value is
provided. For instance, the following will only accept floats::
value = click.prompt('Please enter a number', default=42.0)
Confirmation Prompts
--------------------
To ask if a user wants to continue with an action, the :func:`confirm`
function comes in handy. By default, it returns the result of the prompt
as a boolean value::
if click.confirm('Do you want to continue?'):
click.echo('Well done!')
There is also the option to make the function automatically abort the
execution of the program if it does not return ``True``::
click.confirm('Do you want to continue?', abort=True)
Click-7.0/docs/python3.rst 0000644 0001750 0001750 00000016710 13352517227 015707 0 ustar david david 0000000 0000000 Python 3 Support
================
.. currentmodule:: click
Click supports Python 3, but like all other command line utility libraries,
it suffers from the Unicode text model in Python 3. All examples in the
documentation were written so that they could run on both Python 2.x and
Python 3.4 or higher.
At the moment, it is strongly recommended to use Python 2 for Click
utilities unless Python 3 is a hard requirement.
.. _python3-limitations:
Python 3 Limitations
--------------------
At the moment, Click suffers from a few problems with Python 3:
* The command line in Unix traditionally is in bytes, not Unicode. While
there are encoding hints for all of this, there are generally some
situations where this can break. The most common one is SSH
connections to machines with different locales.
Misconfigured environments can currently cause a wide range of Unicode
problems in Python 3 due to the lack of support for roundtripping
surrogate escapes. This will not be fixed in Click itself!
For more information see :ref:`python3-surrogates`.
* Standard input and output in Python 3 is opened in Unicode mode by
default. Click has to reopen the stream in binary mode in certain
situations. Because there is no standardized way to do this, this
might not always work. Primarily this can become a problem when
testing command-line applications.
This is not supported::
sys.stdin = io.StringIO('Input here')
sys.stdout = io.StringIO()
Instead you need to do this::
input = 'Input here'
in_stream = io.BytesIO(input.encode('utf-8'))
sys.stdin = io.TextIOWrapper(in_stream, encoding='utf-8')
out_stream = io.BytesIO()
sys.stdout = io.TextIOWrapper(out_stream, encoding='utf-8')
Remember that in that case, you need to use ``out_stream.getvalue()``
and not ``sys.stdout.getvalue()`` if you want to access the buffer
contents as the wrapper will not forward that method.
Python 2 and 3 Differences
--------------------------
Click attempts to minimize the differences between Python 2 and Python 3
by following best practices for both languages.
In Python 2, the following is true:
* ``sys.stdin``, ``sys.stdout``, and ``sys.stderr`` are opened in binary
mode, but under some circumstances they support Unicode output. Click
attempts to not subvert this but provides support for forcing streams
to be Unicode-based.
* ``sys.argv`` is always byte-based. Click will pass bytes to all
input types and convert as necessary. The :class:`STRING` type
automatically will decode properly the input value into a string by
trying the most appropriate encodings.
* When dealing with files, Click will never go through the Unicode APIs
and will instead use the operating system's byte APIs to open the
files.
In Python 3, the following is true:
* ``sys.stdin``, ``sys.stdout`` and ``sys.stderr`` are by default
text-based. When Click needs a binary stream, it attempts to discover
the underlying binary stream. See :ref:`python3-limitations` for how
this works.
* ``sys.argv`` is always Unicode-based. This also means that the native
type for input values to the types in Click is Unicode, and not bytes.
This causes problems if the terminal is incorrectly set and Python
does not figure out the encoding. In that case, the Unicode string
will contain error bytes encoded as surrogate escapes.
* When dealing with files, Click will always use the Unicode file system
API calls by using the operating system's reported or guessed
filesystem encoding. Surrogates are supported for filenames, so it
should be possible to open files through the :class:`File` type even
if the environment is misconfigured.
.. _python3-surrogates:
Python 3 Surrogate Handling
---------------------------
Click in Python 3 does all the Unicode handling in the standard library
and is subject to its behavior. In Python 2, Click does all the Unicode
handling itself, which means there are differences in error behavior.
The most glaring difference is that in Python 2, Unicode will "just work",
while in Python 3, it requires extra care. The reason for this is that in
Python 3, the encoding detection is done in the interpreter, and on Linux
and certain other operating systems, its encoding handling is problematic.
The biggest source of frustration is that Click scripts invoked by
init systems (sysvinit, upstart, systemd, etc.), deployment tools (salt,
puppet), or cron jobs (cron) will refuse to work unless a Unicode locale is
exported.
If Click encounters such an environment it will prevent further execution
to force you to set a locale. This is done because Click cannot know
about the state of the system once it's invoked and restore the values
before Python's Unicode handling kicked in.
If you see something like this error in Python 3::
Traceback (most recent call last):
...
RuntimeError: Click will abort further execution because Python 3 was
configured to use ASCII as encoding for the environment. Either switch
to Python 2 or consult the Python 3 section of the docs for
mitigation steps.
You are dealing with an environment where Python 3 thinks you are
restricted to ASCII data. The solution to these problems is different
depending on which locale your computer is running in.
For instance, if you have a German Linux machine, you can fix the problem
by exporting the locale to ``de_DE.utf-8``::
export LC_ALL=de_DE.utf-8
export LANG=de_DE.utf-8
If you are on a US machine, ``en_US.utf-8`` is the encoding of choice. On
some newer Linux systems, you could also try ``C.UTF-8`` as the locale::
export LC_ALL=C.UTF-8
export LANG=C.UTF-8
On some systems it was reported that `UTF-8` has to be written as `UTF8`
and vice versa. To see which locales are supported you can invoke
``locale -a``::
locale -a
You need to do this before you invoke your Python script. If you are
curious about the reasons for this, you can join the discussions in the
Python 3 bug tracker:
* `ASCII is a bad filesystem default encoding
`_
* `Use surrogateescape as default error handler
`_
* `Python 3 raises Unicode errors in the C locale
`_
* `LC_CTYPE=C: pydoc leaves terminal in an unusable state
`_ (this is relevant to Click
because the pager support is provided by the stdlib pydoc module)
Unicode Literals
----------------
Starting with Click 5.0 there will be a warning for the use of the
``unicode_literals`` future import in Python 2. This has been done due to
the negative consequences of this import with regards to unintentionally
causing bugs due to introducing Unicode data to APIs that are incapable of
handling them. For some examples of this issue, see the discussion on
this github issue: `python-future#22
`_.
If you use ``unicode_literals`` in any file that defines a Click command
or that invokes a click command you will be given a warning. You are
strongly encouraged to not use ``unicode_literals`` and instead use
explicit ``u`` prefixes for your Unicode strings.
If you do want to ignore the warning and continue using
``unicode_literals`` on your own peril, you can disable the warning as
follows::
import click
click.disable_unicode_literals_warning = True
Click-7.0/docs/quickstart.rst 0000644 0001750 0001750 00000021716 13351570514 016474 0 ustar david david 0000000 0000000 Quickstart
==========
.. currentmodule:: click
You can get the library directly from PyPI::
pip install click
The installation into a :ref:`virtualenv` is heavily recommended.
.. _virtualenv:
virtualenv
----------
Virtualenv is probably what you want to use for developing Click
applications.
What problem does virtualenv solve? Chances are that you want to use it
for other projects besides your Click script. But the more projects you
have, the more likely it is that you will be working with different
versions of Python itself, or at least different versions of Python
libraries. Let's face it: quite often libraries break backwards
compatibility, and it's unlikely that any serious application will have
zero dependencies. So what do you do if two or more of your projects have
conflicting dependencies?
Virtualenv to the rescue! Virtualenv enables multiple side-by-side
installations of Python, one for each project. It doesn't actually
install separate copies of Python, but it does provide a clever way to
keep different project environments isolated. Let's see how virtualenv
works.
If you are on Mac OS X or Linux, chances are that one of the following two
commands will work for you::
$ sudo easy_install virtualenv
or even better::
$ sudo pip install virtualenv
One of these will probably install virtualenv on your system. Maybe it's even
in your package manager. If you use Ubuntu, try::
$ sudo apt-get install python-virtualenv
If you are on Windows (or none of the above methods worked) you must install
``pip`` first. For more information about this, see `installing pip`_.
Once you have it installed, run the ``pip`` command from above, but without
the `sudo` prefix.
.. _installing pip: https://pip.readthedocs.io/en/latest/installing.html
Once you have virtualenv installed, just fire up a shell and create
your own environment. I usually create a project folder and a `venv`
folder within::
$ mkdir myproject
$ cd myproject
$ virtualenv venv
New python executable in venv/bin/python
Installing setuptools, pip............done.
Now, whenever you want to work on a project, you only have to activate the
corresponding environment. On OS X and Linux, do the following::
$ . venv/bin/activate
If you are a Windows user, the following command is for you::
$ venv\scripts\activate
Either way, you should now be using your virtualenv (notice how the prompt of
your shell has changed to show the active environment).
And if you want to go back to the real world, use the following command::
$ deactivate
After doing this, the prompt of your shell should be as familiar as before.
Now, let's move on. Enter the following command to get Click activated in your
virtualenv::
$ pip install Click
A few seconds later and you are good to go.
Screencast and Examples
-----------------------
There is a screencast available which shows the basic API of Click and
how to build simple applications with it. It also explores how to build
commands with subcommands.
* `Building Command Line Applications with Click
`_
Examples of Click applications can be found in the documentation as well
as in the GitHub repository together with readme files:
* ``inout``: `File input and output
`_
* ``naval``: `Port of docopt naval example
`_
* ``aliases``: `Command alias example
`_
* ``repo``: `Git-/Mercurial-like command line interface
`_
* ``complex``: `Complex example with plugin loading
`_
* ``validation``: `Custom parameter validation example
`_
* ``colors``: `Colorama ANSI color support
`_
* ``termui``: `Terminal UI functions demo
`_
* ``imagepipe``: `Multi command chaining demo
`_
Basic Concepts - Creating a Command
-----------------------------------
Click is based on declaring commands through decorators. Internally, there
is a non-decorator interface for advanced use cases, but it's discouraged
for high-level usage.
A function becomes a Click command line tool by decorating it through
:func:`click.command`. At its simplest, just decorating a function
with this decorator will make it into a callable script:
.. click:example::
import click
@click.command()
def hello():
click.echo('Hello World!')
What's happening is that the decorator converts the function into a
:class:`Command` which then can be invoked::
if __name__ == '__main__':
hello()
And what it looks like:
.. click:run::
invoke(hello, args=[], prog_name='python hello.py')
And the corresponding help page:
.. click:run::
invoke(hello, args=['--help'], prog_name='python hello.py')
Echoing
-------
Why does this example use :func:`echo` instead of the regular
:func:`print` function? The answer to this question is that Click
attempts to support both Python 2 and Python 3 the same way and to be very
robust even when the environment is misconfigured. Click wants to be
functional at least on a basic level even if everything is completely
broken.
What this means is that the :func:`echo` function applies some error
correction in case the terminal is misconfigured instead of dying with an
:exc:`UnicodeError`.
As an added benefit, starting with Click 2.0, the echo function also
has good support for ANSI colors. It will automatically strip ANSI codes
if the output stream is a file and if colorama is supported, ANSI colors
will also work on Windows. Note that in Python 2, the :func:`echo` function
does not parse color code information from bytearrays. See :ref:`ansi-colors`
for more information.
If you don't need this, you can also use the `print()` construct /
function.
Nesting Commands
----------------
Commands can be attached to other commands of type :class:`Group`. This
allows arbitrary nesting of scripts. As an example here is a script that
implements two commands for managing databases:
.. click:example::
@click.group()
def cli():
pass
@click.command()
def initdb():
click.echo('Initialized the database')
@click.command()
def dropdb():
click.echo('Dropped the database')
cli.add_command(initdb)
cli.add_command(dropdb)
As you can see, the :func:`group` decorator works like the :func:`command`
decorator, but creates a :class:`Group` object instead which can be given
multiple subcommands that can be attached with :meth:`Group.add_command`.
For simple scripts, it's also possible to automatically attach and create a
command by using the :meth:`Group.command` decorator instead. The above
script can instead be written like this:
.. click:example::
@click.group()
def cli():
pass
@cli.command()
def initdb():
click.echo('Initialized the database')
@cli.command()
def dropdb():
click.echo('Dropped the database')
You would then invoke the :class:`Group` in your setuptools entry points or
other invocations::
if __name__ == '__main__':
cli()
Adding Parameters
-----------------
To add parameters, use the :func:`option` and :func:`argument` decorators:
.. click:example::
@click.command()
@click.option('--count', default=1, help='number of greetings')
@click.argument('name')
def hello(count, name):
for x in range(count):
click.echo('Hello %s!' % name)
What it looks like:
.. click:run::
invoke(hello, args=['--help'], prog_name='python hello.py')
.. _switching-to-setuptools:
Switching to Setuptools
-----------------------
In the code you wrote so far there is a block at the end of the file which
looks like this: ``if __name__ == '__main__':``. This is traditionally
how a standalone Python file looks like. With Click you can continue
doing that, but there are better ways through setuptools.
There are two main (and many more) reasons for this:
The first one is that setuptools automatically generates executable
wrappers for Windows so your command line utilities work on Windows too.
The second reason is that setuptools scripts work with virtualenv on Unix
without the virtualenv having to be activated. This is a very useful
concept which allows you to bundle your scripts with all requirements into
a virtualenv.
Click is perfectly equipped to work with that and in fact the rest of the
documentation will assume that you are writing applications through
setuptools.
I strongly recommend to have a look at the :ref:`setuptools-integration`
chapter before reading the rest as the examples assume that you will
be using setuptools.
Click-7.0/docs/requirements.txt 0000644 0001750 0001750 00000000053 13352433170 017020 0 ustar david david 0000000 0000000 Sphinx~=1.8.0
Pallets-Sphinx-Themes~=1.1.0
Click-7.0/docs/setuptools.rst 0000644 0001750 0001750 00000010114 13351553406 016512 0 ustar david david 0000000 0000000 .. _setuptools-integration:
Setuptools Integration
======================
When writing command line utilities, it's recommended to write them as
modules that are distributed with setuptools instead of using Unix
shebangs.
Why would you want to do that? There are a bunch of reasons:
1. One of the problems with the traditional approach is that the first
module the Python interpreter loads has an incorrect name. This might
sound like a small issue but it has quite significant implications.
The first module is not called by its actual name, but the
interpreter renames it to ``__main__``. While that is a perfectly
valid name it means that if another piece of code wants to import from
that module it will trigger the import a second time under its real
name and all of a sudden your code is imported twice.
2. Not on all platforms are things that easy to execute. On Linux and OS
X you can add a comment to the beginning of the file (``#!/usr/bin/env
python``) and your script works like an executable (assuming it has
the executable bit set). This however does not work on Windows.
While on Windows you can associate interpreters with file extensions
(like having everything ending in ``.py`` execute through the Python
interpreter) you will then run into issues if you want to use the
script in a virtualenv.
In fact running a script in a virtualenv is an issue with OS X and
Linux as well. With the traditional approach you need to have the
whole virtualenv activated so that the correct Python interpreter is
used. Not very user friendly.
3. The main trick only works if the script is a Python module. If your
application grows too large and you want to start using a package you
will run into issues.
Introduction
------------
To bundle your script with setuptools, all you need is the script in a
Python package and a ``setup.py`` file.
Imagine this directory structure::
yourscript.py
setup.py
Contents of ``yourscript.py``:
.. click:example::
import click
@click.command()
def cli():
"""Example script."""
click.echo('Hello World!')
Contents of ``setup.py``::
from setuptools import setup
setup(
name='yourscript',
version='0.1',
py_modules=['yourscript'],
install_requires=[
'Click',
],
entry_points='''
[console_scripts]
yourscript=yourscript:cli
''',
)
The magic is in the ``entry_points`` parameter. Below
``console_scripts``, each line identifies one console script. The first
part before the equals sign (``=``) is the name of the script that should
be generated, the second part is the import path followed by a colon
(``:``) with the Click command.
That's it.
Testing The Script
------------------
To test the script, you can make a new virtualenv and then install your
package::
$ virtualenv venv
$ . venv/bin/activate
$ pip install --editable .
Afterwards, your command should be available:
.. click:run::
invoke(cli, prog_name='yourscript')
Scripts in Packages
-------------------
If your script is growing and you want to switch over to your script being
contained in a Python package the changes necessary are minimal. Let's
assume your directory structure changed to this::
yourpackage/
__init__.py
main.py
utils.py
scripts/
__init__.py
yourscript.py
In this case instead of using ``py_modules`` in your ``setup.py`` file you
can use ``packages`` and the automatic package finding support of
setuptools. In addition to that it's also recommended to include other
package data.
These would be the modified contents of ``setup.py``::
from setuptools import setup, find_packages
setup(
name='yourpackage',
version='0.1',
packages=find_packages(),
include_package_data=True,
install_requires=[
'Click',
],
entry_points='''
[console_scripts]
yourscript=yourpackage.scripts.yourscript:cli
''',
)
Click-7.0/docs/testing.rst 0000644 0001750 0001750 00000007244 13351570514 015757 0 ustar david david 0000000 0000000 Testing Click Applications
==========================
.. currentmodule:: click.testing
For basic testing, Click provides the :mod:`click.testing` module which
provides test functionality that helps you invoke command line
applications and check their behavior.
These tools should really only be used for testing as they change
the entire interpreter state for simplicity and are not in any way
thread-safe!
Basic Testing
-------------
The basic functionality for testing Click applications is the
:class:`CliRunner` which can invoke commands as command line scripts. The
:meth:`CliRunner.invoke` method runs the command line script in isolation
and captures the output as both bytes and binary data.
The return value is a :class:`Result` object, which has the captured output
data, exit code, and optional exception attached.
Example::
import click
from click.testing import CliRunner
def test_hello_world():
@click.command()
@click.argument('name')
def hello(name):
click.echo('Hello %s!' % name)
runner = CliRunner()
result = runner.invoke(hello, ['Peter'])
assert result.exit_code == 0
assert result.output == 'Hello Peter!\n'
For subcommand testing, a subcommand name must be specified in the `args` parameter of :meth:`CliRunner.invoke` method.
Example::
import click
from click.testing import CliRunner
def test_sync():
@click.group()
@click.option('--debug/--no-debug', default=False)
def cli(debug):
click.echo('Debug mode is %s' % ('on' if debug else 'off'))
@cli.command()
def sync():
click.echo('Syncing')
runner = CliRunner()
result = runner.invoke(cli, ['--debug', 'sync'])
assert result.exit_code == 0
assert 'Debug mode is on' in result.output
assert 'Syncing' in result.output
Additional keyword arguments passed to ``.invoke()`` will be used to construct the initial Context object. For example, if you want to run your tests against a fixed terminal width you can use the following::
runner = CliRunner()
result = runner.invoke(cli, ['--debug', 'sync'], terminal_width=60)
File System Isolation
---------------------
For basic command line tools that want to operate with the file system, the
:meth:`CliRunner.isolated_filesystem` method comes in useful which sets up
an empty folder and changes the current working directory to.
Example::
import click
from click.testing import CliRunner
def test_cat():
@click.command()
@click.argument('f', type=click.File())
def cat(f):
click.echo(f.read())
runner = CliRunner()
with runner.isolated_filesystem():
with open('hello.txt', 'w') as f:
f.write('Hello World!')
result = runner.invoke(cat, ['hello.txt'])
assert result.exit_code == 0
assert result.output == 'Hello World!\n'
Input Streams
-------------
The test wrapper can also be used to provide input data for the input
stream (stdin). This is very useful for testing prompts, for instance::
import click
from click.testing import CliRunner
def test_prompts():
@click.command()
@click.option('--foo', prompt=True)
def test(foo):
click.echo('foo=%s' % foo)
runner = CliRunner()
result = runner.invoke(test, input='wau wau\n')
assert not result.exception
assert result.output == 'Foo: wau wau\nfoo=wau wau\n'
Note that prompts will be emulated so that they write the input data to
the output stream as well. If hidden input is expected then this
obviously does not happen.
Click-7.0/docs/upgrading.rst 0000644 0001750 0001750 00000007264 13351570514 016264 0 ustar david david 0000000 0000000 Upgrading To Newer Releases
===========================
Click attempts the highest level of backwards compatibility but sometimes
this is not entirely possible. In case we need to break backwards
compatibility this document gives you information about how to upgrade or
handle backwards compatibility properly.
.. _upgrade-to-3.2:
Upgrading to 3.2
----------------
Click 3.2 had to perform two changes to multi commands which were
triggered by a change between Click 2 and Click 3 that had bigger
consequences than anticipated.
Context Invokes
```````````````
Click 3.2 contains a fix for the :meth:`Context.invoke` function when used
with other commands. The original intention of this function was to
invoke the other command as as if it came from the command line when it
was passed a context object instead of a function. This use was only
documented in a single place in the documentation before and there was no
proper explanation for the method in the API documentation.
The core issue is that before 3.2 this call worked against intentions::
ctx.invoke(other_command, 'arg1', 'arg2')
This was never intended to work as it does not allow Click to operate on
the parameters. Given that this pattern was never documented and ill
intended the decision was made to change this behavior in a bugfix release
before it spreads by accident and developers depend on it.
The correct invocation for the above command is the following::
ctx.invoke(other_command, name_of_arg1='arg1', name_of_arg2='arg2')
This also allowed us to fix the issue that defaults were not handled
properly by this function.
Multicommand Chaining API
`````````````````````````
Click 3 introduced multicommand chaining. This required a change in how
Click internally dispatches. Unfortunately this change was not correctly
implemented and it appeared that it was possible to provide an API that
can inform the super command about all the subcommands that will be
invoked.
This assumption however does not work with one of the API guarantees that
have been given in the past. As such this functionality has been removed
in 3.2 as it was already broken. Instead the accidentally broken
functionality of the :attr:`Context.invoked_subcommand` attribute was
restored.
If you do require the know which exact commands will be invoked there are
different ways to cope with this. The first one is to let the subcommands
all return functions and then to invoke the functions in a
:meth:`Context.resultcallback`.
.. _upgrade-to-2.0:
Upgrading to 2.0
----------------
Click 2.0 has one breaking change which is the signature for parameter
callbacks. Before 2.0, the callback was invoked with ``(ctx, value)``
whereas now it's ``(ctx, param, value)``. This change was necessary as it
otherwise made reusing callbacks too complicated.
To ease the transition Click will still accept old callbacks. Starting
with Click 3.0 it will start to issue a warning to stderr to encourage you
to upgrade.
In case you want to support both Click 1.0 and Click 2.0, you can make a
simple decorator that adjusts the signatures::
import click
from functools import update_wrapper
def compatcallback(f):
# Click 1.0 does not have a version string stored, so we need to
# use getattr here to be safe.
if getattr(click, '__version__', '0.0') >= '2.0':
return f
return update_wrapper(lambda ctx, value: f(ctx, None, value), f)
With that helper you can then write something like this::
@compatcallback
def callback(ctx, param, value):
return value.upper()
Note that because Click 1.0 did not pass a parameter, the `param` argument
here would be `None`, so a compatibility callback could not use that
argument.
Click-7.0/docs/utils.rst 0000644 0001750 0001750 00000031737 13352517227 015451 0 ustar david david 0000000 0000000 Utilities
=========
.. currentmodule:: click
Besides the functionality that Click provides to interface with argument
parsing and handling, it also provides a bunch of addon functionality that
is useful for writing command line utilities.
Printing to Stdout
------------------
The most obvious helper is the :func:`echo` function, which in many ways
works like the Python ``print`` statement or function. The main difference is
that it works the same in Python 2 and 3, it intelligently detects
misconfigured output streams, and it will never fail (except in Python 3; for
more information see :ref:`python3-limitations`).
Example::
import click
click.echo('Hello World!')
Most importantly, it can print both Unicode and binary data, unlike the
built-in ``print`` function in Python 3, which cannot output any bytes. It
will, however, emit a trailing newline by default, which needs to be
suppressed by passing ``nl=False``::
click.echo(b'\xe2\x98\x83', nl=False)
Last but not least :func:`echo` uses click's intelligent internal output
streams to stdout and stderr which support unicode output on the Windows
console. This means for as long as you are using `click.echo` you can
output unicode character (there are some limitations on the default font
with regards to which characters can be displayed). This functionality is
new in Click 6.0.
.. versionadded:: 6.0
Click now emulates output streams on Windows to support unicode to the
Windows console through separate APIs. For more information see
:doc:`wincmd`.
.. versionadded:: 3.0
Starting with Click 3.0 you can also easily print to standard error by
passing ``err=True``::
click.echo('Hello World!', err=True)
.. _ansi-colors:
ANSI Colors
-----------
.. versionadded:: 2.0
Starting with Click 2.0, the :func:`echo` function gained extra
functionality to deal with ANSI colors and styles. Note that on Windows,
this functionality is only available if `colorama`_ is installed. If it
is installed, then ANSI codes are intelligently handled. Note that in Python
2, the echo function doesn't parse color code information from bytearrays.
Primarily this means that:
- Click's :func:`echo` function will automatically strip ANSI color codes
if the stream is not connected to a terminal.
- the :func:`echo` function will transparently connect to the terminal on
Windows and translate ANSI codes to terminal API calls. This means
that colors will work on Windows the same way they do on other
operating systems.
Note for `colorama` support: Click will automatically detect when `colorama`
is available and use it. Do *not* call ``colorama.init()``!
To install `colorama`, run this command::
$ pip install colorama
For styling a string, the :func:`style` function can be used::
import click
click.echo(click.style('Hello World!', fg='green'))
click.echo(click.style('Some more text', bg='blue', fg='white'))
click.echo(click.style('ATTENTION', blink=True, bold=True))
The combination of :func:`echo` and :func:`style` is also available in
a single function called :func:`secho`::
click.secho('Hello World!', fg='green')
click.secho('Some more text', bg='blue', fg='white')
click.secho('ATTENTION', blink=True, bold=True)
.. _colorama: https://pypi.org/project/colorama/
Pager Support
-------------
In some situations, you might want to show long texts on the terminal and
let a user scroll through it. This can be achieved by using the
:func:`echo_via_pager` function which works similarly to the :func:`echo`
function, but always writes to stdout and, if possible, through a pager.
Example:
.. click:example::
@click.command()
def less():
click.echo_via_pager('\n'.join('Line %d' % idx
for idx in range(200)))
If you want to use the pager for a lot of text, especially if generating everything in advance would take a lot of time, you can pass a generator (or generator function) instead of a string:
.. click:example::
def _generate_output():
for idx in range(50000):
yield "Line %d\n" % idx
@click.command()
def less():
click.echo_via_pager(_generate_output())
Screen Clearing
---------------
.. versionadded:: 2.0
To clear the terminal screen, you can use the :func:`clear` function that
is provided starting with Click 2.0. It does what the name suggests: it
clears the entire visible screen in a platform-agnostic way:
::
import click
click.clear()
Getting Characters from Terminal
--------------------------------
.. versionadded:: 2.0
Normally, when reading input from the terminal, you would read from
standard input. However, this is buffered input and will not show up until
the line has been terminated. In certain circumstances, you might not want
to do that and instead read individual characters as they are being written.
For this, Click provides the :func:`getchar` function which reads a single
character from the terminal buffer and returns it as a Unicode character.
Note that this function will always read from the terminal, even if stdin
is instead a pipe.
Example::
import click
click.echo('Continue? [yn] ', nl=False)
c = click.getchar()
click.echo()
if c == 'y':
click.echo('We will go on')
elif c == 'n':
click.echo('Abort!')
else:
click.echo('Invalid input :(')
Note that this reads raw input, which means that things like arrow keys
will show up in the platform's native escape format. The only characters
translated are ``^C`` and ``^D`` which are converted into keyboard
interrupts and end of file exceptions respectively. This is done because
otherwise, it's too easy to forget about that and to create scripts that
cannot be properly exited.
Waiting for Key Press
---------------------
.. versionadded:: 2.0
Sometimes, it's useful to pause until the user presses any key on the
keyboard. This is especially useful on Windows where ``cmd.exe`` will
close the window at the end of the command execution by default, instead
of waiting.
In click, this can be accomplished with the :func:`pause` function. This
function will print a quick message to the terminal (which can be
customized) and wait for the user to press a key. In addition to that,
it will also become a NOP (no operation instruction) if the script is not
run interactively.
Example::
import click
click.pause()
Launching Editors
-----------------
.. versionadded:: 2.0
Click supports launching editors automatically through :func:`edit`. This
is very useful for asking users for multi-line input. It will
automatically open the user's defined editor or fall back to a sensible
default. If the user closes the editor without saving, the return value
will be `None` otherwise the entered text.
Example usage::
import click
def get_commit_message():
MARKER = '# Everything below is ignored\n'
message = click.edit('\n\n' + MARKER)
if message is not None:
return message.split(MARKER, 1)[0].rstrip('\n')
Alternatively, the function can also be used to launch editors for files by
a specific filename. In this case, the return value is always `None`.
Example usage::
import click
click.edit(filename='/etc/passwd')
Launching Applications
----------------------
.. versionadded:: 2.0
Click supports launching applications through :func:`launch`. This can be
used to open the default application associated with a URL or filetype.
This can be used to launch web browsers or picture viewers, for instance.
In addition to this, it can also launch the file manager and automatically
select the provided file.
Example usage::
click.launch("https://click.palletsprojects.com/")
click.launch("/my/downloaded/file.txt", locate=True)
Printing Filenames
------------------
Because filenames might not be Unicode, formatting them can be a bit
tricky. Generally, this is easier in Python 2 than on 3, as you can just
write the bytes to stdout with the ``print`` function, but in Python 3, you
will always need to operate in Unicode.
The way this works with click is through the :func:`format_filename`
function. It does a best-effort conversion of the filename to Unicode and
will never fail. This makes it possible to use these filenames in the
context of a full Unicode string.
Example::
click.echo('Path: %s' % click.format_filename(b'foo.txt'))
Standard Streams
----------------
For command line utilities, it's very important to get access to input and
output streams reliably. Python generally provides access to these
streams through ``sys.stdout`` and friends, but unfortunately, there are
API differences between 2.x and 3.x, especially with regards to how these
streams respond to Unicode and binary data.
Because of this, click provides the :func:`get_binary_stream` and
:func:`get_text_stream` functions, which produce consistent results with
different Python versions and for a wide variety of terminal configurations.
The end result is that these functions will always return a functional
stream object (except in very odd cases in Python 3; see
:ref:`python3-limitations`).
Example::
import click
stdin_text = click.get_text_stream('stdin')
stdout_binary = click.get_binary_stream('stdout')
.. versionadded:: 6.0
Click now emulates output streams on Windows to support unicode to the
Windows console through separate APIs. For more information see
:doc:`wincmd`.
Intelligent File Opening
------------------------
.. versionadded:: 3.0
Starting with Click 3.0 the logic for opening files from the :class:`File`
type is exposed through the :func:`open_file` function. It can
intelligently open stdin/stdout as well as any other file.
Example::
import click
stdout = click.open_file('-', 'w')
test_file = click.open_file('test.txt', 'w')
If stdin or stdout are returned, the return value is wrapped in a special
file where the context manager will prevent the closing of the file. This
makes the handling of standard streams transparent and you can always use
it like this::
with click.open_file(filename, 'w') as f:
f.write('Hello World!\n')
Finding Application Folders
---------------------------
.. versionadded:: 2.0
Very often, you want to open a configuration file that belongs to your
application. However, different operating systems store these configuration
files in different locations depending on their standards. Click provides
a :func:`get_app_dir` function which returns the most appropriate location
for per-user config files for your application depending on the OS.
Example usage::
import os
import click
import ConfigParser
APP_NAME = 'My Application'
def read_config():
cfg = os.path.join(click.get_app_dir(APP_NAME), 'config.ini')
parser = ConfigParser.RawConfigParser()
parser.read([cfg])
rv = {}
for section in parser.sections():
for key, value in parser.items(section):
rv['%s.%s' % (section, key)] = value
return rv
Showing Progress Bars
---------------------
.. versionadded:: 2.0
Sometimes, you have command line scripts that need to process a lot of data,
but you want to quickly show the user some progress about how long that
will take. Click supports simple progress bar rendering for that through
the :func:`progressbar` function.
The basic usage is very simple: the idea is that you have an iterable that
you want to operate on. For each item in the iterable it might take some
time to do processing. So say you have a loop like this::
for user in all_the_users_to_process:
modify_the_user(user)
To hook this up with an automatically updating progress bar, all you need
to do is to change the code to this::
import click
with click.progressbar(all_the_users_to_process) as bar:
for user in bar:
modify_the_user(user)
Click will then automatically print a progress bar to the terminal and
calculate the remaining time for you. The calculation of remaining time
requires that the iterable has a length. If it does not have a length
but you know the length, you can explicitly provide it::
with click.progressbar(all_the_users_to_process,
length=number_of_users) as bar:
for user in bar:
modify_the_user(user)
Another useful feature is to associate a label with the progress bar which
will be shown preceding the progress bar::
with click.progressbar(all_the_users_to_process,
label='Modifying user accounts',
length=number_of_users) as bar:
for user in bar:
modify_the_user(user)
Sometimes, one may need to iterate over an external iterator, and advance the
progress bar irregularly. To do so, you need to specify the length (and no
iterable), and use the update method on the context return value instead of
iterating directly over it::
with click.progressbar(length=total_size,
label='Unzipping archive') as bar:
for archive in zip_file:
archive.extract()
bar.update(archive.size)
Click-7.0/docs/why.rst 0000644 0001750 0001750 00000016424 13351570514 015111 0 ustar david david 0000000 0000000 Why Click?
==========
There are so many libraries out there for writing command line utilities;
why does Click exist?
This question is easy to answer: because there is not a single command
line utility for Python out there which ticks the following boxes:
* is lazily composable without restrictions
* supports implementation of Unix/POSIX command line conventions
* supports loading values from environment variables out of the box
* supports for prompting of custom values
* is fully nestable and composable
* works the same in Python 2 and 3
* supports file handling out of the box
* comes with useful common helpers (getting terminal dimensions,
ANSI colors, fetching direct keyboard input, screen clearing,
finding config paths, launching apps and editors, etc.)
There are many alternatives to Click and you can have a look at them if
you enjoy them better. The obvious ones are ``optparse`` and ``argparse``
from the standard library.
Click is actually implemented as a wrapper around a mild fork of
``optparse`` and does not implement any parsing itself. The reason it's
not based on ``argparse`` is that ``argparse`` does not allow proper
nesting of commands by design and has some deficiencies when it comes to
POSIX compliant argument handling.
Click is designed to be fun to work with and at the same time not stand in
your way. It's not overly flexible either. Currently, for instance, it
does not allow you to customize the help pages too much. This is intentional
because Click is designed to allow you to nest command line utilities. The
idea is that you can have a system that works together with another system by
tacking two Click instances together and they will continue working as they
should.
Too much customizability would break this promise.
Click was written to support the `Flask `_
microframework ecosystem because no tool could provide it with the
functionality it needed.
To get an understanding of what Click is all about, I strongly recommend
looking at the :ref:`complex-guide` chapter to see what it's useful for.
Why not Argparse?
-----------------
Click is internally based on optparse instead of argparse. This however
is an implementation detail that a user does not have to be concerned
with. The reason however Click is not using argparse is that it has some
problematic behaviors that make handling arbitrary command line interfaces
hard:
* argparse has built-in magic behavior to guess if something is an
argument or an option. This becomes a problem when dealing with
incomplete command lines as it's not possible to know without having a
full understanding of the command line how the parser is going to
behave. This goes against Click's ambitions of dispatching to
subparsers.
* argparse currently does not support disabling of interspersed
arguments. Without this feature it's not possible to safely implement
Click's nested parsing nature.
Why not Docopt etc.?
--------------------
Docopt and many tools like it are cool in how they work, but very few of
these tools deal with nesting of commands and composability in a way like
Click. To the best of the developer's knowledge, Click is the first
Python library that aims to create a level of composability of applications
that goes beyond what the system itself supports.
Docopt, for instance, acts by parsing your help pages and then parsing
according to those rules. The side effect of this is that docopt is quite
rigid in how it handles the command line interface. The upside of docopt
is that it gives you strong control over your help page; the downside is
that due to this it cannot rewrap your output for the current terminal
width and it makes translations hard. On top of that docopt is restricted
to basic parsing. It does not handle argument dispatching and callback
invocation or types. This means there is a lot of code that needs to be
written in addition to the basic help page to handle the parsing results.
Most of all, however, it makes composability hard. While docopt does
support dispatching to subcommands, it for instance does not directly
support any kind of automatic subcommand enumeration based on what's
available or it does not enforce subcommands to work in a consistent way.
This is fine, but it's different from how Click wants to work. Click aims
to support fully composable command line user interfaces by doing the
following:
- Click does not just parse, it also dispatches to the appropriate code.
- Click has a strong concept of an invocation context that allows
subcommands to respond to data from the parent command.
- Click has strong information available for all parameters and commands
so that it can generate unified help pages for the full CLI and to
assist the user in converting the input data as necessary.
- Click has a strong understanding of what types are and can give the user
consistent error messages if something goes wrong. A subcommand
written by a different developer will not suddenly die with a
different error messsage because it's manually handled.
- Click has enough meta information available for its whole program
that it can evolve over time to improve the user experience without
forcing developers to adjust their programs. For instance, if Click
decides to change how help pages are formatted, all Click programs
will automatically benefit from this.
The aim of Click is to make composable systems, whereas the aim of docopt
is to build the most beautiful and hand-crafted command line interfaces.
These two goals conflict with one another in subtle ways. Click
actively prevents people from implementing certain patterns in order to
achieve unified command line interfaces. You have very little input on
reformatting your help pages for instance.
Why Hardcoded Behaviors?
------------------------
The other question is why Click goes away from optparse and hardcodes
certain behaviors instead of staying configurable. There are multiple
reasons for this. The biggest one is that too much configurability makes
it hard to achieve a consistent command line experience.
The best example for this is optparse's ``callback`` functionality for
accepting arbitrary number of arguments. Due to syntactical ambiguities
on the command line, there is no way to implement fully variadic arguments.
There are always tradeoffs that need to be made and in case of
``argparse`` these tradeoffs have been critical enough, that a system like
Click cannot even be implemented on top of it.
In this particular case, Click attempts to stay with a handful of accepted
paradigms for building command line interfaces that can be well documented
and tested.
Why No Auto Correction?
-----------------------
The question came up why Click does not auto correct parameters given that
even optparse and argparse support automatic expansion of long arguments.
The reason for this is that it's a liability for backwards compatibility.
If people start relying on automatically modified parameters and someone
adds a new parameter in the future, the script might stop working. These
kinds of problems are hard to find so Click does not attempt to be magical
about this.
This sort of behavior however can be implemented on a higher level to
support things such as explicit aliases. For more information see
:ref:`aliases`.
Click-7.0/docs/wincmd.rst 0000644 0001750 0001750 00000007660 13351570514 015565 0 ustar david david 0000000 0000000 Windows Console Notes
=====================
.. versionadded:: 6.0
Until Click 6.0 there are various bugs and limitations with using Click on
a Windows console. Most notably the decoding of command line arguments
was performed with the wrong encoding on Python 2 and on all versions of
Python output of unicode characters was impossible. Starting with Click
6.0 we now emulate output streams on Windows to support unicode to the
Windows console through separate APIs and we perform different decoding of
parameters.
Here is a brief overview of how this works and what it means to you.
Unicode Arguments
-----------------
Click internally is generally based on the concept that any argument can
come in as either byte string or unicode string and conversion is
performed to the type expected value as late as possible. This has some
advantages as it allows us to accept the data in the most appropriate form
for the operating system and Python version.
For instance paths are left as bytes on Python 2 unless you explicitly
tell it otherwise.
This caused some problems on Windows where initially the wrong encoding
was used and garbage ended up in your input data. We not only fixed the
encoding part, but we also now extract unicode parameters from `sys.argv`.
This means that on Python 2 under Windows, the arguments processed will
*most likely* be of unicode nature and not bytes. This was something that
previously did not really happen unless you explicitly passed in unicode
parameters so your custom types need to be aware of this.
There is also another limitation with this: if `sys.argv` was modified
prior to invoking a click handler, we have to fall back to the regular
byte input in which case not all unicode values are available but only a
subset of the codepage used for parameters.
Unicode Output and Input
------------------------
Unicode output and input on Windows is implemented through the concept of
a dispatching text stream. What this means is that when click first needs
a text output (or input) stream on windows it goes through a few checks to
figure out of a windows console is connected or not. If no Windows
console is present then the text output stream is returned as such and the
encoding for that stream is set to ``utf-8`` like on all platforms.
However if a console is connected the stream will instead be emulated and
use the cmd.exe unicode APIs to output text information. In this case the
stream will also use ``utf-16-le`` as internal encoding. However there is
some hackery going on that the underlying raw IO buffer is still bypassing
the unicode APIs and byte output through an indirection is still possible.
This hackery is used on both Python 2 and Python 3 as neither version of
Python has native support for cmd.exe with unicode characters. There are
some limitations you need to be aware of:
* This unicode support is limited to ``click.echo``, ``click.prompt`` as
well as ``click.get_text_stream``.
* Depending on if unicode values or byte strings are passed the control
flow goes completely different places internally which can have some
odd artifacts if data partially ends up being buffered. Click
attempts to protect against that by manually always flushing but if
you are mixing and matching different string types to ``stdout`` or
``stderr`` you will need to manually flush.
* The raw output stream is set to binary mode, which is a global
operation on Windows, so ``print`` calls will be affected. Prefer
``click.echo`` over ``print``.
* On Windows 7 and below, there is a limitation where at most 64k
characters can be written in one call in binary mode. In this
situation, ``sys.stdout`` and ``sys.stderr`` are replaced with
wrappers that work around the limitation.
Another important thing to note is that the Windows console's default
fonts do not support a lot of characters which means that you are mostly
limited to international letters but no emojis or special characters.
Click-7.0/examples/ 0000755 0001750 0001750 00000000000 13352517732 014433 5 ustar david david 0000000 0000000 Click-7.0/examples/README 0000644 0001750 0001750 00000000664 13352517576 015327 0 ustar david david 0000000 0000000 Click Examples
This folder contains various Click examples. Note that
all of these are not runnable by themselves but should be
installed into a virtualenv.
This is done this way so that scripts also properly work
on Windows and in virtualenvs without accidentally executing
through the wrong interpreter.
For more information about this see the documentation:
https://click.palletsprojects.com/en/7.x/setuptools/
Click-7.0/examples/aliases/ 0000755 0001750 0001750 00000000000 13352517732 016054 5 ustar david david 0000000 0000000 Click-7.0/examples/aliases/README 0000644 0001750 0001750 00000000675 13351553373 016744 0 ustar david david 0000000 0000000 $ aliases_
aliases is a fairly advanced example that shows how
to implement command aliases with Click. It uses a
subclass of the default group to customize how commands
are located.
It supports both aliases read from a config file as well
as automatic abbreviations.
The aliases from the config are read from the aliases.ini
file. Try `aliases st` and `aliases ci`!
Usage:
$ pip install --editable .
$ aliases --help
Click-7.0/examples/aliases/aliases.ini 0000644 0001750 0001750 00000000024 13351553367 020175 0 ustar david david 0000000 0000000 [aliases]
ci=commit
Click-7.0/examples/aliases/aliases.py 0000644 0001750 0001750 00000006037 13351553367 020060 0 ustar david david 0000000 0000000 import os
import click
try:
import ConfigParser as configparser
except ImportError:
import configparser
class Config(object):
"""The config in this example only holds aliases."""
def __init__(self):
self.path = os.getcwd()
self.aliases = {}
def read_config(self, filename):
parser = configparser.RawConfigParser()
parser.read([filename])
try:
self.aliases.update(parser.items('aliases'))
except configparser.NoSectionError:
pass
pass_config = click.make_pass_decorator(Config, ensure=True)
class AliasedGroup(click.Group):
"""This subclass of a group supports looking up aliases in a config
file and with a bit of magic.
"""
def get_command(self, ctx, cmd_name):
# Step one: bulitin commands as normal
rv = click.Group.get_command(self, ctx, cmd_name)
if rv is not None:
return rv
# Step two: find the config object and ensure it's there. This
# will create the config object is missing.
cfg = ctx.ensure_object(Config)
# Step three: lookup an explicit command aliase in the config
if cmd_name in cfg.aliases:
actual_cmd = cfg.aliases[cmd_name]
return click.Group.get_command(self, ctx, actual_cmd)
# Alternative option: if we did not find an explicit alias we
# allow automatic abbreviation of the command. "status" for
# instance will match "st". We only allow that however if
# there is only one command.
matches = [x for x in self.list_commands(ctx)
if x.lower().startswith(cmd_name.lower())]
if not matches:
return None
elif len(matches) == 1:
return click.Group.get_command(self, ctx, matches[0])
ctx.fail('Too many matches: %s' % ', '.join(sorted(matches)))
def read_config(ctx, param, value):
"""Callback that is used whenever --config is passed. We use this to
always load the correct config. This means that the config is loaded
even if the group itself never executes so our aliases stay always
available.
"""
cfg = ctx.ensure_object(Config)
if value is None:
value = os.path.join(os.path.dirname(__file__), 'aliases.ini')
cfg.read_config(value)
return value
@click.command(cls=AliasedGroup)
@click.option('--config', type=click.Path(exists=True, dir_okay=False),
callback=read_config, expose_value=False,
help='The config file to use instead of the default.')
def cli():
"""An example application that supports aliases."""
@cli.command()
def push():
"""Pushes changes."""
click.echo('Push')
@cli.command()
def pull():
"""Pulls changes."""
click.echo('Pull')
@cli.command()
def clone():
"""Clones a repository."""
click.echo('Clone')
@cli.command()
def commit():
"""Commits pending changes."""
click.echo('Commit')
@cli.command()
@pass_config
def status(config):
"""Shows the status."""
click.echo('Status for %s' % config.path)
Click-7.0/examples/aliases/setup.py 0000644 0001750 0001750 00000000432 13351553377 017571 0 ustar david david 0000000 0000000 from setuptools import setup
setup(
name='click-example-aliases',
version='1.0',
py_modules=['aliases'],
include_package_data=True,
install_requires=[
'click',
],
entry_points='''
[console_scripts]
aliases=aliases:cli
''',
)
Click-7.0/examples/bashcompletion/ 0000755 0001750 0001750 00000000000 13352517732 017442 5 ustar david david 0000000 0000000 Click-7.0/examples/bashcompletion/README 0000644 0001750 0001750 00000000462 13351570514 020320 0 ustar david david 0000000 0000000 $ bashcompletion
bashcompletion is a simple example of an application that
tries to autocomplete commands, arguments and options.
This example requires Click 2.0 or higher.
Usage:
$ pip install --editable .
$ eval "$(_BASHCOMPLETION_COMPLETE=source bashcompletion)"
$ bashcompletion --help
Click-7.0/examples/bashcompletion/bashcompletion.py 0000644 0001750 0001750 00000002331 13351570514 023016 0 ustar david david 0000000 0000000 import click
import os
@click.group()
def cli():
pass
def get_env_vars(ctx, args, incomplete):
# Completions returned as strings do not have a description displayed.
for key in os.environ.keys():
if incomplete in key:
yield key
@cli.command(help='A command to print environment variables')
@click.argument("envvar", type=click.STRING, autocompletion=get_env_vars)
def cmd1(envvar):
click.echo('Environment variable: %s' % envvar)
click.echo('Value: %s' % os.environ[envvar])
@click.group(help='A group that holds a subcommand')
def group():
pass
def list_users(ctx, args, incomplete):
# You can generate completions with descriptions by returning
# tuples in the form (completion, description).
users = [('bob', 'butcher'),
('alice', 'baker'),
('jerry', 'candlestick maker')]
# Ths will allow completion matches based on matches within the description string too!
return [user for user in users if incomplete in user[0] or incomplete in user[1]]
@group.command(help='Choose a user')
@click.argument("user", type=click.STRING, autocompletion=list_users)
def subcmd(user):
click.echo('Chosen user is %s' % user)
cli.add_command(group)
Click-7.0/examples/bashcompletion/setup.py 0000644 0001750 0001750 00000000466 13351570514 021156 0 ustar david david 0000000 0000000 from setuptools import setup
setup(
name='click-example-bashcompletion',
version='1.0',
py_modules=['bashcompletion'],
include_package_data=True,
install_requires=[
'click',
],
entry_points='''
[console_scripts]
bashcompletion=bashcompletion:cli
''',
)
Click-7.0/examples/colors/ 0000755 0001750 0001750 00000000000 13352517732 015734 5 ustar david david 0000000 0000000 Click-7.0/examples/colors/README 0000644 0001750 0001750 00000000267 13351553367 016624 0 ustar david david 0000000 0000000 $ colors_
colors is a simple example that shows how you can
colorize text.
For this to work on Windows, colorama is required.
Usage:
$ pip install --editable .
$ colors
Click-7.0/examples/colors/colors.py 0000644 0001750 0001750 00000002011 13351570514 017575 0 ustar david david 0000000 0000000 import click
all_colors = 'black', 'red', 'green', 'yellow', 'blue', 'magenta', \
'cyan', 'white', 'bright_black', 'bright_red', \
'bright_green', 'bright_yellow', 'bright_blue', \
'bright_magenta', 'bright_cyan', 'bright_white'
@click.command()
def cli():
"""This script prints some colors. If colorama is installed this will
also work on Windows. It will also automatically remove all ANSI
styles if data is piped into a file.
Give it a try!
"""
for color in all_colors:
click.echo(click.style('I am colored %s' % color, fg=color))
for color in all_colors:
click.echo(click.style('I am colored %s and bold' % color,
fg=color, bold=True))
for color in all_colors:
click.echo(click.style('I am reverse colored %s' % color, fg=color,
reverse=True))
click.echo(click.style('I am blinking', blink=True))
click.echo(click.style('I am underlined', underline=True))
Click-7.0/examples/colors/setup.py 0000644 0001750 0001750 00000000533 13351553377 017453 0 ustar david david 0000000 0000000 from setuptools import setup
setup(
name='click-example-colors',
version='1.0',
py_modules=['colors'],
include_package_data=True,
install_requires=[
'click',
# Colorama is only required for Windows.
'colorama',
],
entry_points='''
[console_scripts]
colors=colors:cli
''',
)
Click-7.0/examples/complex/ 0000755 0001750 0001750 00000000000 13352517732 016102 5 ustar david david 0000000 0000000 Click-7.0/examples/complex/README 0000644 0001750 0001750 00000000704 13351553373 016763 0 ustar david david 0000000 0000000 $ complex_
complex is an example of building very complex cli
applications that load subcommands dynamically from
a plugin folder and other things.
All the commands are implemented as plugins in the
`complex.commands` package. If a python module is
placed named "cmd_foo" it will show up as "foo"
command and the `cli` object within it will be
loaded as nested Click command.
Usage:
$ pip install --editable .
$ complex --help
Click-7.0/examples/complex/complex/ 0000755 0001750 0001750 00000000000 13352517732 017551 5 ustar david david 0000000 0000000 Click-7.0/examples/complex/complex/__init__.py 0000644 0001750 0001750 00000000000 13143622635 021645 0 ustar david david 0000000 0000000 Click-7.0/examples/complex/complex/cli.py 0000644 0001750 0001750 00000003465 13351553367 020705 0 ustar david david 0000000 0000000 import os
import sys
import click
CONTEXT_SETTINGS = dict(auto_envvar_prefix='COMPLEX')
class Context(object):
def __init__(self):
self.verbose = False
self.home = os.getcwd()
def log(self, msg, *args):
"""Logs a message to stderr."""
if args:
msg %= args
click.echo(msg, file=sys.stderr)
def vlog(self, msg, *args):
"""Logs a message to stderr only if verbose is enabled."""
if self.verbose:
self.log(msg, *args)
pass_context = click.make_pass_decorator(Context, ensure=True)
cmd_folder = os.path.abspath(os.path.join(os.path.dirname(__file__),
'commands'))
class ComplexCLI(click.MultiCommand):
def list_commands(self, ctx):
rv = []
for filename in os.listdir(cmd_folder):
if filename.endswith('.py') and \
filename.startswith('cmd_'):
rv.append(filename[4:-3])
rv.sort()
return rv
def get_command(self, ctx, name):
try:
if sys.version_info[0] == 2:
name = name.encode('ascii', 'replace')
mod = __import__('complex.commands.cmd_' + name,
None, None, ['cli'])
except ImportError:
return
return mod.cli
@click.command(cls=ComplexCLI, context_settings=CONTEXT_SETTINGS)
@click.option('--home', type=click.Path(exists=True, file_okay=False,
resolve_path=True),
help='Changes the folder to operate on.')
@click.option('-v', '--verbose', is_flag=True,
help='Enables verbose mode.')
@pass_context
def cli(ctx, verbose, home):
"""A complex command line interface."""
ctx.verbose = verbose
if home is not None:
ctx.home = home
Click-7.0/examples/complex/complex/commands/ 0000755 0001750 0001750 00000000000 13352517732 021352 5 ustar david david 0000000 0000000 Click-7.0/examples/complex/complex/commands/__init__.py 0000644 0001750 0001750 00000000000 13143622635 023446 0 ustar david david 0000000 0000000 Click-7.0/examples/complex/complex/commands/cmd_init.py 0000644 0001750 0001750 00000000605 13143622635 023510 0 ustar david david 0000000 0000000 import click
from complex.cli import pass_context
@click.command('init', short_help='Initializes a repo.')
@click.argument('path', required=False, type=click.Path(resolve_path=True))
@pass_context
def cli(ctx, path):
"""Initializes a repository."""
if path is None:
path = ctx.home
ctx.log('Initialized the repository in %s',
click.format_filename(path))
Click-7.0/examples/complex/complex/commands/cmd_status.py 0000644 0001750 0001750 00000000425 13351553367 024076 0 ustar david david 0000000 0000000 import click
from complex.cli import pass_context
@click.command('status', short_help='Shows file changes.')
@pass_context
def cli(ctx):
"""Shows file changes in the current working directory."""
ctx.log('Changed files: none')
ctx.vlog('bla bla bla, debug info')
Click-7.0/examples/complex/setup.py 0000644 0001750 0001750 00000000460 13351553377 017620 0 ustar david david 0000000 0000000 from setuptools import setup
setup(
name='click-example-complex',
version='1.0',
packages=['complex', 'complex.commands'],
include_package_data=True,
install_requires=[
'click',
],
entry_points='''
[console_scripts]
complex=complex.cli:cli
''',
)
Click-7.0/examples/imagepipe/ 0000755 0001750 0001750 00000000000 13352517732 016373 5 ustar david david 0000000 0000000 Click-7.0/examples/imagepipe/.gitignore 0000644 0001750 0001750 00000000014 13351553373 020356 0 ustar david david 0000000 0000000 processed-*
Click-7.0/examples/imagepipe/README 0000644 0001750 0001750 00000000466 13351553373 017261 0 ustar david david 0000000 0000000 $ imagepipe_
imagepipe is an example application that implements some
multi commands that chain image processing instructions
together.
This requires pillow.
Usage:
$ pip install --editable .
$ imagepipe open -i example01.jpg resize -w 128 display
$ imagepipe open -i example02.jpg blur save
Click-7.0/examples/imagepipe/example01.jpg 0000644 0001750 0001750 00000144735 13351553373 020707 0 ustar david david 0000000 0000000 JFIF ` ` XICC_PROFILE HLino mntrRGB XYZ 1 acspMSFT IEC sRGB -HP cprt P 3desc lwtpt bkpt rXYZ gXYZ , bXYZ @ dmnd T pdmdd vued L view $lumi meas $tech 0 rTRC < gTRC < bTRC < text Copyright (c) 1998 Hewlett-Packard Company desc sRGB IEC61966-2.1 sRGB IEC61966-2.1 XYZ Q XYZ XYZ o 8 XYZ b XYZ $ desc IEC http://www.iec.ch IEC http://www.iec.ch desc .IEC 61966-2.1 Default RGB colour space - sRGB .IEC 61966-2.1 Default RGB colour space - sRGB desc ,Reference Viewing Condition in IEC61966-2.1 ,Reference Viewing Condition in IEC61966-2.1 view _. \ XYZ L V P W meas sig CRT curv
# ( - 2 7 ; @ E J O T Y ^ c h m r w |
%+28>ELRY`gnu| &/8AKT]gqz !-8COZfr~ -;HUcq~
+:IXgw'7HYj{+=Oat 2FZn % : O d y
'
=
T
j
" 9 Q i * C \ u
&
@
Z
t
.Id %A^z &Ca~1Om&Ed#Cc'Ij4Vx&Il Ae@e Ek*Qw;c * R { G p @ j > i A l ! !H!u!!!"'"U"""#
#8#f###$ $M$|$$% %8%h%%%&'&W&&&''I'z''(
(?(q(())8)k))**5*h**++6+i++,,9,n,,- -A-v--..L.../$/Z///050l0011J1112*2c223
3F3334+4e4455M555676r667$7`7788P8899B999:6:t::;-;k;;<' >`>>?!?a??@#@d@@A)AjAAB0BrBBC:C}CDDGDDEEUEEF"FgFFG5G{GHHKHHI IcIIJ7J}JK KSKKL*LrLMMJMMN%NnNO OIOOP'PqPQQPQQR1R|RSS_SSTBTTU(UuUVV\VVWDWWX/X}XYYiYZZVZZ[E[[\5\\]']x]^^l^__a_``W``aOaabIbbcCccd@dde=eef=ffg=ggh?hhiCiijHjjkOkklWlmm`mnnkno oxop+ppq:qqrKrss]sttptu(uuv>vvwVwxxnxy*yyzFz{{c{|!||}A}~~b~#G
k͂0W Grׇ;iΉ3dʋ0cʍ1fΏ6n֑?zM _ɖ4
uL$h՛B dҞ@ iءG&vVǥ8nRĩ7 u\ЭD- u`ֲK³8%yhYѹJº;.!
zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖ ޢ)߯6DScs
2F[p(@Xr4Pm8Ww)Km Exif MM * J R( i Z ` ` Р C
% # , #&')*) -0-(0%()( C
((((((((((((((((((((((((((((((((((((((((((((((((((( "
} !1AQa"q2#BR$3br
%&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz
w !1AQaq"2B #3Rbr
$4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ? ֍ޢ.+ MbMԻ,њb.ygCG.I'=: ^+ImE?Q\\hz%IX'ytckM|KGj[ޣf Y2`rUf80FQbZ5 n*IRHn1 3ګ)ہ<yR\KEc\B|n Jv.qr pX ʛtOm] @cU-o&o+ Si`9$nC)#\7Zc>O *O1B2mt=~~'X,"
dNC18 1һ& Vqmi|q$3Ӓk(jmhWzOu G2L7H{]}Je7+Ȗ
WD_4WZmZ]7e TTd+=~m[Rr\J_'G01_Ins3_72VSs-[ \]uoіSs jcG洶smqq" '^-i0i̾`L3q]^wo.VBIc`ǷSEѧִ)m. َ^EfO|ߵκ9sjkUk
R -H*\pħ \WjZ `7vEs"4XV>Wֹ\;+r=?e e/2Ꭵ%iW$V9x'O$+bKohK y !Z}jCEFmg.Y&Ѡ;06MyjTI %fU%dIyr$ Fv5Ff$ ZnWM'
RR;r ?Qf̵9M7ڮ
:yr &cũj ެTc~@WxZoŬmad ;#vJ/e3 Gy T֨cy~<[x5K\H> ?R3Ϛ8a[^I$m~Y.lR0F> zxs-ܓEgi#D@bWq7z5fm8Ɯ 6.n@5^Q}$pq+K+PA=}4oJϥC#[#)76k^Hȷw>pXuWkjz-kso2dbX?V[%OK{%cIԟzK_5-&ɛtfX|%5ҨXp *gZވs}
"eW#^O?]ݦBvhO} bu;ͬ-# w]
/M*x#~g$g =Me:Ҟ9/k KgQJX#$x
uuioN N^% n"8%9&}z kZ_"cO[ZSw{hFbāvKh ZlqqZxԍppkmn]
;}Ptue7 ! BW$Soq c8x4 d[Q 4j 79Q'SZGUJJ/~HҞ+
zK%Ը{c<+קOr8-G Y] D6B߂5{KݶP3sm ~WQߏZB^=>|gU7'ݷ]sKD(co A2B7k~D TLeM>߫0Յ6ݏ+hv3qSͅBO@?JԉZfEKH
9$m* bmW7F~Sl~Iڬ[+Ig[1ܭ m,$ռY#Giܶq7!=0NuQguXAx v4 jʊkk;ww#Γ>I4ax2)>R zE2;?ZOñWz 8 lq?J ! WcXp<\;l*6 Ek%mQF\'dzS|^"[D"}0 \\]$һ G5]Rc9ҹsMX. ԹTv>BTՒI Mlys $¢vjy:me"(^WFׅ45! d'rm#uUObcl?|GNd} \5%/#pt5ݔ6q4i4v(fUB㌓
"q]&m}eC!S.B *(8Ydc ֯D&4qur풎3ɍ=OX^ݏžnup̶.u}L ZW͊u*eMD7fr1M 4
YXEKk]Bج 9nGҹg\,iq1G9e77_iDcj
=qÐTU5NN| m>ȇ^- W0]
zi d2Vkf*0v# kwNqէJo+Z>qumleWRM'^zYHaӮeNUêQ7(
{hgx_\ ۻX\F窩e }sޱ|7 9A ec"d>
Vht;w nXI A< V85{kEm+,AfeÁUc @qQrz&T []}k4d3죲 +7Ol+TrOrO$Ս 79G˔BG,¼n jvJ"uT=?*0SVMFŭVdn`tS(66Uњ
'VMdwvֶCUr @+$HV~t'v'OpM=#巅KhNscmi mYY٩[hR<5lU[Z7WѮsIl%Nn )sjʄvYX~j /"+$qngtf\ψ ;c?ֶ)
k}#*}Q?518FП U.j ] Ҵm?u{-=ns (u3I${I?
g߆_~Dzz#>xau"ZBmT} g'*A \ƻpTfti;:=\ibKyє`yEɯ-GsȽ<
-o<;`jY?w2 ڭx_IeHeϛrСfG>k'S%۠ނaA8P𦐺6 Iwc:~Zmϧx<$ڒf&m4=#:" p?3f.%2J`21Ů9cpINwϥb8_sLN̮~"tskŨM-Ɛ#9' AO nj.2}g_}B?JT{%^J_
xsEưs -
:OxF5Ƨ4r.4EWoY4?
s'6?y:(;?ӎkڍy:BAc4v ?3W7@*M' kSؒKXyU1RN{;[0,>syjʩ~U a'')[NQ]x?@ دFpc$#;Oҡo{-*@؊I GBh6ִ 1t/0gy,ry,d:u=3DO2A8'a'x}fO5_xO4H#\dCIA^LJ[|Udw x +]Hn!O>j-$W]Bo }kе ^ FbTp>UX{ztڜG%LW#b߽K4~&CyBKiqB#g. jv5.Pc\
|.]02?G]* -6wԪJ]:=q%i9s6nbeu4P|)']zpi0x4K{dm3d
kMG,p0K3=-%.L.0#"v7ߊ# ed!߷ ~2=Imrek1#x! H!|#ϣuHf P|-c?T'lNGOqg$!^>G\
};q$ g ,}'WͻB?3wHxx$Xm+Di+<֭Q4k}8G
oEHu[c]&.ہQK]G;0L{z=E{\r58FsYֺtXS0;3\rUOUsВg~BHf?H.dg)4m:e_ƣH vndz~4FY- [8Fm$g]*ۼ;w QA
RIڧ u>Z Z*l" x[M>-䄇'<~'\cOҴmվ gǙYJ;?@Lp \} 9 .~'OWt1 AUd>Kd-]laR'mRvHM~wIwiOE^S/5 *5@ːA9kI}蝣 [ ҹp^ݦt[Ҵ1*e< ~ <,*=jֳ lX/v cu_x+K
d}sPy=s_=căޝe.q`GzkH>&wtsJ(_zWڬ>
{aV:urЌ7 2:EyOtG.leo7)r=̻\Sv
3"iy~> :TFR #S G+XթƢȧ-+,m{p#9sƬױs
1ܧԮ~Z<˦kP,qݺA #'9+w Iy seE%V+ο [
8OkCm,T,= c-.
2H?CneC ڹmQt敾 %F/32 Ev V[2@@m?i'Q hT4ql u>o m{
?Hk**F'-lZ^^~gB= |ö>ڧ ܵ̓(O}x` <]o⛛BNۻboҞ*ئuUaxoŖ 1@yX>&![kM yɓw] 6}O`=dJo 5dU˔k7*2}f 8^Q^BhdXd]}|I1nx5%FHĉvjƟKV{ǚO =0z 7S.1M\ώ `?rq V7Io&siϯ ƝiI\
5 9$ f·%p'fgӀ(좽VڳV9gķZWY Ѧ̐0 95_ctHnlZ /N=qZo5e[h5hzT a6u8]^fi#8(F}zqpҎװV֩k [,nu(x ԏ\f? ZFa3ZZ5M(sy'g )Z]>I&|0P~OCW4yqRUc^*:+#O\t@aiZ1 &2H#Dm6IZ[{{ H[X˛p{3 ,EJWGZ0~O?4~ }>PԒH48R _3iz枫;g?^[hZ> R7e(uA Wysuq TI͟Nxe{` Q:r>*֮-4E6 1?1~f&HDIpͼ@*d(qj͝UR B ܳ#Vs%,G8 "wfv!nʃ
`1.s=?*DW wq ҡso&ep ºaW̒ 1m-.5 2HɄ>en-IJ GOAS"Y_pGqMjs*2KVZۓ©
@9V x nf[aHnl,HEFyRJ zkfam N ?mD <05qouH4y2n|oᭌwWk2n~[9~&G,y}Bn^źy $CUq UKOn|L>A#bK~|/
uvb,1$krø } Z3xWԮC]^62]' w'
n"q~=nY6YDQ*SۏLWLJda^v3ϟ} ]`ImgMn
ٕN:eϖ)f" v8TE Tap9XU>K ]鷠?RZO7}ୌ}OҷZWEqg8Iu=J /FQ&~>CYrw567,ZkX xv Vx AιJqsbhT|I?C7n@ =jDs g6++a sU!?
IZյ}tLy(|Ñj>+j66J6 +ǣ7P> EtD(Kt]}24f4C:QXܽI#7u GqWDWbUҳcXGn o4̀F]Z]JAaOwn θ{Ynk.U.T q?uBcЍdJ=='Y]jҮ 弘U`YŧvAGh*M"Qh?<ӷʧnOTt9HলT# psݷzVW
HCԧQuw§~OspSc '5{xQsfၟ
& r\&nΚJ1qa ď*7:$27qyDy
OjBȎw:2Acnu헹1
:W?,b厜[Nط q p3ҷ7tI
(Ā~v= ֻ(c(JRrɩ>IfY2"-O NM_[ؙWʷ@ OcV kaBrniMi124C /#>t>sÚƥ^ ?1B$ }uZ 9\i "[ϖ
Q`g J?P4BK[YoG"'v#VW48W+]h>?a ?+>%jg;yml3!zڊy;s+# sSí%ռ&3g \漸oO?v4 ݐIhRӛ5x{݉e =ҲG~ AZ7rrp*q&Xp1zc5o,JK6ƸUD@r?V鹍z4 ΡuʟRi0#I%
YZ\c?k>@կ|WclfGl#x`^VN;֟r -88ڴa(K+);r:' ^Irǯp~m7~y6bXwu?j9ePa|3gYHZ[X
`_SSIJ#|bqZY4lON6"}m,sn]Ff ~ZFjsG%O&Q <
c_ϕZ, ӕ[UӴ[V}kܢI: XkD3 9 O T|l)L W-S"25
N8#Es"fQ+,Wp¡(YX$h73 VrKVQ
$ ܧ a(Sti>X
>[ibkx } A鎪? 02rO)#٣vwQv.Rca ?`FXS}ߔzcA($3}ַM6[f`z-}S6#C(; +cׯҽ-tBHb lnE\, zrxҡU \MfjZW#G( E{ l Tc5ҁN \ѭ$=Ck BfP798 sROVmf( E P.aSPH-ALQҦQHLzb '
\A
9z/s.E vRb8QQI!,ۉ${["ԂZxC$ZTMqQw"EbF
8R;44
942 D 99'zZ ϼܿ-(O z`sE}z|q$0?
i KڝFݣ8
sv ҥ&9@F݈5)&]Cæt{ho/-ȗ ،@jobM
HGЃ*}蕛%(4ҊINU)p$+I"C#;U3N
3BR`[E;II#j[oM9S{p?! R)o+GC3G4'洷 q3?Uncm_:o#TL}GN[bvD1L?:CZŎ$s5;aԵ+-mqf +HJ\ ~Fv?u8kuſn,Y|zRx÷z[^)hTʿѽEQҮIl&Ys?7:MW1RMza99Q
}aGm"ApEQ՜+ؤ[Tv
5'm/k 챗φ#ϛ'M=H=3t6u.K(Hi? > HeI |onG?_cj|wݮ{' G__'k]Α^]YU;)mYy=uV/;ueqk , oFuojP^EJ*}AҾ}Sq'!H$vªMu>>%Ri Y/ø c hY֥)TN&x Z.|KҼ1ۦѮ$$% bgw u G5s ,E,uAr^JMFU;xzD0wɃ! }HsvASlMƆ.5E_ iaYXϽvv7VOFcU,O?yFkn9f2Ma:
rv\u kMlç Ҽ_D݆3RK/1Ojyo,E [i
q/uXaFtM [n{qJe2*وЬ%`F? B@3q]`@`O۵尵XQrOֱfNdԔ[geeO[[G*ݸKᥡ>\Kc
.,W;s;)%>U:p e4?J#f,p M1rz HrX@jh2@I4m3eoןP$>*ȢgL=#
FH'2?F-gV]SzVU9_Ƿ͢[+ƊKBrc` ~=W{6I-ޟi
+po vUB$CyG Rĺ(RꧯMDͪ&Z}+Y",YJUKݮF# /=4ݱZVǠcxlzrć?Aӏ+cxGNb4k +D2)Ry~ %vvp&B澈d#F,pz^=_IjE:Jϯ[_8Hlo21 ( {yMW/ XU>qN}CW=-=gg9z oZgFfBqA=sN~iE̚9|3hQs= \m_p #?Jtz%Ŧa0HI@ ^ض k h`*s (۸җ<1use w8$g JmN:fedy%1ְ~ x?*u FG==:WkTW*0bdW NXpu
M=*؆4O)mm]h;>X=P-(Z =X=*>AM&u
5"!5-J
EJԋ *3sDj1ROxRi1i#d ֞#J_.)<1V-ܸD3-Wځ r 4)r` SpSG s RR@W)@W8Svʥ\h)qKP%8KP0To' X̙AVm]Z (U~x JĒ~@~9
z<00č??3=\ekR^# 1ꮡk/4JΝ vWz~5bBgM ,o >fp*Ic~~*A ?VV u?^!1>Ƭ>?]v;KIMW8k m~$V/${8dJ4itߵ.hVreŻd T 0z+Ǿ4ˢ_jRX]G&hnD2#-p=iywq]C[ȡTOǰչxGA'H+HrML-~&, EUowĺa-"229ӊ>!;Do_OM 2gb lu
IO8* r9汮wi'yebRkϧtԬ) S=LC }!7r8 ~0" UFI=&36<
QVdPNz =^µ$vsֱڗg1.A>>п<=Eܧθ#tϠ p_.jNEEs迭r)9T<8b1vQݦme vypK?VıAiCo
ʖMp:Wz#u N
#VKٲ7/H6rncEX :
߮ > (TWVM~-GN:,ԯ ʹNtٴr.fX Y;p˿) 溨?Tqb={Ow\RBL|Zeyy=#C[ i~_ 2>! 5!xR>b n?ytLl6]7_{jp? J,P Fl`"A~b2?+{Cj?un2q=:J_2_MYno/&2m iq*>l ?Gp'zyU8pMOQұogf9Z*skځRlM~pRA-V7U?c)vvI ⺝wk +cfa_#[Ni; ~EдHX؎cҭ= ~@WQIHĒ,8x'5Mw}`R%nbt wn}{ h2 voՆc3jdOk2 u*ߘzvob>Fm{( ? n: |'j$_ *ʣnUJl}k2ͨ7SMnnA; p:} T; v@(_tECb12k ޙvJ0?#{Sm7?)^?XY@=+XATtSIE'01lOo@CtT1Ȍg;G?O.k}a%?<@Tv "K;So:|!LT9E&)R5b SUgQcyٓ&qjrެ{('x SӴ6%5l| y1ҽFL%{qndI z; so&,W 3
ú]k=>'C OU''ܞIW[E{w eP [yjNm?\Vwh4
L;x Nj%z|sJ ["+ڜ!8eq
/V@[VF)\ #ҭQ9C䊳K+EH!0Mr!
xzT*\Q.LF)Du.)@O0 (9EGzRJ4r `=*RyB6bg;"4BvPR(Ȣp NۊMoZ)v7易$
}zQT \ACU%j<؟CM&$SIDڔE Oֻ
:]V𫵖~kOCQ\A$j è\{ԔWQt5 #?z1豨QTإ;7&!LV![ v2g= ?t_|KA.In%Sq+n J|7z{V{N\eE FUTBB ²I|av9 [6r5N)Ŷj68_ַJvF !j$ 5
!xN3iI ~><% ]1) Q'~BW=k
qfurce^#HZ yG +b9^+3mQ´b *V^MV2sQ%hPAKcy?x䓚ѹ3nH.`5p"#}~ tnsocUƜGqo{-աp1"Hʵe F yQI"G#0 J
))L*:>L-zZYXiyG1URbL.jMUIZ9-p$q<6H?{¶/{(!w?ʨ!lă5.tIuKW dK k \ݝ[E-ԋK }>,ׯukfJy-FSߝV6q~+Dl 2LдZZMs*?c'Z
瑜椼?DT_&YQywg\+_@ - hש 뚱w땅<:c9f 5IHPڣ2}I"kӵPg/ *w G"i''
kYɌJQWeIdn텞d6 ;M yPDE#t`v^/chNd0 6C= y/ *;ڥ54Mʹb{T֮Ӥim m<@'qV}jۚg+|=XVxѳ ӞFmlp > Wv*:SrwԶif&x:S|qU|ڈɂECJ26y҉=j4[(*zpj|,j yLV%O
PZ04LPMJ
(
QDI&b)<,@UOzκgiD]m $A]@> \xO5/»bQR!KBPԵ-)oλlֶ lT^SvO~Qug~
/SͦLw '/:Zrv&sN4ts,Qõ^K"?ju[ܣ5q\ :ֿmC#B]3oMFOfM> G24N d; J{#̱v,דA* (֯"%!OB:}sXz7W!S+ i ,p t zkw3 S
&c$tzrjVNMY JiQª;tiiۊoj/<
?#G]}ov" گ' QG"w /? ^ƴ#me:Nk,k$E#X {86ՙ7y"H?Kͤ'"Wi#
sOTDG _s0Ij6v 92
xv^.Ig;ĐOֽ
ziT9 c s9[]V'o ¦Ymq5vsΒәX{ PD#,^o9-&%mWB2q H0 kPAr?ӬFvG[aGfլ?U 3~BLnc W A?OJͼ7W2|dTs;W rBZٻgG9GWwdWշ+E 82I/ߚWp* -(};.eS}M]b9ZM3HO?fkJ~ 3-*BLHi]RHѱXI
| Er +Z BO\#<{>N)|kd9.EJyF_ʓ& 74l`M1PZƳl!ju L
H\R)&L5&@E8)wqIp*˻!ozg Ƹ @ɊkZ7?- FIZ7hr 5}d'P'HG'}k38J%>.BfIZY;}Cb4cI17vh 0yN؟qQf4ġyLsN
i`~2@i$p8z;?JbA?ZC!UcMN8VO1R@u?=iV!5 :TP<Z1D6()vGh 80>b$$n /ƪ_Ound cV cwWv/6܃"bW07]x*B NB%gu WT~Q ?|4*s{ D y ³e)aӇ?5?fΕ} M< WEsWdx5h [ך{ 7 }E ͘qt/驵Om? H-SvfMŰ \' r>!_V֪גĚ | sǛsiڼ q[^Fy
u|.IiܱiW" O\#@=jٝ9ehN6{y?o?S߲
*FA +]LMLww=zW?ſ+hPag?4>~S5ֲuU,=W p߅"Gz[P {
u laqarI@zǵ}q8WFGV</ǟ5j37"2
Cxk䳃;UW%[[Zx9m-ؙ1%0o-uSֺBLr} ׂx ZWO ?5躯㴻&M"[xhɌȿ# j-XZ9NƗhw` }1^s/y D8 9f?Һ/^kZf2٢h^
x =Нb!IfU2?+Ѻ3Tw2:{iSY$Uqa}EhL[?VA}~eTsPVU|G\MZgr)bss DʹBzsV'#ۊw>L܈D
܁ԋHQ.CDh?Aq(Z9EpV(*@(U
A֟d-R-D\sMOl
wBg8 y{mn>Rr}8 T*x LQi2~%A`ED=*TPzi\S
8:#3'
Ddq ) w4`A 0AF;\+v>lTe#ץfMI{HOxeݧ w@F>x^}|6ci o4Ϣ_r띷UQ\8zboAv+Z?nWtZI˰j/
OWQ/5[ LZDJ )KR' -hfbPwrG֟|+R
L۸VhrH AW87 qMYkJTR]˾<9KMNϖMw`8#0@5W S
Ƨe<~kn a@I e?ß7q\[j %ŴK%NTcQSsLs%ARMkTEffR$, \* ZzKj+|#ɤ-x
o'}F%Ah*pFX{{䵟դݖX_ 5RNiro-a+1<Ȋr [T+gp ϐ1 w({ҷծsD 3*;W{xKYI;G
z5I<8$`Rp?{v )
(kͪ*QVzySI92ϴmRk |a&ZA0s2WPr=3:{wvݲ+# r?6<=Ez ݺ<,I k
08:7 ӧ 7YZݺC$ENsW5\~`ֽ^#ӴVv]
F={7\ k9%
.V]eNKIōFFjJit8O=kڦebJ"2]{hD29_?*YPO@?m[)Vz[~d^A_a_^qaڤ:a8 Vy# x]t"4v)\0?:oc-܀ga4iه5cM6KuSbY2ߠeKԋ# JԜ{+h*i'WڞkHG#HGb^[c} ,G'W[ue-~VdwW6S Bݽ GCNX _4gY wjw& {lw3`1FYq$|IYT#R^ ]My 6 cbz$`~elgiM{Rtuų :ͽ-n_*SH1SY^9#( 7QVg5;v= >`g{?ȍ?4TCӃT.T[e'K,c'>©glĜ4n'B9 5.ópUC(@)ROLhJ6"=
zRJ"v **WDdzlv?e }M/ػB&Z[\L8/1Oӄhu~j,~t23 **ePSIޟ)2h*xSSO^O֬0*QĊӢ.~dp8/Jzդsɏ( Z,gr *} *sr PԩtL:+; OlhZxҊ, )S :*6 1jYTw I4fbɘ< QƑ>ڍzB;7RU ,M
7
Kc52&:J),x 0SRDc8 iVGVP)GJ3Ux-Q'VO5Oio{zX$eQzD8SI(]NKy'!ZI*&_4-hJ:LO?Sy%Bi=wz~J Ywr jTJ' yGf}+-c{{Bzש㯑6 Lٛa2x}ǵQ4Z+-2K>H9>ztP
40xe\yIME0製z78|ZhYAs2rIN+qbzV)eͤ7<`.OfJff#ԏʷC˯߮JKg._<`'$Wwyq PaݳW;*8ZVM
0t' /j lD_||}[])hB۽)9n:qg{Υb( qԯ
A9T]=
2wFk[pAҝ+!\4ϖ!g ]@ U A
"g\)TZUt][obuA]DE%I0byO?Zh9$3)m s]
KF?L GձNZ=Bd i'*E ?SSvDU&#N0 ʟ )ȦmїY@FivbԈH5?JCs
|
)aNT굢FTԊj&-TUQK❌^.=xCvmpUGґe ~tF|",p"1=>;84VWQW9
CE%0ɊYL2Uc-0Qq%W ]8'T;XU,0>ϵT] ZEɓH*VfF,zE"H*
8Hc8؋\I / =4MH$"䑂ǠxuKW+=+ 8gPB*5ڈd* u}VY aݴ{i=^2 55"^ St1^t} sֱִd)xg X≵244{uʤص:3
YVc4aяZƽ
a>SPfǡ=Ň5Rf滩N5 wRUl5xIb1` ` ioj!?7ВqҬ)s$#ぜs(?q<4~f=ojzjׄ-P7_?:qgR %/i[sSik$.X3OH pz~5趶a#QM]MyY,F,"$My4u(%cɼ<~lȞC-n#oa Msha9[C"P^]5/u {dg%3J93j
Ȭh[Ee12f;9?~՝?gc͌1ٛQ
AM
N#6,F@ AMVVVb89
ZXM=MWRjU56$z*%> !뜌uqFsd?ZDR QxZpZv&X(`o.v)LΒ
E7˭'@A1֗)j=SXq.0_j` ԊAhHW@M8 t
dnXA,@Y3|}*H' 8 tgPǯ 04xx<Հp T@] nh5F^O}*#%C-D^P)'Rj# !`($Te .I -]]炑W5` qrgr}*#4Vƻ~skm?2@X?&
cJT j~H$YvV q^oZ+7
?=5>0 -4J/>Njidzx|N.R ! Y3嚼
"$ zXDz vYXK{|a$tJW#ݞc ];+72a`}
}i"A27_ϰ아=[V:t&.۔杠d3o ʌn+^e%d{ybY!pzެ G *U?쉞8;Xm-T=L)kvc7!s_FŭtfI%%]Nx'Zl+|v+a֫kčW}N;+#M6w]⌛I U4*b$$r?vSj> 6Q:tm j6t F[M 2?"}jR^KF=V\ q5}e5& 2*r3m g5 M4h8h3D$Ե 杜JD~@3Lk}.r:;佾3/m-lm^ޑ9'nNeHz0\r=^Fv#~⛳搥pҷS~z IET
; q\מrR{8 =5D{~\" 7wJy?X<ͽ@>zЎFF,+ӴE\lBb UViO^XW+] yBG k?:tU *?@+Rs$ I J]$vԟ(8 a
u 깻69(~s O|sIr iГv^RXI_&z$C8q3pX& %8 ryE,ƫ$XP0AxQ\ V&4i55F5|@c:SՃk
,Q zR:בQG235FxzֻV>m2yHAG}}+J$KTUPN R+k]]Q#~C#V ^1}|KYH) i5&K VPA9HF[xV""& ?oLt5:nHF>mr\HI K?
fzs^ :0V c )B
M Hs? ~+Ӻ8=t<'].t=E.9@dO;~U^!^ 5!1Hz`"u%YOU#?:ircR;Rcu؆VTD8V?j,fJjULvUE+1P;4XQRF
<,"ECSQbKvGJ
fS-ca۽8ܼ
.~EI@ 皌[h'iw \1-UHcRƢI,DYLtfV L7RnXE!4 u!ozzm i7c7BPRlWpiqi^W5d}Ң{ ş²̜OXei\9-
A/ ZDl U1{&Hnyh0GyΊz
x'yL҅ M+ D9OHV="ROʬƝ(*e*ԣ sQңg.yLZBx^0STK
晚BԅbMԌ =Db3-Bu15 '" + Gxn0Ӟʓjb-&Ů&؝F זj0/$>E ? &x)/> /oŽŸr.C ҸF])nz>rտFutT'ް~ToƩ i jE 9i);y+Jrw9/,%O'E.6b$OԓϰGj3tTsIJgx2!S 51 VLVexc & klHT \p=wAR]_Mn-Z`F8;{>c%Rȃe< '-8!%O =h SWgʶG
lO<ؠP3?DϏ K y(Q#1u)$cXe5UT5A裒߇jϒF#$fڊY ɥ{Up#Y-rYʮu?~ W=\4&D*zk x+e֩Ai?s9qIx" |μ 1y&]H S*Lҽ5
fe(Hm+Rd}su 1$r c*
|!re$,@0ytsK̺,n:HD&_ 4-L.!oPP ?\QGREr C/CU5E& n CV" pT\Yi6Ko!-(x*:ʓ]㡮un Ԫ P)J"5*)
+J)p6Z@JGK"H84aY
ar$FV >Bj SZ^jl'MgVij6ޓE(IQ4Q^oz Q- MUoz> o5BҟZ{Ա[Ⱦ)d̩ws}[ǭKދXcHȼ.SLH
9j5Jǁ5$qAJ6655e EXHҫȍXE)X 7e{הzgR
!Pi"5 i Pɦ3 꼒{cJ'ZI})%Ue I` ڲ6 ^z>d=+UBٱHzz
β5&`Y_Un屄}%v0uKz3ouo5A ߽VA(VJ~TF=OҽWIta]0Jܱ {
/5X39rGʠN-;ؕ^n| ֵu Gn
{j P0 Xctķ ' 8(S.aKG[ e#&A6^S->lu ?8L0u%}9 ʾ, kcz[lZ] sޞ&C(AFtZ/4Y-G$ݲZ<3BucJZiNMm`4g`{Mq>`=Oo˚➳<ѵV6.
û @8 J
KOݘɹ;M
bʝmUHEj:mi8,do"?:A}N@BEc c5%5;QcQO'z.[Z3Տ$tb+5TtkÕuZ]d]khNŷyyT X}HOd ֪;IxQGAR5 I uB@Řǩ5u֠k9 TZ&Y4qQ]yϸ"5ɷ/'5A˚\
N^Eȫ*ŝБ,
$|p)1Z:9ִ_.ܟ`{'ϧҫiˋ<ܹN{;$#1EZ?0twIYݭ7 k nw/WxkYm*䬹kIH%OM9Iau'WSErT+Mҕ`à |?JjFӒCTr=Z{$c*:®
ǕS]cNyImd@~h )V joY yI`;K /;^1V,Yb0ƙs Mn/-ux4͛Veĺ?i.W^?R
{(de/c2Ӝ]cLtA^ta
x3\x +(+OVdy:d"@0kjs\穔Մ+(LPeQ]҃TAQ&''j/,(isjNXk b!OQLV9֝tdqȠ(4<҃Hv&V;5iw{blK!}J}8=Uy0fXHd/FӏZK\T/?=j`*RT?B1̵,@fi}꩔,0I7A}Od2{$
x 3XNĹv#2n6I5iZ,fH
8S$(Ķ*jtCK }*|"JC B'N*SHqS([zgvPZ\䜚AKRRIpsM 3L4&1婍%Db\T>I1UnI%ɬ6 5O5 I
ҖC/~ rcsԟSYM9hvF]D:n $3,هʿA[B( SV5N曹.kKω/Jm39Q?34Tʒ/Ub@?IzU@/%$SPYdϵޡ-PK.94rޔKXy֚/ǭ ɛe >cl "U㐈Ix ֦~[%ǗVI}fF7 +d-Mu$+<0F72x[Q!S&=떤]g &O6Ud'9"2z JVujQwܥ"I''u֠qe$uBEZbƼ AVV &% k6RoDRfB<`tҪȵvE
Ge6):"0wQϷ _[T3pXO³SFጒ3 Cᾓ bAQ
J}8 iA좎r:Uu5rk&:סFW;HV#mZ rпcQXGSɨ%8h.eb:qz?S %Rtct?oN"e;IO +P{ \W_x j1ݪ>8,7x Zх:'kѹ FTs GQp .y0si,|sSt,W^
3\q
:#u -)[Ys~5
\qȫgT =qS, AHvd2`pqUjW!y皣-\B٬z 3I=
6G eO5W}OLr ҕʐ<0I.06&ൎ>Oޭ`暉}ᶎ"oV
y(4CrLњfiE+vjJWTa1VEW*q6Z?QK xV,c)IrIjdj*@Uc;Ҵ>J zA%w.r߀4isJ
(54x Z4AP3e$HQ<ު5C.1%^RYRU$桳x䨉&[ Z20K5ƌ#뎕q# c敉=Av<ִT G)N1fQڶ'zVu֩#L͑95RV95RAkb }+>-泎;-,1oj| f 3 :W6F5X[(Է2 $SZq˹k5m>GZM fh;UiXع]ǧY ډ\͠IIb!uܬ;^a-.^w$/~Uzm)Iɏ8+tyk5㖧3Z ո"Tn? Փk]q\ax?tV&%aX +J/GVmhR Ojq$?ks#Nh ]^IZ{>[]
X)ޝt 4Pkc$
N%QIZu2
dr5B-OS D52Gڥ:Rc#"PE3
2֢wTT X#6K,!{ZOJPxC iA$&b$R~XAZFPRVf5)F_!Οyg"\ }ч}[c,Zb <+ Z"nk5dcF FRi9&@qJj%Z.zՈ ZZxy 1jdiVNi&,iVc^i#ZzL,e3) F^$.}4RBZJL!QM$) )L-I1H,Jc5ZYP6;iM?Z4A,RI}I-B^19ȩ"4۽e n^S(TrFIxKǩmV=MON䙧dD
8 $?5S4!<ұ6,f]7Ftힵc&Tcrb rzT;NM i4jJHVjޜ犂Fff)J0k6zbFRI5 SMM#$B*soZn2)8'fܷz2yހ!GҴ!iȨ8~4##ROk5Vf,I#N\wv^$vv ݽ?g(6H!5ñ~Tߩ_5OrO6} ]RdukJj}3ZZ0d:WF A R 2=Os_] L1Mۅ XznwOhϸ#G+yC0*r=
uy+FJ W^O$٧*/'^z=9?:d^oy]9K%B^g Q07uU&h&Fj%P"5W
NSE,TMZCҦ4^jMsV<4CGvEs.֓F UI1/ef}!HA@ޥ"4ȾpL rA~}kP.0Y>qz:Wjs#-hx298 *GM:j0u.L+s{{g
^x5( p?SYR3 YБUdtOLZ:)MG2s]W5VUҿk6>O9,]4 lw R!'>a *{9>i/c/mʹu:;BaT=G_znJ| SPf-584-=EbH4f (@XlH=ڋqܸ$, w#g5a,Ơw?ZU
g Zewzs^DU_SXZkR@ |0&GsX~ c%3Ǔg FTr(d`rztG.?Zb]HK}
dIx]_ ;mFI:ڷZ!fc~U$Rb#4m܋b&i`sYn;zd
I3YsL2rO|**<-=V.Cqw$nTnL>ԡi:rid'&\Ң'&))2@ic-f6`s^25_FאSt ;~UۅmKɞdy 4jiףaؔPj-Դ"pqNQ@J
"]%!۩fMC5P )59M 4)ƐnGDb0@)RSi*dpjU>*ATg(Iv83j%sQgZ1(u GW:F5i]276?ŹENzdU+D܀~\{jcJnlp 5ӗR7
a?ke;Ocq!Y{ !9 x'[U =z#Idi # 3:S I7cӌU|J$TN+Jj iIp54ҰX<)IX4yxI&sM-FBqQ搚Lc^@QOԊ* No 5RvV##-FV
֩ NA?JYx iXf8I8 `ZK}3F8R:`VaOVoi.XvJ';Ml kFZ&W$+*VH4l {B ZLF{huӯ(鹯 `qڭFB.I<=Me؆9 Mh gV{%wE?Szţ* $=OVRK'ʠd9?AW E 鹕Xցb6nqYY Ձ_g [U iUp@q\'^s4<6mFqy{vXYʷ af$ÌI vf6m \>a0 \ ~psR-TfT,ޑ~ERSB5QR=fe,90x*EVZZqP5R+0ST\2 sNߝ;m.*!s4Zp+T܄ OJQW[
TR?ew-j֩
O|OTqHÚRqM&!6Q*dآ%杈lu.i+fLg< hf m;W=yˋS-ǽPzfXb~D\5j7fDJ
i[y`RmS:*yn4۲u.=uA' a9?*-VQ0Ӡyq=\V R
B9{%Ǚ+nltsG [ jLӃT9]&d$IG
9'kxRz,LLܝ=L,[ JZ.h3se: CPZ٨f ݚ3 Z]b0E 5
]Ԅ3KH.i(j :
zkGt*E jEd٠i괪2TY*O R*ԁ3[FG
DAga)l03=г*ZU:\ȣ38"VzcHc
~ q5 zgQ\20\!כTlӴS<̚|7 U#qxIPu%NE8NM%ĒGABۻ Ճ` *奜#I( ҺeM `ٔ,>>U9CFJ#+NwKk2]Y0%8< oCZQ4=यe[eNJC[fe-*pqZ+ ls+Lm%у{˗
0SU$( z{{Vz1w QFMicVN_i:*-HA2Z֫qdbH
.$ +UԛQ6"4(z s;W^/[3ϭ(R7+&d٤>85Y}Ōw$&bA vϧq5uF"[3qQ5 kDx5f Zmuf}ǚj65#LRL23L才MSL.(L5<+hGdijIMHzI&4KM5d1hFl\iB N*%G,U@I' Y>^k.'D)OqYP6OZϚį&j2lќұ7VI(ޢۉf 7:{hf>4c2@isLB$Pj:\"L҃Q# :fEv:{yG.,h D
#Xڒf5(4b\ӁA=ia C 58 b,sY.h.iXV%\"G~C5e`{+ :楫wD+8trTG}Aڞ"B(c L o_mo EsK#">c^yv<qε
([x K ՟cL+n)E=Q#4d4náV ԒfN i۲1J8 5 z֩+=QRF>eU%'h苓]8Jżڤ{3P$T+wM-}Xj:T*v4JsJhQ TH֮8f "H3zEy<65 hHڙ(٢
BqEƓQZb( EXQEj4QZ"̍^YqҊ*<]^hFU=k>YsPuE酨`iXZ94sK((Fh )sE.jq?Q(j(j.i) N
}9,I<\E#(4E 8K(amI aE!ӨץWC*ԩE3(uĦYUQA*tQViOa%P=ɢU%fri@*= ^~kUFEŋQ"tEEOz(إ6,1Gr*GE2iIB?( TW6ȋQNhѻA '˗݀{j(swF]]s0 M4Q_[&\_&ie J(EeƔQX!Ji+3X:U)l |cR9 Click-7.0/examples/imagepipe/example02.jpg 0000644 0001750 0001750 00000114302 13351553373 020673 0 ustar david david 0000000 0000000 JFIF ` ` XICC_PROFILE HLino mntrRGB XYZ 1 acspMSFT IEC sRGB -HP cprt P 3desc lwtpt bkpt rXYZ gXYZ , bXYZ @ dmnd T pdmdd vued L view $lumi meas $tech 0 rTRC < gTRC < bTRC < text Copyright (c) 1998 Hewlett-Packard Company desc sRGB IEC61966-2.1 sRGB IEC61966-2.1 XYZ Q XYZ XYZ o 8 XYZ b XYZ $ desc IEC http://www.iec.ch IEC http://www.iec.ch desc .IEC 61966-2.1 Default RGB colour space - sRGB .IEC 61966-2.1 Default RGB colour space - sRGB desc ,Reference Viewing Condition in IEC61966-2.1 ,Reference Viewing Condition in IEC61966-2.1 view _. \ XYZ L V P W meas sig CRT curv
# ( - 2 7 ; @ E J O T Y ^ c h m r w |
%+28>ELRY`gnu| &/8AKT]gqz !-8COZfr~ -;HUcq~
+:IXgw'7HYj{+=Oat 2FZn % : O d y
'
=
T
j
" 9 Q i * C \ u
&
@
Z
t
.Id %A^z &Ca~1Om&Ed#Cc'Ij4Vx&Il Ae@e Ek*Qw;c * R { G p @ j > i A l ! !H!u!!!"'"U"""#
#8#f###$ $M$|$$% %8%h%%%&'&W&&&''I'z''(
(?(q(())8)k))**5*h**++6+i++,,9,n,,- -A-v--..L.../$/Z///050l0011J1112*2c223
3F3334+4e4455M555676r667$7`7788P8899B999:6:t::;-;k;;<' >`>>?!?a??@#@d@@A)AjAAB0BrBBC:C}CDDGDDEEUEEF"FgFFG5G{GHHKHHI IcIIJ7J}JK KSKKL*LrLMMJMMN%NnNO OIOOP'PqPQQPQQR1R|RSS_SSTBTTU(UuUVV\VVWDWWX/X}XYYiYZZVZZ[E[[\5\\]']x]^^l^__a_``W``aOaabIbbcCccd@dde=eef=ffg=ggh?hhiCiijHjjkOkklWlmm`mnnkno oxop+ppq:qqrKrss]sttptu(uuv>vvwVwxxnxy*yyzFz{{c{|!||}A}~~b~#G
k͂0W Grׇ;iΉ3dʋ0cʍ1fΏ6n֑?zM _ɖ4
uL$h՛B dҞ@ iءG&vVǥ8nRĩ7 u\ЭD- u`ֲK³8%yhYѹJº;.!
zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖ ޢ)߯6DScs
2F[p(@Xr4Pm8Ww)Km Exif MM * J R( i Z ` ` Р C
% # , #&')*) -0-(0%()( C
((((((((((((((((((((((((((((((((((((((((((((((((((( "
} !1AQa"q2#BR$3br
%&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz
w !1AQaq"2B #3Rbr
$4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ? њnhOcILi\.h%٥拊p4(q\x4)h~iE2QqI4\hvh&i \43ACKfh 4Ա~i.is@g][iеCA4:2>qcL*ah 7a.iÅJ횵ƈE/ZjʚcIC=)&i搚w)!4AI@4
1ؐp K)~h 'qO4vf im 7C8?{ iZ0Ag_NZV{ 5`n$>lc?d{xCd_+v/g02{Exu)k}Ξ(B((*+D\HG. AP5ƌ i ZF"#^1VDKQE
(
(n#cF4w`&wÿ[{/$X+q$^ӃZU*NQEQ@Q@Q@Q@R Pzs
/uK\_S{5|T)ifީmnJ$ zVdqK }WWV{;#6m.$?<? q2 ƫN {ɣZV~}z5mC*M#z3Z nLG̡7t˄vf{&4
(X1ԠE-Kd*
;E+ZZm-+] .}j((&hh=
Vpjj>}k9M&i͒<I3LL ;f`<$Z`<p4#("GJMeȥkǚ"*Vf Yw0rxʉ!&lk+fZ6mQBAVT+f-VwV7W1eJ
Q{ryI[֒O<>qoZV]
V05VPޯ,fUAV5ym,lK}\dU
m,hg=~qTyY5 :UrG'Nnճ3Ƿ 0/u\557zDBOU*}ZOWN8E#z`ӔZ\mkg > ;I;ۛ
E7v`#1 m~#>.[?y-5$ n.X~Ҿ4xdyOQ58W] uJi'1qèC "8}[ K<[G}a u z |.--RَKf
}A#^+8> (Omh?,2 E|smF,)1' VYJ>kqM(# YN Fv~_EL5ZJGWͩY5Au 8 xp`
H%E/A ! >-ZcW0Ŭ}W;&qx-W icqqTe^Ij\H۟2
M.OW:2%E`F9"i˩_qtKGH@jivJE!#?Ry;{=E=8淋Sѫ9MGTgg{ ҭUd}C%.J8Jd*dPr:(*]\ QQM&ݐ[Їuc Pt
Vݶ=
^}sX:osr~â{TױƕersOӡ 0*.X ={_U[[ :"s gd\ (f }OzKUt&kw=?OͶ}áЊ^IeϦݭųr8e' ^jv]6cq=T}x;\+V+ z"ms"&k{
zzYݝس,䟭rV(i Y)7:Jռ]?Jߵ;hNcqku=vrq'"
Zu$ԅR
&bkȶc
77Phm#@؝$uEĸܕN4YhPN-:Ӂfh :oV7ׯ8} /p9PћDӁǑ =qӃCnex xFI(nkOB`9>W Cdy}+R8$ Q]| %9
ng -p@t_
/m VӃQM#DSH֖*QKISq
(RP4:Bv*EI `+Hv,R5pBfԕE!zTڦRFMcH(!Hk#d.i &i?4f3LK`4iRL ֔ Zd3@4X+ 4@V1E&{ENYqb2"O R+-gt=͘nEEOSVM#n*zU Xf}=*42r KDy%̊#Ebz\}rޅ[k~>N{-^~j(TX|r-QZܺ4? 1]FGڻp Z|E
J 6uC
S_SaHf #9ܞ= eMFw:F^A;G"ڸwfuĊy?t HO<[9v-kF T@sbGg:+=N#AQВEW2b#Rd5=JC
nt!OCұb=K#<$ٓ t5NeA+ѣ3M] VD,I3F@'ZΛEܥ<7ǰ#@r* _Ղ^:"ML5
г/M iH6M#(\\ pq]L!9 z~UIqZ-
1Wa؎A*EN.,r)el
W gv@zqßL9bI$'|*n ҅.oy PWJ
kZkb3 WaQXۀ {V|/`k?ϩ2ָ
ZK f9%KdrI7 Z#y1'UYmXKa誃 SVg8?> u&U8;
tS8KZIi`
Gcf;nc3 yc'$v5,^%ּz uӖ8V -n# QV-5t )W]/\ٳ͵E< ~k>/xkkY
_2 ;¾} jB˟ӇLSO c.{cW?c誴R= ᇵ0 8HQIY1X^P(
JSIEƃqҐ(,G(?{NO4z[Fjx_3I=)DYsOQfR5H SF
S(\曚)zPpi ,&J
.j0i٦@ { P;ҹ6\"RI0Wi44<5r6R!7ST;Kw!N
PJlBR3qP3dԶ4LipzL Q*Ԭ0)T$}*OP8056MUpCd9"O~Rx]Xp{Ak ENuУ;4ZBY9^Uia.m7ms d]Gַ\Y7Iַ-N2х6=Tl͜C!q9GSޟt)`lC>JnW̾o{ڭmb\$s28 m̨Woϓq{i[Bқ[`ӕ1> xſ /;εB]GQW?zIFJ7|qƪVoV{o,c^dK/C|>ok, 2WS v^ Y קg; `Cڶx )C/; ?f V'ֹ
I.8Ү-"-yO, ?tEm
^O UETUF jx5Z?d N
sXnDO*Ta~8Hvj ӃTؗCKk{ ; 5hZd7QJn n@+OF.<}YP2I:O
6/xYO1߫oj)u%ʅ>TyD|MKbl6径zWMF-O[VJCG ~xf,Jso aGx}F0J[7Sr@LV >az՜ब͢2lS
yrVv,;QE i~
%2 IFGzi-!4&"4f3VZ IIޙh\f4SE Fi(vqHZMF@2pjF@gu#?n)2Egҹz < K1V'U
ei3Z7ԃW c TnB b QTmP?hc̺(&oBH*gjVc=8jy-Gn[p}z՞i3'?A&q-*#rC92GNR7Uiw kϠ+Xܻ1 z߇|GaǛG+:ïX]<qFfh^H'G_Bg63K]ZoŦݮã"TG+]F8,<NH c_W_ӋK 2aEmJ 9~Rϔ~ x5 mx%>=#mOW^P4I+beRNRmݓ4NUzvq^A\U*'n>bxK]A K+,Jp@< iYYJ ";HC=GX U/]#Ji9#mgOo" W ~#^)PcԴ&e\n%Xr}eԶWRh[i#:t;//OiVxux D95TIMCMD]>OzR(rɒUc'O\jwZYդs֧I+NU#)%TĒI+P,k(u4* :*sI=Mz7-#Vf.ziF5 {h$ Y M@jZZT:m9 똩"U(@*z)rZZ)
03|G[:-֥w +# 8
n{⻫]Z\tr~*}0 QA?:\MɒO*5Srvgh WxCBÚ
E {]pVkƉk j t(W!)QON
p%¡,V#S+̩-!sFi R@O4m A4HvJLfH٤&
UH\RA
;^1~[^ {^ q ~-fhbȎzXF+J*^UY;!"2!TǠȨ3ƠV
V!뎧k&I K~[k?tbY,y$Tua.m(WIMDjW5s)>aQy8=j0 ЌՃU5vM*MجjJXuWSikI]FKw ~)sWd[z֧+ē."z/6=ǟϊh$U3-4qK KrF O%xN⻭"`օ3y܍_gZ)3 u u\2zGgtl&ﲷ`X*fj/:Ȟ6
e' 5i&sqX.^ W F%RއdWG~n8Ԝ]jSүZPzUa%}'ͧٵKHT M[ 1}TWq=tƤ%<( נZiSb@~>>iV\.:!Z\oc4- Pd aSX/ӯz <7mY>m̘3\0se ]LPY%AoEUQ ^+ lm[Vd 8/Iu6 m 5kS 6 4${@?:& qR&Ik+?9G۔Yl891k)T-6o~Qqwȣ|108yA ^ 6 .*gi:,úQ;zV$0mXQE%0qT770Zd8Pu28Q+W/TJh.'qnP6r uS\卢2i9X y]_hn7ERvE f;
jm/h
zj ֑#.-.VV9/ `O խU]lj^b(V84Y_OMN/ + ʽR=qej )E?1U a~A֢UAҗ4jH{dV {<
*fҰ/zk zh4a؆HPWFI$TW PӱHM%# >f 4fHq4f3THvi3Mh;8f41٠nh&SO *i)](J;-*`F 4FM݀G>P)Ч3`U`F
gk
4r %y|U&TZ\v;!BI3RY6~9r*yaRlj9W+0 V*,dՌ둚eL|IH5v8kbU$Qtq:]U.%]9<0Erdx,@Zk뀻Qa\14NVk*r@ʒW&orU(?ݷ?֩L%8K !\P>1iX'/e=ǒ)pe^W<
uWPЙU~NO^O^Nsk%l 66Kt y&s[/b.n6y[78UeFA]
] . Gm
[ףx;@O
hc^C4 v 9涉>_'dryj`U`Lc\VwEF&cޭBu*hzW` ua"*Ez)_Z3 PT9SkJ\HiG;\LXbf79 s?O,AdWI@upCA^wunuI
r PF4wo0 4hݶ%OZB$ rsHO}nmM?Q]>i,$Ku$U O # fbT'xQc!a?lX)-
uE^TfU
rMҨf2,x K ,:0e9|_AִoKi eu{s3I=ù
e{J~8iE KjPZb\WApBB j0 ~4gUJQxQs-ͤD]_<=g$7gH* ?5e:=Xt6X#$}'-G
&VVSEPI 2>>ffpy5NcV8re8K-P4lB,nd1 og+=X+[#/$(Tswj'|MO5kJQx`T( g)/SRME
yU"bEsZ| 1 h+UpBA1ߟꪹcI!HA zW+B.RVK͍y7dt4+!ʜ)OWBmH iy lh8?q z3Zjt=7\\ nE_k LC3 }t YH$1 ! v ?Q5hF>\߿nHWО>S?Sv` Z'XP@pٻ cƶc(s^V&F&m*\f9Q="Glo :"/"#5xE٦r@ 9e(Ւh6H GRr<֯j6xV>C]|O[:d 5uaEU oC+ʦLcm![V⠇H!3 ЄOB75V7uEY :-2"ЌUZ&o_=0=j `?Eҹf"ZG
Z羻59n$W{X
>c'~내LKMQT@WQڅC1A:d$k v>$5:M}*Y 4.uk {fIbIJuo\W,\]E j5V
]
X
8ZhV&
W }яQ,yo=j,43Iftu &6GQ0BiiH$\ǥ+6>$sKQ N4 4&"<$gnsQI+;fF,}雫Hƪ6%IFj.7Ty4X 3Fi,Q&h34f&h0\aS٩`k@)sMhK49
CF R 2 nٙMk&m\sb_sC= 5JIBXG$4fg=ARҶ zw?Z*JF qvQu,s/C!=+:~HhWb5BW Wu cOJOjH"7jaRo+K1+FG'
p?JI-̅Fƥ o;?? U-Jmb aiӏ5Gq"[[ LF$|ryb?̎X)Hҹy ,p+E7# Q45jN9 2n#JrvFQՙL&9 #NN~w s4G #(kNdRST5fS]4W+TƷ)(T<ק< ^[iȲ02A>歨TRZ2_-܅l G$};U ?=+N%aY~FD M7F;9|d I\UmV
F@y^yVAk*e+^˩IKִ-n ZЊ<`*w:շBXd k56D55 0烑BbJqq6% >0/UZKd_I2f :m=bc'u"=*EZrHiLj+DuTV2u,gMm9CڑCǡC`T5EWh6!]Y \ZElp㒿A 2=O;w2,h#5[= NU" v.NANNkdS4c+ܒ$@e9%p0}A+buf 1Sոյ|%p ]5LJ+Yw]3P5-b;K-/Gq!>_>&ǣ薒\wQ\\tv eO;W_"kVtk z_IX5Īr@6
8dL^$f%A#ӊ}JIۖ(P)UozZ:Z
85V
85f6,nPu.QطGU)qxr)OΣ4 9ԛ5q25XF[ޓuZEb]ԛ-nHdQn4&-Ի,K
CPX,MFV(4j i` vj<4RE?4f
/jv uys[o5FF
&uPO y[5A
a#ޣ>d"
Z4z j8&DzU5r6q<ʱ-ޜv櫚66# 1nw .g̊-֭iD Y8QAVTS¨xؒ_n2[֞]kEdf <# BGi س'1 ù< 6)qLcO&km%8FIOE ԬY= tWH H`ARZZGi 1ǫ ZɿY5;[G J0Tsۢ+j>%+kq;S
z{X- } aْC>c.4]6a,`>O+d#XU
h_dԭDx6?qǡ&[nm& p#І#ڴLsV_NJfk0i z{ο6 O@y k呤ݹ,ܓYT>TU:ՆMF4p߇4{964Ȓ8cPuOֵ :[ ţF>2WUj7'BWv4ϣ!WnzyZK^WÑf cɋ YӯotD]͛G(? )A=^t>Ii^Y$L֊&F!@Ub:+lt@3{35˻Hfc'֦)I y Uޫjݞ=p[<=@FSՒZ
MOUEZ}#\l,vLaiK;Y8 6kӕk(J"+
K@U 6w*-xnDJv!E0_J2})UiDeX^߅Cf2*T& }8Pr9!
nrMe~g=
]3~"ۺr7k:O쐘"Ԕw\'KJzS9}CF%_B J0O# ]~o[XpyIx;~hJ
;I.4Ź#wFF{Wc^IN6fӧ̴ckp>NWHF}
nĕҡ*r89& AU:W%A8 p
ҭB( S KկfѮ$ mC[?xkWIDS0:`nOކO_E
lUUj5w4vCSU`
ō7RXw
Ѿbmԛ ԅDnwP[;wQ CRu;sSA%sz
8Q A]HF1G@*dHUM p*qcl?蠮ۦ<-ɪgB:-X*њɣibWajψMMJшکDjfGR%5aOJ>a58ѪUozhK ӃW
NEy!o`[s ކYrF 5A}yKc 𫞦57ℜ]kNApa9o[k$ckYu42Gm@?@kWK-r urhqַɕV՚d uloxH gs CR][&HW dtjg}uuu%G\ZVVQ͘B犞8 m>K xN $ hѵ?TtɍcVy*4tBs8j*t ,q jGƤu:RD Ttdo_CJ:}^;
}T7G&0$Cч#歹DRE&K61(xe>^ 7ta;/gu=i;:x _j[ d'q#2 kX$EQPM&yLz(ԕة_vJMNc{ i ë ]-{8eېNߧjه2nt`Ôj_Nq Sq07
]rXXyCcNSΰx9#؎yH{KU:WU|BԭT&w Bn׃i~6/ܛIO\CF, 6 )rG۩뽣hX?(zXҰO7;nCuRC67{;;{ѻޡFz,;w֡J[>aX鴈vj||0`C?I\s4њQRʌS@/#m_ޕ% V$ReJ U "%+[
'ҬT-eeyz3.pUKbOSQ$$PjX4 tUk:52:̜UI1sHhsY2Un#U!Qucv*үC 0E
5,c5aM1!QS,\|5G=
Hx5r̓442G4wU[4Jqy56iȻE/Mg pIo" d5\HL%:2:
{K$jF\ qZ\x8SKV֛wQ 7k$3ASg34''7va99;hYcoBE\ȂD(:nph!.Y\)HV"#lNqԟZ?yr]ԹWf^ZR8M ƞЬ,>זKۗ#,'P t=? z]i亨I?56d*iWXsDSq~Vj~}vFMMmmZ0F+ VZq,Dz oCVI^9uY q8>.W xq _3_!zMr9eAF\2-&[, Pkimh$h捷#U> s{{;Jr[ k/A
O Г+tV)okG.JrM] ]Z=sLKڳ/mNvnJ?-SEPW1G}ȉ_kCÑ<"eSo/ݽCϩF]SCsZ/<ב{ *0\)JS#ltGT+#su85W
85sz,PuMŝnwQ'Fu.\bmowѿ4PNJuC\`&KjPh ( U=^vsr}{(ُ;D3̗j1ɩ )i#݃rjbE1N+"'bҠjkL$]}+AE
@ b eIݏ^Z
jZ9=pjqPÚQ9f niOs&
7'4CX4d" `2[i]9 r)G_Σ$I'=˸!✠# N
ȅ-L?)ZLɐATT
棘~ j$gLٖU\ c tҥy67$uIbhE&Ydz^-O Qk) ky<p/0}kV~ctѹ K19me%VomӊqͧͶA"~YC5r q^9Ƣ拺9%fTڥ *sgjS-b I8 $hwe_pQ2G +2*t 3F{ wslq|#|#pT)%-ަe
Z=L'Gq]u;4'x CjG/ieܖy`z/$]ܢ0#{VBn9N?ʼKGyQ
W>լcIȎF0U Nյ_AN?]REh .ߍj9_cB 2*}{IIVrXt$tax:!Gl ܟ˥tNxoS2WF vE n^
'V@Kifn^1VRSH
{j{HiN|N
UNEVŀԻ ԻX,N}@b}nwQ۩CT;KwRsK٣uDb`ԻXV&
V+ Á'c>9nwJ2T#i~eL!ex'hjH
?±tYF=J VM^Z+9mÐOCTm9m!bI$\3KNQҙs0IOj,G&
֞
uD)A!_Sf.j^& Ӗ**%G 5ab>Eg7C"Z>:S*tP) ܹʃ*`
rRN
QYJC8RHTz$g\E:&bsI3 m LS_4F:)\#bZxZ-<%tF&lo@Jh߅a
̷Cҵ}~uE_4+1 ךh bW5wnAQx:sruE\ OzCRDմ)ƜTcpu=rKSk,YOOv.T\zcO'DTOP܂0 ɭ
Zol__!G_ʼv[%AuX EDk5_De`T uF$lV̎ (SZm&>Jz~U*);ӕ#߄l$x (*=s
DL ^$0V|?j$xb mo^*{2i.l:YkQQWza܊m85FI`~&-Ǚt# F½10{,_Ii!0\\}AS q.ǕQmt5z%Q*\ c֔#5QRCc_&g\ jF*FQAYS DQRAC/hY=Pv*ż۟dcަQNxD#}+79+<.xm;lq0A g|d,rƸO-3G( B22 vG+ѡM954xE8d(j>/*OO֘ISՠhl0 \[u.lɳʣRIuB
(jV uEP S .8e#v qZV)
0
'
s!˱K /ٮ$*ՒL @_Q?ZĥݚPj# 4Y0aN
QN=((jp54y5}C>C у(*AR29QW,林ȉSXΟ6p+-tc + 9 m²R2f`$$ՁqS x*\J 'Pi
| j5TǃNOQR SR:Ӆ&Ʈ9EHR)楰w&JjԲY"9ȨT\ɓGz(ǹiE.1ĒyR($U5%cҊbSJ8yИ()q\DX@*X"
4'Qɰ ZF=:3CN RL FLiTH=+mDVW 3WQ-&F .: aQ_K죱bK!) ZC 0=f]yGrIQ _Bq~~STǩ\Rlw j4|VZmd k+F˨N\ PUJּNŁ?( X*;(jč ۍ:(RƣzD G'۠
6Ong-Ni-z$Վ*+ͭ1 l_ &B0O8*ûV{+9-rZ"fwvF\p2p6U fO9O˷/ -$/?OΪ ?uR*R}N贺 zVg ӵPqҽJiMY\7$z Bc!+J!%*6dLj'8Ɍ[F#ٽ鏇R#pL#<,l m%On*&Op7^Ra%chYa\q'7_jϼ!ګrk ݎ@Ŷzͩ i^'z :gZjܧ(,K1=껯y֫2GT$Ru$AdFxz d/~ QGoC]MԛX!b0:=*Wd^AXS)8DA vvjAQMǰu'/;u:yȣrl0:;
%자 V UZm
2x *Pz*( VU淮e\B2Ƈ`o,u )r;ף閶 oSgtM9\ ?*uϛbIRǕV` N2}?F&֩C% t ?7Oclfg;NlN{ _'V]wۨ%& ڥb?REB$С%N{]&\db6R *Zy0GV"H1)Aelbe`:zj4=QmsZpڅ}ق(TD\J9Ia*WEkh9Q4ueAwѴced\*K1ltG5P ;WRt$zNUȇ¡qXNu"AU.oܑ8 s/q.aAze} )>?
}͒hOZAP5ZY}Mc4ˁ֫&RTEj/ھyVqWd^3Ud.MKb!f
8$>s! ڿAZ `:zUId駫ξi6q#
8+[@p.n 6ʃ -AU} MmNi6r1y eܲ*"
1^l㵓9qXXpmMe-D[3]I긫Qg8? B }%\ ~$fW\ t +{]BLu(6[ d8#p e[#->5zrTS*x >NΥ]D6/g[J=jQ #畽VLr7ַ>ule4WRY=Tk
trVx$7̿ʭ B 2IXۭ 5QW0.Q֖pۏݨݏ&LAS(69m ]i&Z
RIm !RUuݼVƫn0&QFȮyFꌹvO"2j<ўk)
"L֎8(b'VQj@X25+NV:T`Q&[p§+"T˕Bi©f (&Kyy 'y5wz (hF73L*SVQk\jtjSQc&;e9M#?Znꈽ75J%UTzG!j u5B6vrU t T*@UeknE TU&zo6 "M4&*o}Vް4h $5H==^-J$SR,3q47ި )|ʴ.4u-A$EV]Ԋ3Oc^Jd7fy,hGJgl5`iVzdZo[sDqS!رV@rv Q5]QGeEk!XC|[rʚ3%8\vĬ
k]ϒ
' ?ZK9X1^rm=c ,1;t^
ٞ/R}\x!'9Aֻxʺ+F B;6= &][];M:6 ۖ~ESXƥD|G 3_̢BnG<
k$K@D`HIў߽uz>ck-[ \`=
-_@t+da^iX 9`d*Xv3`&7|Ӵ˭Je M"c v< ?E} pLcu@B3w۞J=qWANҕ-팑W?^=`,{ϥzJzj{ռԨcPS6 [>d JX2]nU f\}xRm%V;x% xv61/ x歯/N m^bjݏ +Z}-2[ wC曛YTy,~ x/~cN,AWei?4duI;3 FlkЬ.-eCс =*&RqGTڒ_qj 5OT3Te$k ZZf֤G(Uz+ 5H
M K yc`Kn11 Xw4T 5"h Ԩ+gHPU5Oj8XE*➫OSqLei\EF l9L,W\(ǵI\b(R(R9
Meһ.- 9H낎 Fݣ? =N*6gKDT%r"bԁ
DlFj2;˨j'u5
l U# Y.GЇ%PAԠ{Xfm )2wsF*64|5=ZnS,=VVblXIT%#U&ޖGSpyAu?{19ܹ9Ԛ$P&ٓWZ,R:\*U 1U;h5_Y*0Zm#ɩ+"ͥ +^c*Օ88m#RN*NV[(v?- ݔ2۫]|dt9?
!VTz^*̲pd5 # E^m[>Y?b! O AZk`<΅H
ɍW z;J5**m̪S'u
枷ռSǴy?݊?UW`U$ 뼇Gmƫ{v/u4H'` >%b1U((yõõàFC!E { eVr B2~ : ч `Us֭/iȯuk$mp14NH:|pQUnOzw>d(xS #^s$Y}93 k3mwZ0X.A#=uϭzzA2ᢑ_m*ONjvvPIp
>gϷ0H5_θnL(оOHwƹ\< ժoVOp5x5B<\/5*-H#1^g"-YzS*iL.>5Vi*/bVRlD;id´\
\ejZ@aM09)}]-YD-=@ uVU*2Wү,he~͘l5Lylm?Q}2FK_J-5*%t<#2 *[M"~ =:r"nx8Av80jvu-{SIy)v¯7U:wBޣk)6,M+ 뚕B;n敏5 ʻ x: =FT} kԅG1tR.gCèQi
C8B'oE{
]e/꜐=WHZ|PwXVTrl_
{5
}ƍ0>fU73Md#ylzOR@'%`
}'k5DW2=ϳ ^o%Š|伌3\Ml.Dߴ瑎K>6U'C)S}YW4WPK]pG?u
8˃9-JNx8s[º=y+&~|Ek9%9#z ?.@ iNj3Xx:U=Qf:FFہ[~sv'3J.Y!\ Y۹P
_=
cJUyjGri]yJ!5 UL"?jR)1XEG LXƪԊ<¹Md[)h\QUJi@LWSonQ*ֳtH];~&WE%z;y<1b <F)hjv?v 2{U`ko]@a~Me(ٝP|4u)-#2!I CZꖎ?l>1\lS i4D sj2n#jַ[)cq=NvJ.Kr^F,5KU ƖK-/Fc%FSNTL&J)DZ-M-JXh
Pnu>P c֜4V-G T]n >#RUکLy
NTjZd$o>zm5]U ⱞ{5BƆjDv'ScS,>բ0cRGiA>S:`TY#;hcr Q6; !?xWo9/O>ҷ @qv칷%<~n_}$c 69 &* 8V99`~_/":WdːA,D?t
OTtү}"uV:ǟWtu) ZԶ%c Wڵ"]С Vb-
Ε_1SD\ї0Xy[U[x;trՑnҞ)-;U4cRF%s8h6:Ҝj&YI=H撔i`+Q TEYYG~=ڲX.$Cwo4{4r?2Jz j# ]N$^ZˢY6CLIW?C/QiZj- ud7vˍ-Wđl~WRF*KQ<`\#gslp\&GUa| IőnL}D e%'H]zuq<Yv:"IFWvzWWũAh;ĩ\w Ak_> =V>~ͷ;xV8Fz>F5=iOzm
g7hF[iݫ(+7>]'BP}` u=7z,݉i Tgb^jRXfK
;!Ζ͑EpM-qh y ըakiHJfpڞU&CY9TXEJ"8GY9%.ڟe)\9v
ՂI̹*
1gCU=? ֻ
'`y t )H#N7RqZ4M&3 `Gvu6[5-V.{cRGU5hPn =RF&i*6i=7Hv'i*3! IVXd'Қ_Nñ9ziz!j,2b@j,&IޢJ u87aX4S=ZFz(jua\͵䰮nE_T?`ѼRnsIE nF˱'lJ n=:)7%+;b|e-M"xϘAW*,߃Wl2zRĿ:Gɽ!
2~ZQM ɩVk "_
8T{akoSHmMbgԎ>H$ dK :\Ww̕jLg})Y)
pGz)ů.S_[Ҭ9Xl1WGՀUXGQwJa +YoI9*@ZnnՉǢ ku鶮SUJsw
\M H# ,N N/]
9JҬ @k7C6ߊո;a֩e9MCzjq,-"#\[-}#NCZr8(33bzi(=EE3JIs'SQǽU\qqa ljzi[Q7pQZerK 6QV ji|1{RrZƸc lI s7h P; J{i*'z]Eؕ䨚Jޣ/Z$;)UaJ_ސjL wEz2h n4`.iCTYu* ҃41X5HUTEj[ *LPЋ2TUz =^#6&Ű櫡&ZʘOUxD\֝ I9^Қf3WԸS*SP˹HaV?jfaG ?ZY2 FOl!Κ9"( RSVc ZR#QW̿!#5J
qwfC)''zc-[e{W9T1ʫ[ hW9W˩zEKsӏSҶ9!z1ڠ떫)o >?U^5#AP6AԽ &SJ*6jl=ߊއ~*z5cfJ^A/5j&pqhC?
1]tXvC Ju1#'$@9 *GӊRkTc)(}Hf
1# ҕf#& UWҮ,+Nc>H ZaUe=jeR)1LWPR61M^T ` Ik #ϩ!+jU=xԈTSG}J*6&fcV.9XkBNcQ5+Oj|AgZE#+
sk5Ȯd! 8fQQ'VÏMYU.0BЌY9I \Zs7"}.c2.y<p*OL?ȭUȠr-ŦpwM-%U(3$j:jXQ+( ?eƲ#
uv| 1#qt[;qo2)\ Bz
9Iݳ˝5"o&ϓnֳWauj|ʒ2Z%%XN=wQ4u<%Hbb J0̈́gz~UБ*+ wuLG~s\
5zjv'FS~wMN[I؏Csҕ/.Fs"vS5X5N\JEH ri94V
ȳl5`"m"0+z.Sg
jcRM& %qҢaJj&Ⱃ)2'PLVw4LJnjg|߅ic_W~a5Ey
@Ʀk
QkNԎ 9:} V?~3G
bőx[;?AcutYK Gq7Wc~avNբ<ʺuمmŶ
e̸OWD
O jξI,$eNFq?J̯J4{ҠqZv}mEP,$j,xӤ9d;Lo
}B*jSi泸@qC[qөKY9 qY- zӡx:ƲJ2C%r l.ՏqỀY+rSMnQ*UED..a`Ri Xj=XeR+ݑe?6H*r& a21y[mF汮VͬXEm;V V'sKR&|4Q\)jЅ.(ZW\h"UQ]0f+H8Ӆ sEfZs
('DJstQEoDU~(Q"cQEh74P3E(4QL,.iADPh\E
p44QRJ
P?uJEɐMTlkV۵VlfZVL呥 U؏J($sH~(ك$/LfRFlFZ+hSdlW-M1RW1Dur6
J(iI`d9Q]%2'872!zw4QNm
bQҚ(F)(bi\vGLK=&*dVa#v?SϨ}*g1t($ ^.n-[/&q V{If( RcQEգϮ8 &hXǴ4k#F*U>àZcǾxfmqw`r
(ĵd'L]
ƥY,i 7n E{{ٝ~2 ܑ?gY ,!Hқo-4QX'Q;&Ӳ5LVc( Click-7.0/examples/imagepipe/imagepipe.py 0000644 0001750 0001750 00000020351 13351553373 020706 0 ustar david david 0000000 0000000 import click
from functools import update_wrapper
from PIL import Image, ImageFilter, ImageEnhance
@click.group(chain=True)
def cli():
"""This script processes a bunch of images through pillow in a unix
pipe. One commands feeds into the next.
Example:
\b
imagepipe open -i example01.jpg resize -w 128 display
imagepipe open -i example02.jpg blur save
"""
@cli.resultcallback()
def process_commands(processors):
"""This result callback is invoked with an iterable of all the chained
subcommands. As in this example each subcommand returns a function
we can chain them together to feed one into the other, similar to how
a pipe on unix works.
"""
# Start with an empty iterable.
stream = ()
# Pipe it through all stream processors.
for processor in processors:
stream = processor(stream)
# Evaluate the stream and throw away the items.
for _ in stream:
pass
def processor(f):
"""Helper decorator to rewrite a function so that it returns another
function from it.
"""
def new_func(*args, **kwargs):
def processor(stream):
return f(stream, *args, **kwargs)
return processor
return update_wrapper(new_func, f)
def generator(f):
"""Similar to the :func:`processor` but passes through old values
unchanged and does not pass through the values as parameter.
"""
@processor
def new_func(stream, *args, **kwargs):
for item in stream:
yield item
for item in f(*args, **kwargs):
yield item
return update_wrapper(new_func, f)
def copy_filename(new, old):
new.filename = old.filename
return new
@cli.command('open')
@click.option('-i', '--image', 'images', type=click.Path(),
multiple=True, help='The image file to open.')
@generator
def open_cmd(images):
"""Loads one or multiple images for processing. The input parameter
can be specified multiple times to load more than one image.
"""
for image in images:
try:
click.echo('Opening "%s"' % image)
if image == '-':
img = Image.open(click.get_binary_stdin())
img.filename = '-'
else:
img = Image.open(image)
yield img
except Exception as e:
click.echo('Could not open image "%s": %s' % (image, e), err=True)
@cli.command('save')
@click.option('--filename', default='processed-%04d.png', type=click.Path(),
help='The format for the filename.',
show_default=True)
@processor
def save_cmd(images, filename):
"""Saves all processed images to a series of files."""
for idx, image in enumerate(images):
try:
fn = filename % (idx + 1)
click.echo('Saving "%s" as "%s"' % (image.filename, fn))
yield image.save(fn)
except Exception as e:
click.echo('Could not save image "%s": %s' %
(image.filename, e), err=True)
@cli.command('display')
@processor
def display_cmd(images):
"""Opens all images in an image viewer."""
for image in images:
click.echo('Displaying "%s"' % image.filename)
image.show()
yield image
@cli.command('resize')
@click.option('-w', '--width', type=int, help='The new width of the image.')
@click.option('-h', '--height', type=int, help='The new height of the image.')
@processor
def resize_cmd(images, width, height):
"""Resizes an image by fitting it into the box without changing
the aspect ratio.
"""
for image in images:
w, h = (width or image.size[0], height or image.size[1])
click.echo('Resizing "%s" to %dx%d' % (image.filename, w, h))
image.thumbnail((w, h))
yield image
@cli.command('crop')
@click.option('-b', '--border', type=int, help='Crop the image from all '
'sides by this amount.')
@processor
def crop_cmd(images, border):
"""Crops an image from all edges."""
for image in images:
box = [0, 0, image.size[0], image.size[1]]
if border is not None:
for idx, val in enumerate(box):
box[idx] = max(0, val - border)
click.echo('Cropping "%s" by %dpx' % (image.filename, border))
yield copy_filename(image.crop(box), image)
else:
yield image
def convert_rotation(ctx, param, value):
if value is None:
return
value = value.lower()
if value in ('90', 'r', 'right'):
return (Image.ROTATE_90, 90)
if value in ('180', '-180'):
return (Image.ROTATE_180, 180)
if value in ('-90', '270', 'l', 'left'):
return (Image.ROTATE_270, 270)
raise click.BadParameter('invalid rotation "%s"' % value)
def convert_flip(ctx, param, value):
if value is None:
return
value = value.lower()
if value in ('lr', 'leftright'):
return (Image.FLIP_LEFT_RIGHT, 'left to right')
if value in ('tb', 'topbottom', 'upsidedown', 'ud'):
return (Image.FLIP_LEFT_RIGHT, 'top to bottom')
raise click.BadParameter('invalid flip "%s"' % value)
@cli.command('transpose')
@click.option('-r', '--rotate', callback=convert_rotation,
help='Rotates the image (in degrees)')
@click.option('-f', '--flip', callback=convert_flip,
help='Flips the image [LR / TB]')
@processor
def transpose_cmd(images, rotate, flip):
"""Transposes an image by either rotating or flipping it."""
for image in images:
if rotate is not None:
mode, degrees = rotate
click.echo('Rotate "%s" by %ddeg' % (image.filename, degrees))
image = copy_filename(image.transpose(mode), image)
if flip is not None:
mode, direction = flip
click.echo('Flip "%s" %s' % (image.filename, direction))
image = copy_filename(image.transpose(mode), image)
yield image
@cli.command('blur')
@click.option('-r', '--radius', default=2, show_default=True,
help='The blur radius.')
@processor
def blur_cmd(images, radius):
"""Applies gaussian blur."""
blur = ImageFilter.GaussianBlur(radius)
for image in images:
click.echo('Blurring "%s" by %dpx' % (image.filename, radius))
yield copy_filename(image.filter(blur), image)
@cli.command('smoothen')
@click.option('-i', '--iterations', default=1, show_default=True,
help='How many iterations of the smoothen filter to run.')
@processor
def smoothen_cmd(images, iterations):
"""Applies a smoothening filter."""
for image in images:
click.echo('Smoothening "%s" %d time%s' %
(image.filename, iterations, iterations != 1 and 's' or '',))
for x in xrange(iterations):
image = copy_filename(image.filter(ImageFilter.BLUR), image)
yield image
@cli.command('emboss')
@processor
def emboss_cmd(images):
"""Embosses an image."""
for image in images:
click.echo('Embossing "%s"' % image.filename)
yield copy_filename(image.filter(ImageFilter.EMBOSS), image)
@cli.command('sharpen')
@click.option('-f', '--factor', default=2.0,
help='Sharpens the image.', show_default=True)
@processor
def sharpen_cmd(images, factor):
"""Sharpens an image."""
for image in images:
click.echo('Sharpen "%s" by %f' % (image.filename, factor))
enhancer = ImageEnhance.Sharpness(image)
yield copy_filename(enhancer.enhance(max(1.0, factor)), image)
@cli.command('paste')
@click.option('-l', '--left', default=0, help='Offset from left.')
@click.option('-r', '--right', default=0, help='Offset from right.')
@processor
def paste_cmd(images, left, right):
"""Pastes the second image on the first image and leaves the rest
unchanged.
"""
imageiter = iter(images)
image = next(imageiter, None)
to_paste = next(imageiter, None)
if to_paste is None:
if image is not None:
yield image
return
click.echo('Paste "%s" on "%s"' %
(to_paste.filename, image.filename))
mask = None
if to_paste.mode == 'RGBA' or 'transparency' in to_paste.info:
mask = to_paste
image.paste(to_paste, (left, right), mask)
image.filename += '+' + to_paste.filename
yield image
for image in imageiter:
yield image
Click-7.0/examples/imagepipe/setup.py 0000644 0001750 0001750 00000000464 13351553377 020115 0 ustar david david 0000000 0000000 from setuptools import setup
setup(
name='click-example-imagepipe',
version='1.0',
py_modules=['imagepipe'],
include_package_data=True,
install_requires=[
'click',
'pillow',
],
entry_points='''
[console_scripts]
imagepipe=imagepipe:cli
''',
)
Click-7.0/examples/inout/ 0000755 0001750 0001750 00000000000 13352517732 015571 5 ustar david david 0000000 0000000 Click-7.0/examples/inout/README 0000644 0001750 0001750 00000000354 13143622635 016450 0 ustar david david 0000000 0000000 $ inout_
inout is a simple example of an application that
can read from files and write to files but also
accept input from stdin or write to stdout.
Usage:
$ pip install --editable .
$ inout input_file.txt output_file.txt
Click-7.0/examples/inout/inout.py 0000644 0001750 0001750 00000001322 13351553367 017302 0 ustar david david 0000000 0000000 import click
@click.command()
@click.argument('input', type=click.File('rb'), nargs=-1)
@click.argument('output', type=click.File('wb'))
def cli(input, output):
"""This script works similar to the Unix `cat` command but it writes
into a specific file (which could be the standard output as denoted by
the ``-`` sign).
\b
Copy stdin to stdout:
inout - -
\b
Copy foo.txt and bar.txt to stdout:
inout foo.txt bar.txt -
\b
Write stdin into the file foo.txt
inout - foo.txt
"""
for f in input:
while True:
chunk = f.read(1024)
if not chunk:
break
output.write(chunk)
output.flush()
Click-7.0/examples/inout/setup.py 0000644 0001750 0001750 00000000422 13351553377 017305 0 ustar david david 0000000 0000000 from setuptools import setup
setup(
name='click-example-inout',
version='0.1',
py_modules=['inout'],
include_package_data=True,
install_requires=[
'click',
],
entry_points='''
[console_scripts]
inout=inout:cli
''',
)
Click-7.0/examples/naval/ 0000755 0001750 0001750 00000000000 13352517732 015534 5 ustar david david 0000000 0000000 Click-7.0/examples/naval/README 0000644 0001750 0001750 00000000542 13143622635 016412 0 ustar david david 0000000 0000000 $ naval_
naval is a simple example of an application that
is ported from the docopt example of the same name.
Unlike the original this one also runs some code and
prints messages and it's command line interface was
changed slightly to make more sense with established
POSIX semantics.
Usage:
$ pip install --editable .
$ naval --help
Click-7.0/examples/naval/naval.py 0000644 0001750 0001750 00000003344 13351553367 017216 0 ustar david david 0000000 0000000 import click
@click.group()
@click.version_option()
def cli():
"""Naval Fate.
This is the docopt example adopted to Click but with some actual
commands implemented and not just the empty parsing which really
is not all that interesting.
"""
@cli.group()
def ship():
"""Manages ships."""
@ship.command('new')
@click.argument('name')
def ship_new(name):
"""Creates a new ship."""
click.echo('Created ship %s' % name)
@ship.command('move')
@click.argument('ship')
@click.argument('x', type=float)
@click.argument('y', type=float)
@click.option('--speed', metavar='KN', default=10,
help='Speed in knots.')
def ship_move(ship, x, y, speed):
"""Moves SHIP to the new location X,Y."""
click.echo('Moving ship %s to %s,%s with speed %s' % (ship, x, y, speed))
@ship.command('shoot')
@click.argument('ship')
@click.argument('x', type=float)
@click.argument('y', type=float)
def ship_shoot(ship, x, y):
"""Makes SHIP fire to X,Y."""
click.echo('Ship %s fires to %s,%s' % (ship, x, y))
@cli.group('mine')
def mine():
"""Manages mines."""
@mine.command('set')
@click.argument('x', type=float)
@click.argument('y', type=float)
@click.option('ty', '--moored', flag_value='moored',
default=True,
help='Moored (anchored) mine. Default.')
@click.option('ty', '--drifting', flag_value='drifting',
help='Drifting mine.')
def mine_set(x, y, ty):
"""Sets a mine at a specific coordinate."""
click.echo('Set %s mine at %s,%s' % (ty, x, y))
@mine.command('remove')
@click.argument('x', type=float)
@click.argument('y', type=float)
def mine_remove(x, y):
"""Removes a mine at a specific coordinate."""
click.echo('Removed mine at %s,%s' % (x, y))
Click-7.0/examples/naval/setup.py 0000644 0001750 0001750 00000000422 13351553377 017250 0 ustar david david 0000000 0000000 from setuptools import setup
setup(
name='click-example-naval',
version='2.0',
py_modules=['naval'],
include_package_data=True,
install_requires=[
'click',
],
entry_points='''
[console_scripts]
naval=naval:cli
''',
)
Click-7.0/examples/repo/ 0000755 0001750 0001750 00000000000 13352517732 015400 5 ustar david david 0000000 0000000 Click-7.0/examples/repo/README 0000644 0001750 0001750 00000000231 13143622635 016251 0 ustar david david 0000000 0000000 $ repo_
repo is a simple example of an application that looks
and works similar to hg or git.
Usage:
$ pip install --editable .
$ repo --help
Click-7.0/examples/repo/repo.py 0000644 0001750 0001750 00000011302 13351553367 016717 0 ustar david david 0000000 0000000 import os
import sys
import posixpath
import click
class Repo(object):
def __init__(self, home):
self.home = home
self.config = {}
self.verbose = False
def set_config(self, key, value):
self.config[key] = value
if self.verbose:
click.echo(' config[%s] = %s' % (key, value), file=sys.stderr)
def __repr__(self):
return '' % self.home
pass_repo = click.make_pass_decorator(Repo)
@click.group()
@click.option('--repo-home', envvar='REPO_HOME', default='.repo',
metavar='PATH', help='Changes the repository folder location.')
@click.option('--config', nargs=2, multiple=True,
metavar='KEY VALUE', help='Overrides a config key/value pair.')
@click.option('--verbose', '-v', is_flag=True,
help='Enables verbose mode.')
@click.version_option('1.0')
@click.pass_context
def cli(ctx, repo_home, config, verbose):
"""Repo is a command line tool that showcases how to build complex
command line interfaces with Click.
This tool is supposed to look like a distributed version control
system to show how something like this can be structured.
"""
# Create a repo object and remember it as as the context object. From
# this point onwards other commands can refer to it by using the
# @pass_repo decorator.
ctx.obj = Repo(os.path.abspath(repo_home))
ctx.obj.verbose = verbose
for key, value in config:
ctx.obj.set_config(key, value)
@cli.command()
@click.argument('src')
@click.argument('dest', required=False)
@click.option('--shallow/--deep', default=False,
help='Makes a checkout shallow or deep. Deep by default.')
@click.option('--rev', '-r', default='HEAD',
help='Clone a specific revision instead of HEAD.')
@pass_repo
def clone(repo, src, dest, shallow, rev):
"""Clones a repository.
This will clone the repository at SRC into the folder DEST. If DEST
is not provided this will automatically use the last path component
of SRC and create that folder.
"""
if dest is None:
dest = posixpath.split(src)[-1] or '.'
click.echo('Cloning repo %s to %s' % (src, os.path.abspath(dest)))
repo.home = dest
if shallow:
click.echo('Making shallow checkout')
click.echo('Checking out revision %s' % rev)
@cli.command()
@click.confirmation_option()
@pass_repo
def delete(repo):
"""Deletes a repository.
This will throw away the current repository.
"""
click.echo('Destroying repo %s' % repo.home)
click.echo('Deleted!')
@cli.command()
@click.option('--username', prompt=True,
help='The developer\'s shown username.')
@click.option('--email', prompt='E-Mail',
help='The developer\'s email address')
@click.password_option(help='The login password.')
@pass_repo
def setuser(repo, username, email, password):
"""Sets the user credentials.
This will override the current user config.
"""
repo.set_config('username', username)
repo.set_config('email', email)
repo.set_config('password', '*' * len(password))
click.echo('Changed credentials.')
@cli.command()
@click.option('--message', '-m', multiple=True,
help='The commit message. If provided multiple times each '
'argument gets converted into a new line.')
@click.argument('files', nargs=-1, type=click.Path())
@pass_repo
def commit(repo, files, message):
"""Commits outstanding changes.
Commit changes to the given files into the repository. You will need to
"repo push" to push up your changes to other repositories.
If a list of files is omitted, all changes reported by "repo status"
will be committed.
"""
if not message:
marker = '# Files to be committed:'
hint = ['', '', marker, '#']
for file in files:
hint.append('# U %s' % file)
message = click.edit('\n'.join(hint))
if message is None:
click.echo('Aborted!')
return
msg = message.split(marker)[0].rstrip()
if not msg:
click.echo('Aborted! Empty commit message')
return
else:
msg = '\n'.join(message)
click.echo('Files to be committed: %s' % (files,))
click.echo('Commit message:\n' + msg)
@cli.command(short_help='Copies files.')
@click.option('--force', is_flag=True,
help='forcibly copy over an existing managed file')
@click.argument('src', nargs=-1, type=click.Path())
@click.argument('dst', type=click.Path())
@pass_repo
def copy(repo, src, dst, force):
"""Copies one or multiple files to a new location. This copies all
files from SRC to DST.
"""
for fn in src:
click.echo('Copy from %s -> %s' % (fn, dst))
Click-7.0/examples/repo/setup.py 0000644 0001750 0001750 00000000416 13351553377 017117 0 ustar david david 0000000 0000000 from setuptools import setup
setup(
name='click-example-repo',
version='0.1',
py_modules=['repo'],
include_package_data=True,
install_requires=[
'click',
],
entry_points='''
[console_scripts]
repo=repo:cli
''',
)
Click-7.0/examples/termui/ 0000755 0001750 0001750 00000000000 13352517732 015740 5 ustar david david 0000000 0000000 Click-7.0/examples/termui/README 0000644 0001750 0001750 00000000217 13351553373 016620 0 ustar david david 0000000 0000000 $ termui_
termui showcases the different terminal UI helpers that
Click provides.
Usage:
$ pip install --editable .
$ termui --help
Click-7.0/examples/termui/setup.py 0000644 0001750 0001750 00000000533 13351553377 017457 0 ustar david david 0000000 0000000 from setuptools import setup
setup(
name='click-example-termui',
version='1.0',
py_modules=['termui'],
include_package_data=True,
install_requires=[
'click',
# Colorama is only required for Windows.
'colorama',
],
entry_points='''
[console_scripts]
termui=termui:cli
''',
)
Click-7.0/examples/termui/termui.py 0000644 0001750 0001750 00000010354 13351553377 017626 0 ustar david david 0000000 0000000 # coding: utf-8
import click
import math
import time
import random
try:
range_type = xrange
except NameError:
range_type = range
@click.group()
def cli():
"""This script showcases different terminal UI helpers in Click."""
pass
@cli.command()
def colordemo():
"""Demonstrates ANSI color support."""
for color in 'red', 'green', 'blue':
click.echo(click.style('I am colored %s' % color, fg=color))
click.echo(click.style('I am background colored %s' % color, bg=color))
@cli.command()
def pager():
"""Demonstrates using the pager."""
lines = []
for x in range_type(200):
lines.append('%s. Hello World!' % click.style(str(x), fg='green'))
click.echo_via_pager('\n'.join(lines))
@cli.command()
@click.option('--count', default=8000, type=click.IntRange(1, 100000),
help='The number of items to process.')
def progress(count):
"""Demonstrates the progress bar."""
items = range_type(count)
def process_slowly(item):
time.sleep(0.002 * random.random())
def filter(items):
for item in items:
if random.random() > 0.3:
yield item
with click.progressbar(items, label='Processing accounts',
fill_char=click.style('#', fg='green')) as bar:
for item in bar:
process_slowly(item)
def show_item(item):
if item is not None:
return 'Item #%d' % item
with click.progressbar(filter(items), label='Committing transaction',
fill_char=click.style('#', fg='yellow'),
item_show_func=show_item) as bar:
for item in bar:
process_slowly(item)
with click.progressbar(length=count, label='Counting',
bar_template='%(label)s %(bar)s | %(info)s',
fill_char=click.style(u'█', fg='cyan'),
empty_char=' ') as bar:
for item in bar:
process_slowly(item)
with click.progressbar(length=count, width=0, show_percent=False,
show_eta=False,
fill_char=click.style('#', fg='magenta')) as bar:
for item in bar:
process_slowly(item)
# 'Non-linear progress bar'
steps = [math.exp( x * 1. / 20) - 1 for x in range(20)]
count = int(sum(steps))
with click.progressbar(length=count, show_percent=False,
label='Slowing progress bar',
fill_char=click.style(u'█', fg='green')) as bar:
for item in steps:
time.sleep(item)
bar.update(item)
@cli.command()
@click.argument('url')
def open(url):
"""Opens a file or URL In the default application."""
click.launch(url)
@cli.command()
@click.argument('url')
def locate(url):
"""Opens a file or URL In the default application."""
click.launch(url, locate=True)
@cli.command()
def edit():
"""Opens an editor with some text in it."""
MARKER = '# Everything below is ignored\n'
message = click.edit('\n\n' + MARKER)
if message is not None:
msg = message.split(MARKER, 1)[0].rstrip('\n')
if not msg:
click.echo('Empty message!')
else:
click.echo('Message:\n' + msg)
else:
click.echo('You did not enter anything!')
@cli.command()
def clear():
"""Clears the entire screen."""
click.clear()
@cli.command()
def pause():
"""Waits for the user to press a button."""
click.pause()
@cli.command()
def menu():
"""Shows a simple menu."""
menu = 'main'
while 1:
if menu == 'main':
click.echo('Main menu:')
click.echo(' d: debug menu')
click.echo(' q: quit')
char = click.getchar()
if char == 'd':
menu = 'debug'
elif char == 'q':
menu = 'quit'
else:
click.echo('Invalid input')
elif menu == 'debug':
click.echo('Debug menu')
click.echo(' b: back')
char = click.getchar()
if char == 'b':
menu = 'main'
else:
click.echo('Invalid input')
elif menu == 'quit':
return
Click-7.0/examples/validation/ 0000755 0001750 0001750 00000000000 13352517732 016565 5 ustar david david 0000000 0000000 Click-7.0/examples/validation/README 0000644 0001750 0001750 00000000361 13351553367 017450 0 ustar david david 0000000 0000000 $ validation_
validation is a simple example of an application that
performs custom validation of parameters in different
ways.
This example requires Click 2.0 or higher.
Usage:
$ pip install --editable .
$ validation --help
Click-7.0/examples/validation/setup.py 0000644 0001750 0001750 00000000446 13351553377 020307 0 ustar david david 0000000 0000000 from setuptools import setup
setup(
name='click-example-validation',
version='1.0',
py_modules=['validation'],
include_package_data=True,
install_requires=[
'click',
],
entry_points='''
[console_scripts]
validation=validation:cli
''',
)
Click-7.0/examples/validation/validation.py 0000644 0001750 0001750 00000002623 13351570514 021270 0 ustar david david 0000000 0000000 import click
try:
from urllib import parse as urlparse
except ImportError:
import urlparse
def validate_count(ctx, param, value):
if value < 0 or value % 2 != 0:
raise click.BadParameter('Should be a positive, even integer.')
return value
class URL(click.ParamType):
name = 'url'
def convert(self, value, param, ctx):
if not isinstance(value, tuple):
value = urlparse.urlparse(value)
if value.scheme not in ('http', 'https'):
self.fail('invalid URL scheme (%s). Only HTTP URLs are '
'allowed' % value.scheme, param, ctx)
return value
@click.command()
@click.option('--count', default=2, callback=validate_count,
help='A positive even number.')
@click.option('--foo', help='A mysterious parameter.')
@click.option('--url', help='A URL', type=URL())
@click.version_option()
def cli(count, foo, url):
"""Validation.
This example validates parameters in different ways. It does it
through callbacks, through a custom type as well as by validating
manually in the function.
"""
if foo is not None and foo != 'wat':
raise click.BadParameter('If a value is provided it needs to be the '
'value "wat".', param_hint=['--foo'])
click.echo('count: %s' % count)
click.echo('foo: %s' % foo)
click.echo('url: %s' % repr(url))
Click-7.0/setup.cfg 0000644 0001750 0001750 00000000453 13352517732 014440 0 ustar david david 0000000 0000000 [metadata]
license_file = LICENSE.rst
[bdist_wheel]
universal = 1
[tool:pytest]
testpaths = tests
[coverage:run]
branch = True
source =
click
tests
[coverage:paths]
source =
click
.tox/*/lib/python*/site-packages/click
.tox/pypy/site-packages/click
[egg_info]
tag_build =
tag_date = 0
Click-7.0/setup.py 0000644 0001750 0001750 00000003026 13352433170 014321 0 ustar david david 0000000 0000000 import io
import re
from setuptools import setup
with io.open("README.rst", "rt", encoding="utf8") as f:
readme = f.read()
with io.open("click/__init__.py", "rt", encoding="utf8") as f:
version = re.search(r"__version__ = \'(.*?)\'", f.read()).group(1)
setup(
name="Click",
version=version,
url="https://palletsprojects.com/p/click/",
project_urls={
"Documentation": "https://click.palletsprojects.com/",
"Code": "https://github.com/pallets/click",
"Issue tracker": "https://github.com/pallets/click/issues",
},
license="BSD",
author="Armin Ronacher",
author_email="armin.ronacher@active-4.com",
maintainer="Pallets Team",
maintainer_email="contact@palletsprojects.com",
description="Composable command line interface toolkit",
long_description=readme,
packages=["click"],
include_package_data=True,
python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*",
classifiers=[
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.4",
"Programming Language :: Python :: 3.5",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
],
)
Click-7.0/tests/ 0000755 0001750 0001750 00000000000 13352517732 013757 5 ustar david david 0000000 0000000 Click-7.0/tests/conftest.py 0000644 0001750 0001750 00000000203 13143622635 016146 0 ustar david david 0000000 0000000 from click.testing import CliRunner
import pytest
@pytest.fixture(scope='function')
def runner(request):
return CliRunner()
Click-7.0/tests/test_arguments.py 0000644 0001750 0001750 00000017271 13351570514 017401 0 ustar david david 0000000 0000000 # -*- coding: utf-8 -*-
import pytest
import click
from click._compat import PY2
def test_nargs_star(runner):
@click.command()
@click.argument('src', nargs=-1)
@click.argument('dst')
def copy(src, dst):
click.echo('src=%s' % '|'.join(src))
click.echo('dst=%s' % dst)
result = runner.invoke(copy, ['foo.txt', 'bar.txt', 'dir'])
assert not result.exception
assert result.output.splitlines() == [
'src=foo.txt|bar.txt',
'dst=dir',
]
def test_nargs_default(runner):
try:
@click.command()
@click.argument('src', nargs=-1, default=42)
def copy(src):
pass
except TypeError as e:
assert 'nargs=-1' in str(e)
else:
assert False
def test_nargs_tup(runner):
@click.command()
@click.argument('name', nargs=1)
@click.argument('point', nargs=2, type=click.INT)
def copy(name, point):
click.echo('name=%s' % name)
click.echo('point=%d/%d' % point)
result = runner.invoke(copy, ['peter', '1', '2'])
assert not result.exception
assert result.output.splitlines() == [
'name=peter',
'point=1/2',
]
def test_nargs_tup_composite(runner):
variations = [
dict(type=(str, int)),
dict(type=click.Tuple([str, int])),
dict(nargs=2, type=click.Tuple([str, int])),
dict(nargs=2, type=(str, int)),
]
for opts in variations:
@click.command()
@click.argument('item', **opts)
def copy(item):
click.echo('name=%s id=%d' % item)
result = runner.invoke(copy, ['peter', '1'])
assert not result.exception
assert result.output.splitlines() == [
'name=peter id=1',
]
def test_nargs_err(runner):
@click.command()
@click.argument('x')
def copy(x):
click.echo(x)
result = runner.invoke(copy, ['foo'])
assert not result.exception
assert result.output == 'foo\n'
result = runner.invoke(copy, ['foo', 'bar'])
assert result.exit_code == 2
assert 'Got unexpected extra argument (bar)' in result.output
def test_file_args(runner):
@click.command()
@click.argument('input', type=click.File('rb'))
@click.argument('output', type=click.File('wb'))
def inout(input, output):
while True:
chunk = input.read(1024)
if not chunk:
break
output.write(chunk)
with runner.isolated_filesystem():
result = runner.invoke(inout, ['-', 'hello.txt'], input='Hey!')
assert result.output == ''
assert result.exit_code == 0
with open('hello.txt', 'rb') as f:
assert f.read() == b'Hey!'
result = runner.invoke(inout, ['hello.txt', '-'])
assert result.output == 'Hey!'
assert result.exit_code == 0
def test_path_args(runner):
@click.command()
@click.argument('input', type=click.Path(dir_okay=False, allow_dash=True))
def foo(input):
click.echo(input)
result = runner.invoke(foo, ['-'])
assert result.output == '-\n'
assert result.exit_code == 0
def test_file_atomics(runner):
@click.command()
@click.argument('output', type=click.File('wb', atomic=True))
def inout(output):
output.write(b'Foo bar baz\n')
output.flush()
with open(output.name, 'rb') as f:
old_content = f.read()
assert old_content == b'OLD\n'
with runner.isolated_filesystem():
with open('foo.txt', 'wb') as f:
f.write(b'OLD\n')
result = runner.invoke(inout, ['foo.txt'], input='Hey!',
catch_exceptions=False)
assert result.output == ''
assert result.exit_code == 0
with open('foo.txt', 'rb') as f:
assert f.read() == b'Foo bar baz\n'
def test_stdout_default(runner):
@click.command()
@click.argument('output', type=click.File('w'), default='-')
def inout(output):
output.write('Foo bar baz\n')
output.flush()
result = runner.invoke(inout, [])
assert not result.exception
assert result.output == 'Foo bar baz\n'
def test_nargs_envvar(runner):
@click.command()
@click.option('--arg', nargs=2)
def cmd(arg):
click.echo('|'.join(arg))
result = runner.invoke(cmd, [], auto_envvar_prefix='TEST',
env={'TEST_ARG': 'foo bar'})
assert not result.exception
assert result.output == 'foo|bar\n'
@click.command()
@click.option('--arg', envvar='X', nargs=2)
def cmd(arg):
click.echo('|'.join(arg))
result = runner.invoke(cmd, [], env={'X': 'foo bar'})
assert not result.exception
assert result.output == 'foo|bar\n'
def test_empty_nargs(runner):
@click.command()
@click.argument('arg', nargs=-1)
def cmd(arg):
click.echo('arg:' + '|'.join(arg))
result = runner.invoke(cmd, [])
assert result.exit_code == 0
assert result.output == 'arg:\n'
@click.command()
@click.argument('arg', nargs=-1, required=True)
def cmd2(arg):
click.echo('arg:' + '|'.join(arg))
result = runner.invoke(cmd2, [])
assert result.exit_code == 2
assert 'Missing argument "ARG..."' in result.output
def test_missing_arg(runner):
@click.command()
@click.argument('arg')
def cmd(arg):
click.echo('arg:' + arg)
result = runner.invoke(cmd, [])
assert result.exit_code == 2
assert 'Missing argument "ARG".' in result.output
def test_implicit_non_required(runner):
@click.command()
@click.argument('f', default='test')
def cli(f):
click.echo(f)
result = runner.invoke(cli, [])
assert result.exit_code == 0
assert result.output == 'test\n'
def test_eat_options(runner):
@click.command()
@click.option('-f')
@click.argument('files', nargs=-1)
def cmd(f, files):
for filename in files:
click.echo(filename)
click.echo(f)
result = runner.invoke(cmd, ['--', '-foo', 'bar'])
assert result.output.splitlines() == [
'-foo',
'bar',
'',
]
result = runner.invoke(cmd, ['-f', '-x', '--', '-foo', 'bar'])
assert result.output.splitlines() == [
'-foo',
'bar',
'-x',
]
def test_nargs_star_ordering(runner):
@click.command()
@click.argument('a', nargs=-1)
@click.argument('b')
@click.argument('c')
def cmd(a, b, c):
for arg in (a, b, c):
click.echo(arg)
result = runner.invoke(cmd, ['a', 'b', 'c'])
assert result.output.splitlines() == [
PY2 and "(u'a',)" or "('a',)",
'b',
'c',
]
def test_nargs_specified_plus_star_ordering(runner):
@click.command()
@click.argument('a', nargs=-1)
@click.argument('b')
@click.argument('c', nargs=2)
def cmd(a, b, c):
for arg in (a, b, c):
click.echo(arg)
result = runner.invoke(cmd, ['a', 'b', 'c', 'd', 'e', 'f'])
assert result.output.splitlines() == [
PY2 and "(u'a', u'b', u'c')" or "('a', 'b', 'c')",
'd',
PY2 and "(u'e', u'f')" or "('e', 'f')",
]
def test_defaults_for_nargs(runner):
@click.command()
@click.argument('a', nargs=2, type=int, default=(1, 2))
def cmd(a):
x, y = a
click.echo(x + y)
result = runner.invoke(cmd, [])
assert result.output.strip() == '3'
result = runner.invoke(cmd, ['3', '4'])
assert result.output.strip() == '7'
result = runner.invoke(cmd, ['3'])
assert result.exception is not None
assert 'argument a takes 2 values' in result.output
def test_multiple_param_decls_not_allowed(runner):
with pytest.raises(TypeError):
@click.command()
@click.argument('x', click.Choice(['a', 'b']))
def copy(x):
click.echo(x)
Click-7.0/tests/test_bashcomplete.py 0000644 0001750 0001750 00000035605 13351570514 020043 0 ustar david david 0000000 0000000 # -*- coding: utf-8 -*-
import click
from click._bashcomplete import get_choices
def choices_without_help(cli, args, incomplete):
completions = get_choices(cli, 'dummy', args, incomplete)
return [c[0] for c in completions]
def choices_with_help(cli, args, incomplete):
return list(get_choices(cli, 'dummy', args, incomplete))
def test_single_command():
@click.command()
@click.option('--local-opt')
def cli(local_opt):
pass
assert choices_without_help(cli, [], '-') == ['--local-opt']
assert choices_without_help(cli, [], '') == []
def test_boolean_flag():
@click.command()
@click.option('--shout/--no-shout', default=False)
def cli(local_opt):
pass
assert choices_without_help(cli, [], '-') == ['--shout', '--no-shout']
def test_multi_value_option():
@click.group()
@click.option('--pos', nargs=2, type=float)
def cli(local_opt):
pass
@cli.command()
@click.option('--local-opt')
def sub(local_opt):
pass
assert choices_without_help(cli, [], '-') == ['--pos']
assert choices_without_help(cli, ['--pos'], '') == []
assert choices_without_help(cli, ['--pos', '1.0'], '') == []
assert choices_without_help(cli, ['--pos', '1.0', '1.0'], '') == ['sub']
def test_multi_option():
@click.command()
@click.option('--message', '-m', multiple=True)
def cli(local_opt):
pass
assert choices_without_help(cli, [], '-') == ['--message', '-m']
assert choices_without_help(cli, ['-m'], '') == []
def test_small_chain():
@click.group()
@click.option('--global-opt')
def cli(global_opt):
pass
@cli.command()
@click.option('--local-opt')
def sub(local_opt):
pass
assert choices_without_help(cli, [], '') == ['sub']
assert choices_without_help(cli, [], '-') == ['--global-opt']
assert choices_without_help(cli, ['sub'], '') == []
assert choices_without_help(cli, ['sub'], '-') == ['--local-opt']
def test_long_chain():
@click.group('cli')
@click.option('--cli-opt')
def cli(cli_opt):
pass
@cli.group('asub')
@click.option('--asub-opt')
def asub(asub_opt):
pass
@asub.group('bsub')
@click.option('--bsub-opt')
def bsub(bsub_opt):
pass
COLORS = ['red', 'green', 'blue']
def get_colors(ctx, args, incomplete):
for c in COLORS:
if c.startswith(incomplete):
yield c
def search_colors(ctx, args, incomplete):
for c in COLORS:
if incomplete in c:
yield c
CSUB_OPT_CHOICES = ['foo', 'bar']
CSUB_CHOICES = ['bar', 'baz']
@bsub.command('csub')
@click.option('--csub-opt', type=click.Choice(CSUB_OPT_CHOICES))
@click.option('--csub', type=click.Choice(CSUB_CHOICES))
@click.option('--search-color', autocompletion=search_colors)
@click.argument('color', autocompletion=get_colors)
def csub(csub_opt, color):
pass
assert choices_without_help(cli, [], '-') == ['--cli-opt']
assert choices_without_help(cli, [], '') == ['asub']
assert choices_without_help(cli, ['asub'], '-') == ['--asub-opt']
assert choices_without_help(cli, ['asub'], '') == ['bsub']
assert choices_without_help(cli, ['asub', 'bsub'], '-') == ['--bsub-opt']
assert choices_without_help(cli, ['asub', 'bsub'], '') == ['csub']
assert choices_without_help(cli, ['asub', 'bsub', 'csub'], '-') == ['--csub-opt', '--csub', '--search-color']
assert choices_without_help(cli, ['asub', 'bsub', 'csub', '--csub-opt'], '') == CSUB_OPT_CHOICES
assert choices_without_help(cli, ['asub', 'bsub', 'csub'], '--csub') == ['--csub-opt', '--csub']
assert choices_without_help(cli, ['asub', 'bsub', 'csub', '--csub'], '') == CSUB_CHOICES
assert choices_without_help(cli, ['asub', 'bsub', 'csub', '--csub-opt'], 'f') == ['foo']
assert choices_without_help(cli, ['asub', 'bsub', 'csub'], '') == COLORS
assert choices_without_help(cli, ['asub', 'bsub', 'csub'], 'b') == ['blue']
assert choices_without_help(cli, ['asub', 'bsub', 'csub', '--search-color'], 'een') == ['green']
def test_chaining():
@click.group('cli', chain=True)
@click.option('--cli-opt')
@click.argument('arg', type=click.Choice(['cliarg1', 'cliarg2']))
def cli(cli_opt, arg):
pass
@cli.command()
@click.option('--asub-opt')
def asub(asub_opt):
pass
@cli.command(help='bsub help')
@click.option('--bsub-opt')
@click.argument('arg', type=click.Choice(['arg1', 'arg2']))
def bsub(bsub_opt, arg):
pass
@cli.command()
@click.option('--csub-opt')
@click.argument('arg', type=click.Choice(['carg1', 'carg2']), default='carg1')
def csub(csub_opt, arg):
pass
assert choices_without_help(cli, [], '-') == ['--cli-opt']
assert choices_without_help(cli, [], '') == ['cliarg1', 'cliarg2']
assert choices_without_help(cli, ['cliarg1', 'asub'], '-') == ['--asub-opt']
assert choices_without_help(cli, ['cliarg1', 'asub'], '') == ['bsub', 'csub']
assert choices_without_help(cli, ['cliarg1', 'bsub'], '') == ['arg1', 'arg2']
assert choices_without_help(cli, ['cliarg1', 'asub', '--asub-opt'], '') == []
assert choices_without_help(cli, ['cliarg1', 'asub', '--asub-opt', '5', 'bsub'], '-') == ['--bsub-opt']
assert choices_without_help(cli, ['cliarg1', 'asub', 'bsub'], '-') == ['--bsub-opt']
assert choices_without_help(cli, ['cliarg1', 'asub', 'csub'], '') == ['carg1', 'carg2']
assert choices_without_help(cli, ['cliarg1', 'bsub', 'arg1', 'csub'], '') == ['carg1', 'carg2']
assert choices_without_help(cli, ['cliarg1', 'asub', 'csub'], '-') == ['--csub-opt']
assert choices_with_help(cli, ['cliarg1', 'asub'], 'b') == [('bsub', 'bsub help')]
def test_argument_choice():
@click.command()
@click.argument('arg1', required=True, type=click.Choice(['arg11', 'arg12']))
@click.argument('arg2', type=click.Choice(['arg21', 'arg22']), default='arg21')
@click.argument('arg3', type=click.Choice(['arg', 'argument']), default='arg')
def cli():
pass
assert choices_without_help(cli, [], '') == ['arg11', 'arg12']
assert choices_without_help(cli, [], 'arg') == ['arg11', 'arg12']
assert choices_without_help(cli, ['arg11'], '') == ['arg21', 'arg22']
assert choices_without_help(cli, ['arg12', 'arg21'], '') == ['arg', 'argument']
assert choices_without_help(cli, ['arg12', 'arg21'], 'argu') == ['argument']
def test_option_choice():
@click.command()
@click.option('--opt1', type=click.Choice(['opt11', 'opt12']), help='opt1 help')
@click.option('--opt2', type=click.Choice(['opt21', 'opt22']), default='opt21')
@click.option('--opt3', type=click.Choice(['opt', 'option']))
def cli():
pass
assert choices_with_help(cli, [], '-') == [('--opt1', 'opt1 help'),
('--opt2', None),
('--opt3', None)]
assert choices_without_help(cli, [], '--opt') == ['--opt1', '--opt2', '--opt3']
assert choices_without_help(cli, [], '--opt1=') == ['opt11', 'opt12']
assert choices_without_help(cli, [], '--opt2=') == ['opt21', 'opt22']
assert choices_without_help(cli, ['--opt2'], '=') == ['opt21', 'opt22']
assert choices_without_help(cli, ['--opt2', '='], 'opt') == ['opt21', 'opt22']
assert choices_without_help(cli, ['--opt1'], '') == ['opt11', 'opt12']
assert choices_without_help(cli, ['--opt2'], '') == ['opt21', 'opt22']
assert choices_without_help(cli, ['--opt1', 'opt11', '--opt2'], '') == ['opt21', 'opt22']
assert choices_without_help(cli, ['--opt2', 'opt21'], '-') == ['--opt1', '--opt3']
assert choices_without_help(cli, ['--opt1', 'opt11'], '-') == ['--opt2', '--opt3']
assert choices_without_help(cli, ['--opt1'], 'opt') == ['opt11', 'opt12']
assert choices_without_help(cli, ['--opt3'], 'opti') == ['option']
assert choices_without_help(cli, ['--opt1', 'invalid_opt'], '-') == ['--opt2', '--opt3']
def test_option_and_arg_choice():
@click.command()
@click.option('--opt1', type=click.Choice(['opt11', 'opt12']))
@click.argument('arg1', required=False, type=click.Choice(['arg11', 'arg12']))
@click.option('--opt2', type=click.Choice(['opt21', 'opt22']))
def cli():
pass
assert choices_without_help(cli, ['--opt1'], '') == ['opt11', 'opt12']
assert choices_without_help(cli, [''], '--opt1=') == ['opt11', 'opt12']
assert choices_without_help(cli, [], '') == ['arg11', 'arg12']
assert choices_without_help(cli, ['--opt2'], '') == ['opt21', 'opt22']
assert choices_without_help(cli, ['arg11'], '--opt') == ['--opt1', '--opt2']
assert choices_without_help(cli, [], '--opt') == ['--opt1', '--opt2']
def test_boolean_flag_choice():
@click.command()
@click.option('--shout/--no-shout', default=False)
@click.argument('arg', required=False, type=click.Choice(['arg1', 'arg2']))
def cli(local_opt):
pass
assert choices_without_help(cli, [], '-') == ['--shout', '--no-shout']
assert choices_without_help(cli, ['--shout'], '') == ['arg1', 'arg2']
def test_multi_value_option_choice():
@click.command()
@click.option('--pos', nargs=2, type=click.Choice(['pos1', 'pos2']))
@click.argument('arg', required=False, type=click.Choice(['arg1', 'arg2']))
def cli(local_opt):
pass
assert choices_without_help(cli, ['--pos'], '') == ['pos1', 'pos2']
assert choices_without_help(cli, ['--pos', 'pos1'], '') == ['pos1', 'pos2']
assert choices_without_help(cli, ['--pos', 'pos1', 'pos2'], '') == ['arg1', 'arg2']
assert choices_without_help(cli, ['--pos', 'pos1', 'pos2', 'arg1'], '') == []
def test_multi_option_choice():
@click.command()
@click.option('--message', '-m', multiple=True, type=click.Choice(['m1', 'm2']))
@click.argument('arg', required=False, type=click.Choice(['arg1', 'arg2']))
def cli(local_opt):
pass
assert choices_without_help(cli, ['-m'], '') == ['m1', 'm2']
assert choices_without_help(cli, ['-m', 'm1', '-m'], '') == ['m1', 'm2']
assert choices_without_help(cli, ['-m', 'm1'], '') == ['arg1', 'arg2']
def test_variadic_argument_choice():
@click.command()
@click.option('--opt', type=click.Choice(['opt1', 'opt2']))
@click.argument('src', nargs=-1, type=click.Choice(['src1', 'src2']))
def cli(local_opt):
pass
assert choices_without_help(cli, ['src1', 'src2'], '') == ['src1', 'src2']
assert choices_without_help(cli, ['src1', 'src2'], '--o') == ['--opt']
assert choices_without_help(cli, ['src1', 'src2', '--opt'], '') == ['opt1', 'opt2']
assert choices_without_help(cli, ['src1', 'src2'], '') == ['src1', 'src2']
def test_variadic_argument_complete():
def _complete(ctx, args, incomplete):
return ['abc', 'def', 'ghi', 'jkl', 'mno', 'pqr', 'stu', 'vwx', 'yz']
@click.group()
def entrypoint():
pass
@click.command()
@click.option('--opt', autocompletion=_complete)
@click.argument('arg', nargs=-1)
def subcommand(opt, arg):
pass
entrypoint.add_command(subcommand)
assert choices_without_help(entrypoint, ['subcommand', '--opt'], '') == _complete(0,0,0)
assert choices_without_help(entrypoint, ['subcommand', 'whatever', '--opt'], '') == _complete(0,0,0)
assert choices_without_help(entrypoint, ['subcommand', 'whatever', '--opt', 'abc'], '') == []
def test_long_chain_choice():
@click.group()
def cli():
pass
@cli.group()
@click.option('--sub-opt', type=click.Choice(['subopt1', 'subopt2']))
@click.argument('sub-arg', required=False, type=click.Choice(['subarg1', 'subarg2']))
def sub(sub_opt, sub_arg):
pass
@sub.command(short_help='bsub help')
@click.option('--bsub-opt', type=click.Choice(['bsubopt1', 'bsubopt2']))
@click.argument('bsub-arg1', required=False, type=click.Choice(['bsubarg1', 'bsubarg2']))
@click.argument('bbsub-arg2', required=False, type=click.Choice(['bbsubarg1', 'bbsubarg2']))
def bsub(bsub_opt):
pass
@sub.group('csub')
def csub():
pass
@csub.command()
def dsub():
pass
assert choices_with_help(cli, ['sub', 'subarg1'], '') == [('bsub', 'bsub help'), ('csub', '')]
assert choices_without_help(cli, ['sub'], '') == ['subarg1', 'subarg2']
assert choices_without_help(cli, ['sub', '--sub-opt'], '') == ['subopt1', 'subopt2']
assert choices_without_help(cli, ['sub', '--sub-opt', 'subopt1'], '') == \
['subarg1', 'subarg2']
assert choices_without_help(cli,
['sub', '--sub-opt', 'subopt1', 'subarg1', 'bsub'], '-') == ['--bsub-opt']
assert choices_without_help(cli,
['sub', '--sub-opt', 'subopt1', 'subarg1', 'bsub'], '') == ['bsubarg1', 'bsubarg2']
assert choices_without_help(cli,
['sub', '--sub-opt', 'subopt1', 'subarg1', 'bsub', '--bsub-opt'], '') == \
['bsubopt1', 'bsubopt2']
assert choices_without_help(cli,
['sub', '--sub-opt', 'subopt1', 'subarg1', 'bsub', '--bsub-opt', 'bsubopt1', 'bsubarg1'],
'') == ['bbsubarg1', 'bbsubarg2']
assert choices_without_help(cli,
['sub', '--sub-opt', 'subopt1', 'subarg1', 'csub'],
'') == ['dsub']
def test_chained_multi():
@click.group()
def cli():
pass
@cli.group()
def sub():
pass
@sub.group()
def bsub():
pass
@sub.group(chain=True)
def csub():
pass
@csub.command()
def dsub():
pass
@csub.command()
def esub():
pass
assert choices_without_help(cli, ['sub'], '') == ['bsub', 'csub']
assert choices_without_help(cli, ['sub'], 'c') == ['csub']
assert choices_without_help(cli, ['sub', 'csub'], '') == ['dsub', 'esub']
assert choices_without_help(cli, ['sub', 'csub', 'dsub'], '') == ['esub']
def test_hidden():
@click.group()
@click.option('--name', hidden=True)
@click.option('--choices', type=click.Choice([1, 2]), hidden=True)
def cli(name):
pass
@cli.group(hidden=True)
def hgroup():
pass
@hgroup.group()
def hgroupsub():
pass
@cli.command()
def asub():
pass
@cli.command(hidden=True)
@click.option('--hname')
def hsub():
pass
assert choices_without_help(cli, [], '--n') == []
assert choices_without_help(cli, [], '--c') == []
# If the user exactly types out the hidden param, complete its options.
assert choices_without_help(cli, ['--choices'], '') == [1, 2]
assert choices_without_help(cli, [], '') == ['asub']
assert choices_without_help(cli, [], '') == ['asub']
assert choices_without_help(cli, [], 'h') == []
# If the user exactly types out the hidden command, complete its subcommands.
assert choices_without_help(cli, ['hgroup'], '') == ['hgroupsub']
assert choices_without_help(cli, ['hsub'], '--h') == ['--hname']
Click-7.0/tests/test_basic.py 0000644 0001750 0001750 00000036773 13351570514 016465 0 ustar david david 0000000 0000000 # -*- coding: utf-8 -*-
import os
import uuid
import click
def test_basic_functionality(runner):
@click.command()
def cli():
"""Hello World!"""
click.echo('I EXECUTED')
result = runner.invoke(cli, ['--help'])
assert not result.exception
assert 'Hello World!' in result.output
assert 'Show this message and exit.' in result.output
assert result.exit_code == 0
assert 'I EXECUTED' not in result.output
result = runner.invoke(cli, [])
assert not result.exception
assert 'I EXECUTED' in result.output
assert result.exit_code == 0
def test_return_values():
@click.command()
def cli():
return 42
with cli.make_context('foo', []) as ctx:
rv = cli.invoke(ctx)
assert rv is 42
def test_basic_group(runner):
@click.group()
def cli():
"""This is the root."""
click.echo('ROOT EXECUTED')
@cli.command()
def subcommand():
"""This is a subcommand."""
click.echo('SUBCOMMAND EXECUTED')
result = runner.invoke(cli, ['--help'])
assert not result.exception
assert 'COMMAND [ARGS]...' in result.output
assert 'This is the root' in result.output
assert 'This is a subcommand.' in result.output
assert result.exit_code == 0
assert 'ROOT EXECUTED' not in result.output
result = runner.invoke(cli, ['subcommand'])
assert not result.exception
assert result.exit_code == 0
assert 'ROOT EXECUTED' in result.output
assert 'SUBCOMMAND EXECUTED' in result.output
def test_basic_option(runner):
@click.command()
@click.option('--foo', default='no value')
def cli(foo):
click.echo('FOO:[%s]' % foo)
result = runner.invoke(cli, [])
assert not result.exception
assert 'FOO:[no value]' in result.output
result = runner.invoke(cli, ['--foo=42'])
assert not result.exception
assert 'FOO:[42]' in result.output
result = runner.invoke(cli, ['--foo'])
assert result.exception
assert '--foo option requires an argument' in result.output
result = runner.invoke(cli, ['--foo='])
assert not result.exception
assert 'FOO:[]' in result.output
result = runner.invoke(cli, [u'--foo=\N{SNOWMAN}'])
assert not result.exception
assert u'FOO:[\N{SNOWMAN}]' in result.output
def test_int_option(runner):
@click.command()
@click.option('--foo', default=42)
def cli(foo):
click.echo('FOO:[%s]' % (foo * 2))
result = runner.invoke(cli, [])
assert not result.exception
assert 'FOO:[84]' in result.output
result = runner.invoke(cli, ['--foo=23'])
assert not result.exception
assert 'FOO:[46]' in result.output
result = runner.invoke(cli, ['--foo=bar'])
assert result.exception
assert 'Invalid value for "--foo": bar is not a valid integer' \
in result.output
def test_uuid_option(runner):
@click.command()
@click.option('--u', default='ba122011-349f-423b-873b-9d6a79c688ab',
type=click.UUID)
def cli(u):
assert type(u) is uuid.UUID
click.echo('U:[%s]' % u)
result = runner.invoke(cli, [])
assert not result.exception
assert 'U:[ba122011-349f-423b-873b-9d6a79c688ab]' in result.output
result = runner.invoke(cli, ['--u=821592c1-c50e-4971-9cd6-e89dc6832f86'])
assert not result.exception
assert 'U:[821592c1-c50e-4971-9cd6-e89dc6832f86]' in result.output
result = runner.invoke(cli, ['--u=bar'])
assert result.exception
assert 'Invalid value for "--u": bar is not a valid UUID value' \
in result.output
def test_float_option(runner):
@click.command()
@click.option('--foo', default=42, type=click.FLOAT)
def cli(foo):
assert type(foo) is float
click.echo('FOO:[%s]' % foo)
result = runner.invoke(cli, [])
assert not result.exception
assert 'FOO:[42.0]' in result.output
result = runner.invoke(cli, ['--foo=23.5'])
assert not result.exception
assert 'FOO:[23.5]' in result.output
result = runner.invoke(cli, ['--foo=bar'])
assert result.exception
assert 'Invalid value for "--foo": bar is not a valid float' \
in result.output
def test_boolean_option(runner):
for default in True, False:
@click.command()
@click.option('--with-foo/--without-foo', default=default)
def cli(with_foo):
click.echo(with_foo)
result = runner.invoke(cli, ['--with-foo'])
assert not result.exception
assert result.output == 'True\n'
result = runner.invoke(cli, ['--without-foo'])
assert not result.exception
assert result.output == 'False\n'
result = runner.invoke(cli, [])
assert not result.exception
assert result.output == '%s\n' % default
for default in True, False:
@click.command()
@click.option('--flag', is_flag=True, default=default)
def cli(flag):
click.echo(flag)
result = runner.invoke(cli, ['--flag'])
assert not result.exception
assert result.output == '%s\n' % (not default)
result = runner.invoke(cli, [])
assert not result.exception
assert result.output == '%s\n' % (default)
def test_boolean_conversion(runner):
for default in True, False:
@click.command()
@click.option('--flag', default=default, type=bool)
def cli(flag):
click.echo(flag)
for value in 'true', 't', '1', 'yes', 'y':
result = runner.invoke(cli, ['--flag', value])
assert not result.exception
assert result.output == 'True\n'
for value in 'false', 'f', '0', 'no', 'n':
result = runner.invoke(cli, ['--flag', value])
assert not result.exception
assert result.output == 'False\n'
result = runner.invoke(cli, [])
assert not result.exception
assert result.output == '%s\n' % default
def test_file_option(runner):
@click.command()
@click.option('--file', type=click.File('w'))
def input(file):
file.write('Hello World!\n')
@click.command()
@click.option('--file', type=click.File('r'))
def output(file):
click.echo(file.read())
with runner.isolated_filesystem():
result_in = runner.invoke(input, ['--file=example.txt'])
result_out = runner.invoke(output, ['--file=example.txt'])
assert not result_in.exception
assert result_in.output == ''
assert not result_out.exception
assert result_out.output == 'Hello World!\n\n'
def test_file_lazy_mode(runner):
do_io = False
@click.command()
@click.option('--file', type=click.File('w'))
def input(file):
if do_io:
file.write('Hello World!\n')
@click.command()
@click.option('--file', type=click.File('r'))
def output(file):
pass
with runner.isolated_filesystem():
os.mkdir('example.txt')
do_io = True
result_in = runner.invoke(input, ['--file=example.txt'])
assert result_in.exit_code == 1
do_io = False
result_in = runner.invoke(input, ['--file=example.txt'])
assert result_in.exit_code == 0
result_out = runner.invoke(output, ['--file=example.txt'])
assert result_out.exception
@click.command()
@click.option('--file', type=click.File('w', lazy=False))
def input_non_lazy(file):
file.write('Hello World!\n')
with runner.isolated_filesystem():
os.mkdir('example.txt')
result_in = runner.invoke(input_non_lazy, ['--file=example.txt'])
assert result_in.exit_code == 2
assert 'Invalid value for "--file": Could not open file: example.txt' \
in result_in.output
def test_path_option(runner):
@click.command()
@click.option('-O', type=click.Path(file_okay=False, exists=True,
writable=True))
def write_to_dir(o):
with open(os.path.join(o, 'foo.txt'), 'wb') as f:
f.write(b'meh\n')
with runner.isolated_filesystem():
os.mkdir('test')
result = runner.invoke(write_to_dir, ['-O', 'test'])
assert not result.exception
with open('test/foo.txt', 'rb') as f:
assert f.read() == b'meh\n'
result = runner.invoke(write_to_dir, ['-O', 'test/foo.txt'])
assert 'Invalid value for "-O": Directory "test/foo.txt" is a file.' \
in result.output
@click.command()
@click.option('-f', type=click.Path(exists=True))
def showtype(f):
click.echo('is_file=%s' % os.path.isfile(f))
click.echo('is_dir=%s' % os.path.isdir(f))
with runner.isolated_filesystem():
result = runner.invoke(showtype, ['-f', 'xxx'])
assert 'Error: Invalid value for "-f": Path "xxx" does not exist' \
in result.output
result = runner.invoke(showtype, ['-f', '.'])
assert 'is_file=False' in result.output
assert 'is_dir=True' in result.output
@click.command()
@click.option('-f', type=click.Path())
def exists(f):
click.echo('exists=%s' % os.path.exists(f))
with runner.isolated_filesystem():
result = runner.invoke(exists, ['-f', 'xxx'])
assert 'exists=False' in result.output
result = runner.invoke(exists, ['-f', '.'])
assert 'exists=True' in result.output
def test_choice_option(runner):
@click.command()
@click.option('--method', type=click.Choice(['foo', 'bar', 'baz']))
def cli(method):
click.echo(method)
result = runner.invoke(cli, ['--method=foo'])
assert not result.exception
assert result.output == 'foo\n'
result = runner.invoke(cli, ['--method=meh'])
assert result.exit_code == 2
assert 'Invalid value for "--method": invalid choice: meh. ' \
'(choose from foo, bar, baz)' in result.output
result = runner.invoke(cli, ['--help'])
assert '--method [foo|bar|baz]' in result.output
def test_datetime_option_default(runner):
@click.command()
@click.option('--start_date', type=click.DateTime())
def cli(start_date):
click.echo(start_date.strftime('%Y-%m-%dT%H:%M:%S'))
result = runner.invoke(cli, ['--start_date=2015-09-29'])
assert not result.exception
assert result.output == '2015-09-29T00:00:00\n'
result = runner.invoke(cli, ['--start_date=2015-09-29T09:11:22'])
assert not result.exception
assert result.output == '2015-09-29T09:11:22\n'
result = runner.invoke(cli, ['--start_date=2015-09'])
assert result.exit_code == 2
assert ('Invalid value for "--start_date": '
'invalid datetime format: 2015-09. '
'(choose from %Y-%m-%d, %Y-%m-%dT%H:%M:%S, %Y-%m-%d %H:%M:%S)'
) in result.output
result = runner.invoke(cli, ['--help'])
assert '--start_date [%Y-%m-%d|%Y-%m-%dT%H:%M:%S|%Y-%m-%d %H:%M:%S]' in result.output
def test_datetime_option_custom(runner):
@click.command()
@click.option('--start_date',
type=click.DateTime(formats=['%A %B %d, %Y']))
def cli(start_date):
click.echo(start_date.strftime('%Y-%m-%dT%H:%M:%S'))
result = runner.invoke(cli, ['--start_date=Wednesday June 05, 2010'])
assert not result.exception
assert result.output == '2010-06-05T00:00:00\n'
def test_int_range_option(runner):
@click.command()
@click.option('--x', type=click.IntRange(0, 5))
def cli(x):
click.echo(x)
result = runner.invoke(cli, ['--x=5'])
assert not result.exception
assert result.output == '5\n'
result = runner.invoke(cli, ['--x=6'])
assert result.exit_code == 2
assert 'Invalid value for "--x": 6 is not in the valid range of 0 to 5.\n' \
in result.output
@click.command()
@click.option('--x', type=click.IntRange(0, 5, clamp=True))
def clamp(x):
click.echo(x)
result = runner.invoke(clamp, ['--x=5'])
assert not result.exception
assert result.output == '5\n'
result = runner.invoke(clamp, ['--x=6'])
assert not result.exception
assert result.output == '5\n'
result = runner.invoke(clamp, ['--x=-1'])
assert not result.exception
assert result.output == '0\n'
def test_float_range_option(runner):
@click.command()
@click.option('--x', type=click.FloatRange(0, 5))
def cli(x):
click.echo(x)
result = runner.invoke(cli, ['--x=5.0'])
assert not result.exception
assert result.output == '5.0\n'
result = runner.invoke(cli, ['--x=6.0'])
assert result.exit_code == 2
assert 'Invalid value for "--x": 6.0 is not in the valid range of 0 to 5.\n' \
in result.output
@click.command()
@click.option('--x', type=click.FloatRange(0, 5, clamp=True))
def clamp(x):
click.echo(x)
result = runner.invoke(clamp, ['--x=5.0'])
assert not result.exception
assert result.output == '5.0\n'
result = runner.invoke(clamp, ['--x=6.0'])
assert not result.exception
assert result.output == '5\n'
result = runner.invoke(clamp, ['--x=-1.0'])
assert not result.exception
assert result.output == '0\n'
def test_required_option(runner):
@click.command()
@click.option('--foo', required=True)
def cli(foo):
click.echo(foo)
result = runner.invoke(cli, [])
assert result.exit_code == 2
assert 'Missing option "--foo"' in result.output
def test_evaluation_order(runner):
called = []
def memo(ctx, param, value):
called.append(value)
return value
@click.command()
@click.option('--missing', default='missing',
is_eager=False, callback=memo)
@click.option('--eager-flag1', flag_value='eager1',
is_eager=True, callback=memo)
@click.option('--eager-flag2', flag_value='eager2',
is_eager=True, callback=memo)
@click.option('--eager-flag3', flag_value='eager3',
is_eager=True, callback=memo)
@click.option('--normal-flag1', flag_value='normal1',
is_eager=False, callback=memo)
@click.option('--normal-flag2', flag_value='normal2',
is_eager=False, callback=memo)
@click.option('--normal-flag3', flag_value='normal3',
is_eager=False, callback=memo)
def cli(**x):
pass
result = runner.invoke(cli, ['--eager-flag2',
'--eager-flag1',
'--normal-flag2',
'--eager-flag3',
'--normal-flag3',
'--normal-flag3',
'--normal-flag1',
'--normal-flag1'])
assert not result.exception
assert called == [
'eager2',
'eager1',
'eager3',
'normal2',
'normal3',
'normal1',
'missing',
]
def test_hidden_option(runner):
@click.command()
@click.option('--nope', hidden=True)
def cli(nope):
click.echo(nope)
result = runner.invoke(cli, ['--help'])
assert result.exit_code == 0
assert '--nope' not in result.output
def test_hidden_command(runner):
@click.group()
def cli():
pass
@cli.command(hidden=True)
def nope():
pass
result = runner.invoke(cli, ['--help'])
assert result.exit_code == 0
assert 'nope' not in result.output
def test_hidden_group(runner):
@click.group()
def cli():
pass
@cli.group(hidden=True)
def subgroup():
pass
@subgroup.command()
def nope():
pass
result = runner.invoke(cli, ['--help'])
assert result.exit_code == 0
assert 'subgroup' not in result.output
assert 'nope' not in result.output
Click-7.0/tests/test_chain.py 0000644 0001750 0001750 00000013112 13351553412 016442 0 ustar david david 0000000 0000000 import sys
import click
import pytest
def debug():
click.echo('%s=%s' % (
sys._getframe(1).f_code.co_name,
'|'.join(click.get_current_context().args),
))
def test_basic_chaining(runner):
@click.group(chain=True)
def cli():
pass
@cli.command('sdist')
def sdist():
click.echo('sdist called')
@cli.command('bdist')
def bdist():
click.echo('bdist called')
result = runner.invoke(cli, ['bdist', 'sdist', 'bdist'])
assert not result.exception
assert result.output.splitlines() == [
'bdist called',
'sdist called',
'bdist called',
]
def test_chaining_help(runner):
@click.group(chain=True)
def cli():
"""ROOT HELP"""
pass
@cli.command('sdist')
def sdist():
"""SDIST HELP"""
click.echo('sdist called')
@cli.command('bdist')
def bdist():
"""BDIST HELP"""
click.echo('bdist called')
result = runner.invoke(cli, ['--help'])
assert not result.exception
assert 'COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]...' in result.output
assert 'ROOT HELP' in result.output
result = runner.invoke(cli, ['sdist', '--help'])
assert not result.exception
assert 'SDIST HELP' in result.output
result = runner.invoke(cli, ['bdist', '--help'])
assert not result.exception
assert 'BDIST HELP' in result.output
result = runner.invoke(cli, ['bdist', 'sdist', '--help'])
assert not result.exception
assert 'SDIST HELP' in result.output
def test_chaining_with_options(runner):
@click.group(chain=True)
def cli():
pass
@cli.command('sdist')
@click.option('--format')
def sdist(format):
click.echo('sdist called %s' % format)
@cli.command('bdist')
@click.option('--format')
def bdist(format):
click.echo('bdist called %s' % format)
result = runner.invoke(cli, ['bdist', '--format=1', 'sdist', '--format=2'])
assert not result.exception
assert result.output.splitlines() == [
'bdist called 1',
'sdist called 2',
]
def test_chaining_with_arguments(runner):
@click.group(chain=True)
def cli():
pass
@cli.command('sdist')
@click.argument('format')
def sdist(format):
click.echo('sdist called %s' % format)
@cli.command('bdist')
@click.argument('format')
def bdist(format):
click.echo('bdist called %s' % format)
result = runner.invoke(cli, ['bdist', '1', 'sdist', '2'])
assert not result.exception
assert result.output.splitlines() == [
'bdist called 1',
'sdist called 2',
]
def test_pipeline(runner):
@click.group(chain=True, invoke_without_command=True)
@click.option('-i', '--input', type=click.File('r'))
def cli(input):
pass
@cli.resultcallback()
def process_pipeline(processors, input):
iterator = (x.rstrip('\r\n') for x in input)
for processor in processors:
iterator = processor(iterator)
for item in iterator:
click.echo(item)
@cli.command('uppercase')
def make_uppercase():
def processor(iterator):
for line in iterator:
yield line.upper()
return processor
@cli.command('strip')
def make_strip():
def processor(iterator):
for line in iterator:
yield line.strip()
return processor
result = runner.invoke(cli, ['-i', '-'], input='foo\nbar')
assert not result.exception
assert result.output.splitlines() == [
'foo',
'bar',
]
result = runner.invoke(cli, ['-i', '-', 'strip'], input='foo \n bar')
assert not result.exception
assert result.output.splitlines() == [
'foo',
'bar',
]
result = runner.invoke(cli, ['-i', '-', 'strip', 'uppercase'],
input='foo \n bar')
assert not result.exception
assert result.output.splitlines() == [
'FOO',
'BAR',
]
def test_args_and_chain(runner):
@click.group(chain=True)
def cli():
debug()
@cli.command()
def a():
debug()
@cli.command()
def b():
debug()
@cli.command()
def c():
debug()
result = runner.invoke(cli, ['a', 'b', 'c'])
assert not result.exception
assert result.output.splitlines() == [
'cli=',
'a=',
'b=',
'c=',
]
def test_multicommand_arg_behavior(runner):
with pytest.raises(RuntimeError):
@click.group(chain=True)
@click.argument('forbidden', required=False)
def bad_cli():
pass
with pytest.raises(RuntimeError):
@click.group(chain=True)
@click.argument('forbidden', nargs=-1)
def bad_cli2():
pass
@click.group(chain=True)
@click.argument('arg')
def cli(arg):
click.echo('cli:%s' % arg)
@cli.command()
def a():
click.echo('a')
result = runner.invoke(cli, ['foo', 'a'])
assert not result.exception
assert result.output.splitlines() == [
'cli:foo',
'a',
]
@pytest.mark.xfail
def test_multicommand_chaining(runner):
@click.group(chain=True)
def cli():
debug()
@cli.group()
def l1a():
debug()
@l1a.command()
def l2a():
debug()
@l1a.command()
def l2b():
debug()
@cli.command()
def l1b():
debug()
result = runner.invoke(cli, ['l1a', 'l2a', 'l1b'])
assert not result.exception
assert result.output.splitlines() == [
'cli=',
'l1a=',
'l2a=',
'l1b=',
]
Click-7.0/tests/test_commands.py 0000644 0001750 0001750 00000017146 13351570514 017176 0 ustar david david 0000000 0000000 # -*- coding: utf-8 -*-
import re
import click
import pytest
def test_other_command_invoke(runner):
@click.command()
@click.pass_context
def cli(ctx):
return ctx.invoke(other_cmd, arg=42)
@click.command()
@click.argument('arg', type=click.INT)
def other_cmd(arg):
click.echo(arg)
result = runner.invoke(cli, [])
assert not result.exception
assert result.output == '42\n'
def test_other_command_forward(runner):
cli = click.Group()
@cli.command()
@click.option('--count', default=1)
def test(count):
click.echo('Count: %d' % count)
@cli.command()
@click.option('--count', default=1)
@click.pass_context
def dist(ctx, count):
ctx.forward(test)
ctx.invoke(test, count=42)
result = runner.invoke(cli, ['dist'])
assert not result.exception
assert result.output == 'Count: 1\nCount: 42\n'
def test_auto_shorthelp(runner):
@click.group()
def cli():
pass
@cli.command()
def short():
"""This is a short text."""
@cli.command()
def special_chars():
"""Login and store the token in ~/.netrc."""
@cli.command()
def long():
"""This is a long text that is too long to show as short help
and will be truncated instead."""
result = runner.invoke(cli, ['--help'])
assert re.search(
r'Commands:\n\s+'
r'long\s+This is a long text that is too long to show as short help\.\.\.\n\s+'
r'short\s+This is a short text\.\n\s+'
r'special-chars\s+Login and store the token in ~/.netrc\.\s*',
result.output) is not None
def test_default_maps(runner):
@click.group()
def cli():
pass
@cli.command()
@click.option('--name', default='normal')
def foo(name):
click.echo(name)
result = runner.invoke(cli, ['foo'], default_map={
'foo': {'name': 'changed'}
})
assert not result.exception
assert result.output == 'changed\n'
def test_group_with_args(runner):
@click.group()
@click.argument('obj')
def cli(obj):
click.echo('obj=%s' % obj)
@cli.command()
def move():
click.echo('move')
result = runner.invoke(cli, [])
assert result.exit_code == 0
assert 'Show this message and exit.' in result.output
result = runner.invoke(cli, ['obj1'])
assert result.exit_code == 2
assert 'Error: Missing command.' in result.output
result = runner.invoke(cli, ['obj1', '--help'])
assert result.exit_code == 0
assert 'Show this message and exit.' in result.output
result = runner.invoke(cli, ['obj1', 'move'])
assert result.exit_code == 0
assert result.output == 'obj=obj1\nmove\n'
def test_base_command(runner):
import optparse
@click.group()
def cli():
pass
class OptParseCommand(click.BaseCommand):
def __init__(self, name, parser, callback):
click.BaseCommand.__init__(self, name)
self.parser = parser
self.callback = callback
def parse_args(self, ctx, args):
try:
opts, args = parser.parse_args(args)
except Exception as e:
ctx.fail(str(e))
ctx.args = args
ctx.params = vars(opts)
def get_usage(self, ctx):
return self.parser.get_usage()
def get_help(self, ctx):
return self.parser.format_help()
def invoke(self, ctx):
ctx.invoke(self.callback, ctx.args, **ctx.params)
parser = optparse.OptionParser(usage='Usage: foo test [OPTIONS]')
parser.add_option("-f", "--file", dest="filename",
help="write report to FILE", metavar="FILE")
parser.add_option("-q", "--quiet",
action="store_false", dest="verbose", default=True,
help="don't print status messages to stdout")
def test_callback(args, filename, verbose):
click.echo(' '.join(args))
click.echo(filename)
click.echo(verbose)
cli.add_command(OptParseCommand('test', parser, test_callback))
result = runner.invoke(cli, ['test', '-f', 'test.txt', '-q',
'whatever.txt', 'whateverelse.txt'])
assert not result.exception
assert result.output.splitlines() == [
'whatever.txt whateverelse.txt',
'test.txt',
'False',
]
result = runner.invoke(cli, ['test', '--help'])
assert not result.exception
assert result.output.splitlines() == [
'Usage: foo test [OPTIONS]',
'',
'Options:',
' -h, --help show this help message and exit',
' -f FILE, --file=FILE write report to FILE',
' -q, --quiet don\'t print status messages to stdout',
]
def test_object_propagation(runner):
for chain in False, True:
@click.group(chain=chain)
@click.option('--debug/--no-debug', default=False)
@click.pass_context
def cli(ctx, debug):
if ctx.obj is None:
ctx.obj = {}
ctx.obj['DEBUG'] = debug
@cli.command()
@click.pass_context
def sync(ctx):
click.echo('Debug is %s' % (ctx.obj['DEBUG'] and 'on' or 'off'))
result = runner.invoke(cli, ['sync'])
assert result.exception is None
assert result.output == 'Debug is off\n'
def test_other_command_invoke_with_defaults(runner):
@click.command()
@click.pass_context
def cli(ctx):
return ctx.invoke(other_cmd)
@click.command()
@click.option('--foo', type=click.INT, default=42)
@click.pass_context
def other_cmd(ctx, foo):
assert ctx.info_name == 'other-cmd'
click.echo(foo)
result = runner.invoke(cli, [])
assert not result.exception
assert result.output == '42\n'
def test_invoked_subcommand(runner):
@click.group(invoke_without_command=True)
@click.pass_context
def cli(ctx):
if ctx.invoked_subcommand is None:
click.echo('no subcommand, use default')
ctx.invoke(sync)
else:
click.echo('invoke subcommand')
@cli.command()
def sync():
click.echo('in subcommand')
result = runner.invoke(cli, ['sync'])
assert not result.exception
assert result.output == 'invoke subcommand\nin subcommand\n'
result = runner.invoke(cli)
assert not result.exception
assert result.output == 'no subcommand, use default\nin subcommand\n'
def test_unprocessed_options(runner):
@click.command(context_settings=dict(
ignore_unknown_options=True
))
@click.argument('args', nargs=-1, type=click.UNPROCESSED)
@click.option('--verbose', '-v', count=True)
def cli(verbose, args):
click.echo('Verbosity: %s' % verbose)
click.echo('Args: %s' % '|'.join(args))
result = runner.invoke(cli, ['-foo', '-vvvvx', '--muhaha', 'x', 'y', '-x'])
assert not result.exception
assert result.output.splitlines() == [
'Verbosity: 4',
'Args: -foo|-x|--muhaha|x|y|-x',
]
def test_deprecated_in_help_messages(runner):
@click.command(deprecated=True)
def cmd_with_help():
"""CLI HELP"""
pass
result = runner.invoke(cmd_with_help, ['--help'])
assert '(DEPRECATED)' in result.output
@click.command(deprecated=True)
def cmd_without_help():
pass
result = runner.invoke(cmd_without_help, ['--help'])
assert '(DEPRECATED)' in result.output
def test_deprecated_in_invocation(runner):
@click.command(deprecated=True)
def deprecated_cmd():
debug()
result = runner.invoke(deprecated_cmd)
assert 'DeprecationWarning:' in result.output
Click-7.0/tests/test_compat.py 0000644 0001750 0001750 00000001455 13351570514 016654 0 ustar david david 0000000 0000000 import click
import pytest
if click.__version__ >= '3.0':
def test_legacy_callbacks(runner):
def legacy_callback(ctx, value):
return value.upper()
@click.command()
@click.option('--foo', callback=legacy_callback)
def cli(foo):
click.echo(foo)
with pytest.warns(Warning, match='Invoked legacy parameter callback'):
result = runner.invoke(cli, ['--foo', 'wat'])
assert result.exit_code == 0
assert 'WAT' in result.output
def test_bash_func_name():
from click._bashcomplete import get_completion_script
script = get_completion_script('foo-bar baz_blah', '_COMPLETE_VAR', 'bash').strip()
assert script.startswith('_foo_barbaz_blah_completion()')
assert '_COMPLETE_VAR=complete $1' in script
Click-7.0/tests/test_context.py 0000644 0001750 0001750 00000012742 13351570514 017056 0 ustar david david 0000000 0000000 # -*- coding: utf-8 -*-
import click
def test_ensure_context_objects(runner):
class Foo(object):
def __init__(self):
self.title = 'default'
pass_foo = click.make_pass_decorator(Foo, ensure=True)
@click.group()
@pass_foo
def cli(foo):
pass
@cli.command()
@pass_foo
def test(foo):
click.echo(foo.title)
result = runner.invoke(cli, ['test'])
assert not result.exception
assert result.output == 'default\n'
def test_get_context_objects(runner):
class Foo(object):
def __init__(self):
self.title = 'default'
pass_foo = click.make_pass_decorator(Foo, ensure=True)
@click.group()
@click.pass_context
def cli(ctx):
ctx.obj = Foo()
ctx.obj.title = 'test'
@cli.command()
@pass_foo
def test(foo):
click.echo(foo.title)
result = runner.invoke(cli, ['test'])
assert not result.exception
assert result.output == 'test\n'
def test_get_context_objects_no_ensuring(runner):
class Foo(object):
def __init__(self):
self.title = 'default'
pass_foo = click.make_pass_decorator(Foo)
@click.group()
@click.pass_context
def cli(ctx):
ctx.obj = Foo()
ctx.obj.title = 'test'
@cli.command()
@pass_foo
def test(foo):
click.echo(foo.title)
result = runner.invoke(cli, ['test'])
assert not result.exception
assert result.output == 'test\n'
def test_get_context_objects_missing(runner):
class Foo(object):
pass
pass_foo = click.make_pass_decorator(Foo)
@click.group()
@click.pass_context
def cli(ctx):
pass
@cli.command()
@pass_foo
def test(foo):
click.echo(foo.title)
result = runner.invoke(cli, ['test'])
assert result.exception is not None
assert isinstance(result.exception, RuntimeError)
assert "Managed to invoke callback without a context object " \
"of type 'Foo' existing" in str(result.exception)
def test_multi_enter(runner):
called = []
@click.command()
@click.pass_context
def cli(ctx):
def callback():
called.append(True)
ctx.call_on_close(callback)
with ctx:
pass
assert not called
result = runner.invoke(cli, [])
assert result.exception is None
assert called == [True]
def test_global_context_object(runner):
@click.command()
@click.pass_context
def cli(ctx):
assert click.get_current_context() is ctx
ctx.obj = 'FOOBAR'
assert click.get_current_context().obj == 'FOOBAR'
assert click.get_current_context(silent=True) is None
runner.invoke(cli, [], catch_exceptions=False)
assert click.get_current_context(silent=True) is None
def test_context_meta(runner):
LANG_KEY = __name__ + '.lang'
def set_language(value):
click.get_current_context().meta[LANG_KEY] = value
def get_language():
return click.get_current_context().meta.get(LANG_KEY, 'en_US')
@click.command()
@click.pass_context
def cli(ctx):
assert get_language() == 'en_US'
set_language('de_DE')
assert get_language() == 'de_DE'
runner.invoke(cli, [], catch_exceptions=False)
def test_context_pushing():
rv = []
@click.command()
def cli():
pass
ctx = click.Context(cli)
@ctx.call_on_close
def test_callback():
rv.append(42)
with ctx.scope(cleanup=False):
# Internal
assert ctx._depth == 2
assert rv == []
with ctx.scope():
# Internal
assert ctx._depth == 1
assert rv == [42]
def test_pass_obj(runner):
@click.group()
@click.pass_context
def cli(ctx):
ctx.obj = 'test'
@cli.command()
@click.pass_obj
def test(obj):
click.echo(obj)
result = runner.invoke(cli, ['test'])
assert not result.exception
assert result.output == 'test\n'
def test_close_before_pop(runner):
called = []
@click.command()
@click.pass_context
def cli(ctx):
ctx.obj = 'test'
@ctx.call_on_close
def foo():
assert click.get_current_context().obj == 'test'
called.append(True)
click.echo('aha!')
result = runner.invoke(cli, [])
assert not result.exception
assert result.output == 'aha!\n'
assert called == [True]
def test_make_pass_decorator_args(runner):
"""
Test to check that make_pass_decorator doesn't consume arguments based on
invocation order.
"""
class Foo(object):
title = 'foocmd'
pass_foo = click.make_pass_decorator(Foo)
@click.group()
@click.pass_context
def cli(ctx):
ctx.obj = Foo()
@cli.command()
@click.pass_context
@pass_foo
def test1(foo, ctx):
click.echo(foo.title)
@cli.command()
@pass_foo
@click.pass_context
def test2(ctx, foo):
click.echo(foo.title)
result = runner.invoke(cli, ['test1'])
assert not result.exception
assert result.output == 'foocmd\n'
result = runner.invoke(cli, ['test2'])
assert not result.exception
assert result.output == 'foocmd\n'
def test_exit_not_standalone():
@click.command()
@click.pass_context
def cli(ctx):
ctx.exit(1)
assert cli.main([], 'test_exit_not_standalone', standalone_mode=False) == 1
@click.command()
@click.pass_context
def cli(ctx):
ctx.exit(0)
assert cli.main([], 'test_exit_not_standalone', standalone_mode=False) == 0
Click-7.0/tests/test_defaults.py 0000644 0001750 0001750 00000002175 13351553373 017204 0 ustar david david 0000000 0000000 import click
def test_basic_defaults(runner):
@click.command()
@click.option('--foo', default=42, type=click.FLOAT)
def cli(foo):
assert type(foo) is float
click.echo('FOO:[%s]' % foo)
result = runner.invoke(cli, [])
assert not result.exception
assert 'FOO:[42.0]' in result.output
def test_multiple_defaults(runner):
@click.command()
@click.option('--foo', default=[23, 42], type=click.FLOAT,
multiple=True)
def cli(foo):
for item in foo:
assert type(item) is float
click.echo(item)
result = runner.invoke(cli, [])
assert not result.exception
assert result.output.splitlines() == [
'23.0',
'42.0',
]
def test_nargs_plus_multiple(runner):
@click.command()
@click.option('--arg', default=((1, 2), (3, 4)),
nargs=2, multiple=True, type=click.INT)
def cli(arg):
for item in arg:
click.echo('<%d|%d>' % item)
result = runner.invoke(cli, [])
assert not result.exception
assert result.output.splitlines() == [
'<1|2>',
'<3|4>',
]
Click-7.0/tests/test_formatting.py 0000644 0001750 0001750 00000016415 13351570514 017545 0 ustar david david 0000000 0000000 # -*- coding: utf-8 -*-
import click
def test_basic_functionality(runner):
@click.command()
def cli():
"""First paragraph.
This is a very long second
paragraph and not correctly
wrapped but it will be rewrapped.
\b
This is
a paragraph
without rewrapping.
\b
1
2
3
And this is a paragraph
that will be rewrapped again.
"""
result = runner.invoke(cli, ['--help'], terminal_width=60)
assert not result.exception
assert result.output.splitlines() == [
'Usage: cli [OPTIONS]',
'',
' First paragraph.',
'',
' This is a very long second paragraph and not correctly',
' wrapped but it will be rewrapped.',
'',
' This is',
' a paragraph',
' without rewrapping.',
'',
' 1',
' 2',
' 3',
'',
' And this is a paragraph that will be rewrapped again.',
'',
'Options:',
' --help Show this message and exit.',
]
def test_wrapping_long_options_strings(runner):
@click.group()
def cli():
"""Top level command
"""
@cli.group()
def a_very_long():
"""Second level
"""
@a_very_long.command()
@click.argument('first')
@click.argument('second')
@click.argument('third')
@click.argument('fourth')
@click.argument('fifth')
@click.argument('sixth')
def command():
"""A command.
"""
# 54 is chosen as a length where the second line is one character
# longer than the maximum length.
result = runner.invoke(cli, ['a-very-long', 'command', '--help'],
terminal_width=54)
assert not result.exception
assert result.output.splitlines() == [
'Usage: cli a-very-long command [OPTIONS] FIRST SECOND',
' THIRD FOURTH FIFTH',
' SIXTH',
'',
' A command.',
'',
'Options:',
' --help Show this message and exit.',
]
def test_wrapping_long_command_name(runner):
@click.group()
def cli():
"""Top level command
"""
@cli.group()
def a_very_very_very_long():
"""Second level
"""
@a_very_very_very_long.command()
@click.argument('first')
@click.argument('second')
@click.argument('third')
@click.argument('fourth')
@click.argument('fifth')
@click.argument('sixth')
def command():
"""A command.
"""
result = runner.invoke(cli, ['a-very-very-very-long', 'command', '--help'],
terminal_width=54)
assert not result.exception
assert result.output.splitlines() == [
'Usage: cli a-very-very-very-long command ',
' [OPTIONS] FIRST SECOND THIRD FOURTH FIFTH',
' SIXTH',
'',
' A command.',
'',
'Options:',
' --help Show this message and exit.',
]
def test_formatting_empty_help_lines(runner):
@click.command()
def cli():
"""Top level command
"""
result = runner.invoke(cli, ['--help'])
assert not result.exception
assert result.output.splitlines() == [
'Usage: cli [OPTIONS]',
'',
' Top level command',
'',
'',
'',
'Options:',
' --help Show this message and exit.',
]
def test_formatting_usage_error(runner):
@click.command()
@click.argument('arg')
def cmd(arg):
click.echo('arg:' + arg)
result = runner.invoke(cmd, [])
assert result.exit_code == 2
assert result.output.splitlines() == [
'Usage: cmd [OPTIONS] ARG',
'Try "cmd --help" for help.',
'',
'Error: Missing argument "ARG".'
]
def test_formatting_usage_error_metavar_missing_arg(runner):
"""
:author: @r-m-n
Including attribution to #612
"""
@click.command()
@click.argument('arg', metavar='metavar')
def cmd(arg):
pass
result = runner.invoke(cmd, [])
assert result.exit_code == 2
assert result.output.splitlines() == [
'Usage: cmd [OPTIONS] metavar',
'Try "cmd --help" for help.',
'',
'Error: Missing argument "metavar".'
]
def test_formatting_usage_error_metavar_bad_arg(runner):
@click.command()
@click.argument('arg', type=click.INT, metavar='metavar')
def cmd(arg):
pass
result = runner.invoke(cmd, ['3.14'])
assert result.exit_code == 2
assert result.output.splitlines() == [
'Usage: cmd [OPTIONS] metavar',
'Try "cmd --help" for help.',
'',
'Error: Invalid value for "metavar": 3.14 is not a valid integer'
]
def test_formatting_usage_error_nested(runner):
@click.group()
def cmd():
pass
@cmd.command()
@click.argument('bar')
def foo(bar):
click.echo('foo:' + bar)
result = runner.invoke(cmd, ['foo'])
assert result.exit_code == 2
assert result.output.splitlines() == [
'Usage: cmd foo [OPTIONS] BAR',
'Try "cmd foo --help" for help.',
'',
'Error: Missing argument "BAR".'
]
def test_formatting_usage_error_no_help(runner):
@click.command(add_help_option=False)
@click.argument('arg')
def cmd(arg):
click.echo('arg:' + arg)
result = runner.invoke(cmd, [])
assert result.exit_code == 2
assert result.output.splitlines() == [
'Usage: cmd [OPTIONS] ARG',
'',
'Error: Missing argument "ARG".'
]
def test_formatting_usage_custom_help(runner):
@click.command(context_settings=dict(help_option_names=['--man']))
@click.argument('arg')
def cmd(arg):
click.echo('arg:' + arg)
result = runner.invoke(cmd, [])
assert result.exit_code == 2
assert result.output.splitlines() == [
'Usage: cmd [OPTIONS] ARG',
'Try "cmd --man" for help.',
'',
'Error: Missing argument "ARG".'
]
def test_formatting_custom_type_metavar(runner):
class MyType(click.ParamType):
def get_metavar(self, param):
return "MY_TYPE"
@click.command("foo")
@click.help_option()
@click.argument("param", type=MyType())
def cmd(param):
pass
result = runner.invoke(cmd, '--help')
assert not result.exception
assert result.output.splitlines() == [
'Usage: foo [OPTIONS] MY_TYPE',
'',
'Options:',
' --help Show this message and exit.'
]
def test_truncating_docstring(runner):
@click.command()
@click.pass_context
def cli(ctx):
"""First paragraph.
This is a very long second
paragraph and not correctly
wrapped but it will be rewrapped.
\f
:param click.core.Context ctx: Click context.
"""
result = runner.invoke(cli, ['--help'], terminal_width=60)
assert not result.exception
assert result.output.splitlines() == [
'Usage: cli [OPTIONS]',
'',
' First paragraph.',
'',
' This is a very long second paragraph and not correctly',
' wrapped but it will be rewrapped.',
'',
'Options:',
' --help Show this message and exit.',
]
Click-7.0/tests/test_imports.py 0000644 0001750 0001750 00000002625 13351570514 017066 0 ustar david david 0000000 0000000 import sys
import json
import subprocess
from click._compat import WIN
IMPORT_TEST = b'''\
try:
import __builtin__ as builtins
except ImportError:
import builtins
found_imports = set()
real_import = builtins.__import__
import sys
def tracking_import(module, locals=None, globals=None, fromlist=None,
level=0):
rv = real_import(module, locals, globals, fromlist, level)
if globals and globals['__name__'].startswith('click') and level == 0:
found_imports.add(module)
return rv
builtins.__import__ = tracking_import
import click
rv = list(found_imports)
import json
click.echo(json.dumps(rv))
'''
ALLOWED_IMPORTS = set([
'weakref', 'os', 'struct', 'collections', 'sys', 'contextlib',
'functools', 'stat', 're', 'codecs', 'inspect', 'itertools', 'io',
'threading', 'colorama', 'errno', 'fcntl', 'datetime'
])
if WIN:
ALLOWED_IMPORTS.update(['ctypes', 'ctypes.wintypes', 'msvcrt', 'time',
'zlib'])
def test_light_imports():
c = subprocess.Popen([sys.executable, '-'], stdin=subprocess.PIPE,
stdout=subprocess.PIPE)
rv = c.communicate(IMPORT_TEST)[0]
if sys.version_info[0] != 2:
rv = rv.decode('utf-8')
imported = json.loads(rv)
for module in imported:
if module == 'click' or module.startswith('click.'):
continue
assert module in ALLOWED_IMPORTS
Click-7.0/tests/test_normalization.py 0000644 0001750 0001750 00000001673 13351553367 020270 0 ustar david david 0000000 0000000 import click
CONTEXT_SETTINGS = dict(token_normalize_func=lambda x: x.lower())
def test_option_normalization(runner):
@click.command(context_settings=CONTEXT_SETTINGS)
@click.option('--foo')
@click.option('-x')
def cli(foo, x):
click.echo(foo)
click.echo(x)
result = runner.invoke(cli, ['--FOO', '42', '-X', 23])
assert result.output == '42\n23\n'
def test_choice_normalization(runner):
@click.command(context_settings=CONTEXT_SETTINGS)
@click.option('--choice', type=click.Choice(['Foo', 'Bar']))
def cli(choice):
click.echo('Foo')
result = runner.invoke(cli, ['--CHOICE', 'FOO'])
assert result.output == 'Foo\n'
def test_command_normalization(runner):
@click.group(context_settings=CONTEXT_SETTINGS)
def cli():
pass
@cli.command()
def foo():
click.echo('here!')
result = runner.invoke(cli, ['FOO'])
assert result.output == 'here!\n'
Click-7.0/tests/test_options.py 0000644 0001750 0001750 00000035120 13351570514 017060 0 ustar david david 0000000 0000000 # -*- coding: utf-8 -*-
import re
import os
import click
import pytest
from click._compat import text_type
def test_prefixes(runner):
@click.command()
@click.option('++foo', is_flag=True, help='das foo')
@click.option('--bar', is_flag=True, help='das bar')
def cli(foo, bar):
click.echo('foo=%s bar=%s' % (foo, bar))
result = runner.invoke(cli, ['++foo', '--bar'])
assert not result.exception
assert result.output == 'foo=True bar=True\n'
result = runner.invoke(cli, ['--help'])
assert re.search(r'\+\+foo\s+das foo', result.output) is not None
assert re.search(r'--bar\s+das bar', result.output) is not None
def test_invalid_option(runner):
try:
@click.command()
@click.option('foo')
def cli(foo):
pass
except TypeError as e:
assert 'No options defined but a name was passed (foo).' \
in str(e)
else:
assert False, 'Expected a type error because of an invalid option.'
def test_invalid_nargs(runner):
try:
@click.command()
@click.option('--foo', nargs=-1)
def cli(foo):
pass
except TypeError as e:
assert 'Options cannot have nargs < 0' in str(e)
else:
assert False, 'Expected a type error because of an invalid option.'
def test_nargs_tup_composite_mult(runner):
@click.command()
@click.option('--item', type=(str, int), multiple=True)
def copy(item):
for item in item:
click.echo('name=%s id=%d' % item)
result = runner.invoke(copy, ['--item', 'peter', '1', '--item', 'max', '2'])
assert not result.exception
assert result.output.splitlines() == [
'name=peter id=1',
'name=max id=2',
]
def test_counting(runner):
@click.command()
@click.option('-v', count=True, help='Verbosity',
type=click.IntRange(0, 3))
def cli(v):
click.echo('verbosity=%d' % v)
result = runner.invoke(cli, ['-vvv'])
assert not result.exception
assert result.output == 'verbosity=3\n'
result = runner.invoke(cli, ['-vvvv'])
assert result.exception
assert 'Invalid value for "-v": 4 is not in the valid range of 0 to 3.' \
in result.output
result = runner.invoke(cli, [])
assert not result.exception
assert result.output == 'verbosity=0\n'
result = runner.invoke(cli, ['--help'])
assert re.search(r'-v\s+Verbosity', result.output) is not None
@pytest.mark.parametrize('unknown_flag', ['--foo', '-f'])
def test_unknown_options(runner, unknown_flag):
@click.command()
def cli():
pass
result = runner.invoke(cli, [unknown_flag])
assert result.exception
assert 'no such option: {0}'.format(unknown_flag) in result.output
def test_multiple_required(runner):
@click.command()
@click.option('-m', '--message', multiple=True, required=True)
def cli(message):
click.echo('\n'.join(message))
result = runner.invoke(cli, ['-m', 'foo', '-mbar'])
assert not result.exception
assert result.output == 'foo\nbar\n'
result = runner.invoke(cli, [])
assert result.exception
assert 'Error: Missing option "-m" / "--message".' in result.output
def test_multiple_envvar(runner):
@click.command()
@click.option('--arg', multiple=True)
def cmd(arg):
click.echo('|'.join(arg))
result = runner.invoke(cmd, [], auto_envvar_prefix='TEST',
env={'TEST_ARG': 'foo bar baz'})
assert not result.exception
assert result.output == 'foo|bar|baz\n'
@click.command()
@click.option('--arg', multiple=True, envvar='X')
def cmd(arg):
click.echo('|'.join(arg))
result = runner.invoke(cmd, [], env={'X': 'foo bar baz'})
assert not result.exception
assert result.output == 'foo|bar|baz\n'
@click.command()
@click.option('--arg', multiple=True, type=click.Path())
def cmd(arg):
click.echo('|'.join(arg))
result = runner.invoke(cmd, [], auto_envvar_prefix='TEST',
env={'TEST_ARG': 'foo%sbar' % os.path.pathsep})
assert not result.exception
assert result.output == 'foo|bar\n'
def test_multiple_default_help(runner):
@click.command()
@click.option('--arg1', multiple=True, default=('foo', 'bar'),
show_default=True)
@click.option('--arg2', multiple=True, default=(1, 2), type=int,
show_default=True)
def cmd(arg, arg2):
pass
result = runner.invoke(cmd, ['--help'])
assert not result.exception
assert 'foo, bar' in result.output
assert '1, 2' in result.output
def test_multiple_default_type(runner):
@click.command()
@click.option('--arg1', multiple=True, default=('foo', 'bar'))
@click.option('--arg2', multiple=True, default=(1, 'a'))
def cmd(arg1, arg2):
assert all(isinstance(e[0], text_type) for e in arg1)
assert all(isinstance(e[1], text_type) for e in arg1)
assert all(isinstance(e[0], int) for e in arg2)
assert all(isinstance(e[1], text_type) for e in arg2)
result = runner.invoke(cmd, '--arg1 a b --arg1 test 1 --arg2 2 '
'two --arg2 4 four'.split())
assert not result.exception
def test_dynamic_default_help_unset(runner):
@click.command()
@click.option('--username', prompt=True,
default=lambda: os.environ.get('USER', ''),
show_default=True)
def cmd(username):
print("Hello,", username)
result = runner.invoke(cmd, ['--help'])
assert result.exit_code == 0
assert '--username' in result.output
assert 'lambda' not in result.output
assert '(dynamic)' in result.output
def test_dynamic_default_help_text(runner):
@click.command()
@click.option('--username', prompt=True,
default=lambda: os.environ.get('USER', ''),
show_default='current user')
def cmd(username):
print("Hello,", username)
result = runner.invoke(cmd, ['--help'])
assert result.exit_code == 0
assert '--username' in result.output
assert 'lambda' not in result.output
assert '(current user)' in result.output
def test_toupper_envvar_prefix(runner):
@click.command()
@click.option('--arg')
def cmd(arg):
click.echo(arg)
result = runner.invoke(cmd, [], auto_envvar_prefix='test',
env={'TEST_ARG': 'foo'})
assert not result.exception
assert result.output == 'foo\n'
def test_nargs_envvar(runner):
@click.command()
@click.option('--arg', nargs=2)
def cmd(arg):
click.echo('|'.join(arg))
result = runner.invoke(cmd, [], auto_envvar_prefix='TEST',
env={'TEST_ARG': 'foo bar'})
assert not result.exception
assert result.output == 'foo|bar\n'
@click.command()
@click.option('--arg', nargs=2, multiple=True)
def cmd(arg):
for item in arg:
click.echo('|'.join(item))
result = runner.invoke(cmd, [], auto_envvar_prefix='TEST',
env={'TEST_ARG': 'x 1 y 2'})
assert not result.exception
assert result.output == 'x|1\ny|2\n'
def test_show_envvar(runner):
@click.command()
@click.option('--arg1', envvar='ARG1',
show_envvar=True)
def cmd(arg):
pass
result = runner.invoke(cmd, ['--help'])
assert not result.exception
assert 'ARG1' in result.output
def test_show_envvar_auto_prefix(runner):
@click.command()
@click.option('--arg1', show_envvar=True)
def cmd(arg):
pass
result = runner.invoke(cmd, ['--help'],
auto_envvar_prefix='TEST')
assert not result.exception
assert 'TEST_ARG1' in result.output
def test_custom_validation(runner):
def validate_pos_int(ctx, param, value):
if value < 0:
raise click.BadParameter('Value needs to be positive')
return value
@click.command()
@click.option('--foo', callback=validate_pos_int, default=1)
def cmd(foo):
click.echo(foo)
result = runner.invoke(cmd, ['--foo', '-1'])
assert 'Invalid value for "--foo": Value needs to be positive' \
in result.output
result = runner.invoke(cmd, ['--foo', '42'])
assert result.output == '42\n'
def test_winstyle_options(runner):
@click.command()
@click.option('/debug;/no-debug', help='Enables or disables debug mode.')
def cmd(debug):
click.echo(debug)
result = runner.invoke(cmd, ['/debug'], help_option_names=['/?'])
assert result.output == 'True\n'
result = runner.invoke(cmd, ['/no-debug'], help_option_names=['/?'])
assert result.output == 'False\n'
result = runner.invoke(cmd, [], help_option_names=['/?'])
assert result.output == 'False\n'
result = runner.invoke(cmd, ['/?'], help_option_names=['/?'])
assert '/debug; /no-debug Enables or disables debug mode.' in result.output
assert '/? Show this message and exit.' in result.output
def test_legacy_options(runner):
@click.command()
@click.option('-whatever')
def cmd(whatever):
click.echo(whatever)
result = runner.invoke(cmd, ['-whatever', '42'])
assert result.output == '42\n'
result = runner.invoke(cmd, ['-whatever=23'])
assert result.output == '23\n'
def test_missing_choice(runner):
@click.command()
@click.option('--foo', type=click.Choice(['foo', 'bar']),
required=True)
def cmd(foo):
click.echo(foo)
result = runner.invoke(cmd)
assert result.exit_code == 2
error, separator, choices = result.output.partition('Choose from')
assert 'Error: Missing option "--foo". ' in error
assert 'Choose from' in separator
assert 'foo' in choices
assert 'bar' in choices
def test_case_insensitive_choice(runner):
@click.command()
@click.option('--foo', type=click.Choice(
['Orange', 'Apple'], case_sensitive=False))
def cmd(foo):
click.echo(foo)
result = runner.invoke(cmd, ['--foo', 'apple'])
assert result.exit_code == 0
result = runner.invoke(cmd, ['--foo', 'oRANGe'])
assert result.exit_code == 0
result = runner.invoke(cmd, ['--foo', 'Apple'])
assert result.exit_code == 0
@click.command()
@click.option('--foo', type=click.Choice(['Orange', 'Apple']))
def cmd2(foo):
click.echo(foo)
result = runner.invoke(cmd2, ['--foo', 'apple'])
assert result.exit_code == 2
result = runner.invoke(cmd2, ['--foo', 'oRANGe'])
assert result.exit_code == 2
result = runner.invoke(cmd2, ['--foo', 'Apple'])
assert result.exit_code == 0
def test_multiline_help(runner):
@click.command()
@click.option('--foo', help="""
hello
i am
multiline
""")
def cmd(foo):
click.echo(foo)
result = runner.invoke(cmd, ['--help'])
assert result.exit_code == 0
out = result.output.splitlines()
assert ' --foo TEXT hello' in out
assert ' i am' in out
assert ' multiline' in out
def test_argument_custom_class(runner):
class CustomArgument(click.Argument):
def get_default(self, ctx):
'''a dumb override of a default value for testing'''
return 'I am a default'
@click.command()
@click.argument('testarg', cls=CustomArgument, default='you wont see me')
def cmd(testarg):
click.echo(testarg)
result = runner.invoke(cmd)
assert 'I am a default' in result.output
assert 'you wont see me' not in result.output
def test_option_custom_class(runner):
class CustomOption(click.Option):
def get_help_record(self, ctx):
'''a dumb override of a help text for testing'''
return ('--help', 'I am a help text')
@click.command()
@click.option('--testoption', cls=CustomOption, help='you wont see me')
def cmd(testoption):
click.echo(testoption)
result = runner.invoke(cmd, ['--help'])
assert 'I am a help text' in result.output
assert 'you wont see me' not in result.output
def test_option_custom_class_reusable(runner):
"""Ensure we can reuse a custom class option. See Issue #926"""
class CustomOption(click.Option):
def get_help_record(self, ctx):
'''a dumb override of a help text for testing'''
return ('--help', 'I am a help text')
# Assign to a variable to re-use the decorator.
testoption = click.option('--testoption', cls=CustomOption, help='you wont see me')
@click.command()
@testoption
def cmd1(testoption):
click.echo(testoption)
@click.command()
@testoption
def cmd2(testoption):
click.echo(testoption)
# Both of the commands should have the --help option now.
for cmd in (cmd1, cmd2):
result = runner.invoke(cmd, ['--help'])
assert 'I am a help text' in result.output
assert 'you wont see me' not in result.output
def test_aliases_for_flags(runner):
@click.command()
@click.option('--warnings/--no-warnings', ' /-W', default=True)
def cli(warnings):
click.echo(warnings)
result = runner.invoke(cli, ['--warnings'])
assert result.output == 'True\n'
result = runner.invoke(cli, ['--no-warnings'])
assert result.output == 'False\n'
result = runner.invoke(cli, ['-W'])
assert result.output == 'False\n'
@click.command()
@click.option('--warnings/--no-warnings', '-w', default=True)
def cli_alt(warnings):
click.echo(warnings)
result = runner.invoke(cli_alt, ['--warnings'])
assert result.output == 'True\n'
result = runner.invoke(cli_alt, ['--no-warnings'])
assert result.output == 'False\n'
result = runner.invoke(cli_alt, ['-w'])
assert result.output == 'True\n'
@pytest.mark.parametrize('option_args,expected', [
(['--aggressive', '--all', '-a'], 'aggressive'),
(['--first', '--second', '--third', '-a', '-b', '-c'], 'first'),
(['--apple', '--banana', '--cantaloupe', '-a', '-b', '-c'], 'apple'),
(['--cantaloupe', '--banana', '--apple', '-c', '-b', '-a'], 'cantaloupe'),
(['-a', '-b', '-c'], 'a'),
(['-c', '-b', '-a'], 'c'),
(['-a', '--apple', '-b', '--banana', '-c', '--cantaloupe'], 'apple'),
(['-c', '-a', '--cantaloupe', '-b', '--banana', '--apple'], 'cantaloupe'),
(['--from', '-f', '_from'], '_from'),
(['--return', '-r', '_ret'], '_ret'),
])
def test_option_names(runner, option_args, expected):
@click.command()
@click.option(*option_args, is_flag=True)
def cmd(**kwargs):
click.echo(str(kwargs[expected]))
assert cmd.params[0].name == expected
for form in option_args:
if form.startswith('-'):
result = runner.invoke(cmd, [form])
assert result.output == 'True\n'
Click-7.0/tests/test_termui.py 0000644 0001750 0001750 00000007145 13351570514 016700 0 ustar david david 0000000 0000000 import click
import time
class FakeClock(object):
def __init__(self):
self.now = time.time()
def advance_time(self, seconds=1):
self.now += seconds
def time(self):
return self.now
def test_progressbar_strip_regression(runner, monkeypatch):
fake_clock = FakeClock()
label = ' padded line'
@click.command()
def cli():
with click.progressbar(tuple(range(10)), label=label) as progress:
for thing in progress:
fake_clock.advance_time()
monkeypatch.setattr(time, 'time', fake_clock.time)
monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
assert label in runner.invoke(cli, []).output
def test_progressbar_length_hint(runner, monkeypatch):
class Hinted(object):
def __init__(self, n):
self.items = list(range(n))
def __length_hint__(self):
return len(self.items)
def __iter__(self):
return self
def __next__(self):
if self.items:
return self.items.pop()
else:
raise StopIteration
next = __next__
fake_clock = FakeClock()
@click.command()
def cli():
with click.progressbar(Hinted(10), label='test') as progress:
for thing in progress:
fake_clock.advance_time()
monkeypatch.setattr(time, 'time', fake_clock.time)
monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
result = runner.invoke(cli, [])
assert result.exception is None
def test_progressbar_hidden(runner, monkeypatch):
fake_clock = FakeClock()
label = 'whatever'
@click.command()
def cli():
with click.progressbar(tuple(range(10)), label=label) as progress:
for thing in progress:
fake_clock.advance_time()
monkeypatch.setattr(time, 'time', fake_clock.time)
monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: False)
assert runner.invoke(cli, []).output == ''
def test_choices_list_in_prompt(runner, monkeypatch):
@click.command()
@click.option('-g', type=click.Choice(['none', 'day', 'week', 'month']),
prompt=True)
def cli_with_choices(g):
pass
@click.command()
@click.option('-g', type=click.Choice(['none', 'day', 'week', 'month']),
prompt=True, show_choices=False)
def cli_without_choices(g):
pass
result = runner.invoke(cli_with_choices, [], input='none')
assert '(none, day, week, month)' in result.output
result = runner.invoke(cli_without_choices, [], input='none')
assert '(none, day, week, month)' not in result.output
def test_secho(runner):
with runner.isolation() as outstreams:
click.secho(None, nl=False)
bytes = outstreams[0].getvalue()
assert bytes == b''
def test_progressbar_yields_all_items(runner):
with click.progressbar(range(3)) as progress:
assert len(list(progress)) == 3
def test_progressbar_update(runner, monkeypatch):
fake_clock = FakeClock()
@click.command()
def cli():
with click.progressbar(range(4)) as progress:
for _ in progress:
fake_clock.advance_time()
print("")
monkeypatch.setattr(time, 'time', fake_clock.time)
monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
output = runner.invoke(cli, []).output
lines = [line for line in output.split('\n') if '[' in line]
assert ' 25% 00:00:03' in lines[0]
assert ' 50% 00:00:02' in lines[1]
assert ' 75% 00:00:01' in lines[2]
assert '100% ' in lines[3]
Click-7.0/tests/test_testing.py 0000644 0001750 0001750 00000016111 13351570514 017041 0 ustar david david 0000000 0000000 import os
import sys
import pytest
import click
from click.testing import CliRunner
from click._compat import PY2, WIN
# Use the most reasonable io that users would use for the python version.
if PY2:
from cStringIO import StringIO as ReasonableBytesIO
else:
from io import BytesIO as ReasonableBytesIO
def test_runner():
@click.command()
def test():
i = click.get_binary_stream('stdin')
o = click.get_binary_stream('stdout')
while 1:
chunk = i.read(4096)
if not chunk:
break
o.write(chunk)
o.flush()
runner = CliRunner()
result = runner.invoke(test, input='Hello World!\n')
assert not result.exception
assert result.output == 'Hello World!\n'
runner = CliRunner(echo_stdin=True)
result = runner.invoke(test, input='Hello World!\n')
assert not result.exception
assert result.output == 'Hello World!\nHello World!\n'
def test_runner_with_stream():
@click.command()
def test():
i = click.get_binary_stream('stdin')
o = click.get_binary_stream('stdout')
while 1:
chunk = i.read(4096)
if not chunk:
break
o.write(chunk)
o.flush()
runner = CliRunner()
result = runner.invoke(test, input=ReasonableBytesIO(b'Hello World!\n'))
assert not result.exception
assert result.output == 'Hello World!\n'
runner = CliRunner(echo_stdin=True)
result = runner.invoke(test, input=ReasonableBytesIO(b'Hello World!\n'))
assert not result.exception
assert result.output == 'Hello World!\nHello World!\n'
def test_prompts():
@click.command()
@click.option('--foo', prompt=True)
def test(foo):
click.echo('foo=%s' % foo)
runner = CliRunner()
result = runner.invoke(test, input='wau wau\n')
assert not result.exception
assert result.output == 'Foo: wau wau\nfoo=wau wau\n'
@click.command()
@click.option('--foo', prompt=True, hide_input=True)
def test(foo):
click.echo('foo=%s' % foo)
runner = CliRunner()
result = runner.invoke(test, input='wau wau\n')
assert not result.exception
assert result.output == 'Foo: \nfoo=wau wau\n'
def test_getchar():
@click.command()
def continue_it():
click.echo(click.getchar())
runner = CliRunner()
result = runner.invoke(continue_it, input='y')
assert not result.exception
assert result.output == 'y\n'
def test_catch_exceptions():
class CustomError(Exception):
pass
@click.command()
def cli():
raise CustomError(1)
runner = CliRunner()
result = runner.invoke(cli)
assert isinstance(result.exception, CustomError)
assert type(result.exc_info) is tuple
assert len(result.exc_info) == 3
with pytest.raises(CustomError):
runner.invoke(cli, catch_exceptions=False)
CustomError = SystemExit
result = runner.invoke(cli)
assert result.exit_code == 1
@pytest.mark.skipif(WIN, reason='Test does not make sense on Windows.')
def test_with_color():
@click.command()
def cli():
click.secho('hello world', fg='blue')
runner = CliRunner()
result = runner.invoke(cli)
assert result.output == 'hello world\n'
assert not result.exception
result = runner.invoke(cli, color=True)
assert result.output == click.style('hello world', fg='blue') + '\n'
assert not result.exception
def test_with_color_but_pause_not_blocking():
@click.command()
def cli():
click.pause()
runner = CliRunner()
result = runner.invoke(cli, color=True)
assert not result.exception
assert result.output == ''
def test_exit_code_and_output_from_sys_exit():
# See issue #362
@click.command()
def cli_string():
click.echo('hello world')
sys.exit('error')
@click.command()
@click.pass_context
def cli_string_ctx_exit(ctx):
click.echo('hello world')
ctx.exit('error')
@click.command()
def cli_int():
click.echo('hello world')
sys.exit(1)
@click.command()
@click.pass_context
def cli_int_ctx_exit(ctx):
click.echo('hello world')
ctx.exit(1)
@click.command()
def cli_float():
click.echo('hello world')
sys.exit(1.0)
@click.command()
@click.pass_context
def cli_float_ctx_exit(ctx):
click.echo('hello world')
ctx.exit(1.0)
@click.command()
def cli_no_error():
click.echo('hello world')
runner = CliRunner()
result = runner.invoke(cli_string)
assert result.exit_code == 1
assert result.output == 'hello world\nerror\n'
result = runner.invoke(cli_string_ctx_exit)
assert result.exit_code == 1
assert result.output == 'hello world\nerror\n'
result = runner.invoke(cli_int)
assert result.exit_code == 1
assert result.output == 'hello world\n'
result = runner.invoke(cli_int_ctx_exit)
assert result.exit_code == 1
assert result.output == 'hello world\n'
result = runner.invoke(cli_float)
assert result.exit_code == 1
assert result.output == 'hello world\n1.0\n'
result = runner.invoke(cli_float_ctx_exit)
assert result.exit_code == 1
assert result.output == 'hello world\n1.0\n'
result = runner.invoke(cli_no_error)
assert result.exit_code == 0
assert result.output == 'hello world\n'
def test_env():
@click.command()
def cli_env():
click.echo('ENV=%s' % os.environ['TEST_CLICK_ENV'])
runner = CliRunner()
env_orig = dict(os.environ)
env = dict(env_orig)
assert 'TEST_CLICK_ENV' not in env
env['TEST_CLICK_ENV'] = 'some_value'
result = runner.invoke(cli_env, env=env)
assert result.exit_code == 0
assert result.output == 'ENV=some_value\n'
assert os.environ == env_orig
def test_stderr():
@click.command()
def cli_stderr():
click.echo("stdout")
click.echo("stderr", err=True)
runner = CliRunner(mix_stderr=False)
result = runner.invoke(cli_stderr)
assert result.output == 'stdout\n'
assert result.stdout == 'stdout\n'
assert result.stderr == 'stderr\n'
runner_mix = CliRunner(mix_stderr=True)
result_mix = runner_mix.invoke(cli_stderr)
assert result_mix.output == 'stdout\nstderr\n'
assert result_mix.stdout == 'stdout\nstderr\n'
with pytest.raises(ValueError):
result_mix.stderr
@pytest.mark.parametrize('args, expected_output', [
(None, 'bar\n'),
([], 'bar\n'),
('', 'bar\n'),
(['--foo', 'one two'], 'one two\n'),
('--foo "one two"', 'one two\n'),
])
def test_args(args, expected_output):
@click.command()
@click.option('--foo', default='bar')
def cli_args(foo):
click.echo(foo)
runner = CliRunner()
result = runner.invoke(cli_args, args=args)
assert result.exit_code == 0
assert result.output == expected_output
def test_setting_prog_name_in_extra():
@click.command()
def cli():
click.echo("ok")
runner = CliRunner()
result = runner.invoke(cli, prog_name="foobar")
assert not result.exception
assert result.output == 'ok\n'
Click-7.0/tests/test_utils.py 0000644 0001750 0001750 00000022577 13351570514 016541 0 ustar david david 0000000 0000000 import os
import sys
import pytest
import click
import click.utils
import click._termui_impl
from click._compat import WIN, PY2
def test_echo(runner):
with runner.isolation() as outstreams:
click.echo(u'\N{SNOWMAN}')
click.echo(b'\x44\x44')
click.echo(42, nl=False)
click.echo(b'a', nl=False)
click.echo('\x1b[31mx\x1b[39m', nl=False)
bytes = outstreams[0].getvalue().replace(b'\r\n', b'\n')
assert bytes == b'\xe2\x98\x83\nDD\n42ax'
# If we are in Python 2, we expect that writing bytes into a string io
# does not do anything crazy. In Python 3
if sys.version_info[0] == 2:
import StringIO
sys.stdout = x = StringIO.StringIO()
try:
click.echo('\xf6')
finally:
sys.stdout = sys.__stdout__
assert x.getvalue() == '\xf6\n'
# And in any case, if wrapped, we expect bytes to survive.
@click.command()
def cli():
click.echo(b'\xf6')
result = runner.invoke(cli, [])
assert result.stdout_bytes == b'\xf6\n'
# Ensure we do not strip for bytes.
with runner.isolation() as outstreams:
click.echo(bytearray(b'\x1b[31mx\x1b[39m'), nl=False)
assert outstreams[0].getvalue() == b'\x1b[31mx\x1b[39m'
def test_echo_custom_file():
import io
f = io.StringIO()
click.echo(u'hello', file=f)
assert f.getvalue() == u'hello\n'
def test_styling():
examples = [
('x', dict(fg='black'), '\x1b[30mx\x1b[0m'),
('x', dict(fg='red'), '\x1b[31mx\x1b[0m'),
('x', dict(fg='green'), '\x1b[32mx\x1b[0m'),
('x', dict(fg='yellow'), '\x1b[33mx\x1b[0m'),
('x', dict(fg='blue'), '\x1b[34mx\x1b[0m'),
('x', dict(fg='magenta'), '\x1b[35mx\x1b[0m'),
('x', dict(fg='cyan'), '\x1b[36mx\x1b[0m'),
('x', dict(fg='white'), '\x1b[37mx\x1b[0m'),
('x', dict(bg='black'), '\x1b[40mx\x1b[0m'),
('x', dict(bg='red'), '\x1b[41mx\x1b[0m'),
('x', dict(bg='green'), '\x1b[42mx\x1b[0m'),
('x', dict(bg='yellow'), '\x1b[43mx\x1b[0m'),
('x', dict(bg='blue'), '\x1b[44mx\x1b[0m'),
('x', dict(bg='magenta'), '\x1b[45mx\x1b[0m'),
('x', dict(bg='cyan'), '\x1b[46mx\x1b[0m'),
('x', dict(bg='white'), '\x1b[47mx\x1b[0m'),
('foo bar', dict(blink=True), '\x1b[5mfoo bar\x1b[0m'),
('foo bar', dict(underline=True), '\x1b[4mfoo bar\x1b[0m'),
('foo bar', dict(bold=True), '\x1b[1mfoo bar\x1b[0m'),
('foo bar', dict(dim=True), '\x1b[2mfoo bar\x1b[0m'),
]
for text, styles, ref in examples:
assert click.style(text, **styles) == ref
assert click.unstyle(ref) == text
def test_filename_formatting():
assert click.format_filename(b'foo.txt') == 'foo.txt'
assert click.format_filename(b'/x/foo.txt') == '/x/foo.txt'
assert click.format_filename(u'/x/foo.txt') == '/x/foo.txt'
assert click.format_filename(u'/x/foo.txt', shorten=True) == 'foo.txt'
# filesystem encoding on windows permits this.
if not WIN:
assert click.format_filename(b'/x/foo\xff.txt', shorten=True) \
== u'foo\ufffd.txt'
def test_prompts(runner):
@click.command()
def test():
if click.confirm('Foo'):
click.echo('yes!')
else:
click.echo('no :(')
result = runner.invoke(test, input='y\n')
assert not result.exception
assert result.output == 'Foo [y/N]: y\nyes!\n'
result = runner.invoke(test, input='\n')
assert not result.exception
assert result.output == 'Foo [y/N]: \nno :(\n'
result = runner.invoke(test, input='n\n')
assert not result.exception
assert result.output == 'Foo [y/N]: n\nno :(\n'
@click.command()
def test_no():
if click.confirm('Foo', default=True):
click.echo('yes!')
else:
click.echo('no :(')
result = runner.invoke(test_no, input='y\n')
assert not result.exception
assert result.output == 'Foo [Y/n]: y\nyes!\n'
result = runner.invoke(test_no, input='\n')
assert not result.exception
assert result.output == 'Foo [Y/n]: \nyes!\n'
result = runner.invoke(test_no, input='n\n')
assert not result.exception
assert result.output == 'Foo [Y/n]: n\nno :(\n'
@pytest.mark.skipif(WIN, reason='Different behavior on windows.')
def test_prompts_abort(monkeypatch, capsys):
def f(_):
raise KeyboardInterrupt()
monkeypatch.setattr('click.termui.hidden_prompt_func', f)
try:
click.prompt('Password', hide_input=True)
except click.Abort:
click.echo('Screw you.')
out, err = capsys.readouterr()
assert out == 'Password: \nScrew you.\n'
def _test_gen_func():
yield 'a'
yield 'b'
yield 'c'
yield 'abc'
@pytest.mark.skipif(WIN, reason='Different behavior on windows.')
@pytest.mark.parametrize('cat', ['cat', 'cat ', 'cat '])
@pytest.mark.parametrize('test', [
# We need lambda here, because pytest will
# reuse the parameters, and then the generators
# are already used and will not yield anymore
('just text\n', lambda: 'just text'),
('iterable\n', lambda: ["itera", "ble"]),
('abcabc\n', lambda: _test_gen_func),
('abcabc\n', lambda: _test_gen_func()),
('012345\n', lambda: (c for c in range(6))),
])
def test_echo_via_pager(monkeypatch, capfd, cat, test):
monkeypatch.setitem(os.environ, 'PAGER', cat)
monkeypatch.setattr(click._termui_impl, 'isatty', lambda x: True)
expected_output = test[0]
test_input = test[1]()
click.echo_via_pager(test_input)
out, err = capfd.readouterr()
assert out == expected_output
@pytest.mark.skipif(WIN, reason='Test does not make sense on Windows.')
def test_echo_color_flag(monkeypatch, capfd):
isatty = True
monkeypatch.setattr(click._compat, 'isatty', lambda x: isatty)
text = 'foo'
styled_text = click.style(text, fg='red')
assert styled_text == '\x1b[31mfoo\x1b[0m'
click.echo(styled_text, color=False)
out, err = capfd.readouterr()
assert out == text + '\n'
click.echo(styled_text, color=True)
out, err = capfd.readouterr()
assert out == styled_text + '\n'
isatty = True
click.echo(styled_text)
out, err = capfd.readouterr()
assert out == styled_text + '\n'
isatty = False
click.echo(styled_text)
out, err = capfd.readouterr()
assert out == text + '\n'
@pytest.mark.skipif(WIN, reason='Test too complex to make work windows.')
def test_echo_writing_to_standard_error(capfd, monkeypatch):
def emulate_input(text):
"""Emulate keyboard input."""
if sys.version_info[0] == 2:
from StringIO import StringIO
else:
from io import StringIO
monkeypatch.setattr(sys, 'stdin', StringIO(text))
click.echo('Echo to standard output')
out, err = capfd.readouterr()
assert out == 'Echo to standard output\n'
assert err == ''
click.echo('Echo to standard error', err=True)
out, err = capfd.readouterr()
assert out == ''
assert err == 'Echo to standard error\n'
emulate_input('asdlkj\n')
click.prompt('Prompt to stdin')
out, err = capfd.readouterr()
assert out == 'Prompt to stdin: '
assert err == ''
emulate_input('asdlkj\n')
click.prompt('Prompt to stderr', err=True)
out, err = capfd.readouterr()
assert out == ''
assert err == 'Prompt to stderr: '
emulate_input('y\n')
click.confirm('Prompt to stdin')
out, err = capfd.readouterr()
assert out == 'Prompt to stdin [y/N]: '
assert err == ''
emulate_input('y\n')
click.confirm('Prompt to stderr', err=True)
out, err = capfd.readouterr()
assert out == ''
assert err == 'Prompt to stderr [y/N]: '
monkeypatch.setattr(click.termui, 'isatty', lambda x: True)
monkeypatch.setattr(click.termui, 'getchar', lambda: ' ')
click.pause('Pause to stdout')
out, err = capfd.readouterr()
assert out == 'Pause to stdout\n'
assert err == ''
click.pause('Pause to stderr', err=True)
out, err = capfd.readouterr()
assert out == ''
assert err == 'Pause to stderr\n'
def test_open_file(runner):
with runner.isolated_filesystem():
with open('hello.txt', 'w') as f:
f.write('Cool stuff')
@click.command()
@click.argument('filename')
def cli(filename):
with click.open_file(filename) as f:
click.echo(f.read())
click.echo('meep')
result = runner.invoke(cli, ['hello.txt'])
assert result.exception is None
assert result.output == 'Cool stuff\nmeep\n'
result = runner.invoke(cli, ['-'], input='foobar')
assert result.exception is None
assert result.output == 'foobar\nmeep\n'
@pytest.mark.xfail(WIN and not PY2, reason='God knows ...')
def test_iter_keepopenfile(tmpdir):
expected = list(map(str, range(10)))
p = tmpdir.mkdir('testdir').join('testfile')
p.write(os.linesep.join(expected))
with p.open() as f:
for e_line, a_line in zip(expected, click.utils.KeepOpenFile(f)):
assert e_line == a_line.strip()
@pytest.mark.xfail(WIN and not PY2, reason='God knows ...')
def test_iter_lazyfile(tmpdir):
expected = list(map(str, range(10)))
p = tmpdir.mkdir('testdir').join('testfile')
p.write(os.linesep.join(expected))
with p.open() as f:
with click.utils.LazyFile(f.name) as lf:
for e_line, a_line in zip(expected, lf):
assert e_line == a_line.strip()
Click-7.0/tox.ini 0000644 0001750 0001750 00000001455 13352433170 014126 0 ustar david david 0000000 0000000 [tox]
envlist =
py{37,36,35,34,27,py3,py}
docs-html
coverage-report
skip_missing_interpreters = true
[testenv]
passenv = LANG
deps =
pytest
coverage
colorama
commands = coverage run -p -m pytest {posargs}
[testenv:docs-html]
deps = -r docs/requirements.txt
commands = sphinx-build -W -b html -d {envtmpdir}/doctrees docs {envtmpdir}/html
[testenv:docs-linkcheck]
deps = -r docs/requirements.txt
commands = sphinx-build -W -b linkcheck -d {envtmpdir}/doctrees docs {envtmpdir}/linkcheck
[testenv:coverage-report]
deps = coverage
skip_install = true
commands =
coverage combine
coverage report
coverage html
[testenv:codecov]
passenv = CI TRAVIS TRAVIS_* APPVEYOR APPVEYOR_*
deps = codecov
skip_install = true
commands =
coverage combine
coverage report
codecov