pax_global_header00006660000000000000000000000064145271012250014511gustar00rootroot0000000000000052 comment=a92b4b0434ae03100a14d9e082e017b87904f0c8 asyncclick-8.1.7.0-async/000077500000000000000000000000001452710122500151225ustar00rootroot00000000000000asyncclick-8.1.7.0-async/.editorconfig000066400000000000000000000003311452710122500175740ustar00rootroot00000000000000root = true [*] indent_style = space indent_size = 4 insert_final_newline = true trim_trailing_whitespace = true end_of_line = lf charset = utf-8 max_line_length = 88 [*.{yml,yaml,json,js,css,html}] indent_size = 2 asyncclick-8.1.7.0-async/.github/000077500000000000000000000000001452710122500164625ustar00rootroot00000000000000asyncclick-8.1.7.0-async/.github/ISSUE_TEMPLATE/000077500000000000000000000000001452710122500206455ustar00rootroot00000000000000asyncclick-8.1.7.0-async/.github/ISSUE_TEMPLATE/bug-report.md000066400000000000000000000011371452710122500232570ustar00rootroot00000000000000--- name: Bug report about: Report a bug in Click (not other projects which depend on Click) --- Environment: - Python version: - Click version: asyncclick-8.1.7.0-async/.github/ISSUE_TEMPLATE/config.yml000066400000000000000000000007601452710122500226400ustar00rootroot00000000000000blank_issues_enabled: false contact_links: - name: Security issue url: security@palletsprojects.com about: Do not report security issues publicly. Email our security contact. - name: Questions url: https://stackoverflow.com/questions/tagged/python-click?tab=Frequent about: Search for and ask questions about your code on Stack Overflow. - name: Questions and discussions url: https://discord.gg/pallets about: Discuss questions about your code on our Discord chat. asyncclick-8.1.7.0-async/.github/ISSUE_TEMPLATE/feature-request.md000066400000000000000000000006351452710122500243140ustar00rootroot00000000000000--- name: Feature request about: Suggest a new feature for Click --- asyncclick-8.1.7.0-async/.github/dependabot.yml000066400000000000000000000002471452710122500213150ustar00rootroot00000000000000version: 2 updates: - package-ecosystem: "github-actions" directory: "/" schedule: interval: "monthly" day: "monday" time: "16:00" timezone: "UTC" asyncclick-8.1.7.0-async/.github/pull_request_template.md000066400000000000000000000017131452710122500234250ustar00rootroot00000000000000 - fixes # Checklist: - [ ] Add tests that demonstrate the correct behavior of the change. Tests should fail without the change. - [ ] Add or update relevant docs, in the docs folder and in code. - [ ] Add an entry in `CHANGES.rst` summarizing the change and linking to the issue. - [ ] Add `.. versionchanged::` entries in any relevant code docs. - [ ] Run `pre-commit` hooks and fix any issues. - [ ] Run `pytest` and `tox`, no tests failed. asyncclick-8.1.7.0-async/.github/workflows/000077500000000000000000000000001452710122500205175ustar00rootroot00000000000000asyncclick-8.1.7.0-async/.github/workflows/lock.yaml000066400000000000000000000011501452710122500223300ustar00rootroot00000000000000name: 'Lock threads' # Lock closed issues that have not received any further activity for # two weeks. This does not close open issues, only humans may do that. # We find that it is easier to respond to new issues with fresh examples # rather than continuing discussions on old issues. on: schedule: - cron: '0 0 * * *' permissions: issues: write pull-requests: write concurrency: group: lock jobs: lock: runs-on: ubuntu-latest steps: - uses: dessant/lock-threads@c1b35aecc5cdb1a34539d14196df55838bb2f836 with: issue-inactive-days: 14 pr-inactive-days: 14 asyncclick-8.1.7.0-async/.github/workflows/publish.yaml000066400000000000000000000050441452710122500230540ustar00rootroot00000000000000name: Publish on: push: tags: - '*' jobs: build: runs-on: ubuntu-latest outputs: hash: ${{ steps.hash.outputs.hash }} steps: - uses: actions/checkout@8f4b7f84864484a7bf31766abe9204da3cbe65b3 - uses: actions/setup-python@d27e3f3d7c64b4bbf8e4abfb9b63b83e846e0435 with: python-version: '3.x' cache: 'pip' cache-dependency-path: 'requirements/*.txt' - run: pip install -r requirements/build.txt # Use the commit date instead of the current date during the build. - run: echo "SOURCE_DATE_EPOCH=$(git log -1 --pretty=%ct)" >> $GITHUB_ENV - run: python -m build # Generate hashes used for provenance. - name: generate hash id: hash run: cd dist && echo "hash=$(sha256sum * | base64 -w0)" >> $GITHUB_OUTPUT - uses: actions/upload-artifact@0b7f8abb1508181956e8e162db84b466c27e18ce with: path: ./dist provenance: needs: ['build'] permissions: actions: read id-token: write contents: write # Can't pin with hash due to how this workflow works. uses: slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@v1.7.0 with: base64-subjects: ${{ needs.build.outputs.hash }} create-release: # Upload the sdist, wheels, and provenance to a GitHub release. They remain # available as build artifacts for a while as well. needs: ['provenance'] runs-on: ubuntu-latest permissions: contents: write steps: - uses: actions/download-artifact@9bc31d5ccc31df68ecc42ccf4149144866c47d8a - name: create release run: > gh release create --draft --repo ${{ github.repository }} ${{ github.ref_name }} *.intoto.jsonl/* artifact/* env: GH_TOKEN: ${{ github.token }} publish-pypi: needs: ['provenance'] # Wait for approval before attempting to upload to PyPI. This allows reviewing the # files in the draft release. environment: 'publish' runs-on: ubuntu-latest permissions: id-token: write steps: - uses: actions/download-artifact@9bc31d5ccc31df68ecc42ccf4149144866c47d8a # Try uploading to Test PyPI first, in case something fails. - uses: pypa/gh-action-pypi-publish@29930c9cf57955dc1b98162d0d8bc3ec80d9e75c with: repository-url: https://test.pypi.org/legacy/ packages-dir: artifact/ - uses: pypa/gh-action-pypi-publish@29930c9cf57955dc1b98162d0d8bc3ec80d9e75c with: packages-dir: artifact/ asyncclick-8.1.7.0-async/.github/workflows/tests.yaml000066400000000000000000000035541452710122500225540ustar00rootroot00000000000000name: Tests on: push: branches: - main - '*.x' paths-ignore: - 'docs/**' - '*.md' - '*.rst' pull_request: branches: - main - '*.x' paths-ignore: - 'docs/**' - '*.md' - '*.rst' jobs: tests: name: ${{ matrix.name }} runs-on: ${{ matrix.os }} strategy: fail-fast: false matrix: include: - {name: Linux, python: '3.11', os: ubuntu-latest, tox: py311} - {name: Windows, python: '3.11', os: windows-latest, tox: py311} - {name: Mac, python: '3.11', os: macos-latest, tox: py311} - {name: '3.12-dev', python: '3.12-dev', os: ubuntu-latest, tox: py312} - {name: '3.10', python: '3.10', os: ubuntu-latest, tox: py310} - {name: '3.9', python: '3.9', os: ubuntu-latest, tox: py39} - {name: '3.8', python: '3.8', os: ubuntu-latest, tox: py38} - {name: '3.7', python: '3.7', os: ubuntu-latest, tox: py37} - {name: 'PyPy', python: 'pypy-3.10', os: ubuntu-latest, tox: pypy310} - {name: Typing, python: '3.11', os: ubuntu-latest, tox: typing} steps: - uses: actions/checkout@ac593985615ec2ede58e132d2e21d2b1cbd6127c - uses: actions/setup-python@5ccb29d8773c3f3f653e1705f474dfaa8a06a912 with: python-version: ${{ matrix.python }} cache: 'pip' cache-dependency-path: 'requirements/*.txt' - name: update pip run: | pip install -U wheel pip install -U setuptools python -m pip install -U pip - name: cache mypy uses: actions/cache@58c146cc91c5b9e778e71775dfe9bf1442ad9a12 with: path: ./.mypy_cache key: mypy|${{ matrix.python }}|${{ hashFiles('setup.cfg') }} if: matrix.tox == 'typing' - run: pip install tox - run: tox run -e ${{ matrix.tox }} asyncclick-8.1.7.0-async/.gitignore000066400000000000000000000002711452710122500171120ustar00rootroot00000000000000/.idea/ /.vscode/ .DS_Store/ /env/ /venv/ /.pybuild/ .cache/ __pycache__/ *.pyc *.egg-info/ /build/ /dist/ /.pytest_cache/ /.tox/ .coverage .coverage.* htmlcov/ /htmlcov/ /docs/_build/ asyncclick-8.1.7.0-async/.pre-commit-config.yaml000066400000000000000000000014701452710122500214050ustar00rootroot00000000000000ci: autoupdate_branch: "8.1.x" autoupdate_schedule: monthly repos: - repo: https://github.com/asottile/pyupgrade rev: v3.10.1 hooks: - id: pyupgrade args: ["--py37-plus"] - repo: https://github.com/asottile/reorder-python-imports rev: v3.10.0 hooks: - id: reorder-python-imports args: ["--application-directories", "src"] - repo: https://github.com/psf/black rev: 23.7.0 hooks: - id: black - repo: https://github.com/PyCQA/flake8 rev: 6.1.0 hooks: - id: flake8 additional_dependencies: - flake8-bugbear - flake8-implicit-str-concat - repo: https://github.com/pre-commit/pre-commit-hooks rev: v4.4.0 hooks: - id: fix-byte-order-marker - id: trailing-whitespace - id: end-of-file-fixer asyncclick-8.1.7.0-async/.readthedocs.yaml000066400000000000000000000003211452710122500203450ustar00rootroot00000000000000version: 2 build: os: ubuntu-20.04 tools: python: "3.10" python: install: - requirements: requirements/docs.txt - method: pip path: . sphinx: builder: dirhtml fail_on_warning: true asyncclick-8.1.7.0-async/CHANGES.rst000066400000000000000000001333531452710122500167340ustar00rootroot00000000000000.. currentmodule:: click Version 8.1.7 ------------- Released 2023-08-17 - Fix issue with regex flags in shell completion. :issue:`2581` - Bash version detection issues a warning instead of an error. :issue:`2574` - Fix issue with completion script for Fish shell. :issue:`2567` Version 8.1.6 ------------- Released 2023-07-18 - Fix an issue with type hints for ``@click.group()``. :issue:`2558` Version 8.1.5 ------------- Released 2023-07-13 - Fix an issue with type hints for ``@click.command()``, ``@click.option()``, and other decorators. Introduce typing tests. :issue:`2558` Version 8.1.4 ------------- Released 2023-07-06 - Replace all ``typing.Dict`` occurrences to ``typing.MutableMapping`` for parameter hints. :issue:`2255` - Improve type hinting for decorators and give all generic types parameters. :issue:`2398` - Fix return value and type signature of `shell_completion.add_completion_class` function. :pr:`2421` - Bash version detection doesn't fail on Windows. :issue:`2461` - Completion works if there is a dot (``.``) in the program name. :issue:`2166` - Improve type annotations for pyright type checker. :issue:`2268` - Improve responsiveness of ``click.clear()``. :issue:`2284` - Improve command name detection when using Shiv or PEX. :issue:`2332` - Avoid showing empty lines if command help text is empty. :issue:`2368` - ZSH completion script works when loaded from ``fpath``. :issue:`2344`. - ``EOFError`` and ``KeyboardInterrupt`` tracebacks are not suppressed when ``standalone_mode`` is disabled. :issue:`2380` - ``@group.command`` does not fail if the group was created with a custom ``command_class``. :issue:`2416` - ``multiple=True`` is allowed for flag options again and does not require setting ``default=()``. :issue:`2246, 2292, 2295` - Make the decorators returned by ``@argument()`` and ``@option()`` reusable when the ``cls`` parameter is used. :issue:`2294` - Don't fail when writing filenames to streams with strict errors. Replace invalid bytes with the replacement character (``�``). :issue:`2395` - Remove unnecessary attempt to detect MSYS2 environment. :issue:`2355` - Remove outdated and unnecessary detection of App Engine environment. :pr:`2554` - ``echo()`` does not fail when no streams are attached, such as with ``pythonw`` on Windows. :issue:`2415` - Argument with ``expose_value=False`` do not cause completion to fail. :issue:`2336` Version 8.1.3 ------------- Released 2022-04-28 - Use verbose form of ``typing.Callable`` for ``@command`` and ``@group``. :issue:`2255` - Show error when attempting to create an option with ``multiple=True, is_flag=True``. Use ``count`` instead. :issue:`2246` Version 8.1.2 ------------- Released 2022-03-31 - Fix error message for readable path check that was mixed up with the executable check. :pr:`2236` - Restore parameter order for ``Path``, placing the ``executable`` parameter at the end. It is recommended to use keyword arguments instead of positional arguments. :issue:`2235` Version 8.1.1 ------------- Released 2022-03-30 - Fix an issue with decorator typing that caused type checking to report that a command was not callable. :issue:`2227` Version 8.1.0 ------------- Released 2022-03-28 - Drop support for Python 3.6. :pr:`2129` - Remove previously deprecated code. :pr:`2130` - ``Group.resultcallback`` is renamed to ``result_callback``. - ``autocompletion`` parameter to ``Command`` is renamed to ``shell_complete``. - ``get_terminal_size`` is removed, use ``shutil.get_terminal_size`` instead. - ``get_os_args`` is removed, use ``sys.argv[1:]`` instead. - Rely on :pep:`538` and :pep:`540` to handle selecting UTF-8 encoding instead of ASCII. Click's locale encoding detection is removed. :issue:`2198` - Single options boolean flags with ``show_default=True`` only show the default if it is ``True``. :issue:`1971` - The ``command`` and ``group`` decorators can be applied with or without parentheses. :issue:`1359` - The ``Path`` type can check whether the target is executable. :issue:`1961` - ``Command.show_default`` overrides ``Context.show_default``, instead of the other way around. :issue:`1963` - Parameter decorators and ``@group`` handles ``cls=None`` the same as not passing ``cls``. ``@option`` handles ``help=None`` the same as not passing ``help``. :issue:`#1959` - A flag option with ``required=True`` requires that the flag is passed instead of choosing the implicit default value. :issue:`1978` - Indentation in help text passed to ``Option`` and ``Command`` is cleaned the same as using the ``@option`` and ``@command`` decorators does. A command's ``epilog`` and ``short_help`` are also processed. :issue:`1985` - Store unprocessed ``Command.help``, ``epilog`` and ``short_help`` strings. Processing is only done when formatting help text for output. :issue:`2149` - Allow empty str input for ``prompt()`` when ``confirmation_prompt=True`` and ``default=""``. :issue:`2157` - Windows glob pattern expansion doesn't fail if a value is an invalid pattern. :issue:`2195` - It's possible to pass a list of ``params`` to ``@command``. Any params defined with decorators are appended to the passed params. :issue:`2131`. - ``@command`` decorator is annotated as returning the correct type if a ``cls`` argument is used. :issue:`2211` - A ``Group`` with ``invoke_without_command=True`` and ``chain=False`` will invoke its result callback with the group function's return value. :issue:`2124` - ``to_info_dict`` will not fail if a ``ParamType`` doesn't define a ``name``. :issue:`2168` - Shell completion prioritizes option values with option prefixes over new options. :issue:`2040` - Options that get an environment variable value using ``autoenvvar_prefix`` treat an empty value as ``None``, consistent with a direct ``envvar``. :issue:`2146` Version 8.0.4 ------------- Released 2022-02-18 - ``open_file`` recognizes ``Path("-")`` as a standard stream, the same as the string ``"-"``. :issue:`2106` - The ``option`` and ``argument`` decorators preserve the type annotation of the decorated function. :pr:`2155` - A callable default value can customize its help text by overriding ``__str__`` instead of always showing ``(dynamic)``. :issue:`2099` - Fix a typo in the Bash completion script that affected file and directory completion. If this script was generated by a previous version, it should be regenerated. :issue:`2163` - Fix typing for ``echo`` and ``secho`` file argument. :issue:`2174, 2185` Version 8.0.3 ------------- Released 2021-10-10 - Fix issue with ``Path(resolve_path=True)`` type creating invalid paths. :issue:`2088` - Importing ``readline`` does not cause the ``confirm()`` prompt to disappear when pressing backspace. :issue:`2092` - Any default values injected by ``invoke()`` are cast to the corresponding parameter's type. :issue:`2089, 2090` Version 8.0.2 ------------- Released 2021-10-08 - ``is_bool_flag`` is not set to ``True`` if ``is_flag`` is ``False``. :issue:`1925` - Bash version detection is locale independent. :issue:`1940` - Empty ``default`` value is not shown for ``multiple=True``. :issue:`1969` - Fix shell completion for arguments that start with a forward slash such as absolute file paths. :issue:`1929` - ``Path`` type with ``resolve_path=True`` resolves relative symlinks to be relative to the containing directory. :issue:`1921` - Completion does not skip Python's resource cleanup when exiting, avoiding some unexpected warning output. :issue:`1738, 2017` - Fix type annotation for ``type`` argument in ``prompt`` function. :issue:`2062` - Fix overline and italic styles, which were incorrectly added when adding underline. :pr:`2058` - An option with ``count=True`` will not show "[x>=0]" in help text. :issue:`2072` - Default values are not cast to the parameter type twice during processing. :issue:`2085` - Options with ``multiple`` and ``flag_value`` use the flag value instead of leaving an internal placeholder. :issue:`2001` Version 8.0.1 ------------- Released 2021-05-19 - Mark top-level names as exported so type checking understand imports in user projects. :issue:`1879` - Annotate ``Context.obj`` as ``Any`` so type checking allows all operations on the arbitrary object. :issue:`1885` - Fix some types that weren't available in Python 3.6.0. :issue:`1882` - Fix type checking for iterating over ``ProgressBar`` object. :issue:`1892` - The ``importlib_metadata`` backport package is installed on Python < 3.8. :issue:`1889` - Arguments with ``nargs=-1`` only use env var value if no command line values are given. :issue:`1903` - Flag options guess their type from ``flag_value`` if given, like regular options do from ``default``. :issue:`1886` - Added documentation that custom parameter types may be passed already valid values in addition to strings. :issue:`1898` - Resolving commands returns the name that was given, not ``command.name``, fixing an unintended change to help text and ``default_map`` lookups. When using patterns like ``AliasedGroup``, override ``resolve_command`` to change the name that is returned if needed. :issue:`1895` - If a default value is invalid, it does not prevent showing help text. :issue:`1889` - Pass ``windows_expand_args=False`` when calling the main command to disable pattern expansion on Windows. There is no way to escape patterns in CMD, so if the program needs to pass them on as-is then expansion must be disabled. :issue:`1901` Version 8.0.0 ------------- Released 2021-05-11 - Drop support for Python 2 and 3.5. - Colorama is always installed on Windows in order to provide style and color support. :pr:`1784` - Adds a repr to Command, showing the command name for friendlier debugging. :issue:`1267`, :pr:`1295` - Add support for distinguishing the source of a command line parameter. :issue:`1264`, :pr:`1329` - Add an optional parameter to ``ProgressBar.update`` to set the ``current_item``. :issue:`1226`, :pr:`1332` - ``version_option`` uses ``importlib.metadata`` (or the ``importlib_metadata`` backport) instead of ``pkg_resources``. The version is detected based on the package name, not the entry point name. The Python package name must match the installed package name, or be passed with ``package_name=``. :issue:`1582` - If validation fails for a prompt with ``hide_input=True``, the value is not shown in the error message. :issue:`1460` - An ``IntRange`` or ``FloatRange`` option shows the accepted range in its help text. :issue:`1525`, :pr:`1303` - ``IntRange`` and ``FloatRange`` bounds can be open (``<``) instead of closed (``<=``) by setting ``min_open`` and ``max_open``. Error messages have changed to reflect this. :issue:`1100` - An option defined with duplicate flag names (``"--foo/--foo"``) raises a ``ValueError``. :issue:`1465` - ``echo()`` will not fail when using pytest's ``capsys`` fixture on Windows. :issue:`1590` - Resolving commands returns the canonical command name instead of the matched name. This makes behavior such as help text and ``Context.invoked_subcommand`` consistent when using patterns like ``AliasedGroup``. :issue:`1422` - The ``BOOL`` type accepts the values "on" and "off". :issue:`1629` - A ``Group`` with ``invoke_without_command=True`` will always invoke its result callback. :issue:`1178` - ``nargs == -1`` and ``nargs > 1`` is parsed and validated for values from environment variables and defaults. :issue:`729` - Detect the program name when executing a module or package with ``python -m name``. :issue:`1603` - Include required parent arguments in help synopsis of subcommands. :issue:`1475` - Help for boolean flags with ``show_default=True`` shows the flag name instead of ``True`` or ``False``. :issue:`1538` - Non-string objects passed to ``style()`` and ``secho()`` will be converted to string. :pr:`1146` - ``edit(require_save=True)`` will detect saves for editors that exit very fast on filesystems with 1 second resolution. :pr:`1050` - New class attributes make it easier to use custom core objects throughout an entire application. :pr:`938` - ``Command.context_class`` controls the context created when running the command. - ``Context.invoke`` creates new contexts of the same type, so a custom type will persist to invoked subcommands. - ``Context.formatter_class`` controls the formatter used to generate help and usage. - ``Group.command_class`` changes the default type for subcommands with ``@group.command()``. - ``Group.group_class`` changes the default type for subgroups with ``@group.group()``. Setting it to ``type`` will create subgroups of the same type as the group itself. - Core objects use ``super()`` consistently for better support of subclassing. - Use ``Context.with_resource()`` to manage resources that would normally be used in a ``with`` statement, allowing them to be used across subcommands and callbacks, then cleaned up when the context ends. :pr:`1191` - The result object returned by the test runner's ``invoke()`` method has a ``return_value`` attribute with the value returned by the invoked command. :pr:`1312` - Required arguments with the ``Choice`` type show the choices in curly braces to indicate that one is required (``{a|b|c}``). :issue:`1272` - If only a name is passed to ``option()``, Click suggests renaming it to ``--name``. :pr:`1355` - A context's ``show_default`` parameter defaults to the value from the parent context. :issue:`1565` - ``click.style()`` can output 256 and RGB color codes. Most modern terminals support these codes. :pr:`1429` - When using ``CliRunner.invoke()``, the replaced ``stdin`` file has ``name`` and ``mode`` attributes. This lets ``File`` options with the ``-`` value match non-testing behavior. :issue:`1064` - When creating a ``Group``, allow passing a list of commands instead of a dict. :issue:`1339` - When a long option name isn't valid, use ``difflib`` to make better suggestions for possible corrections. :issue:`1446` - Core objects have a ``to_info_dict()`` method. This gathers information about the object's structure that could be useful for a tool generating user-facing documentation. To get the structure of an entire CLI, use ``Context(cli).to_info_dict()``. :issue:`461` - Redesign the shell completion system. :issue:`1484`, :pr:`1622` - Support Bash >= 4.4, Zsh, and Fish, with the ability for extensions to add support for other shells. - Allow commands, groups, parameters, and types to override their completions suggestions. - Groups complete the names commands were registered with, which can differ from the name they were created with. - The ``autocompletion`` parameter for options and arguments is renamed to ``shell_complete``. The function must take ``ctx, param, incomplete``, must do matching rather than return all values, and must return a list of strings or a list of ``CompletionItem``. The old name and behavior is deprecated and will be removed in 8.1. - The env var values used to start completion have changed order. The shell now comes first, such as ``{shell}_source`` rather than ``source_{shell}``, and is always required. - Completion correctly parses command line strings with incomplete quoting or escape sequences. :issue:`1708` - Extra context settings (``obj=...``, etc.) are passed on to the completion system. :issue:`942` - Include ``--help`` option in completion. :pr:`1504` - ``ParameterSource`` is an ``enum.Enum`` subclass. :issue:`1530` - Boolean and UUID types strip surrounding space before converting. :issue:`1605` - Adjusted error message from parameter type validation to be more consistent. Quotes are used to distinguish the invalid value. :issue:`1605` - The default value for a parameter with ``nargs`` > 1 and ``multiple=True`` must be a list of tuples. :issue:`1649` - When getting the value for a parameter, the default is tried in the same section as other sources to ensure consistent processing. :issue:`1649` - All parameter types accept a value that is already the correct type. :issue:`1649` - For shell completion, an argument is considered incomplete if its value did not come from the command line args. :issue:`1649` - Added ``ParameterSource.PROMPT`` to track parameter values that were prompted for. :issue:`1649` - Options with ``nargs`` > 1 no longer raise an error if a default is not given. Parameters with ``nargs`` > 1 default to ``None``, and parameters with ``multiple=True`` or ``nargs=-1`` default to an empty tuple. :issue:`472` - Handle empty env vars as though the option were not passed. This extends the change introduced in 7.1 to be consistent in more cases. :issue:`1285` - ``Parameter.get_default()`` checks ``Context.default_map`` to handle overrides consistently in help text, ``invoke()``, and prompts. :issue:`1548` - Add ``prompt_required`` param to ``Option``. When set to ``False``, the user will only be prompted for an input if no value was passed. :issue:`736` - Providing the value to an option can be made optional through ``is_flag=False``, and the value can instead be prompted for or passed in as a default value. :issue:`549, 736, 764, 921, 1015, 1618` - Fix formatting when ``Command.options_metavar`` is empty. :pr:`1551` - Revert adding space between option help text that wraps. :issue:`1831` - The default value passed to ``prompt`` will be cast to the correct type like an input value would be. :pr:`1517` - Automatically generated short help messages will stop at the first ending of a phrase or double linebreak. :issue:`1082` - Skip progress bar render steps for efficiency with very fast iterators by setting ``update_min_steps``. :issue:`676` - Respect ``case_sensitive=False`` when doing shell completion for ``Choice`` :issue:`1692` - Use ``mkstemp()`` instead of ``mktemp()`` in pager implementation. :issue:`1752` - If ``Option.show_default`` is a string, it is displayed even if ``default`` is ``None``. :issue:`1732` - ``click.get_terminal_size()`` is deprecated and will be removed in 8.1. Use :func:`shutil.get_terminal_size` instead. :issue:`1736` - Control the location of the temporary directory created by ``CLIRunner.isolated_filesystem`` by passing ``temp_dir``. A custom directory will not be removed automatically. :issue:`395` - ``click.confirm()`` will prompt until input is given if called with ``default=None``. :issue:`1381` - Option prompts validate the value with the option's callback in addition to its type. :issue:`457` - ``confirmation_prompt`` can be set to a custom string. :issue:`723` - Allow styled output in Jupyter on Windows. :issue:`1271` - ``style()`` supports the ``strikethrough``, ``italic``, and ``overline`` styles. :issue:`805, 1821` - Multiline marker is removed from short help text. :issue:`1597` - Restore progress bar behavior of echoing only the label if the file is not a TTY. :issue:`1138` - Progress bar output is shown even if execution time is less than 0.5 seconds. :issue:`1648` - Progress bar ``item_show_func`` shows the current item, not the previous item. :issue:`1353` - The ``Path`` param type can be passed ``path_type=pathlib.Path`` to return a path object instead of a string. :issue:`405` - ``TypeError`` is raised when parameter with ``multiple=True`` or ``nargs > 1`` has non-iterable default. :issue:`1749` - Add a ``pass_meta_key`` decorator for passing a key from ``Context.meta``. This is useful for extensions using ``meta`` to store information. :issue:`1739` - ``Path`` ``resolve_path`` resolves symlinks on Windows Python < 3.8. :issue:`1813` - Command deprecation notice appears at the start of the help text, as well as in the short help. The notice is not in all caps. :issue:`1791` - When taking arguments from ``sys.argv`` on Windows, glob patterns, user dir, and env vars are expanded. :issue:`1096` - Marked messages shown by the CLI with ``gettext()`` to allow applications to translate Click's built-in strings. :issue:`303` - Writing invalid characters to ``stderr`` when using the test runner does not raise a ``UnicodeEncodeError``. :issue:`848` - Fix an issue where ``readline`` would clear the entire ``prompt()`` line instead of only the input when pressing backspace. :issue:`665` - Add all kwargs passed to ``Context.invoke()`` to ``ctx.params``. Fixes an inconsistency when nesting ``Context.forward()`` calls. :issue:`1568` - The ``MultiCommand.resultcallback`` decorator is renamed to ``result_callback``. The old name is deprecated. :issue:`1160` - Fix issues with ``CliRunner`` output when using ``echo_stdin=True``. :issue:`1101` - Fix a bug of ``click.utils.make_default_short_help`` for which the returned string could be as long as ``max_width + 3``. :issue:`1849` - When defining a parameter, ``default`` is validated with ``multiple`` and ``nargs``. More validation is done for values being processed as well. :issue:`1806` - ``HelpFormatter.write_text`` uses the full line width when wrapping text. :issue:`1871` Version 7.1.2 ------------- Released 2020-04-27 - Revert applying shell quoting to commands for ``echo_with_pager`` and ``edit``. This was intended to allows spaces in commands, but caused issues if the string was actually a command and arguments, or on Windows. Instead, the string must be quoted manually as it should appear on the command line. :issue:`1514` Version 7.1.1 ------------- Released 2020-03-09 - Fix ``ClickException`` output going to stdout instead of stderr. :issue:`1495` Version 7.1 ----------- Released 2020-03-09 - Fix PyPI package name, "click" is lowercase again. - Fix link in ``unicode_literals`` error message. :pr:`1151` - Add support for colored output on UNIX Jupyter notebooks. :issue:`1185` - Operations that strip ANSI controls will strip the cursor hide/show sequences. :issue:`1216` - Remove unused compat shim for ``bytes``. :pr:`1195` - Expand testing around termui, especially getchar on Windows. :issue:`1116` - Fix output on Windows Python 2.7 built with MSVC 14. :pr:`1342` - Fix ``OSError`` when running in MSYS2. :issue:`1338` - Fix ``OSError`` when redirecting to ``NUL`` stream on Windows. :issue:`1065` - Fix memory leak when parsing Unicode arguments on Windows. :issue:`1136` - Fix error in new AppEngine environments. :issue:`1462` - Always return one of the passed choices for ``click.Choice`` :issue:`1277`, :pr:`1318` - Add ``no_args_is_help`` option to ``click.Command``, defaults to False :pr:`1167` - Add ``show_default`` parameter to ``Context`` to enable showing defaults globally. :issue:`1018` - Handle ``env MYPATH=''`` as though the option were not passed. :issue:`1196` - It is once again possible to call ``next(bar)`` on an active progress bar instance. :issue:`1125` - ``open_file`` with ``atomic=True`` retains permissions of existing files and respects the current umask for new files. :issue:`1376` - When using the test ``CliRunner`` with ``mix_stderr=False``, if ``result.stderr`` is empty it will not raise a ``ValueError``. :issue:`1193` - Remove the unused ``mix_stderr`` parameter from ``CliRunner.invoke``. :issue:`1435` - Fix ``TypeError`` raised when using bool flags and specifying ``type=bool``. :issue:`1287` - Newlines in option help text are replaced with spaces before re-wrapping to avoid uneven line breaks. :issue:`834` - ``MissingParameter`` exceptions are printable in the Python interpreter. :issue:`1139` - Fix how default values for file-type options are shown during prompts. :issue:`914` - Fix environment variable automatic generation for commands containing ``-``. :issue:`1253` - Option help text replaces newlines with spaces when rewrapping, but preserves paragraph breaks, fixing multiline formatting. :issue:`834, 1066, 1397` - Option help text that is wrapped adds an extra newline at the end to distinguish it from the next option. :issue:`1075` - Consider ``sensible-editor`` when determining the editor to use for ``click.edit()``. :pr:`1469` - Arguments to system calls such as the executable path passed to ``click.edit`` can contains spaces. :pr:`1470` - Add ZSH completion autoloading and error handling. :issue:`1348` - Add a repr to ``Command``, ``Group``, ``Option``, and ``Argument``, showing the name for friendlier debugging. :issue:`1267` - Completion doesn't consider option names if a value starts with ``-`` after the ``--`` separator. :issue:`1247` - ZSH completion escapes special characters in values. :pr:`1418` - Add completion support for Fish shell. :pr:`1423` - Decoding bytes option values falls back to UTF-8 in more cases. :pr:`1468` - Make the warning about old 2-arg parameter callbacks a deprecation warning, to be removed in 8.0. This has been a warning since Click 2.0. :pr:`1492` - Adjust error messages to standardize the types of quotes used so they match error messages from Python. Version 7.0 ----------- Released 2018-09-25 - Drop support for Python 2.6 and 3.3. :pr:`967, 976` - Wrap ``click.Choice``'s missing message. :issue:`202`, :pr:`1000` - Add native ZSH autocompletion support. :issue:`323`, :pr:`865` - Document that ANSI color info isn't parsed from bytearrays in Python 2. :issue:`334` - Document byte-stripping behavior of ``CliRunner``. :issue:`334`, :pr:`1010` - Usage errors now hint at the ``--help`` option. :issue:`393`, :pr:`557` - Implement streaming pager. :issue:`409`, :pr:`889` - Extract bar formatting to its own method. :pr:`414` - Add ``DateTime`` type for converting input in given date time formats. :pr:`423` - ``secho``'s first argument can now be ``None``, like in ``echo``. :pr:`424` - Fixes a ``ZeroDivisionError`` in ``ProgressBar.make_step``, when the arg passed to the first call of ``ProgressBar.update`` is 0. :issue:`447`, :pr:`1012` - Show progressbar only if total execution time is visible. :pr:`487` - Added the ability to hide commands and options from help. :pr:`500` - Document that options can be ``required=True``. :issue:`514`, :pr:`1022` - Non-standalone calls to ``Context.exit`` return the exit code, rather than calling ``sys.exit``. :issue:`667`, :pr:`533, 1098` - ``click.getchar()`` returns Unicode in Python 3 on Windows, consistent with other platforms. :issue:`537, 821, 822, 1088`, :pr:`1108` - Added ``FloatRange`` type. :pr:`538, 553` - Added support for bash completion of ``type=click.Choice`` for ``Options`` and ``Arguments``. :issue:`535`, :pr:`681` - Only allow one positional arg for ``Argument`` parameter declaration. :issue:`568, 574`, :pr:`1014` - Add ``case_sensitive=False`` as an option to Choice. :issue:`569` - ``click.getchar()`` correctly raises ``KeyboardInterrupt`` on "^C" and ``EOFError`` on "^D" on Linux. :issue:`583`, :pr:`1115` - Fix encoding issue with ``click.getchar(echo=True)`` on Linux. :pr:`1115` - ``param_hint`` in errors now derived from param itself. :issue:`598, 704`, :pr:`709` - Add a test that ensures that when an argument is formatted into a usage error, its metavar is used, not its name. :pr:`612` - Allow setting ``prog_name`` as extra in ``CliRunner.invoke``. :issue:`616`, :pr:`999` - Help text taken from docstrings truncates at the ``\f`` form feed character, useful for hiding Sphinx-style parameter documentation. :pr:`629, 1091` - ``launch`` now works properly under Cygwin. :pr:`650` - Update progress after iteration. :issue:`651`, :pr:`706` - ``CliRunner.invoke`` now may receive ``args`` as a string representing a Unix shell command. :pr:`664` - Make ``Argument.make_metavar()`` default to type metavar. :pr:`675` - Add documentation for ``ignore_unknown_options``. :pr:`684` - Add bright colors support for ``click.style`` and fix the reset option for parameters ``fg`` and ``bg``. :issue:`703`, :pr:`809` - Add ``show_envvar`` for showing environment variables in help. :pr:`710` - Avoid ``BrokenPipeError`` during interpreter shutdown when stdout or stderr is a closed pipe. :issue:`712`, :pr:`1106` - Document customizing option names. :issue:`725`, :pr:`1016` - Disable ``sys._getframes()`` on Python interpreters that don't support it. :pr:`728` - Fix bug in test runner when calling ``sys.exit`` with ``None``. :pr:`739` - Clarify documentation on command line options. :issue:`741`, :pr:`1003` - Fix crash on Windows console. :issue:`744` - Fix bug that caused bash completion to give improper completions on chained commands. :issue:`754`, :pr:`774` - Added support for dynamic bash completion from a user-supplied callback. :pr:`755` - Added support for bash completions containing spaces. :pr:`773` - Allow autocompletion function to determine whether or not to return completions that start with the incomplete argument. :issue:`790`, :pr:`806` - Fix option naming routine to match documentation and be deterministic. :issue:`793`, :pr:`794` - Fix path validation bug. :issue:`795`, :pr:`1020` - Add test and documentation for ``Option`` naming: functionality. :pr:`799` - Update doc to match arg name for ``path_type``. :pr:`801` - Raw strings added so correct escaping occurs. :pr:`807` - Fix 16k character limit of ``click.echo`` on Windows. :issue:`816`, :pr:`819` - Overcome 64k character limit when writing to binary stream on Windows 7. :issue:`825`, :pr:`830` - Add bool conversion for "t" and "f". :pr:`842` - ``NoSuchOption`` errors take ``ctx`` so that ``--help`` hint gets printed in error output. :pr:`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. :issue:`862` - Progress bar now uses stderr by default. :pr:`863` - Add support for auto-completion documentation. :issue:`866`, :pr:`869` - Allow ``CliRunner`` to separate stdout and stderr. :pr:`868` - Fix variable precedence. :issue:`873`, :pr:`874` - Fix invalid escape sequences. :pr:`877` - Fix ``ResourceWarning`` that occurs during some tests. :pr:`878` - When detecting a misconfigured locale, don't fail if the ``locale`` command fails. :pr:`880` - Add ``case_sensitive=False`` as an option to ``Choice`` types. :pr:`887` - Force stdout/stderr writable. This works around issues with badly patched standard streams like those from Jupyter. :pr:`918` - Fix completion of subcommand options after last argument :issue:`919`, :pr:`930` - ``_AtomicFile`` now uses the ``realpath`` of the original filename so that changing the working directory does not affect it. :pr:`920` - Fix incorrect completions when defaults are present :issue:`925`, :pr:`930` - Add copy option attrs so that custom classes can be re-used. :issue:`926`, :pr:`994` - "x" and "a" file modes now use stdout when file is ``"-"``. :pr:`929` - Fix missing comma in ``__all__`` list. :pr:`935` - Clarify how parameters are named. :issue:`949`, :pr:`1009` - Stdout is now automatically set to non blocking. :pr:`954` - Do not set options twice. :pr:`962` - Move ``fcntl`` import. :pr:`965` - Fix Google App Engine ``ImportError``. :pr:`995` - Better handling of help text for dynamic default option values. :pr:`996` - Fix ``get_winter_size()`` so it correctly returns ``(0,0)``. :pr:`997` - Add test case checking for custom param type. :pr:`1001` - Allow short width to address cmd formatting. :pr:`1002` - Add details about Python version support. :pr:`1004` - Added deprecation flag to commands. :pr:`1005` - Fixed issues where ``fd`` was undefined. :pr:`1007` - Fix formatting for short help. :pr:`1008` - Document how ``auto_envvar_prefix`` works with command groups. :pr:`1011` - Don't add newlines by default for progress bars. :pr:`1013` - Use Python sorting order for ZSH completions. :issue:`1047`, :pr:`1059` - Document that parameter names are converted to lowercase by default. :pr:`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. :issue:`1058`, :pr:`1061` - Fix absolute import blocking Click from being vendored into a project on Windows. :issue:`1068`, :pr:`1069` - Fix issue where a lowercase ``auto_envvar_prefix`` would not be converted to uppercase. :pr:`1105` Version 6.7 ----------- Released 2017-01-06 - Make ``click.progressbar`` work with ``codecs.open`` files. :pr:`637` - Fix bug in bash completion with nested subcommands. :pr:`639` - Fix test runner not saving caller env correctly. :pr:`644` - Fix handling of SIGPIPE. :pr:`62` - Deal with broken Windows environments such as Google App Engine's. :issue:`711` Version 6.6 ----------- Released 2016-04-04 - Fix bug in ``click.Path`` where it would crash when passed a ``-``. :issue:`551` Version 6.4 ----------- Released 2016-03-24 - Fix bug in bash completion where click would discard one or more trailing arguments. :issue:`471` Version 6.3 ----------- Released 2016-02-22 - 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 ----------- Released 2015-11-27 - Correct fix for hidden progress bars. Version 6.1 ----------- Released 2015-11-27 - 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 ----------- Released 2015-11-24, codename "pow pow" - 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 ----------- Released 2015-08-17 - Fix a bug in ``pass_obj`` that would accidentally pass the context too. Version 5.0 ----------- Released 2015-08-16, codename "tok tok" - 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 ----------- Released 2015-07-14 - 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 ----------- Released 2015-03-31, codename "zoom zoom" - 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 ----------- Released 2014-09-08 - Fixed an issue with error reporting on Python 3 for invalid forwarding of commands. Version 3.2 ----------- Released 2014-08-22 - 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 ----------- Released 2014-08-13 - 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 ----------- Released 2014-08-12, codename "clonk clonk" - Formatter now no longer attempts to accommodate 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 defining 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 ----------- Released 2014-08-11 - Fixed an issue where the wrapped streams on Python 3 would be reporting incorrect values for seekable. Version 2.5 ----------- Released 2014-07-28 - Fixed a bug with text wrapping on Python 3. Version 2.4 ----------- Released 2014-07-04 - Corrected a bug in the change of the help option in 2.3. Version 2.3 ----------- Released 2014-07-03 - 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 ----------- Released 2014-06-26 - Fixed tty detection on PyPy. - Fixed an issue that progress bars were not rendered when the context manager was entered. Version 2.1 ----------- Released 2014-06-14 - 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 ----------- Released 2014-06-06, codename "tap tap tap" - 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 ----------- Released 2014-05-23 - Fixed a bug that caused text files in Python 2 to not accept native strings. Version 1.0 ----------- Released 2014-05-21 - Initial release. asyncclick-8.1.7.0-async/CODE_OF_CONDUCT.md000066400000000000000000000064361452710122500177320ustar00rootroot00000000000000# Contributor Covenant Code of Conduct ## Our Pledge In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation. ## Our Standards Examples of behavior that contributes to creating a positive environment include: * Using welcoming and inclusive language * Being respectful of differing viewpoints and experiences * Gracefully accepting constructive criticism * Focusing on what is best for the community * Showing empathy towards other community members Examples of unacceptable behavior by participants include: * The use of sexualized language or imagery and unwelcome sexual attention or advances * Trolling, insulting/derogatory comments, and personal or political attacks * Public or private harassment * Publishing others' private information, such as a physical or electronic address, without explicit permission * Other conduct which could reasonably be considered inappropriate in a professional setting ## Our Responsibilities Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior. Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful. ## Scope This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers. ## Enforcement Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at report@palletsprojects.com. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately. Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership. ## Attribution This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html [homepage]: https://www.contributor-covenant.org For answers to common questions about this code of conduct, see https://www.contributor-covenant.org/faq asyncclick-8.1.7.0-async/CONTRIBUTING.rst000066400000000000000000000147101452710122500175660ustar00rootroot00000000000000How to contribute to Click ========================== Thank you for considering contributing to Click! Support questions ----------------- Please don't use the issue tracker for this. The issue tracker is a tool to address bugs and feature requests in Click itself. Use one of the following resources for questions about using Click or issues with your own code: - The ``#get-help`` channel on our Discord chat: https://discord.gg/pallets - The mailing list flask@python.org for long term discussion or larger issues. - Ask on `Stack Overflow`_. Search with Google first using: ``site:stackoverflow.com python click {search term, exception message, etc.}`` .. _Stack Overflow: https://stackoverflow.com/questions/tagged/python-click?tab=Frequent Reporting issues ---------------- Include the following information in your post: - Describe what you expected to happen. - If possible, include a `minimal reproducible example`_ to help us identify the issue. This also helps check that the issue is not with your own code. - Describe what actually happened. Include the full traceback if there was an exception. - List your Python and Click versions. If possible, check if this issue is already fixed in the latest releases or the latest code in the repository. .. _minimal reproducible example: https://stackoverflow.com/help/minimal-reproducible-example Submitting patches ------------------ If there is not an open issue for what you want to submit, prefer opening one for discussion before working on a PR. You can work on any issue that doesn't have an open PR linked to it or a maintainer assigned to it. These show up in the sidebar. No need to ask if you can work on an issue that interests you. Include the following in your patch: - Use `Black`_ to format your code. This and other tools will run automatically if you install `pre-commit`_ using the instructions below. - Include tests if your patch adds or changes code. Make sure the test fails without your patch. - Update any relevant docs pages and docstrings. Docs pages and docstrings should be wrapped at 72 characters. - Add an entry in ``CHANGES.rst``. Use the same style as other entries. Also include ``.. versionchanged::`` inline changelogs in relevant docstrings. .. _Black: https://black.readthedocs.io .. _pre-commit: https://pre-commit.com First time setup ~~~~~~~~~~~~~~~~ - Download and install the `latest version of git`_. - Configure git with your `username`_ and `email`_. .. code-block:: text $ git config --global user.name 'your name' $ git config --global user.email 'your email' - Make sure you have a `GitHub account`_. - Fork Click to your GitHub account by clicking the `Fork`_ button. - `Clone`_ the main repository locally. .. code-block:: text $ git clone https://github.com/pallets/click $ cd click - Add your fork as a remote to push your work to. Replace ``{username}`` with your username. This names the remote "fork", the default Pallets remote is "origin". .. code-block:: text $ git remote add fork https://github.com/{username}/click - Create a virtualenv. .. code-block:: text $ python3 -m venv env $ . env/bin/activate On Windows, activating is different. .. code-block:: text > env\Scripts\activate - Upgrade pip and setuptools. .. code-block:: text $ python -m pip install --upgrade pip setuptools - Install the development dependencies, then install Click in editable mode. .. code-block:: text $ pip install -r requirements/dev.txt && pip install -e . - Install the pre-commit hooks. .. code-block:: text $ pre-commit install .. _latest version of git: https://git-scm.com/downloads .. _username: https://docs.github.com/en/github/using-git/setting-your-username-in-git .. _email: https://docs.github.com/en/github/setting-up-and-managing-your-github-user-account/setting-your-commit-email-address .. _GitHub account: https://github.com/join .. _Fork: https://github.com/pallets/click/fork .. _Clone: https://docs.github.com/en/github/getting-started-with-github/fork-a-repo#step-2-create-a-local-clone-of-your-fork Start coding ~~~~~~~~~~~~ - Create a branch to identify the issue you would like to work on. If you're submitting a bug or documentation fix, branch off of the latest ".x" branch. .. code-block:: text $ git fetch origin $ git checkout -b your-branch-name origin/8.0.x If you're submitting a feature addition or change, branch off of the "main" branch. .. code-block:: text $ git fetch origin $ git checkout -b your-branch-name origin/main - Using your favorite editor, make your changes, `committing as you go`_. - Include tests that cover any code changes you make. Make sure the test fails without your patch. Run the tests as described below. - Push your commits to your fork on GitHub and `create a pull request`_. Link to the issue being addressed with ``fixes #123`` in the pull request. .. code-block:: text $ git push --set-upstream fork your-branch-name .. _committing as you go: https://dont-be-afraid-to-commit.readthedocs.io/en/latest/git/commandlinegit.html#commit-your-changes .. _create a pull request: https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/creating-a-pull-request Running the tests ~~~~~~~~~~~~~~~~~ Run the basic test suite with pytest. .. code-block:: text $ pytest This runs the tests for the current environment, which is usually sufficient. CI will run the full suite when you submit your pull request. You can run the full test suite with tox if you don't want to wait. .. code-block:: text $ tox Running test coverage ~~~~~~~~~~~~~~~~~~~~~ Generating a report of lines that do not have test coverage can indicate where to start contributing. Run ``pytest`` using ``coverage`` and generate a report. .. code-block:: text $ pip install coverage $ coverage run -m pytest $ coverage html Open ``htmlcov/index.html`` in your browser to explore the report. Read more about `coverage `__. Building the docs ~~~~~~~~~~~~~~~~~ Build the docs in the ``docs`` directory using Sphinx. .. code-block:: text $ cd docs $ make html Open ``_build/html/index.html`` in your browser to view the docs. Read more about `Sphinx `__. asyncclick-8.1.7.0-async/LICENSE.rst000066400000000000000000000027031452710122500167400ustar00rootroot00000000000000Copyright 2014 Pallets Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. 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. 3. 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 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, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. asyncclick-8.1.7.0-async/MANIFEST.in000066400000000000000000000002651452710122500166630ustar00rootroot00000000000000include CHANGES.rst include tox.ini include requirements/*.txt graft artwork graft docs prune docs/_build graft examples graft tests include src/click/py.typed global-exclude *.pyc asyncclick-8.1.7.0-async/Makefile000066400000000000000000000003611452710122500165620ustar00rootroot00000000000000#!/usr/bin/make -f PACKAGE=asyncclick ifneq ($(wildcard /usr/share/sourcemgr/make/py),) include /usr/share/sourcemgr/make/py # availabe via http://github.com/smurfix/sourcemgr else %: @echo "Please use 'python setup.py'." @exit 1 endif asyncclick-8.1.7.0-async/README.rst000066400000000000000000000063141452710122500166150ustar00rootroot00000000000000asyncclick ========== What's AsyncClick? ------------------ AsyncClick ist a fork of Click that works well with trio or asyncio. 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. AsyncClick in four points: - Arbitrary nesting of commands - Automatic help page generation - Supports lazy loading of subcommands at runtime - Seamlessly use async-enabled command and subcommand handlers Installing ---------- Install and update using `pip`_: .. code-block:: text $ pip install asyncclick AsyncClick supports Python 3.7 and newer, and PyPy3. .. _pip: https://pip.pypa.io/en/stable/getting-started/ A Simple Example ---------------- .. code-block:: python import anyio import asyncclick as click # You can use all of click's features as per its documentation. # Async commands are supported seamlessly; they just work. @click.command() @click.option("--count", default=1, help="Number of greetings.") @click.option("--name", prompt="Your name", help="The person to greet.") async def hello(count, name): """Simple program that greets NAME for a total of COUNT times.""" for x in range(count): if x: await anyio.sleep(0.1) click.echo(f"Hello, {name}!") if __name__ == '__main__': hello(_anyio_backend="trio") # or asyncio # You can use your own event loop: # import anyio # async def main(): # await hello.main() # if __name__ == '__main__': # anyio.run(main) # This is useful for testing. .. note:: AsyncClick automagically starts an anyio event loop and runs your code asynchronously. You don't need to use `anyio.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 The AsyncClick fork is maintained by Matthias Urlichs . It's not a lot of work, so if you'd like to motivate me, donate to the charity of your choice and tell me that you've done so. ;-) Links ----- ``AsyncClick`` is sufficiently minimal to not have its own web page. - Code: https://github.com/python-trio/asyncclick These links point to the original, non-async-enabled, version of ``Click``. - Website: https://palletsprojects.com/p/click/ - Documentation: https://click.palletsprojects.com/ - Changes: https://click.palletsprojects.com/changes/ - PyPI Releases: https://pypi.org/project/click/ - Source Code: https://github.com/pallets/click - Issue Tracker: https://github.com/pallets/click/issues - Chat: https://discord.gg/pallets asyncclick-8.1.7.0-async/artwork/000077500000000000000000000000001452710122500166135ustar00rootroot00000000000000asyncclick-8.1.7.0-async/artwork/logo.svg000066400000000000000000000210011452710122500202660ustar00rootroot00000000000000 image/svg+xml asyncclick-8.1.7.0-async/debian/000077500000000000000000000000001452710122500163445ustar00rootroot00000000000000asyncclick-8.1.7.0-async/debian/.gitignore000066400000000000000000000001231452710122500203300ustar00rootroot00000000000000/files /*.log /*.debhelper /debhelper-build-stamp /*.substvars /python3-asyncclick asyncclick-8.1.7.0-async/debian/changelog000066400000000000000000000064341452710122500202250ustar00rootroot00000000000000asyncclick (1:8.1.3-2) unstable; urgency=medium * new Upstream -- Matthias Urlichs Tue, 07 Jun 2022 18:53:38 +0200 asyncclick (1:8.0.3-6) unstable; urgency=medium * fix test -- Matthias Urlichs Sat, 15 Jan 2022 22:22:34 +0100 asyncclick (1:8.0.3-5) unstable; urgency=medium * enter_context => with_resource -- Matthias Urlichs Sat, 15 Jan 2022 22:21:09 +0100 asyncclick (1:8.0.3-4) unstable; urgency=medium * missed anyio markers -- Matthias Urlichs Wed, 05 Jan 2022 11:44:55 +0100 asyncclick (1:8.0.3-3) unstable; urgency=medium * missed a comflict marker -- Matthias Urlichs Wed, 05 Jan 2022 11:43:07 +0100 asyncclick (1:8.0.3-2) unstable; urgency=medium * Fixed PYTHONPATH for tests -- Matthias Urlichs Wed, 05 Jan 2022 11:42:14 +0100 asyncclick (1:8.0.3-1) unstable; urgency=medium * Merge 8.0.3 -- Matthias Urlichs Wed, 05 Jan 2022 11:33:57 +0100 asyncclick (1:7.0.90-1) unstable; urgency=medium * Merge current 7.1 -- Matthias Urlichs Thu, 13 Feb 2020 12:27:50 +0100 asyncclick (1:7.0.4-2) unstable; urgency=medium * move to anyio -- Matthias Urlichs Fri, 21 Jun 2019 09:36:52 +0200 trio-click (1:7.0.3-1) unstable; urgency=medium * Removed debug output mistakenly left in the code -- Matthias Urlichs Sun, 27 Jan 2019 14:30:39 +0100 trio-click (1:7.0.2-1) unstable; urgency=medium * Mistakenly imported the "real" click -- Matthias Urlichs Mon, 07 Jan 2019 19:18:44 +0100 trio-click (1:7.0.1-3) unstable; urgency=medium * Fix 3.6 compatibility -- Matthias Urlichs Wed, 02 Jan 2019 15:56:11 +0100 trio-click (1:7.0.1-2) unstable; urgency=medium * Add an async context manager -- Matthias Urlichs Wed, 02 Jan 2019 15:49:40 +0100 trio-click (1:7.0.1-1) unstable; urgency=medium * Merge to 7.0 * Switched to AnyIO (instead of directly using Trio). -- Matthias Urlichs Thu, 20 Dec 2018 14:44:04 +0100 trio-click (1:7.0~dev5-1) unstable; urgency=medium * fix version -- Matthias Urlichs Tue, 12 Jun 2018 05:41:03 +0200 trio-click (1:7.0~dev4-1) unstable; urgency=medium * Updated README -- Matthias Urlichs Fri, 08 Jun 2018 12:09:19 +0200 trio-click (1:7.0~dev3-1) unstable; urgency=medium * Merge to current Upstream. -- Matthias Urlichs Mon, 28 May 2018 03:38:15 +0200 trio-click (7.0+trio-dev3-1) unstable; urgency=medium * Merge to current Upstream. -- Matthias Urlichs Mon, 28 May 2018 03:38:15 +0200 trio-click (7.0+trio-dev2-1) unstable; urgency=medium * Merge to current Upstream. -- Matthias Urlichs Wed, 11 Apr 2018 06:19:22 +0200 trio-click (7.0+trio-dev1-1) unstable; urgency=medium * Updated version number to something trackable -- Matthias Urlichs Sun, 28 Jan 2018 09:59:28 +0100 trio-click (7.0~dev0-1) smurf; urgency=low * source package automatically created by stdeb 0.8.5 -- Matthias Urlichs Wed, 24 Jan 2018 22:45:37 +0100 asyncclick-8.1.7.0-async/debian/compat000066400000000000000000000000031452710122500175430ustar00rootroot0000000000000013 asyncclick-8.1.7.0-async/debian/control000066400000000000000000000010271452710122500177470ustar00rootroot00000000000000Source: asyncclick Maintainer: Matthias Urlichs Section: python Priority: optional Build-Depends: dh-python, python3-setuptools, python3-all, debhelper (>= 9), python3-anyio, python3-trio, python3-pytest, python3-pytest-runner, Standards-Version: 3.9.6 Homepage: http://github.com/pallets/click Package: python3-asyncclick Architecture: all Depends: ${misc:Depends}, ${python3:Depends}, python3-anyio, Recommends: python3-trio Description: A simple wrapper around optparse for powerful command line u asyncclick-8.1.7.0-async/debian/rules000077500000000000000000000004071452710122500174250ustar00rootroot00000000000000#!/usr/bin/make -f # This file was automatically generated by stdeb 0.8.5 at # Wed, 24 Jan 2018 22:45:36 +0100 export PYBUILD_NAME=asyncclick %: dh $@ --with python3 --buildsystem=pybuild override_dh_auto_test: env PYTHONPATH=src python3 -mpytest -sxv tests/ asyncclick-8.1.7.0-async/debian/source/000077500000000000000000000000001452710122500176445ustar00rootroot00000000000000asyncclick-8.1.7.0-async/debian/source/format000066400000000000000000000000141452710122500210520ustar00rootroot000000000000003.0 (quilt) asyncclick-8.1.7.0-async/debian/watch000066400000000000000000000003131452710122500173720ustar00rootroot00000000000000# please also check http://pypi.debian.net/asyncclick/watch version=3 opts=uversionmangle=s/(rc|a|b|c)/~$1/ \ http://pypi.debian.net/asyncclick/asyncclick-(.+)\.(?:zip|tgz|tbz|txz|(?:tar\.(?:gz|bz2|xz)))asyncclick-8.1.7.0-async/docs/000077500000000000000000000000001452710122500160525ustar00rootroot00000000000000asyncclick-8.1.7.0-async/docs/Makefile000066400000000000000000000011331452710122500175100ustar00rootroot00000000000000# 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) asyncclick-8.1.7.0-async/docs/_static/000077500000000000000000000000001452710122500175005ustar00rootroot00000000000000asyncclick-8.1.7.0-async/docs/_static/click-icon.png000066400000000000000000000011611452710122500222200ustar00rootroot00000000000000PNG  IHDR@@iqsBIT|d pHYs  dtEXtSoftwarewww.inkscape.org<IDATxٻkQ/F41 (B; @H;ml+; bk'h`ccPRAQDc7a1ua;sKJ)RJ)RJ)RJ)%4:DyZLoburgCMFaSmoqaZ0/܆6ۍʛF31\UFK8;S5Q,ćUѫqU~UgYFzJ3c,4'l%L)RZw{-IENDB`asyncclick-8.1.7.0-async/docs/_static/click-logo-sidebar.png000066400000000000000000000102261452710122500236410ustar00rootroot00000000000000PNG  IHDRd]IDATx] ]VIHD}B%tt2#QjiE NJ=fR(ziRP%(J*D4!F]>}>|w׿_^{>Ru郬{Ջuъx;H4vjpwlQh]Sc+mZ'ffՁG+A@Y^8ZY_"쐖,x}kهYtA (%ϛ \ŷ^H?mpN*/TNVp?B^ԍ^NVq]RbzFƋ2`p7N C?har) #̊H+:i@?KmG1Jen4"oX1T9v ·):|~>sNk 5>^O8p+``4PFZRKȀu-F~ g\^H2x+lfne;yw_ xhG4e-j9]E2< t )4׺}R"fRӤ58Yf+̟]5Boλ3|LoD|0m7T]^ԋ1o͝ \] >/ |ukJȝ`{xfe[XPn= LD!uK2\Kr7Q!)Yת'\D(V[Q*iqope?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 wfWؠ00ur}h'B.jU#GU+`uY g<6l,rv88B8G:_[,/`v|8;? ~Owuݗa=79IiDg|2xcH HJ5.1HviThs? 龵aJJ:Li':ۜpK$%`kPAT2Y<p:l }#΋)/ᶈjdro˔:áнMJ7 gB譶o/ohQ|)2.9W~ ٽ;5c6y늸|F`_;/9RoVpJaZdz,G39TB4QhՁ>j 9"ye9S~qxsOv`k7%_|hx ޸U)511kȑH!/鮎Cʗ L8RHw|ßp6F;= _a\ o x& J/|Nugrˆ,/r4<{F 9µ8\9SRO<3^lY‹pDFyv9ٙ}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>\#@(09 6F]cڒ;hH6jR1ːp@RMv*qYބ಴E~Z ӀCj\u{|2v`-sIChg,tRI$}e@"ڙuFV]\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 iru@1[ZPkTȌҞ51 \{W۞F`0&20)}b#IDk$,ȏyz\[*+g`1Lnl8l  ?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\!勁 ~| (,htU5OШlIm@=!_<> iv+i 2?%&:pnp7fUmk߁YZgͨuWƣa33}^zF`GT1PQ1k:k9΋./q(Q_ﴚB Kb :`t;?ֹq@LB&()NM>r?NO ^ zS1 b\uvzޮ +b7{A|+> ~] @VA?/htD~htmҝ9T3Py1u҉:pN*՝ZMSS@ H@)[@9# ?#`#r zW?@KĀ(CD'J\S\q1ߏ^U,O?ؐގIENDB`asyncclick-8.1.7.0-async/docs/_static/click-logo.png000066400000000000000000000627411452710122500222430ustar00rootroot00000000000000PNG  IHDRH^?t AiCCPICC ProfileH wTSϽ7" %z ;HQIP&vDF)VdTG"cE b PQDE݌k 5ޚYg}׺PtX4X\XffGD=HƳ.d,P&s"7C$ E6<~&S2)212 "įl+ɘ&Y4Pޚ%ᣌ\%g|eTI(L0_&l2E9r9hxgIbטifSb1+MxL 0oE%YmhYh~S=zU&ϞAYl/$ZUm@O ޜl^ ' lsk.+7oʿ9V;?#I3eE妧KD d9i,UQ h A1vjpԁzN6p\W p G@ K0ށiABZyCAP8C@&*CP=#t] 4}a ٰ;GDxJ>,_“@FXDBX$!k"EHqaYbVabJ0՘cVL6f3bձX'?v 6-V``[a;p~\2n5׌ &x*sb|! ߏƿ' Zk! $l$T4QOt"y\b)AI&NI$R$)TIj"]&=&!:dGrY@^O$ _%?P(&OJEBN9J@y@yCR nXZOD}J}/G3ɭk{%Oחw_.'_!JQ@SVF=IEbbbb5Q%O@%!BӥyҸM:e0G7ӓ 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) Σ -rqr.d._xpUەZM׍vm=+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_DHGGu;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`vn%  H:f _  S䕕@0?)mu+Wý)9(U/:{K|} pNRCDZ 1PzNk+Q'793@Bi:V/*juQe;M.qh]`X p>=Y*sfD38K@(1n{porRv:Mm)q@ l͵ sF/c/t\GϤsUKa!?JpT.d/i% 9uT|\Y`iH@ H@$0 X0:]IQA#&䲨ݨӬ( Cfv6*2H-BsښRΏnm&&@jDSv8zmBt>3$  4%uL;0&tM lLcMX$  HB6֥r O=lCSH+Z9ٸ+ TR t]V©P `]sΥ{^3f( H3E L91S|d4$60N_hIG3S H 0MΗxI' H@"P7)}wM:8iċ349 H`sV H$AD15QזB EH[b7F\t)JG@~mWN+ yuG+5Lƫ·2-QK# H:10Vhoq}(?ԠbhN@Xݪ$ (ρKFo!QF$  T@/" %e$  - 2쓢Oώ`JˉqNY H@< RFPI@( 77W(9zOJe%  wiFJL V_4PRF@LOyeR ً1ޝIX! 6>%]fcIy]}=nc&6|ZlXs;( s/@M\f2Rs6|$ C9nUSdߎY啓@DdىΜ;K3s7zz e܈lL%=J'RoRd5*ώ=y\Ib[%9uwv[S_ÐmnG&ͫ8'Y|,>%qqU@ fԋPxN3-El/NNi~D`΢OM)3#|d7}i#G㧿tJ_xNԍn qhy@q=Y1cR_lg]*Rՙu KdLM_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✖bq_.2i H@!#H $n;#uZh lBcFνt_lFDJ_UZt>FeQڌQWO+*Y41>]@z^+a~̢0w sW@7xC'n؀8.}8e7S'ʳzn;h+T 4(e\ė8ZM?ZPN'#K5&||)MI8m'7 h_3itjEJY$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?rSLZd-lH'?c[:lOF2F6qs;OĊY9}t}\>>F>+qM>9M\u8{mNeC "3{Xp<} q|xWC7x$  HO#t7G@,d$ Hqh$gJ ܘOS|7X pV;8G:E)@ZB$E;&X"tЌ  HLLxl{I7H3ϡxB??ϵiU1Md98ȦQR AbiUAZ4Wb!w֡~xD$9$  H!i:c;[ S,p1#0.¡0񙨟ڑTbETWϢ}R`Jó_w'54qxOwĴ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(@#4HwŠl\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?c0{C$  Hzm M<~{H}'c$})O# K~T d U\@U a H1h+*% H@EA #:f{b(=m Ǵ:"FQNFnDF¨fT=|2U52 ƴ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 &_HWڋ61ف$D:Hm'5mǙi %N񭪁ޙ^pË^oSkGf 1~ꖺ0S)/ H@h E)Vb$#EG 0f׼1RY?T(8FZ\/H{[)ZGcT_&\m'F'h^KR+&Nu1[SI@@rVYz4&oAhmcݻxK h{ImOyyM|T>/EiV"? #H\h>ùj5>Af6=$Pŷ^Q.$j# H>Jo jx5x}}:%큉&p|%GDZcH:d a8Tu{x'tЍ:2"1Fb1VOsI/$  J%1y!5'΋Sr7/Y3YkOIۧZ_ $ EYHŌGG^w Hv(6.>Յ_H6N' H@p=s}^2~hxFQ?:u|nt'Hln;O]owԤke_R{oH/1Nm̬@I+qN8;}%[I?@,FFRLWI@@N4@'}6H9ON؟H}](% ҅CʾSӼTG.OƈY;ksm~xd5)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\31TIE"➀Tw=V t~9Mi1.#*s==ɐ)o| hgV9uϳBά8ibu9YIk H@Ij҃h$ޓXS_E8O&wLvSSm@ԔX\_P681\0 )qJ&;y:tʳtuL^^2u[xI@nQwF$0p*c ٕFЦ)O+=9>=sEӰ~)ө:RUoH$Isn$5N9O~qю|M]@'O~eb 0#w}4zyq|s\:{M@Ŀ׽F_UicxW%N٫!SMb4w7.&@E6O&{k7|%5ĹAl~cqV<& Yin_Oy3b4AW nZ ukIGut4>\GbZihPtg̾Ri9zQ{e]=S:ܓxJTٽmgE9.r^9UbH@(/0bۓ˫b[bJsi^6-]SKʌњ%q7t)}sCY c47a^Ͻu_;yv#?hV##oE*=s>_kp_1\I@x97ױ'h |M@,yD#J__rŇgF\rF . .>_Yw\މnCe` -|1mg^P_!wgĺsp: #/BM1{$K>ω?;#ev}v>QVOGlD] sφ5 o$;F];vSyy5[9Ţ,q 5r7h%~v!FrI @\Wc/Jn~TGӿ@ΜO~?KEUo|@E] ?AS_ faWy eJ}1`v8F0ص2hw_֗>N}Ĵզ㱔v_cD}y`%ތDa[}p2Ӱ *@ePx^]&9bùޏ Z'8e*yHN8B#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+zoyL΋S~Η2t6h74!>7OwǏq u0O*?^Tx"'tF^_z8Z QS.p'p4˔0'p~4:U.~/̾IZe5Zp\1ziֈLoq_8i="hרLk_R0tG?FCS@q_GĵUe>mM-0x^8O4v^tM4?cIE [(|Hr?\$ЌZ4q> cFZWgnGq(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;ڍJRFnksKZ k41S!VӺ Fgk7pm^̱eqR,C n-}<?f 漌8}k?J.(Тu_.0~y%9p q^̹{TJe%0@'ܴϚ!Gwߨ$  T&)7H-:]ؼf9ULJ>1âf#5b6 Qƍ0`6-im~^-_A2VXU1.#<Ԩ"8AN#fMYe$  H@@'C=àzJcG+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`Uj92GY%  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@܎&1bXG|,*va㕐X}6*| 25]ɶ٢cI@$  H@"cS*N'$/2XE 8Ů$  H@ 3bNYM!mY"(SMHլ7$  H@@Gg%&UG @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#TKS$  H@@;)XNc)cN$  H@#]+P @qTQ$  H@&0]|IcH=nv$  H@M`"X] h I@$  .^=kYayVY#TKS$  H@@K=Ws+uG4zl$  H@$҉),?3b-0-$  H@ZQ|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@$ ~##Ko8jTIw[o ;H$  H@ g,Һ###(;bHQR$  H`0z2L V\H$  H@h@`IfAKp 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Ų#)gSTRS H@$  8::%OK**Fat]u!=@1p$  H@bxx$ `-@a##Q].6y H@$  H9{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">ChWjEH8^@ !w`)* H@$  8jsL{1#LkyX%J@$  H@&q{VXb4Q1L$  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-Mzxjz#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@$0pXW8-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&94CXY 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@$  11bC7DS81e-j\ l=66v/Y~-lߎۘr=E{߉t+ޥ?$ʱ+D(_XDY>&x>wEa+bomLB?$  H@@H.H6+; >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@$PfHeu$  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`asyncclick-8.1.7.0-async/docs/advanced.rst000066400000000000000000000422261452710122500203570ustar00rootroot00000000000000Advanced 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 (see `Command alias example `_). 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(f"Too many matches: {', '.join(sorted(matches))}") def resolve_command(self, ctx, args): # always return the full command name _, cmd, args = super().resolve_command(ctx, args) return cmd.name, cmd, args 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 additional 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(f"{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(f"{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(f"Name: {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. These methods are asynchrous. Example: .. click:example:: cli = click.Group() @cli.command() @click.option('--count', default=1) def test(count): click.echo(f'Count: {count}') @cli.command() @click.option('--count', default=1) @click.pass_context def dist(ctx, count): await ctx.forward(test) await 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 an :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(f"Invoking: {' '.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 combined 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. Detecting the Source of a Parameter ----------------------------------- In some situations it's helpful to understand whether or not an option or parameter came from the command line, the environment, the default value, or :attr:`Context.default_map`. The :meth:`Context.get_parameter_source` method can be used to find this out. It will return a member of the :class:`~click.core.ParameterSource` enum. .. click:example:: @click.command() @click.argument('port', nargs=1, default=8080, envvar="PORT") @click.pass_context def cli(ctx, port): source = ctx.get_parameter_source("port") click.echo(f"Port came from {source.name}") .. click:run:: invoke(cli, prog_name='cli', args=['8080']) println() invoke(cli, prog_name='cli', args=[], env={"PORT": "8080"}) println() invoke(cli, prog_name='cli', args=[]) println() Managing Resources ------------------ It can be useful to open a resource in a group, to be made available to subcommands. Many types of resources need to be closed or otherwise cleaned up after use. The standard way to do this in Python is by using a context manager with the ``with`` statement. For example, the ``Repo`` class from :doc:`complex` might actually be defined as a context manager: .. code-block:: python class Repo: def __init__(self, home=None): self.home = os.path.abspath(home or ".") self.db = None def __enter__(self): path = os.path.join(self.home, "repo.db") self.db = open_database(path) def __exit__(self, exc_type, exc_value, tb): self.db.close() Ordinarily, it would be used with the ``with`` statement: .. code-block:: python with Repo() as repo: repo.db.query(...) However, a ``with`` block in a group would exit and close the database before it could be used by a subcommand. Instead, use the context's :meth:`~click.Context.with_resource` method to enter the context manager and return the resource. When the group and any subcommands finish, the context's resources are cleaned up. .. code-block:: python @click.group() @click.option("--repo-home", default=".repo") @click.pass_context def cli(ctx, repo_home): ctx.obj = ctx.with_resource(Repo(repo_home)) @cli.command() @click.pass_obj def log(obj): # obj is the repo opened in the cli group for entry in obj.db.query(...): click.echo(entry) If the resource isn't a context manager, usually it can be wrapped in one using something from :mod:`contextlib`. If that's not possible, use the context's :meth:`~click.Context.call_on_close` method to register a cleanup function. .. code-block:: python @click.group() @click.option("--name", default="repo.db") @click.pass_context def cli(ctx, repo_home): ctx.obj = db = open_db(repo_home) @ctx.call_on_close def close_db(): db.record_use() db.save() db.close() asyncclick-8.1.7.0-async/docs/api.rst000066400000000000000000000054451452710122500173650ustar00rootroot00000000000000API === .. module:: asyncclick 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 .. autofunction:: asyncclick.decorators.pass_meta_key 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_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 .. autoclass:: asyncclick.core.ParameterSource :members: :member-order: bysource Types ----- .. autodata:: STRING .. autodata:: INT .. autodata:: FLOAT .. autodata:: BOOL .. autodata:: UUID .. autodata:: UNPROCESSED .. autoclass:: File .. autoclass:: Path .. autoclass:: Choice .. autoclass:: IntRange .. autoclass:: FloatRange .. autoclass:: DateTime .. 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: Shell Completion ---------------- See :doc:`/shell-completion` for information about enabling and customizing Click's shell completion system. .. currentmodule:: asyncclick.shell_completion .. autoclass:: CompletionItem .. autoclass:: ShellComplete :members: :member-order: bysource .. autofunction:: add_completion_class Testing ------- .. currentmodule:: asyncclick.testing .. autoclass:: CliRunner :members: .. autoclass:: Result :members: asyncclick-8.1.7.0-async/docs/arguments.rst000066400000000000000000000203161452710122500206130ustar00rootroot00000000000000.. _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 :ref:`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): """Print 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): """Move file SRC to DST.""" for fn in src: click.echo(f"move {fn} to folder {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): """Copy contents of INPUT to 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. The :class:`Path` type has several checks available which raise nice errors if they fail, such as existence. Filenames in these error messages are formatted with :func:`format_filename`, so any undecodable bytes will be printed nicely. Example: .. click:example:: @click.command() @click.argument('filename', type=click.Path(exists=True)) def touch(filename): """Print FILENAME if the file exists.""" click.echo(click.format_filename(filename)) 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): """Print value of SRC environment variable.""" 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): """Print all FILES file names.""" 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): """Print all FILES file names.""" for filename in files: click.echo(filename) And from the command line: .. click:run:: invoke(touch, ['-foo.txt', 'bar.txt']) asyncclick-8.1.7.0-async/docs/changes.rst000066400000000000000000000000551452710122500202140ustar00rootroot00000000000000Changes ======= .. include:: ../CHANGES.rst asyncclick-8.1.7.0-async/docs/commands.rst000066400000000000000000000450501452710122500204110ustar00rootroot00000000000000Commands 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(f"Debug mode is {'on' if debug else 'off'}") @cli.command() # @cli, not @click! 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(f"Debug is {'on' if ctx.obj['DEBUG'] else '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(f"I am about to invoke {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 asyncclick as 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') and filename != '__init__.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 asyncclick as 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 ``sdist`` 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. The order between options and arguments is limited for chained commands. Currently only ``--options argument`` order is allowed. 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.result_callback` 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.result_callback() 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: .. code-block:: python default_map = { "debug": True, # default for a top level option "runserver": {"port": 5000} # default for a subcommand } The default map can be provided when the script is invoked, or 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 asyncclick as click @click.group() def cli(): pass @cli.command() @click.option('--port', default=8000) def runserver(port): click.echo(f"Serving on http://127.0.0.1:{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 asyncclick as 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(f"Serving on http://127.0.0.1:{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. asyncclick-8.1.7.0-async/docs/complex.rst000066400000000000000000000323461452710122500202630ustar00rootroot00000000000000.. _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 asyncclick as 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, []) Lazily Loading Subcommands -------------------------- Large CLIs and CLIs with slow imports may benefit from deferring the loading of subcommands. The interfaces which support this mode of use are :meth:`MultiCommand.list_commands` and :meth:`MultiCommand.get_command`. A custom :class:`MultiCommand` subclass can implement a lazy loader by storing extra data such that :meth:`MultiCommand.get_command` is responsible for running imports. Since the primary case for this is a :class:`Group` which loads its subcommands lazily, the following example shows a lazy-group implementation. .. warning:: Lazy loading of python code can result in hard to track down bugs, circular imports in order-dependent codebases, and other surprising behaviors. It is recommended that this technique only be used in concert with testing which will at least run the ``--help`` on each subcommand. That will guarantee that each subcommand can be loaded successfully. Defining the Lazy Group ``````````````````````` The following :class:`Group` subclass adds an attribute, ``lazy_subcommands``, which stores a mapping from subcommand names to the information for importing them. .. code-block:: python # in lazy_group.py import importlib import click class LazyGroup(click.Group): def __init__(self, *args, lazy_subcommands=None, **kwargs): super().__init__(*args, **kwargs) # lazy_subcommands is a map of the form: # # {command-name} -> {module-name}.{command-object-name} # self.lazy_subcommands = lazy_subcommands or {} def list_commands(self, ctx): base = super().list_commands(ctx) lazy = sorted(self.lazy_subcommands.keys()) return base + lazy def get_command(self, ctx, cmd_name): if cmd_name in self.lazy_subcommands: return self._lazy_load(cmd_name) return super().get_command(ctx, cmd_name) def _lazy_load(self, cmd_name): # lazily loading a command, first get the module name and attribute name import_path = self.lazy_subcommands[cmd_name] modname, cmd_object_name = import_path.rsplit(".", 1) # do the import mod = importlib.import_module(modname) # get the Command object from that module cmd_object = getattr(mod, cmd_object_name) # check the result to make debugging easier if not isinstance(cmd_object, click.BaseCommand): raise ValueError( f"Lazy loading of {import_path} failed by returning " "a non-command object" ) return cmd_object Using LazyGroup To Define a CLI ``````````````````````````````` With ``LazyGroup`` defined, it's now possible to write a group which lazily loads its subcommands like so: .. code-block:: python # in main.py import click from lazy_group import LazyGroup @click.group( cls=LazyGroup, lazy_subcommands={"foo": "foo.cli", "bar": "bar.cli"}, help="main CLI command for lazy example", ) def cli(): pass # in foo.py import click @click.group(help="foo command for lazy example") def cli(): pass # in bar.py import click from lazy_group import LazyGroup @click.group( cls=LazyGroup, lazy_subcommands={"baz": "baz.cli"}, help="bar command for lazy example", ) def cli(): pass # in baz.py import click @click.group(help="baz command for lazy example") def cli(): pass What triggers Lazy Loading? ``````````````````````````` There are several events which may trigger lazy loading by running the :meth:`MultiCommand.get_command` function. Some are intuititve, and some are less so. All cases are described with respect to the above example, assuming the main program name is ``cli``. 1. Command resolution. If a user runs ``cli bar baz``, this must first resolve ``bar``, and then resolve ``baz``. Each subcommand resolution step does a lazy load. 2. Helptext rendering. In order to get the short help description of subcommands, ``cli --help`` will load ``foo`` and ``bar``. Note that it will still not load ``baz``. 3. Shell completion. In order to get the subcommands of a lazy command, ``cli `` will need to resolve the subcommands of ``cli``. This process will trigger the lazy loads. Further Deferring Imports ````````````````````````` It is possible to make the process even lazier, but it is generally more difficult the more you want to defer work. For example, subcommands could be represented as a custom :class:`BaseCommand` subclass which defers importing the command until it is invoked, but which provides :meth:`BaseCommand.get_short_help_str` in order to support completions and helptext. More simply, commands can be constructed whose callback functions defer any actual work until after an import. This command definition provides ``foo``, but any of the work associated with importing the "real" callback function is deferred until invocation time: .. click:example:: @click.command() @click.option("-n", type=int) @click.option("-w", type=str) def foo(n, w): from mylibrary import foo_concrete foo_concrete(n, w) Because ``click`` builds helptext and usage info from options, arguments, and command attributes, it has no awareness that the underlying function is in any way handling a deferred import. Therefore, all ``click``-provided utilities and functionality will work as normal on such a command. asyncclick-8.1.7.0-async/docs/conf.py000066400000000000000000000035161452710122500173560ustar00rootroot00000000000000from pallets_sphinx_themes import get_version from pallets_sphinx_themes import ProjectLink # Project -------------------------------------------------------------- project = "Click" copyright = "2014 Pallets" author = "Pallets" release, version = get_version("Click") # General -------------------------------------------------------------- master_doc = "index" extensions = [ "sphinx.ext.autodoc", "sphinx.ext.intersphinx", "sphinxcontrib.log_cabinet", "pallets_sphinx_themes", "sphinx_issues", "sphinx_tabs.tabs", ] autodoc_typehints = "description" intersphinx_mapping = {"python": ("https://docs.python.org/3/", None)} issues_github_path = "pallets/click" # HTML ----------------------------------------------------------------- html_theme = "click" html_theme_options = {"index_sidebar_logo": False} html_context = { "project_links": [ ProjectLink("Donate", "https://palletsprojects.com/donate"), 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/"), ProjectLink("Chat", "https://discord.gg/pallets"), ] } html_sidebars = { "index": ["project.html", "localtoc.html", "searchbox.html", "ethicalads.html"], "**": ["localtoc.html", "relations.html", "searchbox.html", "ethicalads.html"], } singlehtml_sidebars = {"index": ["project.html", "localtoc.html", "ethicalads.html"]} html_static_path = ["_static"] html_favicon = "_static/click-icon.png" html_logo = "_static/click-logo-sidebar.png" html_title = f"Click Documentation ({version})" html_show_sourcelink = False # LaTeX ---------------------------------------------------------------- latex_documents = [(master_doc, f"Click-{version}.tex", html_title, author, "manual")] asyncclick-8.1.7.0-async/docs/contrib.rst000066400000000000000000000014641452710122500202510ustar00rootroot00000000000000.. _contrib: ============= click-contrib ============= As the number of users of Click grows, more and more major feature requests are made. To users it may seem reasonable to include those features with Click; however, many of them are experimental or aren't practical to support generically. Maintainers have to choose what is reasonable to maintain in Click core. The click-contrib_ GitHub organization exists as a place to collect third-party packages that extend Click's features. It is also meant to ease the effort of searching for such extensions. Please note that the quality and stability of those packages may be different than Click itself. While published under a common organization, they are still separate from Click and the Pallets maintainers. .. _click-contrib: https://github.com/click-contrib/ asyncclick-8.1.7.0-async/docs/documentation.rst000066400000000000000000000146331452710122500214640ustar00rootroot00000000000000Documenting 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(f"Hello {name}!") And what it looks like: .. click:run:: invoke(hello, args=['--help']) .. _documenting-arguments: Documenting Arguments ~~~~~~~~~~~~~~~~~~~~~ :func:`click.argument` does not take a ``help`` parameter. 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 command help text by referring to them by name. You might prefer to reference the argument in the description: .. click:example:: @click.command() @click.argument('filename') def touch(filename): """Print FILENAME.""" click.echo(filename) And what it looks like: .. click:run:: invoke(touch, args=['--help']) Or you might prefer to explicitly provide a description of the argument: .. click:example:: @click.command() @click.argument('filename') def touch(filename): """Print FILENAME. FILENAME is the name of the file to check. """ click.echo(filename) And what it looks like: .. click:run:: invoke(touch, args=['--help']) For more examples, see the examples in :doc:`/arguments`. Preventing Rewrapping --------------------- The default behavior of Click is to rewrap text based on the width of the terminal, to a maximum 80 characters. 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']) To change the maximum width, pass ``max_content_width`` when calling the command. .. code-block:: python cli(max_content_width=120) .. _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(f"Hello {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') Command Epilog Help ------------------- The help epilog is like the help string but it's printed at the end of the help page after everything else. Useful for showing example command usages or referencing additional help resources. .. click:example:: @click.command(epilog='Check out our docs at https://click.palletsprojects.com/ for more details') def init(): """Initializes the repository.""" And what it looks like: .. click:run:: invoke(init, prog_name='repo.py', args=['--help']) 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']) asyncclick-8.1.7.0-async/docs/exceptions.rst000066400000000000000000000055761452710122500210020ustar00rootroot00000000000000Exception 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 an :exc:`Abort`. The logic applied is the following: 1. If an :exc:`EOFError` or :exc:`KeyboardInterrupt` happens, reraise it as :exc:`Abort`. 2. If a :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 = await command.make_context('command-name', ['args', 'go', 'here']) with ctx: result = await 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:: await 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. asyncclick-8.1.7.0-async/docs/index.rst000066400000000000000000000047271452710122500177250ustar00rootroot00000000000000Welcome to the AsyncClick Documentation ================================== .. rst-class:: hide-header .. image:: _static/click-logo.png :align: center :scale: 50% :target: https://palletsprojects.com/p/click/ AsyncClick ist a fork of Click that works well with (some) async frameworks. Supported: asyncio, trio, and curio. Click, in turn, 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 asyncclick as click import anyio @click.command() @click.option('--count', default=1, help='Number of greetings.') @click.option('--name', prompt='Your name', help='The person to greet.') async def hello(count, name): """Simple program that greets NAME for a total of COUNT times.""" for x in range(count): if x: await anyio.sleep(0.1) click.echo(f"Hello {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 asyncclick 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 shell-completion exceptions unicode-support 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 upgrading license changes asyncclick-8.1.7.0-async/docs/license.rst000066400000000000000000000001071452710122500202240ustar00rootroot00000000000000BSD-3-Clause License ==================== .. include:: ../LICENSE.rst asyncclick-8.1.7.0-async/docs/make.bat000066400000000000000000000014051452710122500174570ustar00rootroot00000000000000@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 asyncclick-8.1.7.0-async/docs/options.rst000066400000000000000000000641371452710122500203120ustar00rootroot00000000000000.. _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 ----------------- Options have a name that will be used as the Python argument name when calling the decorated function. This can be inferred from the option names or given explicitly. Names are given as position arguments to the decorator. A name is chosen in the following order 1. If a name is not prefixed, it is used as the Python argument name and not treated as an option name on the command line. 2. If there is at least one name prefixed with two dashes, the first one given is used as the name. 3. The first name prefixed with one dash is used otherwise. To get the Python argument name, the chosen name is converted to lower case, up to two dashes are removed as the prefix, and other dashes are converted to underscores. .. code-block:: python @click.command() @click.option('-s', '--string-to-echo') def echo(string_to_echo): click.echo(string_to_echo) .. code-block:: python @click.command() @click.option('-s', '--string-to-echo', 'string') def echo(string): click.echo(string) - ``"-f", "--foo-bar"``, the name is ``foo_bar`` - ``"-x"``, the name is ``x`` - ``"-f", "--filename", "dest"``, the name is ``dest`` - ``"--CamelCase"``, the name is ``camelcase`` - ``"-f", "-fb"``, the name is ``f`` - ``"--f", "--foo-bar"``, the name is ``f`` - ``"---f"``, the name is ``_f`` 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(f"from {from_} to {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']) For single option boolean flags, the default remains hidden if the default value is False. .. click:example:: @click.command() @click.option('--n', default=1, show_default=True) @click.option("--gr", is_flag=True, show_default=True, default=False, help="Greet the world.") @click.option("--br", is_flag=True, show_default=True, default=True, help="Add a thematic break") def dots(n, gr, br): if gr: click.echo('Hello world!') click.echo('.' * n) if br: 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): a, b = pos click.echo(f"{a} / {b}") 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): name, id = item click.echo(f"name={name} id={id}") 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): name, id = item click.echo(f"name={name} id={id}") .. _multiple-options: Multiple Options ---------------- Similarly to ``nargs``, there is also the case of wanting to support a parameter being provided multiple times and have all the 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']) When passing a ``default`` with ``multiple=True``, the default value must be a list or tuple, otherwise it will be interpreted as a list of single characters. .. code-block:: python @click.option("--format", multiple=True, default=["json"]) 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(f"Verbosity: {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']) invoke(info) 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']) invoke(info) 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(f"debug={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. The originally passed choice will be returned, not the str passed on the command line. Token normalization functions and ``case_sensitive=False`` can cause the two to be different but still match. Example: .. click:example:: @click.command() @click.option('--hash-type', type=click.Choice(['MD5', 'SHA1'], case_sensitive=False)) 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=md5']) println() invoke(digest, args=['--hash-type=foo']) println() invoke(digest, args=['--help']) Only pass the choices as list or tuple. Other iterables (like generators) may lead to unexpected results. Choices work with options that have ``multiple=True``. If a ``default`` value is given with ``multiple=True``, it should be a list or tuple of valid choices. Choices should be unique after considering the effects of ``case_sensitive`` and any specified token normalization function. .. versionchanged:: 7.1 The resulting value from an option will always be one of the originally passed choices regardless of ``case_sensitive``. .. _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(f"Hello {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(f"Hello {name}!") What it looks like: .. click:run:: invoke(hello, input=['John']) It is advised that prompt not be used in conjunction with the multiple flag set to True. Instead, prompt in the function interactively. By default, the user will be prompted for an input if one was not passed through the command line. To turn this behavior off, see :ref:`optional-value`. Password Prompts ---------------- Click also supports hidden prompts and asking for confirmation. This is useful for password input: .. click:example:: import codecs @click.command() @click.option( "--password", prompt=True, hide_input=True, confirmation_prompt=True ) def encode(password): click.echo(f"encoded: {codecs.encode(password, 'rot13')}") .. click:run:: invoke(encode, input=['secret', 'secret']) Because this combination of parameters is quite common, this can also be replaced with the :func:`password_option` decorator: .. code-block:: python @click.command() @click.password_option() def encrypt(password): click.echo(f"encoded: to {codecs.encode(password, '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: .. code-block:: python import os @click.command() @click.option( "--username", prompt=True, default=lambda: os.environ.get("USER", "") ) def hello(username): click.echo(f"Hello, {username}!") To describe what the default value will be, set it in ``show_default``. .. click:example:: import os @click.command() @click.option( "--username", prompt=True, default=lambda: os.environ.get("USER", ""), show_default="current user" ) def hello(username): click.echo(f"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 three parameters: the current :class:`Context`, the current :class:`Parameter`, 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 ``run`` taking an option called ``reload`` and the prefix is ``WEB``, then the variable is ``WEB_RUN_RELOAD``. Example usage: .. click:example:: @click.command() @click.option('--username') def greet(username): click.echo(f'Hello {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``. If you have a subcommand called ``run-server`` taking an option called ``host`` and the prefix is ``WEB``, then the variable is ``WEB_RUN_SERVER_HOST``. Example: .. click:example:: @click.group() @click.option('--debug/--no-debug') def cli(debug): click.echo(f"Debug mode is {'on' if debug else 'off'}") @cli.command() @click.option('--username') def greet(username): click.echo(f"Hello {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(f"Hello {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": f"./foo/bar{os.path.pathsep}./test"}) 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(f"writable={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(f"debug={debug}") if __name__ == '__main__': log() .. _ranges: Range Options ------------- The :class:`IntRange` type extends the :data:`INT` type to ensure the value is contained in the given range. The :class:`FloatRange` type does the same for :data:`FLOAT`. If ``min`` or ``max`` is omitted, that side is *unbounded*. Any value in that direction is accepted. By default, both bounds are *closed*, which means the boundary value is included in the accepted range. ``min_open`` and ``max_open`` can be used to exclude that boundary from the range. If ``clamp`` mode is enabled, a value that is outside the range is set to the boundary instead of failing. For example, the range ``0, 5`` would return ``5`` for the value ``10``, or ``0`` for the value ``-1``. When using :class:`FloatRange`, ``clamp`` can only be enabled if both bounds are *closed* (the default). .. click:example:: @click.command() @click.option("--count", type=click.IntRange(0, 20, clamp=True)) @click.option("--digit", type=click.IntRange(0, 9)) def repeat(count, digit): click.echo(str(digit) * count) .. click:run:: invoke(repeat, args=['--count=100', '--digit=5']) invoke(repeat, args=['--count=6', '--digit=12']) 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. The callback runs after type conversion. It is called for all sources, including prompts. 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. .. click:example:: def validate_rolls(ctx, param, value): if isinstance(value, tuple): return value try: rolls, _, dice = value.partition("d") return int(dice), int(rolls) except ValueError: raise click.BadParameter("format must be 'NdM'") @click.command() @click.option( "--rolls", type=click.UNPROCESSED, callback=validate_rolls, default="1d6", prompt=True, ) def roll(rolls): sides, times = rolls click.echo(f"Rolling a {sides}-sided dice {times} time(s)") .. click:run:: invoke(roll, args=["--rolls=42"]) println() invoke(roll, args=["--rolls=2d12"]) println() invoke(roll, input=["42", "2d12"]) .. _optional-value: Optional Value -------------- Providing the value to an option can be made optional, in which case providing only the option's flag without a value will either show a prompt or use its ``flag_value``. Setting ``is_flag=False, flag_value=value`` tells Click that the option can still be passed a value, but if only the flag is given the ``flag_value`` is used. .. click:example:: @click.command() @click.option("--name", is_flag=False, flag_value="Flag", default="Default") def hello(name): click.echo(f"Hello, {name}!") .. click:run:: invoke(hello, args=[]) invoke(hello, args=["--name", "Value"]) invoke(hello, args=["--name"]) If the option has ``prompt`` enabled, then setting ``prompt_required=False`` tells Click to only show the prompt if the option's flag is given, instead of if the option is not provided at all. .. click:example:: @click.command() @click.option('--name', prompt=True, prompt_required=False, default="Default") def hello(name): click.echo(f"Hello {name}!") .. click:run:: invoke(hello) invoke(hello, args=["--name", "Value"]) invoke(hello, args=["--name"], input="Prompt") If ``required=True``, then the option will still prompt if it is not given, but it will also prompt if only the flag is given. asyncclick-8.1.7.0-async/docs/parameters.rst000066400000000000000000000114311452710122500207470ustar00rootroot00000000000000Parameters ========== .. 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 (:ref:`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), or they may be specified multiple times using :ref:`multiple-options`. 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. The string values "1", "true", "t", "yes", "y", and "on" convert to ``True``. "0", "false", "f", "no", "n", and "off" 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) have a name that will be used as the Python argument name when calling the decorated function with values. Arguments take only one positional name. To provide a different name for use in help text, see :ref:`doc-meta-variables`. Options can have many names that may be prefixed with one or two dashes. Names with one dash are parsed as short options, names with two are parsed as long options. If a name is not prefixed, it is used as the Python argument name and not parsed as an option name. Otherwise, the first name with a two dash prefix is used, or the first with a one dash prefix if there are none with two. The prefix is removed and dashes are converted to underscores to get the Python argument name. Implementing Custom Types ------------------------- To implement a custom type, you need to subclass the :class:`ParamType` class. Override the :meth:`~ParamType.convert` method to convert the value from a string to the correct type. The following code implements an integer type that accepts hex and octal numbers in addition to normal integers, and converts them into regular integers. .. code-block:: python import asyncclick as click class BasedIntParamType(click.ParamType): name = "integer" def convert(self, value, param, ctx): if isinstance(value, int): return value 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(f"{value!r} is not a valid integer", param, ctx) BASED_INT = BasedIntParamType() The :attr:`~ParamType.name` attribute is optional and is used for documentation. Call :meth:`~ParamType.fail` if conversion fails. The ``param`` and ``ctx`` arguments may be ``None`` in some cases such as prompts. Values from user input or the command line will be strings, but default values and Python arguments may already be the correct type. The custom type should check at the top if the value is already valid and pass it through to support those cases. asyncclick-8.1.7.0-async/docs/prompts.rst000066400000000000000000000031631452710122500203130ustar00rootroot00000000000000User 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) asyncclick-8.1.7.0-async/docs/quickstart.rst000066400000000000000000000206411452710122500210010ustar00rootroot00000000000000Quickstart ========== .. 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. Create your project folder, then a virtualenv within it:: $ mkdir myproject $ cd myproject $ python3 -m venv .venv 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 (venv) $ If you are a Windows user, the following command is for you:: > .venv\scripts\activate (venv) > 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 stop using the virtualenv, 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``: `Color support demo `_ * ``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 asyncclick as 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 different environments consistently 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 a :exc:`UnicodeError`. The echo function also supports color and other styles in output. It will automatically remove styles if the output stream is a file. On Windows, colorama is automatically installed and used. See :ref:`ansi-colors`. 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() Registering Commands Later -------------------------- Instead of using the ``@group.command()`` decorator, commands can be decorated with the plain ``@click.command()`` decorator and registered with a group later with ``group.add_command()``. This could be used to split commands into multiple Python modules. .. code-block:: python @click.command() def greet(): click.echo("Hello, World!") .. code-block:: python @click.group() def group(): pass group.add_command(greet) 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(f"Hello {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. asyncclick-8.1.7.0-async/docs/setuptools.rst000066400000000000000000000104751452710122500210340ustar00rootroot00000000000000.. _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: .. code-block:: text yourscript.py setup.py Contents of ``yourscript.py``: .. click:example:: import asyncclick as click @click.command() def cli(): """Example script.""" click.echo('Hello World!') Contents of ``setup.py``: .. code-block:: python from setuptools import setup setup( name='yourscript', version='0.1.0', 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: .. code-block:: console $ python3 -m venv .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: .. code-block:: text project/ yourpackage/ __init__.py main.py utils.py scripts/ __init__.py yourscript.py setup.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``: .. code-block:: python from setuptools import setup, find_packages setup( name='yourpackage', version='0.1.0', packages=find_packages(), include_package_data=True, install_requires=[ 'Click', ], entry_points={ 'console_scripts': [ 'yourscript = yourpackage.scripts.yourscript:cli', ], }, ) asyncclick-8.1.7.0-async/docs/shell-completion.rst000066400000000000000000000224611452710122500220670ustar00rootroot00000000000000.. currentmodule:: click.shell_completion Shell Completion ================ Click provides tab completion support for Bash (version 4.4 and up), Zsh, and Fish. It is possible to add support for other shells too, and suggestions can be customized at multiple levels. Shell completion suggests command names, option names, and values for choice, file, and path parameter types. Options are only listed if at least a dash has been entered. Hidden commands and options are not shown. .. code-block:: text $ repo clone commit copy delete setuser $ repo clone - --deep --help --rev --shallow -r Enabling Completion ------------------- Completion is only available if a script is installed and invoked through an entry point, not through the ``python`` command. See :doc:`/setuptools`. Once the executable is installed, calling it with a special environment variable will put Click in completion mode. In order for completion to be used, the user needs to register a special function with their shell. The script is different for every shell, and Click will output it when called with ``_{PROG_NAME}_COMPLETE`` set to ``{shell}_source``. ``{PROG_NAME}`` is the executable name in uppercase with dashes replaced by underscores. The built-in shells are ``bash``, ``zsh``, and ``fish``. Provide your users with the following instructions customized to your program name. This uses ``foo-bar`` as an example. .. tabs:: .. group-tab:: Bash Add this to ``~/.bashrc``: .. code-block:: bash eval "$(_FOO_BAR_COMPLETE=bash_source foo-bar)" .. group-tab:: Zsh Add this to ``~/.zshrc``: .. code-block:: zsh eval "$(_FOO_BAR_COMPLETE=zsh_source foo-bar)" .. group-tab:: Fish Add this to ``~/.config/fish/completions/foo-bar.fish``: .. code-block:: fish _FOO_BAR_COMPLETE=fish_source foo-bar | source This is the same file used for the activation script method below. For Fish it's probably always easier to use that method. Using ``eval`` means that the command is invoked and evaluated every time a shell is started, which can delay shell responsiveness. To speed it up, write the generated script to a file, then source that. You can generate the files ahead of time and distribute them with your program to save your users a step. .. tabs:: .. group-tab:: Bash Save the script somewhere. .. code-block:: bash _FOO_BAR_COMPLETE=bash_source foo-bar > ~/.foo-bar-complete.bash Source the file in ``~/.bashrc``. .. code-block:: bash . ~/.foo-bar-complete.bash .. group-tab:: Zsh Save the script somewhere. .. code-block:: bash _FOO_BAR_COMPLETE=zsh_source foo-bar > ~/.foo-bar-complete.zsh Source the file in ``~/.zshrc``. .. code-block:: bash . ~/.foo-bar-complete.zsh .. group-tab:: Fish Save the script to ``~/.config/fish/completions/foo-bar.fish``: .. code-block:: fish _FOO_BAR_COMPLETE=fish_source foo-bar > ~/.config/fish/completions/foo-bar.fish After modifying the shell config, you need to start a new shell in order for the changes to be loaded. Custom Type Completion ---------------------- When creating a custom :class:`~click.ParamType`, override its :meth:`~click.ParamType.shell_complete` method to provide shell completion for parameters with the type. The method must return a list of :class:`~CompletionItem` objects. Besides the value, these objects hold metadata that shell support might use. The built-in implementations use ``type`` to indicate special handling for paths, and ``help`` for shells that support showing a help string next to a suggestion. In this example, the type will suggest environment variables that start with the incomplete value. .. code-block:: python class EnvVarType(ParamType): name = "envvar" def shell_complete(self, ctx, param, incomplete): return [ CompletionItem(name) for name in os.environ if name.startswith(incomplete) ] @click.command() @click.option("--ev", type=EnvVarType()) def cli(ev): click.echo(os.environ[ev]) Overriding Value Completion --------------------------- Value completions for a parameter can be customized without a custom type by providing a ``shell_complete`` function. The function is used instead of any completion provided by the type. It is passed 3 keyword arguments: - ``ctx`` - The current command context. - ``param`` - The current parameter requesting completion. - ``incomplete`` - The partial word that is being completed. May be an empty string if no characters have been entered yet. It must return a list of :class:`CompletionItem` objects, or as a shortcut it can return a list of strings. In this example, the command will suggest environment variables that start with the incomplete value. .. code-block:: python def complete_env_vars(ctx, param, incomplete): return [k for k in os.environ if k.startswith(incomplete)] @click.command() @click.argument("name", shell_complete=complete_env_vars) def cli(name): click.echo(f"Name: {name}") click.echo(f"Value: {os.environ[name]}") Adding Support for a Shell -------------------------- Support can be added for shells that do not come built in. Be sure to check PyPI to see if there's already a package that adds support for your shell. This topic is very technical, you'll want to look at Click's source to study the built-in implementations. Shell support is provided by subclasses of :class:`ShellComplete` registered with :func:`add_completion_class`. When Click is invoked in completion mode, it calls :meth:`~ShellComplete.source` to output the completion script, or :meth:`~ShellComplete.complete` to output completions. The base class provides default implementations that require implementing some smaller parts. First, you'll need to figure out how your shell's completion system works and write a script to integrate it with Click. It must invoke your program with the environment variable ``_{PROG_NAME}_COMPLETE`` set to ``{shell}_complete`` and pass the complete args and incomplete value. How it passes those values, and the format of the completion response from Click is up to you. In your subclass, set :attr:`~ShellComplete.source_template` to the completion script. The default implementation will perform ``%`` formatting with the following variables: - ``complete_func`` - A safe name for the completion function defined in the script. - ``complete_var`` - The environment variable name for passing the ``{shell}_complete`` instruction. - ``prog_name`` - The name of the executable being completed. The example code is for a made up shell "My Shell" or "mysh" for short. .. code-block:: python from asyncclick.shell_completion import add_completion_class from asyncclick.shell_completion import ShellComplete _mysh_source = """\ %(complete_func)s { response=$(%(complete_var)s=mysh_complete %(prog_name)s) # parse response and set completions somehow } call-on-complete %(prog_name)s %(complete_func)s """ @add_completion_class class MyshComplete(ShellComplete): name = "mysh" source_template = _mysh_source Next, implement :meth:`~ShellComplete.get_completion_args`. This must get, parse, and return the complete args and incomplete value from the completion script. For example, for the Bash implementation the ``COMP_WORDS`` env var contains the command line args as a string, and the ``COMP_CWORD`` env var contains the index of the incomplete arg. The method must return a ``(args, incomplete)`` tuple. .. code-block:: python import os from asyncclick.parser import split_arg_string class MyshComplete(ShellComplete): ... def get_completion_args(self): args = split_arg_string(os.environ["COMP_WORDS"]) if os.environ["COMP_PARTIAL"] == "1": incomplete = args.pop() return args, incomplete return args, "" Finally, implement :meth:`~ShellComplete.format_completion`. This is called to format each :class:`CompletionItem` into a string. For example, the Bash implementation returns ``f"{item.type},{item.value}`` (it doesn't support help strings), and the Zsh implementation returns each part separated by a newline, replacing empty help with a ``_`` placeholder. This format is entirely up to what you parse with your completion script. The ``type`` value is usually ``plain``, but it can be another value that the completion script can switch on. For example, ``file`` or ``dir`` can tell the shell to handle path completion, since the shell is better at that than Click. .. code-block:: python class MyshComplete(ShellComplete): ... def format_completion(self, item): return f"{item.type}\t{item.value}" With those three things implemented, the new shell support is ready. In case those weren't sufficient, there are more parts that can be overridden, but that probably isn't necessary. The activation instructions will again depend on how your shell works. Use the following to generate the completion script, then load it into the shell somehow. .. code-block:: text _FOO_BAR_COMPLETE=mysh_source foo-bar asyncclick-8.1.7.0-async/docs/testing.rst000066400000000000000000000112411452710122500202600ustar00rootroot00000000000000Testing 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. Note that :meth:`CliRunner.invoke` is asynchronous. The :func:`runner` fixture, which most Click tests use, contains a synchronous :attr:`invoke` for your convenience. The return value is a :class:`Result` object, which has the captured output data, exit code, and optional exception attached: .. code-block:: python :caption: hello.py import asyncclick as click @click.command() @click.argument('name') async def hello(name): click.echo(f'Hello {name}!') .. code-block:: python :caption: test_hello.py from asyncclick.testing import CliRunner from hello import hello @pytest.mark.anyio async def test_hello_world(): runner = CliRunner() result = await 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: .. code-block:: python :caption: sync.py import asyncclick as click @click.group() @click.option('--debug/--no-debug', default=False) async def cli(debug): click.echo(f"Debug mode is {'on' if debug else 'off'}") @cli.command() async def sync(): click.echo('Syncing') .. code-block:: python :caption: test_sync.py from asyncclick.testing import CliRunner from sync import cli @pytest.mark.anyio async def test_sync(): runner = CliRunner() result = await 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 = await runner.invoke(cli, ['--debug', 'sync'], terminal_width=60) File System Isolation --------------------- For basic command line tools with file system operations, the :meth:`CliRunner.isolated_filesystem` method is useful for setting the current working directory to a new, empty folder. .. code-block:: python :caption: cat.py import asyncclick as click @click.command() @click.argument('f', type=click.File()) async def cat(f): click.echo(f.read()) .. code-block:: python :caption: test_cat.py from asyncclick.testing import CliRunner from cat import cat @pytest.mark.anyio async def test_cat(): runner = CliRunner() with runner.isolated_filesystem(): with open('hello.txt', 'w') as f: f.write('Hello World!') result = await runner.invoke(cat, ['hello.txt']) assert result.exit_code == 0 assert result.output == 'Hello World!\n' Pass ``temp_dir`` to control where the temporary directory is created. The directory will not be removed by Click in this case. This is useful to integrate with a framework like Pytest that manages temporary files. .. code-block:: python def test_keep_dir(tmp_path): runner = CliRunner() with runner.isolated_filesystem(temp_dir=tmp_path) as td: ... 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: .. code-block:: python :caption: prompt.py import asyncclick as click @click.command() @click.option('--foo', prompt=True) async def prompt(foo): click.echo(f"foo={foo}") .. code-block:: python :caption: test_prompt.py from asyncclick.testing import CliRunner from prompt import prompt def test_prompts(): runner = CliRunner() result = await runner.invoke(prompt, 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. asyncclick-8.1.7.0-async/docs/unicode-support.rst000066400000000000000000000105051452710122500217450ustar00rootroot00000000000000Unicode Support =============== .. currentmodule:: click Click has to take extra care to support Unicode text in different environments. * The command line in Unix is traditionally bytes, not Unicode. While there are encoding hints, there are some situations where this can break. The most common one is SSH connections to machines with different locales. Misconfigured environments can cause a wide range of Unicode problems due to the lack of support for roundtripping surrogate escapes. This will not be fixed in Click itself! * Standard input and output is opened in text mode by default. Click has to reopen the stream in binary mode in certain situations. Because there is no standard way to do this, it 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 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. * ``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. * ``sys.argv`` is always text. This means that the native type for input values to the types in Click is Unicode, 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 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. Surrogate Handling ------------------ Click does all the Unicode handling in the standard library and is subject to its behavior. Unicode requires extra care. The reason for this is that 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, deployment tools, or cron jobs 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:: Traceback (most recent call last): ... RuntimeError: Click will abort further execution because Python was configured to use ASCII as encoding for the environment. Consult https://click.palletsprojects.com/unicode-support/ for mitigation steps. You are dealing with an environment where Python 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``. You need to export the values before you invoke your Python script. In Python 3.7 and later you will no longer get a ``RuntimeError`` in many cases thanks to :pep:`538` and :pep:`540`, which changed the default assumption in unconfigured environments. This doesn't change the general issue that your locale may be misconfigured. asyncclick-8.1.7.0-async/docs/upgrading.rst000066400000000000000000000122141452710122500205640ustar00rootroot00000000000000Upgrading 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-anyio: Upgrading to asyncclick ----------------------- The anyio-compatible version of Click is mostly backwards compatible. Several methods, most notably :meth:`BaseCommand.main` and :meth:`Context.invoke`, are now asynchronous. The :meth:`BaseCommand.__call__` alias invokes the main entry point via `anyio.run`. If you already have an async main program, simply use ``await cmd.main()`` instead of ``cmd()``. Commands and callbacks may be asynchronous; Click auto-``await``s them. Support for Python 2.x was dropped. .. _upgrade-to-7.0: Upgrading to 7.0 ---------------- Commands that take their name from the decorated function now replace underscores with dashes. For example, the Python function ``run_server`` will get the command name ``run-server`` now. There are a few options to address this: - To continue with the new behavior, pin your dependency to ``Click>=7`` and update any documentation to use dashes. - To keep existing behavior, add an explicit command name with underscores, like ``@click.command("run_server")``. - To try a name with dashes if the name with underscores was not found, pass a ``token_normalize_func`` to the context: .. code-block:: python def normalize(name): return name.replace("_", "-") @click.group(context_settings={"token_normalize_func": normalize}) def group(): ... @group.command() def run_server(): ... .. _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.result_callback`. .. _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 asyncclick as 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. asyncclick-8.1.7.0-async/docs/utils.rst000066400000000000000000000312221452710122500177440ustar00rootroot00000000000000Utilities ========= .. 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 many different terminal environments. Example:: import asyncclick as click click.echo('Hello World!') It can output both text and binary data. It will 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 characters (there are some limitations on the default font with regards to which characters can be displayed). .. versionadded:: 6.0 Click emulates output streams on Windows to support unicode to the Windows console through separate APIs. For more information see :doc:`wincmd`. .. versionadded:: 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 The :func:`echo` function supports ANSI colors and styles. On Windows this uses `colorama`_. 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. On Windows, Click uses colorama without calling ``colorama.init()``. You can still call that in your code, but it's not required for Click. For styling a string, the :func:`style` function can be used:: import asyncclick as 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(f"Line {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 f"Line {idx}\n" @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 asyncclick as 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 asyncclick as 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 asyncclick as 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 asyncclick as 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 asyncclick as 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. 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(f"Path: {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; see :doc:`/unicode-support`). Example:: import asyncclick as 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 asyncclick as 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 asyncclick as 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[f"{section}.{key}"] = value return rv Showing Progress Bars --------------------- 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. .. note:: If you find that you have requirements beyond what Click's progress bar supports, try using `tqdm`_. .. _tqdm: https://tqdm.github.io/ 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 asyncclick as 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) Note that :func:`progressbar` updates the bar *after* each iteration of the loop. So code like this will render correctly:: import time with click.progressbar([1, 2, 3]) as bar: for x in bar: print(f"sleep({x})...") time.sleep(x) 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) asyncclick-8.1.7.0-async/docs/why.rst000066400000000000000000000157741452710122500174310ustar00rootroot00000000000000Why 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. * Support for prompting of custom values. * Is fully nestable and composable. * 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; the obvious ones are ``optparse`` and ``argparse`` from the standard library. Have a look to see if something else resonates with you. Click actually implements its own parsing of arguments and does not use ``optparse`` or ``argparse`` following the ``optparse`` parsing behavior. 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 and customizable but not overly flexible. For instance, the customizability of help pages is constrained. This constraint is intentional because Click promises multiple Click instances will continue to function as intended when strung together. 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. Why not Argparse? ----------------- Click is internally based on ``optparse`` instead of ``argparse``. This is an implementation detail that a user does not have to be concerned with. Click is not based on ``argparse`` because it has some behaviors that make handling arbitrary command line interfaces hard: * ``argparse`` has built-in behavior to guess if something is an argument or an option. This becomes a problem when dealing with incomplete command lines; the behaviour becomes unpredictable without full knowledge of a command line. This goes against Click's ambitions of dispatching to subparsers. * ``argparse`` does not support disabling interspersed arguments. Without this feature, it's not possible to safely implement Click's nested parsing. 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 it can generate unified help pages for the full CLI and assist the user in converting the input data as necessary. - Click has a strong understanding of what types are, and it 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 message because it's manually handled. - Click has enough meta information available for its whole program to evolve over time and 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. For instance, as a developer, you are given very little choice in formatting your help pages. 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 an 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`. asyncclick-8.1.7.0-async/docs/wincmd.rst000066400000000000000000000061271452710122500200730ustar00rootroot00000000000000Windows Console Notes ===================== .. versionadded:: 6.0 Click emulates 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. 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`. 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 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. asyncclick-8.1.7.0-async/examples/000077500000000000000000000000001452710122500167405ustar00rootroot00000000000000asyncclick-8.1.7.0-async/examples/README000066400000000000000000000006551452710122500176260ustar00rootroot00000000000000Click 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/setuptools/ asyncclick-8.1.7.0-async/examples/aliases/000077500000000000000000000000001452710122500203615ustar00rootroot00000000000000asyncclick-8.1.7.0-async/examples/aliases/README000066400000000000000000000006751452710122500212510ustar00rootroot00000000000000$ 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 asyncclick-8.1.7.0-async/examples/aliases/aliases.ini000066400000000000000000000000241452710122500224770ustar00rootroot00000000000000[aliases] ci=commit asyncclick-8.1.7.0-async/examples/aliases/aliases.py000066400000000000000000000077531452710122500223700ustar00rootroot00000000000000import configparser import os import asyncclick as click class Config: """The config in this example only holds aliases.""" def __init__(self): self.path = os.getcwd() self.aliases = {} def add_alias(self, alias, cmd): self.aliases.update({alias: cmd}) def read_config(self, filename): parser = configparser.RawConfigParser() parser.read([filename]) try: self.aliases.update(parser.items("aliases")) except configparser.NoSectionError: pass def write_config(self, filename): parser = configparser.RawConfigParser() parser.add_section("aliases") for key, value in self.aliases.items(): parser.set("aliases", key, value) with open(filename, "wb") as file: parser.write(file) 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: look up an explicit command alias 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(f"Too many matches: {', '.join(sorted(matches))}") def resolve_command(self, ctx, args): # always return the command's name, not the alias _, cmd, args = super().resolve_command(ctx, args) return cmd.name, cmd, args 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(f"Status for {config.path}") @cli.command() @pass_config @click.argument("alias_", metavar="ALIAS", type=click.STRING) @click.argument("cmd", type=click.STRING) @click.option( "--config_file", type=click.Path(exists=True, dir_okay=False), default="aliases.ini" ) def alias(config, alias_, cmd, config_file): """Adds an alias to the specified configuration file.""" config.add_alias(alias_, cmd) config.write_config(config_file) click.echo(f"Added '{alias_}' as alias for '{cmd}'") asyncclick-8.1.7.0-async/examples/aliases/setup.py000066400000000000000000000004131452710122500220710ustar00rootroot00000000000000from 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 """, ) asyncclick-8.1.7.0-async/examples/colors/000077500000000000000000000000001452710122500202415ustar00rootroot00000000000000asyncclick-8.1.7.0-async/examples/colors/README000066400000000000000000000002361452710122500211220ustar00rootroot00000000000000$ colors_ colors is a simple example that shows how you can colorize text. Uses colorama on Windows. Usage: $ pip install --editable . $ colors asyncclick-8.1.7.0-async/examples/colors/colors.py000066400000000000000000000016541452710122500221220ustar00rootroot00000000000000import asyncclick as 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. 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(f"I am colored {color}", fg=color)) for color in all_colors: click.echo(click.style(f"I am colored {color} and bold", fg=color, bold=True)) for color in all_colors: click.echo(click.style(f"I am reverse colored {color}", fg=color, reverse=True)) click.echo(click.style("I am blinking", blink=True)) click.echo(click.style("I am underlined", underline=True)) asyncclick-8.1.7.0-async/examples/colors/setup.py000066400000000000000000000004071452710122500217540ustar00rootroot00000000000000from setuptools import setup setup( name="click-example-colors", version="1.0", py_modules=["colors"], include_package_data=True, install_requires=["click"], entry_points=""" [console_scripts] colors=colors:cli """, ) asyncclick-8.1.7.0-async/examples/completion/000077500000000000000000000000001452710122500211115ustar00rootroot00000000000000asyncclick-8.1.7.0-async/examples/completion/README000066400000000000000000000007301452710122500217710ustar00rootroot00000000000000$ completion ============ Demonstrates Click's shell completion support. .. code-block:: bash pip install --editable . For Bash: .. code-block:: bash eval "$(_COMPLETION_COMPLETE=bash_source completion)" For Zsh: .. code-block:: zsh eval "$(_COMPLETION_COMPLETE=zsh_source completion)" For Fish: .. code-block:: fish eval (env _COMPLETION_COMPLETE=fish_source completion) Now press tab (maybe twice) after typing something to see completions. asyncclick-8.1.7.0-async/examples/completion/completion.py000066400000000000000000000025771452710122500236470ustar00rootroot00000000000000import os import asyncclick as click from asyncclick.shell_completion import CompletionItem @click.group() def cli(): pass @cli.command() @click.option("--dir", type=click.Path(file_okay=False)) def ls(dir): click.echo("\n".join(os.listdir(dir))) def get_env_vars(ctx, param, incomplete): # Returning a list of values is a shortcut to returning a list of # CompletionItem(value). return [k for k in os.environ if incomplete in k] @cli.command(help="A command to print environment variables") @click.argument("envvar", shell_complete=get_env_vars) def show_env(envvar): click.echo(f"Environment variable: {envvar}") click.echo(f"Value: {os.environ[envvar]}") @cli.group(help="A group that holds a subcommand") def group(): pass def list_users(ctx, param, incomplete): # You can generate completions with help strings by returning a list # of CompletionItem. You can match on whatever you want, including # the help. items = [("bob", "butcher"), ("alice", "baker"), ("jerry", "candlestick maker")] out = [] for value, help in items: if incomplete in value or incomplete in help: out.append(CompletionItem(value, help=help)) return out @group.command(help="Choose a user") @click.argument("user", shell_complete=list_users) def select_user(user): click.echo(f"Chosen user is {user}") cli.add_command(group) asyncclick-8.1.7.0-async/examples/completion/setup.py000066400000000000000000000004271452710122500226260ustar00rootroot00000000000000from setuptools import setup setup( name="click-example-completion", version="1.0", py_modules=["completion"], include_package_data=True, install_requires=["click"], entry_points=""" [console_scripts] completion=completion:cli """, ) asyncclick-8.1.7.0-async/examples/complex/000077500000000000000000000000001452710122500204075ustar00rootroot00000000000000asyncclick-8.1.7.0-async/examples/complex/README000066400000000000000000000007041452710122500212700ustar00rootroot00000000000000$ 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 asyncclick-8.1.7.0-async/examples/complex/complex/000077500000000000000000000000001452710122500220565ustar00rootroot00000000000000asyncclick-8.1.7.0-async/examples/complex/complex/__init__.py000066400000000000000000000000001452710122500241550ustar00rootroot00000000000000asyncclick-8.1.7.0-async/examples/complex/complex/cli.py000066400000000000000000000031351452710122500232010ustar00rootroot00000000000000import os import sys import asyncclick as click CONTEXT_SETTINGS = dict(auto_envvar_prefix="COMPLEX") class Environment: 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_environment = click.make_pass_decorator(Environment, 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: mod = __import__(f"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_environment def cli(ctx, verbose, home): """A complex command line interface.""" ctx.verbose = verbose if home is not None: ctx.home = home asyncclick-8.1.7.0-async/examples/complex/complex/commands/000077500000000000000000000000001452710122500236575ustar00rootroot00000000000000asyncclick-8.1.7.0-async/examples/complex/complex/commands/__init__.py000066400000000000000000000000001452710122500257560ustar00rootroot00000000000000asyncclick-8.1.7.0-async/examples/complex/complex/commands/cmd_init.py000066400000000000000000000006171452710122500260230ustar00rootroot00000000000000from complex.cli import pass_environment import asyncclick as click @click.command("init", short_help="Initializes a repo.") @click.argument("path", required=False, type=click.Path(resolve_path=True)) @pass_environment def cli(ctx, path): """Initializes a repository.""" if path is None: path = ctx.home ctx.log(f"Initialized the repository in {click.format_filename(path)}") asyncclick-8.1.7.0-async/examples/complex/complex/commands/cmd_status.py000066400000000000000000000004541452710122500264020ustar00rootroot00000000000000from complex.cli import pass_environment import asyncclick as click @click.command("status", short_help="Shows file changes.") @pass_environment def cli(ctx): """Shows file changes in the current working directory.""" ctx.log("Changed files: none") ctx.vlog("bla bla bla, debug info") asyncclick-8.1.7.0-async/examples/complex/setup.py000066400000000000000000000004411452710122500221200ustar00rootroot00000000000000from 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 """, ) asyncclick-8.1.7.0-async/examples/imagepipe/000077500000000000000000000000001452710122500207005ustar00rootroot00000000000000asyncclick-8.1.7.0-async/examples/imagepipe/.gitignore000066400000000000000000000000141452710122500226630ustar00rootroot00000000000000processed-* asyncclick-8.1.7.0-async/examples/imagepipe/README000066400000000000000000000004661452710122500215660ustar00rootroot00000000000000$ 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 asyncclick-8.1.7.0-async/examples/imagepipe/example01.jpg000066400000000000000000001447351452710122500232140ustar00rootroot00000000000000JFIF`` XICC_PROFILE HLinomntrRGB XYZ  1acspMSFTIEC sRGB-HP cprtP3desclwtptbkptrXYZgXYZ,bXYZ@dmndTpdmddvuedLview$lumimeas $tech0 rTRC< gTRC< bTRC< textCopyright (c) 1998 Hewlett-Packard CompanydescsRGB IEC61966-2.1sRGB IEC61966-2.1XYZ QXYZ XYZ o8XYZ bXYZ $descIEC http://www.iec.chIEC http://www.iec.chdesc.IEC 61966-2.1 Default RGB colour space - sRGB.IEC 61966-2.1 Default RGB colour space - sRGBdesc,Reference Viewing Condition in IEC61966-2.1,Reference Viewing Condition in IEC61966-2.1view_. \XYZ L VPWmeassig CRT curv #(-27;@EJOTY^chmrw| %+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&IlAe@e Ek*Qw;c*R{Gp@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{GHHKHHIIcIIJ7J}JK KSKKL*LrLMMJMMN%NnNOOIOOP'PqPQQPQQR1R|RSS_SSTBTTU(UuUVV\VVWDWWX/X}XYYiYZZVZZ[E[[\5\\]']x]^^l^__a_``W``aOaabIbbcCccd@dde=eef=ffg=ggh?hhiCiijHjjkOkklWlmm`mnnknooxop+ppq:qqrKrss]sttptu(uuv>vvwVwxxnxy*yyzFz{{c{|!||}A}~~b~#G k͂0WGrׇ;iΉ3dʋ0cʍ1fΏ6n֑?zM _ɖ4 uL$h՛BdҞ@iءG&vVǥ8nRĩ7u\ЭD-u`ֲK³8%yhYѹJº;.! zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖޢ)߯6DScs 2F[p(@Xr4Pm8Ww)KmExifMM*JR(iZ``Р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*IRHn13ګ)ہ<yR\KEc\B|nJv.qrpXʛtOm]@cU-o&o+Si`9$nC)#\7Zc>O*O1B2mt=~~'X," dNC181һ& Vqmi|q$3Ӓk(jmhWzOuG2L7H{]}Je7+Ȗ WD_4WZmZ]7e TTd+=~m[Rr\J_'G01_Ins3_72VSs-[\]uoіSsjcG洶smqq" '^-i0i̾`L3q]^wo.VBIc`ǷSEѧִ)m.َ^EfO|ߵκ9sjkUk R -H*\pħ\WjZ`7vEs"4XV>Wֹ\;+r=?ee/2Ꭵ%iW$V9x'O$+bKohKy!Z}jCEFmg.Y&Ѡ;޺06MyjTI%fU%dIyr$Fv5Ff$ZnWM' RR;r ?Qf̵9M7ڮ :y󍈼r&cũjެTc~@WxZoŬmad ;#vJ/e3GyT֨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{%cžIԟzK_5-&ɛtfX|%5ҨXp*gZވs} "eW#^O?]ݦBvhO}bu;ͬ-#w] /M*x#~g$g=Me:Ҟ9/k KgQJX#$x uuioNN^%n"8%9&}zkZ_"cO[ZSw{hFbāvKh ZlqqZxԍppkmn] ;}Ptue7 !BW$Soqc8x4 d[Q 4j 79Q'SZGUJJ/~HҞ+ zK%Ը{c<+קOr8-G Y]D6B߂5{KݶP3sm~WQߏZB^=>|gU7'ݷ]sKD(coA2B7k~DTLeM>߫0Յ6ݏ+hv3qSͅBŒO@?JԉZfEKH 9$m*bmW7F~Sl~Iڬ[+Ig[1ܭm,$ռY#Giܶq7!=0NuQguXAxv4jʊkk;ww#Γ>I4ax2)>RzE2;?ZOñWz8lq?J!WcXp<\;l*6 Ek%mQF\'dzS|^"[D"}0 \\]$һG5]Rc9ҹsMX.ԹTv>BTՒIMlys$¢vjy:me"(^WFׅ45!d'rm#uUObcl?|GNd}\5%/#pt5ݔ6q4i4v(fUB㌓ "q]&m}eC!S.B*(8Ydc֯D&4qur풎3ɍ=OX^ݏžnup̶.u}LZW͊u*eMD7fr1M 4 YXEKk]Bج9nGҹg\,iq1G9e77_iDcj =qÐTU5NN|m>ȇ^- W0] zid􅻰2Vkf*0v# kwNqէJo+Z>qumleWRM'^zYHaӮeNUêQ7( {hgx_\ ۻX\F窩e }sޱ|7 9Aec"d> Vht;w nXIA<V85{kEm+,AfeÁUc@qQrz&T[]}k4d3죲+7Ol+TrOrO$Ս79G˔BG,¼njvJ"uT=?*0SVMFŭVdn`tS(66Uњ 'VMdwvֶCUr@+$HV~t'v'OpM=#巅KhNscmimYY٩[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𦐺6Iwc:~Zmϧx<$ڒf&m4=#:" p?3f.%2J`21Ů9cpINwϥb8_sLN̮~"tskŨM-Ɛ#9'AOnj.2}g_}B?JT{%^J_ xsEưs- :OxF5Ƨ4r.4EWoY4? s'6?y:(;?ӎkڍy:BAc4v ?3W7@׷*M' kSؒKXyU1RN{;[0,>syjʩ~Ua'')[NQ]x?@ دFpc$#;Oҡo{-*@؊I GBh6ִ1t/0gy,ry,d:u=3DO2A8'a'x}fO5_xO4H#\dCIA^LJ[|Udwx+]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]*ۼ;wQA  RIڧu>ZZ*l"x[M>-䄇'<~'\cOҴmվgǙYJ;?@Lp \} 9.~'OWt1AUd>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 IyseE%V+ο[ 8OkCm,T,=c-. 2H?C޻neCڹmQt敾%F/32EvV[2@@m?i'QhT4qlu>o m{ ?Hk**F'-lZ^^~gB=|ö>ڧ ܵ̓(O}x`<]o⛛BNۻboҞ*ئuUaxoŖ1@yX>&![kMyɓw]6}O`=dJo 5dU˔k7*2}f8^Q^BhdXd]}|I1nx5%FHĉvjƟKV{ǚO=0z7S.1M\ώ `?rqV7Io&siϯƝiI\ 59$ f·%p'fgӀ(좽VڳV9gķZWY Ѧ̐0 95_ctHnlZ/N=qZo5e[h5hzTa6u8]^fi#8(F}zq޼pҎװ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(uAWysuqTI͟Nxe{` Q:r>*֮-4E6 1?1~f&HDIpͼ@*d(qj͝URBܳ#Vs%,G8"wfv!nʃ `1.s=?*DWwqҡso&epºaW̒ 1m-.5 2HɄ>en-IJGOAS"Y_pGqMjs*2KVZ︞ۓ© @9Vxnf[aHnl,HEFyRJzkfamN ?mD<05qouH򍴠4y2n|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" v8TETap9XU>K]鷠?RZO7}ୌ}OҷZWEqg8Iu=J /FQ&~>CYrw567,ZkX xv Vx AιJqsbhT|I?C7n@ =jDs g6++asU!? IZյ}tLy(|Ñj>+j66J6+ǣ7P>EtD(Kt]}24f4C:QXܽI#7uGqWDWbUҳcXGn o4̀•F]Z]JAaOwnθ{Ynk.U.Tq?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"-ONM_[ؙWʷ@ OcV kaBrniMi124C/#>t>sÚƥ^ ?1B$}uZ9\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Ӵ}kܢI: XkD3 9 OT|l)LW-S"25 N8#Es"fQ+,Wp¡(YX$h73VrKVQ $ܧa(Sti>X >bkx }A鎪?02rO)#٣vwQv.Rca?`FXS}ߔzcA($3}ַM6[f`z-}S6#C(;+cׯҽ-tBHb lnE\,zrxҡU\MfjZW#G(E{ l Tc5ҁN \ѭ$=CkBfP798sROVmf( E P.aSPH-ALQҦQHLzb' \A 9z/޳s.EvRb8QQI!,ۉ${["ԂZxC$ZTMqQw"EbF 8R;44 942 D 99'zZϼܿ-(Oz`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/øchY֥)TN&xZ.|KҼ1ۦѮ$$%bgw ׍uG5s,E,uAr^JMFU;xzD0wɃ!}HsvASlMƆ.5E_ iaYXϽvv7VOFcU,O?yFkn9f2Ma: rv\ukMlç Ҽ_D݆3RK/1Ojyo,E [i q/uXaFtM[n{qJe2*وЬ%`F?B@3q]`@`O۵尵XQrOֱfNœdԔ[geeO[[G*ݸKᥡ>\Kc .,W;s;)%>U:pe4?J#f,pM1rz HrX@jh2@I4m3eoןP$>*ȢgL=# FH'2?F-gV]SzVU9_Ƿ͢[+ƊKBrc`~=W{6I-ޟi +povUB$CyGRĺ(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@^ضkh`*s (۸җ<1use w؅8$gJmN:fedy%1ְ~x?*uFG==: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`SšpSG s RR@W)œ@W8Svʥ\h)qKP%8KP0To'X̙AVm׌]Z(U~xJĒ~@~9 z<00č??3=\ekR^#1ꮡk/4JΝ vWz~5bBgM,o>fp*Ic~~*A?VVu?^!1>Ƭ>?]v;KIMW8km~$V/${8dJ4itߵ.hVreŻdT0z+Ǿ4ˢ_jRX]G&hnD2#-p=iywq]C[ȡTOǰչxGA'H+HrML-~&,EUowĺa-"229ӊ>!;Do_OM 2gblu IO8*r9汮wi'yebRkϧtԬ) S=LC}!7r8~0" UFI=&36< QVdPNz =^µ$vsֱڗg1.A>>п<=Eܧθ#tϠp_.jNEEs迭r)9T<8b1vQݦmevypK?VıAiCo ʖMp:Wz#uN #VKٲ7/H6rncEX : ߮ >(TWVM~-GN:,ԯʹNtٴr.fX Y;p˿)溨?Tqb={Ow\RBL|Zeyy=#C[i~_ 2>!5!xR>bn?ytLl6]7_{jp?J,PFl`"A~b2?+{Cj?un2q=:J_2_MYno/&2miq*>l ?Gp'zyU8pMOQұogf9Z*skځRlM~pRA-V7U?c)vvI⺝wk+cfa_#[Ni;~EдHX؎cҭ=~@WQIHĒ,8x'5Mw}`R%nbtwn}{h2voՆc3jdOk2u*ߘ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&)R5bSUgQcyٓ&qjrެ{('x SӴ6%5l| ՘y1ҽFL%{qndI z;so&,W3 ú]k=>'COU''ܞIW[E{weP[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ڔEOֻ :]V𫵖~kOCQ\A$j è\{ԔWQt5#?z1豨QTإ;7&!LV![v2g=?t_|KA.In%Sq+n J|7z{V{N\eEFUTBB²I|av9[6r5N)Ŷj68_ַJvF !j$5 !xN3iI~><% ]1) Q'~BW=k qfurce^#HZyG+b9^+3mQ´b*V^MV2sQ%hPAKcy?x䓚ѹ3nH.`5p"#}~tnsocUƜGqo{-աp1"Hʵe FyQI"G#0J ))L*:>L-zZYXiyG1URbL.jMUIZ9-p$q<6H?{¶/{(!w?ʨ!lă5.tIuKWdKk \ݝ[E-ԋK}>,ׯukfJy-FSߝV6q~+Dl 2LдZZMs*?c'Z 瑜椼?DT_&YQywg\+_@-hש뚱w땅<:c9f5IHPڣ2}I"kӵPg/ *wG"i'' kYɌJQWeIdn텞d6 ;M yPDE#t`v^/chNd06C=y/ *;ڥ54Mʹb{T֮Ӥim m<@'qV}jۚg+|=XVxѳӞFmlp >Wv*:SrwԶif&x:S|qU|ڈɂECJ26y҉=j4[(*zpj|,jyLV%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,ptzkw3S &c$tzrjVNMYJiQª;tiiۊoj/< ?#G]}ov"گ' QG"w /?^ƴ#me:Nk,k$E#X{86ՙ7y"H?Kͤ'"Wi# sOTDG_s0Ij6v92 xv^.Ig;ĐOֽ ziT9 cs9[]V'o ¦Ymq5vsΒәX{PD#,^o9-&%mWB2q H0kPAr?ӬFvG[aGfլ?U3~BLncWA?OJͼ7W2|dTs;WrBZٻgG9GWwdWշ+E82I/ߚWp*Ž-(};.eS}M]b9ZM3HO?fkJ~3-*BLHi]RHѱXI | Er+ZBO\#<{>N)|kd9.EJyF_ʓ& 74l`M1PZƳl!juL H\R)&L5&@E8)wqIp*˻!ozgƸ@ɊkZ7?-FIZ7hr5}d'P'HG'}k38J%>.BfIZY;}Cb4cI17vh0yN؟qQf4ġyLsN iš`~2@i$p8z;?JbA?ZC!UcMN8VO1R@u?=iV!5:TP<Z1D6()vGh80>b$$n/ƪ_Ound cVcwWv/6܃"bW07]x*BNB%guWT~Q ?|4*s{ Dy³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>~S޽5ֲuU,=W p߅"Gz[P{ u laqarI@zǵ}q8WFGV</ǟ5j37"2 Cxk䳃;UW%[[Zx9m-ؙ1%0o-uSֺBLr}ׂxZWO ?5躯㴻&M"[xhɌȿ#j-XZ9NƗhw` }1^s/yD89f?Һ/^kZf2٢h^ x =Нb!IfU2?+Ѻ3Tw2:{iSY$Uqa}EhL[?VA}~eTsPVU|G\MZgr)bss DʹBzsV'#ۊw>L܈D ܁ԋHQ.CDh?A׊q(Z9EpV(*@(U A֟d-R-D\sMOl wBg8y{mn>Rr}8T*x LQi2~%A`ED=*TPzi\S 8:#3' Ddq)w4`A0AF;\+v>lTe#ץfMI{HOxeݧw@F>x^}|6cio4Ϣ_r띷UQ\8zboAv+Z?nWtZI˰j/ OWQ/5[ LZDJ)KR' -hfbPwrG֟|+R L۸VhrH AW87qMYkJTR]˾<9KMNϖMw`8#0@5WS Ƨe<~kna@I e?ß7q\[j %ŴK%NTcQSsLs%ARMkTEffR$, \* ZzKj+|#ɤ-x o'}F%Ah*pFX{{䵟դݖX_5RNiro-a+1<Ȋr [T+gpϐ1w({ҷծ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[)Vz[~d^A_a_^qaڤ:a8Vy#x]t"4v)\0?:oc-܀ga4iه5cM6KuSbY2ߠeKԋ#JԜ{+h*i'WڞkHG#HGb^[c},G'W[ue-~VdwW6SBݽ GCNX_4gYwjw&{lw3`1FYq$|IYT#R^]My 6cbz$`~elgiM{Rtuų:ͽ-n_*SH1SY^9#( 7QVg5;v=>`g{?ȍ?4TCӃT.T[󾵚e'K,c'>©glĜ4n'B95.ó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*}*srPԩtL:+; OlhZxҊ,)S :*61jYTwI4fbɘ<QƑ>ڍzB;7RU ,M 7 Kc52&:J),x0SRDc8iVGVP)GJ3Ux-Q'VO5Oio{zX$eQz֋D8SI(]NKy'!ZI*&_4-hJ:LO?Sy%Bi=wz~JYwrjTJ'yGf}+-c{{Bzש㯑6Lٛa2x}ǵQ4Z+-2K>H9>ztP 40xe\yIME0製z78|ZhYAs2rIN+qbzV)eͤ7<`.OfJff#ԏʷC˯߮JKg._<`'$WwyqPaݳ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?LGձ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+=+8gPB*5ڈd*u}VYaݴ{i=^255"^ St1^t}sֱִd)xg X≵244{uʤص:3 YVc4aяZƽ a>SPfǡ=Ň5Rf滩N5wRUl5xIb1` `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@M8t dnXA,@Y3|}*H' 8tgPǯ04xx<ՀpT@]nh5F^O}*#%C-D^P)'Rj# !`($Te.I-]]炑W5`qrgr}*#4Vƻ~skm?2@X?& cJT j~H$YvVq^oZ+7 ?=5>0 -4J/>Njidzx|N.R!Y3嚼 "$zXDzvYXK{|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:tmj6tF[M2?"}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\lBbUViO^XW+] yBGk?:tU*?@+Rs$IJ]$vԟ(8a u깻69(~sO|sIriГv^RXI_&z$C8q3pX& %8ryE,ƫ$XP0AxQ\V&4i55F5|@c:SՃk ,QzR:בQG235FxzֻV>m2yHAG}}+J$KTUPNR+k]]Q#~C#V^1}|KYH)i5&KVPA9HF[xV""& ?oLt5:nHF>mr\HIK? fzs^ :0V c )B MHs?~+Ӻ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,DYLtfVL7RnXE!4 u!ozzm i7c7BPRlWpiqi^W5d}Ң{ş²̜OXei\9- A/ZDlU1{&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ƩijE 9i);y+Jrw9/,%O'E.6b$OԓϰGj3tTsIJgx2!S51VLVexc& klHT\p=wAR]_Mn-Z`F8;{>c%Rȃe<'-8!%O =hSWgʶG lO<ؠP֋3?DϏKy(Q#1u)$cXe5UT5A裒߇jϒF#$fڊYɥ{Up#Y-rYʮu?~W=\4&D*zkx+e֩Ai?s9qIx" ԰|μ1y&]HS*Lҽ5 fe(Hm+Rd}su1$r c* |!re$,@0ytsK̺,n:HD&_4-L.!oPP?\QGRErC/CU5E&nCV" pT\Yi6Ko!-(x*:ʓ]㡮unԪ P)J"5*) +J)p6Z@JGK"H84aY  ar$FV>BjSZ^jl'MgVij6ޓE(IQ4Q^oz Q- MUoz> o5BҟZ{Ա[Ⱦ)d̩ws}[ǭKދXcHȼ.SLH 9j5Jǁ5$qAJ6655eEXHҫȍXE)X7e{הzgR !Pi"5i Pɦ3꼒{cJ'ZI})%UeI`ڲ6 ^z>d=+UBٱHzz β5&`Y_Un屄}%v0uKz3ouo5A߽VA(VJ~TF=OҽWIta]0Jܱ{  /5X39rGʠN-;ؕ^n|ֵuGn {jP0Xctķ'8(S.aKG[e#&A6^S->lu?8L0u%}9ʾ,kcz[lZ]sޞ&C(AFtZ/4Y-G$ݲZ<3BucJZiNMm`4g`{Mq>`=Oo˚➳<ѵV6. û@8J KOݘɹ;M bʝmUHEj:mi8,do"?:A}N@BEcc5%5;QcQO'z.[Z3Տ$tb+5TtkÕuZ]d]khNŷyyTX}HOd֪;IxQGAR5I uB@Řǩ5u֠k9TZ&Y4qQ]yϸ"5ɷ/'5A˚\ N^Eȫ*ŝБ, $|p)1Z:9ִ_.ܟ`{'ϧҫiˋ<ܹN񤶹{;$#1EZ?0twIYݭ7 knw/WxkYm*䬹kIH%OM9Iau'WSErT+Mҕ`à |?JjFӒCTr=Z{$c*:® ǕS]cNyImd@~h)VjoY yI`;K/;^1V,Yb0ƙs ׌Mn/-ux4͛Veĺ?i.W^?R {(de/c2Ӝ]cLtA^ta x3\x +(+OVdy:d"@0kjs\穔Մ+(LPeQ]҃TAQ&''j/,(isjNXkb!OQLV9֝tdqȠ(4<҃Hv&V;5iw{blK!}J}8=Uy0fXHd/FӏZK\T/?=j`*RT?B1̵,@fi}꩔,0I7A}O‹d2{$ x3XNĹv#2n6I5iZ,fH 8S$(Ķ*jtCK}*|"JC B'N*ŠSHqS([zgvPZ\䜚AKRRIpsM 3L4&1婍%Db\T>I1UnI%ɬ6 5O5I Җ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"2zJVujQwܥ"I''u֠qe$uBEZbƼ򗯫AVV&%k6RoDRfB<`tҪȵvE Ge6):"0wQϷ_[T3pXO³SFጒ3CᾓbAQ J}8iA좎r:Uu5rk&:סFW;HV#mZrпcQXGSɨ%8h.eb:qz?S %Rtct?oN"e;IO+P{\W_x j1ݪ>8,7xZх:'kѹFTsGQp .y0s՗i,|sSt,W^ 3\q :#u-)[Ys~5 \qȫgT =qS, AHvd2`pqUjW!y皣-\B٬z 3I= 6GeO5W}OLr ҕʐ<0I.06&ൎ>Oޭ`暉}ᶎ"oV y(4CrLњfiE+vjJWTa1VEW*q6Z?QKxV,c)IrIjdj*@Uc;Ҵ>J zA%w.r߀4isJ (54xZ4AP3e$HQ<ު5C.1%^RYRU$桳x䨉&[Z20K5ƌ#뎕q# c敉=Av<ִTG)N1fQڶ'zVu֩#L͑95RV95RAkb}+>-泎;-,1oj| f3:W6F5X[(Է2$SZq˹k5m>GZMfh;UiXع]ǧY ډ\͠IIb!uܬ;^a-.^w$/~Uzm)Iɏ8+tyk5㖧3Z ո"Tn?Փk]q\ax?tV&%aX+J/GVmhR Ojq$?ks#Nh]^IZ{>[] X)ޝt4Pkc$ N%QIZu2 dr5B-OS D52Gڥ:Rc#"PE3 2֢wTT X#6K,!{ZOJPxCiA$&b$R~XAZFPRVf5)F_!Οyg"\}ч},Zb<+Z"nk5dcFFRi9&@qJj%Z.zՈZZxy 1jdiVNi&,iVc^i#ZzL,e3) F^$.}4RBZJL!QM$))L-I1H,Jc5ZYP6;iM?Z4A,RI}I-B^19ȩ"4۽en^S(TrFIxKǩmV=MON䙧dD 8$?5S4!<ұ6,f]7Ftힵc&TcrbrzT;NMi4jJHVjޜ犂Fff)J0k6zbFRI5 SMM#$B*soZn2)8'fܷz2yހ!GҴ!iȨ8~4##ROk5Vf,I#N\wv^$vv ݽ?޵g(6H!5ñ~Tߩ_5OrO6}]RdukJj}3ZZ0d:WFAR2=Os_]L1MۅXznwOhϸ#G+yC0*r= uy+FJW^O$٧*/'^z=9?:d^oy]9K%B^gQ07uU&h&Fj%P"5W NSE,TMZCҦ4^jMsV<4CGvEs.֓FUI1/ef}!HA@ޥ"4ȾpLrA~}kP.0Y>qz:Wjs#-hx298*GM:j0u.L+s{{g ^x5(p?SYR3 YБUdtOLZ:)MG2s]W5VUҿk6>O9,]4lwR!'>a*{9>i/c/mʹu:;BaT=G_znJ|SPf-584-=EbH4f(@XlH=ڋqܸ$, w#g5a,Ơw?ZU gZewzs^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ɞdy4jiף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{ !9x'[U ؁=z#Idi#3:S I7cӌU|׹J$TN+Jj iIp54ҰX<)IX4yxI&sM-FBqQ搚Lc^@QOԊ*No 5RvV##-FV ֩NA?JYxiXf8I8`ZK}3F8R:`VaOVoi.XvJ';MlkFZ&W$+*VH4l{BZLF{huӯ(鹯`qڭFB.I<=Me؆9؜Mh gV{%wE?Szţ*$=OVRK'ʠd9?AWE 鹕Xցb6nqYYՁ_g[U iUp@q\'^s4<6mFqy{vXYʷ af$ÌIvf6m\>a0\~psR-TfT,ޑ~ERSB5QR=fe,90x*EVZZqP5R+0ST\2sNߝ;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ݚ3Z]b0E 5 ]Ԅ3KH.i(j: zkGt*EjEd٠i괪2TY*O R*ԁ3[FG DAga)l03=г*ZU:\ȣ38"VzcHc ~ q5zgQ\20\!כTlӴS<̚|7 U#qxIPu%NE8NM%ĒGABۻ Ճ`*奜#I(ҺeM `ٔ,>>U9CFJ#+NwKk2]Y0%8<oCZQ4=यe[eNJC[fe-*pqZ+ ls+Lm%у{˗ 0SU$(z{{Vz1wQFMicVN_i:*-HA2Z֫qdbH .$ +UԛQ6"4(zs;W^/[3ϭ(R7+&d٤>85Y}Ōw$&bA vϧq5uF"[3qQ5kDx5fZmuf}ǚj65#LRL23L才MSL.(L5<+hGdijIMHzI&4KM5d1hFl\iBN*%G,U@I'Y>^k.'D)OqYP6OZϚį&j2lќұ7VI(ޢۉf7:{hf>4c2@isLB$Pj:\"L҃Q#:fEv:{yG.,hD #Xڒf5(4b\ӁA=iaC58b,sY.h.iXV%\"G~C5e`{+:楫wD+8trTG}Aڞ"B(cL o_moEsK#">c^yv<qε ([x K ՟cL+n)E=Q#4d4náV ԒfN i۲1J8 5z֩+=QRF>eU%'h苓]8Jżڤ{3P$T+wM-}Xj:T*v4JsJhQ TH֮8f"H3zEy<65hHڙ(٢ BqEƓQZb( EXQEj4QZ"̍^YqҊ*<]^hFU=k>YsPuE酨`iXZ94sK((Fh)sE.jq?Q(j(j.i)N }9,I<\E#(4E8K(amI aE!ӨץWC*ԩE3(uĦYUQA*tQViOa%P=ɢU%fri@*=^~kUFEŋQ"tEEOz(إ6,1Gr*GE2iIB?(TW6ȋQNhѻA'˗݀{j(swF]]s0M4Q_[&\_&ieJ(EeƔQX!Ji+3X:U)l|cR9asyncclick-8.1.7.0-async/examples/imagepipe/example02.jpg000066400000000000000000001143021452710122500232000ustar00rootroot00000000000000JFIF`` XICC_PROFILE HLinomntrRGB XYZ  1acspMSFTIEC sRGB-HP cprtP3desclwtptbkptrXYZgXYZ,bXYZ@dmndTpdmddvuedLview$lumimeas $tech0 rTRC< gTRC< bTRC< textCopyright (c) 1998 Hewlett-Packard CompanydescsRGB IEC61966-2.1sRGB IEC61966-2.1XYZ QXYZ XYZ o8XYZ bXYZ $descIEC http://www.iec.chIEC http://www.iec.chdesc.IEC 61966-2.1 Default RGB colour space - sRGB.IEC 61966-2.1 Default RGB colour space - sRGBdesc,Reference Viewing Condition in IEC61966-2.1,Reference Viewing Condition in IEC61966-2.1view_. \XYZ L VPWmeassig CRT curv #(-27;@EJOTY^chmrw| %+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&IlAe@e Ek*Qw;c*R{Gp@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{GHHKHHIIcIIJ7J}JK KSKKL*LrLMMJMMN%NnNOOIOOP'PqPQQPQQR1R|RSS_SSTBTTU(UuUVV\VVWDWWX/X}XYYiYZZVZZ[E[[\5\\]']x]^^l^__a_``W``aOaabIbbcCccd@dde=eef=ffg=ggh?hhiCiijHjjkOkklWlmm`mnnknooxop+ppq:qqrKrss]sttptu(uuv>vvwVwxxnxy*yyzFz{{c{|!||}A}~~b~#G k͂0WGrׇ;iΉ3dʋ0cʍ1fΏ6n֑?zM _ɖ4 uL$h՛BdҞ@iءG&vVǥ8nRĩ7u\ЭD-u`ֲK³8%yhYѹJº;.! zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖޢ)߯6DScs 2F[p(@Xr4Pm8Ww)KmExifMM*JR(iZ``Р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 \43ACKfh4Ա~i.is@g][iеCA4:2>qcL*ah 7a.iÅJ횵ƈE/ZjʚcIC=)&i搚w)!4AI@4 1ؐpK)~h'qO4vf im7C8?{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@RPzs /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ǚ"*VfYw0rxʉ!&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`#1m~#>.[?y-5$n.X~Ҿ4xdyOQ58W] uJi'1qèC"8}[K<[G}auz|.--RَKf }A#^+8>(Omh?,2E|smF,)1'VYJ>kqM(#YN Fv~_EL5ZJGWͩY5Au 8xp` 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&ݐ[ЇucPt 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(iY)7:Jռ]?Jߵ;hNcqku=vrq'" Zu$ԅR &bkȶc 77Phm#@؝$uEĸܕN4YhPN-:Ӂfh:oV7ׯ8}/p9PћDӁǑ =qӃCnexxFI(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"OR+-gt=͘nEEOSVM#n*zUXf}=*42r KDy%̊#Ebz\}rޅ[k~>N{-^~j(TX|r-QZܺ4?1]FGڻp Z|E J6uC S_SaHf#9ܞ=eMFw:F^A;G"򬤏ڸwfuĊy?tHO<[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 Wgv@zqßL9bI$'|*n҅.oyPWJ kZkb3WaQXۀ{V|/`k?ϩ2ָ ZK f9%KdrI7 Z#y1'UYmXKa誃SVg8?> u&U8;  tS8KZIi` Gcf;nc3yc'$v5,^%ּzuӖ8V -n#QV-5t )W]/\ٳ͵E< ~k>/xkkY _2;¾}jB˟ӇLSOc.{cW?c誴R= ᇵ08HQIY1X^P( JSIEƃqҐ(,G(?{NO4z[Fjx_3I=)DYsOQfR5H SF S(\曚)zPpi ,&J .j0i٦@ {P;ҹ6\"RI0Wi44<5r6R!7ST;Kw!N PJlBR3qP3dԶ4Lipz՗L Q*Ԭ0)T$}*OP8056MUpCd9"O~Rx]Xp{Ak ENuУ;4ZBY9^Uia.m7msd]Gַ\Y7Iַ-N2х6=Tl͜C!q9GSޟt)`lC>JnW̾o{ڭmb\$s28m̨Woϓq{i[Bқ[`ӕ1> xſ /;εB]GQW?zIFJ7|qƪVoV{o,c^dK/C|>ok, 2WSv^ Y קg;`Cڶx)C/;?fV'ֹ I.8Ү-"-yO,?tEm ^O UETUFjx5Z?dN 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ԃWcTnBbQTmP?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,<NHc_W_ӋK 2aEmJ9~Rϔ~x5mx%>=#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~*}0QA?:\MɒO*5SrvghWxCBÚ E{]pVkƉkjt(W!)QON p%¡,V#S+̩-!sFiR@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)3uu\2zGgtl&ﲷ`X*fj/:Ȟ6 e'5i&sqX.^ WF%RއdWG~n8Ԝ]jSүZPzUa%}'ͧٵKHTM[ 1}TWq=tƤ%<( נZiSb@~>>iV\.:!Z\oc4-P׮daSX/ӯz<7mY>m̘3\0se]LPY%AoEUQ^+ lm[Vd8/Iu6m5kS64${@?:&qR&Ik+?9G۔Yl891k)T-6o~Qqwȣ|108yA^6.*gi:,úQ;zV$0mXQE%0qT770Zd8Pu28Q+W/TJh.'qnP6ruS\卢2i9Xy]_hn7ERvEf; jm/h zj֑#.-.VV9/`O խU]lj^b(V84Y_OMN/+ʽR=qej )E?1Ua~A֢UAҗ4jH{dV{< *fҰ/zkzh4a؆HPWFI$TWPӱHM%# >f 4fHq4f3THvi3Mh;8f41٠nh&SO*i)](J;-*`F4FM݀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 66Kty&s[/b.n6y[78UeFA] ].Gm [ףx;@O hc^C4 v9涉>_'dryj`U`Lc\VwEF&cޭBu*hzW`ua"*Ez)_Z3 PT9SkJ\HiG;\LXbf79s?O,AdWI@upCA^wunuI rPF4wo04hݶ%OZB$rsHO}nmM?Q]>񥦋i,$Ku$UO #fbT'xQc!a?lX)- uE^TfU rMҨf2,xK,:0e9|_AִoKieu{s3I=ù e{J~8iEKjPZb\WApBBj0~4gUJQxQs-ͤD]_<=g$7gH*?5e:=Xt6X#$}'-G &VVSEPI2>>ffpy5NcV8re8K-P4lB,nd1og+=X+[#/$(Tswj'|MO5kJQx`T(׸g)/SRME yU"bEsZ| 1ƒ h+UpBA1ߟꪹcI!HA zW+B.RVK͍y7dt4+!ʜ)OWBmHiylh8?q ׭z3Zjt=7\\nE_kLC3}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[:d5uaEUoC+ʦLcm![V⠇H!3ЄOB75V7uEY:-2"ЌUZ&o_=0=j `?Eҹf"ZG Z羻59n$W{X >c'~내LKMQT@WQڅC1A:d$kv>$5:M}*Y4.uk {fIbIJuo\W,\]΁E j5V ] X 8ZhV& W }яQ,yo=j,43Iftu &6GQ0BiiH$\ǥ+6>$sKQN44&"<$gnsQI+;fF,}雫Hƪ6%IFj.7Ty4X 3Fi,Q&h34f&h0\aS٩`k@)sMhK49 CFR 2nٙMk&m\sb_sC= 5JIBXG$4fg=ARҶzw?Z*JFqvQu,s/C޴!=+:~HhWb5BW WucOJOjH"7jaRo+K1+FG' p?JI-̅Fƥ o;??U-Jmbaiӏ5Gq"[[ LF$|ryb?̎X)Hҹy,p+E7#Q45jN92n#JrvFQՙL&9#NN~ws4G #(kNdRST5fS]4W+TƷ)(T<ק< ^[iȲ02A>歨TRZ2_-܅l G$};U?=+N%aY~FDM7F;9|dI\UmV F@y^yVAk*e+^˩IKִ-nZЊ<`*w:շBXdk56D550烑BbJqq6%’ >0/UZKd_I2f:m=bc'u"=*EZrH܎iLj+DuTV2u,gMm9CڑCǡC`T5EWh6!]Y\ZElp㒿A2=O;w2,h#5[=NU" v.NANNkdS4c+ܒ$@e9%p0}A+buf1Sոյ|%p]5LJ+Yw]3P5-b;K-/Gq!>_>&ǣ薒\wQ\\tveO;W_"kVtkz_IX5Īr@6 8dL^$f%A#ӊ}JIۖ(P)UozZ:Z 85V 85f6,nPu.QطGU)qxr)OΣ49ԛ򏐹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̊-֭iDY8QAVTS¨xؒ_n2[֞]kEdf<#BGiس'1ù<6)qLcO&km%8FIOEԬY=tWHH`ARZZGi1ǫZɿY5;[GJ0Tsۢ+j>%+kq;S z{X-}aْC>c.4]6a,`>O+d#XU h_dԭDx6?qǡ&[nm&p#І#ڴLsV_NJfk0iz{ο6O@y k呤ݹ,ܓYT>TU:ՆMF4p߇4{964Ȓ8cPuOֵ ޽:[ ţF>2WUj7'BWv4ϣ!WnzyZK^WÑfcɋYӯotD]͛G(?)A=^t>Ii^Y$L֊&F!@Ub:+lt@3{35˻Hfc'֦)Iy Uޫjݞ=p[<=@FSՒZ MOUEZ}#\׌l,vLaiK;Y86kӕ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(SKկfѮ$mC[?xkWIDS0:`nOކO_E  lUUj5w4vCSU` ō7RXw ѾbmԛԅDnwP[;wQCRu;sSA%sz  8QA]HF1G@*dHUM p*qcl?蠮ۦ<-ɪgB:-X*њɣibWajψMMJш՘کDjfGR%5aOJ>a58ѪUozhK ӃW NEy!o`[sކYrF 5A}yKc 𫞦57ℜ]kNApa9o[k$ckYu42Gm@?@kWK-rurhqַɕV՚duloxH gsCR][&HWdtjg}uuu%G\ZVVQ͘B犞8 m>K xN$hѵ?TtɍcVy*4tBs8j*t ,qjGƤu:RDTtdo_CJ:}^; }T7G&0$Cч#歹DRE&K61(xe>^7ta;/gu=i;:x_j[d'q#2 kX$EQPM&yLz(ԕة_vJMNc{i ë]-{8eېNߧjهš2nt`Ôj_NqSq07 ]rXXyCcNSΰx9#؎yH{KU:WU|BԭT&wBn׃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/MgpIo" d5\HL%:2: {K$jF\qZ\x8SKV֛wQ7k$3ASg34''7va99;hYcoBE\ȂD(:nph!.Y\)HV"#lNqԟZ?yr]ԹWf^ZR8MƞЬ,>זKۗ#,'Pt=?z]i亨I?56d*iWXsDSq~Vj~}vFMMmmZ0F+VZq,DzoCVI^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 @beIݏ^Z jZ9=pjqPÚQ9fniOs& 7'4CX4d" `2[i׊]9r)G_Σ$I'=˸!✠#N ȅ-L?)ZLɐATT 棘~j$gLٖU\ctҥy67$uIbhE&Ydz^-O Qk) ky<p/0}kV~ctѹK19me%VomӊqͧͶA"~YC5rq^9Ƣ拺9%fTڥ*sgjS-b I8$hwe_pQ2G܏+2*t3F{ wslq|#|#pT)%-ަe Z=L'Gq]u;4'xCjG/ieܖy`z/$]ܢ0#{VBn9N?ʼKGyQ W>լcIȎF0UNյ_AN?]REh.ߍj9_cB 2*}{IIVrXt$tax:!Glܟ˥tN󦳥xoS2WFvEn^ '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^׋& Ӗ**%G5ab>Eg7C"Z>:S*tP)ܹʃ*` 򞝪rRN QYJC8RHTz$g\E:&bsI3mLS_4F:)\#bZxZ-<%tF&lo@Jh߅a ̷Cҵ}~uE_4+1ךh bW5wnAQx:sruE\OzCRDմ)ƜTcpu=rKSk,YOOv.T\zcO'DTOP܂0 ɭ Zol__!G_ʼv[%AuXEDk5_De`T uF$lV̎ (SZm&>Jz~U*);ӕ#߄l$x (*=s DL^$0V|?j$xbmo^*{2i.l:YkQQWza܊m85FI`~&-Ǚt# F½10{,_Ii!0\\}ASq.ǕQmt5z%Q*\c֔#5QRCc_&g\jF*FQAYSDQRAC/hY=Pv*ż۟dcަQNxD#}+79+<.xm;lq0Ag|d,rƸO-3G( B22 vG+ѡM954xE8d޵(j>/*OO֘ISՠhl0\[u.lɳʣRIuB (jV uEP S .8e#vqZV) 0 ' s!˱K/ٮ$*ՒL @_Q?ZĥݚPj# 4Y0aN QN=((jp54y5}C>C у(*AR29QW,林ȉSXΟ6p+-tc+9m²R2f`$$ՁqSx*\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|VZmdk+F˨N\ PUJּNŁ?(X*;(jč ۍ:(R⺚ƣzDG'۠ 6Ong-Ni-z$Վ*+ͭ1 l_&B0O8*ûV{+9-rZ"fwvF\p2p6U fO9O˷/-$/?OΪ ?uR*R}N贺 zVg ӵPqҽJiMY\7$zBc!+J!%*6dLj'8Ɍ[F#ٽ鏇R#pL#<,lm%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*Zy0GV"H1)Aelbe`:zj4=QmsZpڅ}ق(TD\J9Ia*WEkh9Q4ueAwѴced\*K1ltG5P;WRt$zNUȇ¡qXNu"AU.oܑ8s/q.aAze})>? }͒hOZAP5ZY}Mc4ˁ֫&RTEj/ھyVqWd^3Ud.MKb!f 8$>s!ڿAZ `:zUId駫ξi6q#  8+[@p.n6ʃ-AU} MmNi6r1yeܲ*"  1^l㵓9qXXpmMe-D[3]I긫Qg8?B }%\~$fW\t+{]BLu(6[d8#pe[#->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!ju5B6vrUtT*@UeknE TU&zo6"M4&*o}Vް4h$5H==^-J$SR,3q47ި )|ʴ.4u-A$EV]Ԋ3Oc^Jd7fy,hGJgl5`iVzdZo[sDqS!رV@rvQ5]QGeEk!XC|[rʚ3%8\vĬ k]ϒ '?ZK9X1^rm=c,1;t^ ٞ/R}\x!'9Aֻxʺ+FB;6=&][];M:6 ۖ~ESXƥD|G3_̢BnG< k׾$K@D`HIў߽uz>ck-[\`= -_@t+da^iX9`d*Xv3`&7|Ӵ˭Je M"cv< ?E} pLcu@B3w۞J=qWANҕ-팑W?^=`,{ϥzJzj{ռԨcPS6[>dJX2]nUf\}xRm%V;x%xv61/ x歯/Nm^bj„ݏ+Z}-2[wC曛YTy,~x/~cN,AWei?4duI;3FlkЬ.-eCс=*&RqGTڒ_qj 5OT3Te$kZZf֤G(Uz+5H MK yc`Kn11 Xw4T 5"hԨ+gHPU5Oj8XE*➫OSqLei\EFl9L,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:\*U1U;h5_Y*0Zm#ɩ+"ͥ+^c*Օ88m#RN*NV[(v?-ݔ2۫]|dt9? !VTz^*̲pd5#E^m[>Y?b!OAZk`<΅H ɍWz׵;J5**m̪S'u 枷ռSǴy?݊?UW`U$뼇Gmƫ{v/u4H'`>%b1U((yõõàFC!E { eVrB2~ : ч `Us֭/iȯuk$mp14NH:|pQUnOzw>d(xS#^s$Y}93 k3mwZ0X.A#=uϭzzA2ᢑ_m*ON޵jvvPIp >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!5UL"?jR)1XEGLXƪԊ<¹Md[)h\QUJ׊i@LWSonQ*ֳtH];~&WE%z;y<1b <F)hjv?v2{U`ko]@a~Me(ٝP|4u)-#2!ICZꖎ?l>1\lS i4Dsj2n#jַ[)cq=NvJ.Kr^F,5KU ƖK-/Fc%FSNTL&J)DZ-M-JXh Pnu>Pc֜4V-GT]n>#RUکLy NTjZd$o>zm5]Uⱞ{5BƆjDv'ScS,>բ0cRGiA>S:`TY#;hcrQ6; !?xWo9/O>ҷ@qv칷%<~n_}$c69&*8V99`~_/":WdːA,D?t OTtү}"uV:֋ǟWtu)ZԶ%cWڵ"]СVb- Ε_1SD\ї0Xy[U[x;trՑnҞ)-;U4cRF%s8h6:Ҝj&YI=H撔i`+Q TEYYG~=ڲX.$Cwo4{4r?2Jzj#]N$^ZˢY6CLIW?C/QiZj- ud7vˍ-Wđl~WRF*KQ<`\#gslp\&GUa|IőnL}De%'H]zuq<Yv:"IFWvzWWũAh;ĩ\wAk_> =V>~ͷ;xV8Fz>F5=iOzm g7hF[iݫ(+7>]'BP}`u=7z,݉iTgb^jRXfK ;!Ζ͑EpM-qhyըakiHJfpڞU&CY9TXEJ"8GY9%.ڟe)\9v ՂI̹* 1gCU=?ֻ '`yt )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?`ѼRnsIEnF˱'޳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 \MH# ,NN/] 9JҬ @k7C6ߊո;a֩e9MCzjq,-"#\[-}#NCZr8(33bzi(=EE3JIs'SQǽU\qqaljzi[Q7pQZerK 6QVji|1{RrZƸclIs7hP;J{i*'z]Eؕ䨚Jޣ/Z$;)UaJ_ސjL wEz2h n4`.iCTYu*҃41X5HUTEj[*LPЋ2TUz =^#6&Ű櫡&ZʘOUxD\֝I9^Қf3WԸS*SP˹HaV?jfaG?ZY2FOl!Κ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]tXvCJu1#'$@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<%HbbJ0̈́gz~UБ*+wuLG~s\ 5zjv'FS׶~wMN[I؏Csҕ/.Fs"vS5X5N\JEHri94V ȳl5`"m"0+z.Sg jcRM&%qҢaJj&Ⱃ)2'PLVw4LJnjg|߅ic_W~a5Ey @Ʀk QkNԎ9:}V?~3G bőx[;?AcutYKGq7Wc~avNբ<ʺuمmŶ e̸OWD OjξI,$eNFq?J̯J4­{ҠqZv}mEP,$j,xӤ9d;Lo }B*jSi泸@qC[qөKY9qY-zӡx:ƲJ2C%֋rl.ՏqỀY+rSMnQ*UED..a`RiXj=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-[/&qV{If(RcQEգϮ8 &hXǴ4k#F*U>àZcǾxfmqw`r (ĵd'L] ƥY,i7nE{{ٝ~2ܑ?gY,!Hқo-4QX'Q;&Ӳ5LVc(asyncclick-8.1.7.0-async/examples/imagepipe/imagepipe.py000066400000000000000000000201171452710122500232130ustar00rootroot00000000000000from functools import update_wrapper from PIL import Image from PIL import ImageEnhance from PIL import ImageFilter import asyncclick as click @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.result_callback() 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): yield from stream yield from f(*args, **kwargs) 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(f"Opening '{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(f"Could not open image '{image}': {e}", err=True) @cli.command("save") @click.option( "--filename", default="processed-{:04}.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.format(idx + 1) click.echo(f"Saving '{image.filename}' as '{fn}'") yield image.save(fn) except Exception as e: click.echo(f"Could not save image '{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(f"Displaying '{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(f"Resizing '{image.filename}' to {w}x{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(f"Cropping '{image.filename}' by {border}px") 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(f"invalid rotation '{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(f"invalid flip '{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(f"Rotate '{image.filename}' by {degrees}deg") image = copy_filename(image.transpose(mode), image) if flip is not None: mode, direction = flip click.echo(f"Flip '{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(f"Blurring '{image.filename}' by {radius}px") 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( f"Smoothening {image.filename!r} {iterations}" f" time{'s' if iterations != 1 else ''}" ) for _ in range(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(f"Embossing '{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(f"Sharpen '{image.filename}' by {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(f"Paste '{to_paste.filename}' on '{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 += f"+{to_paste.filename}" yield image yield from imageiter asyncclick-8.1.7.0-async/examples/imagepipe/setup.py000066400000000000000000000004351452710122500224140ustar00rootroot00000000000000from 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 """, ) asyncclick-8.1.7.0-async/examples/inout/000077500000000000000000000000001452710122500200765ustar00rootroot00000000000000asyncclick-8.1.7.0-async/examples/inout/README000066400000000000000000000003541452710122500207600ustar00rootroot00000000000000$ 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 asyncclick-8.1.7.0-async/examples/inout/inout.py000066400000000000000000000013401452710122500216040ustar00rootroot00000000000000import asyncclick as 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() asyncclick-8.1.7.0-async/examples/inout/setup.py000066400000000000000000000004031452710122500216050ustar00rootroot00000000000000from 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 """, ) asyncclick-8.1.7.0-async/examples/naval/000077500000000000000000000000001452710122500200415ustar00rootroot00000000000000asyncclick-8.1.7.0-async/examples/naval/README000066400000000000000000000005421452710122500207220ustar00rootroot00000000000000$ 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 asyncclick-8.1.7.0-async/examples/naval/naval.py000066400000000000000000000032571452710122500215230ustar00rootroot00000000000000import asyncclick as 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(f"Created ship {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(f"Moving ship {ship} to {x},{y} with speed {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(f"Ship {ship} fires to {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(f"Set {ty} mine at {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(f"Removed mine at {x},{y}") asyncclick-8.1.7.0-async/examples/naval/setup.py000066400000000000000000000004031452710122500215500ustar00rootroot00000000000000from 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 """, ) asyncclick-8.1.7.0-async/examples/repo/000077500000000000000000000000001452710122500177055ustar00rootroot00000000000000asyncclick-8.1.7.0-async/examples/repo/README000066400000000000000000000002311452710122500205610ustar00rootroot00000000000000$ repo_ repo is a simple example of an application that looks and works similar to hg or git. Usage: $ pip install --editable . $ repo --help asyncclick-8.1.7.0-async/examples/repo/repo.py000066400000000000000000000111731452710122500212270ustar00rootroot00000000000000import os import posixpath import sys import asyncclick as click class Repo: 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(f" config[{key}] = {value}", file=sys.stderr) def __repr__(self): return f"" 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(f"Cloning repo {src} to {os.path.basename(dest)}") repo.home = dest if shallow: click.echo("Making shallow checkout") click.echo(f"Checking out revision {rev}") @cli.command() @click.confirmation_option() @pass_repo def delete(repo): """Deletes a repository. This will throw away the current repository. """ click.echo(f"Destroying repo {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(f"# U {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(f"Files to be committed: {files}") click.echo(f"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(f"Copy from {fn} -> {dst}") asyncclick-8.1.7.0-async/examples/repo/setup.py000066400000000000000000000003771452710122500214260ustar00rootroot00000000000000from 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 """, ) asyncclick-8.1.7.0-async/examples/termui/000077500000000000000000000000001452710122500202455ustar00rootroot00000000000000asyncclick-8.1.7.0-async/examples/termui/README000066400000000000000000000002171452710122500211250ustar00rootroot00000000000000$ termui_ termui showcases the different terminal UI helpers that Click provides. Usage: $ pip install --editable . $ termui --help asyncclick-8.1.7.0-async/examples/termui/setup.py000066400000000000000000000004071452710122500217600ustar00rootroot00000000000000from setuptools import setup setup( name="click-example-termui", version="1.0", py_modules=["termui"], include_package_data=True, install_requires=["click"], entry_points=""" [console_scripts] termui=termui:cli """, ) asyncclick-8.1.7.0-async/examples/termui/termui.py000066400000000000000000000101041452710122500221200ustar00rootroot00000000000000import math import random import time import asyncclick as click @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(f"I am colored {color}", fg=color)) click.echo(click.style(f"I am background colored {color}", bg=color)) @cli.command() def pager(): """Demonstrates using the pager.""" lines = [] for x in range(200): lines.append(f"{click.style(str(x), fg='green')}. Hello World!") 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(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 f"Item #{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("█", 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.0 / 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("█", 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(f"\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(f"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 True: 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 asyncclick-8.1.7.0-async/examples/validation/000077500000000000000000000000001452710122500210725ustar00rootroot00000000000000asyncclick-8.1.7.0-async/examples/validation/README000066400000000000000000000003611452710122500217520ustar00rootroot00000000000000$ 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 asyncclick-8.1.7.0-async/examples/validation/setup.py000066400000000000000000000004271452710122500226070ustar00rootroot00000000000000from 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 """, ) asyncclick-8.1.7.0-async/examples/validation/validation.py000066400000000000000000000026151452710122500236020ustar00rootroot00000000000000from urllib import parse as urlparse import asyncclick as click 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( f"invalid URL scheme ({value.scheme}). Only HTTP URLs are allowed", 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(f"count: {count}") click.echo(f"foo: {foo}") click.echo(f"url: {url!r}") asyncclick-8.1.7.0-async/requirements/000077500000000000000000000000001452710122500176455ustar00rootroot00000000000000asyncclick-8.1.7.0-async/requirements/build.in000066400000000000000000000000061452710122500212700ustar00rootroot00000000000000build asyncclick-8.1.7.0-async/requirements/build.txt000066400000000000000000000004111452710122500215010ustar00rootroot00000000000000# SHA1:80754af91bfb6d1073585b046fe0a474ce868509 # # This file is autogenerated by pip-compile-multi # To update, run: # # pip-compile-multi # build==0.10.0 # via -r requirements/build.in packaging==23.1 # via build pyproject-hooks==1.0.0 # via build asyncclick-8.1.7.0-async/requirements/dev.in000066400000000000000000000001051452710122500207470ustar00rootroot00000000000000-r docs.in -r tests.in -r typing.in pip-compile-multi pre-commit tox asyncclick-8.1.7.0-async/requirements/dev.txt000066400000000000000000000021671452710122500211720ustar00rootroot00000000000000# SHA1:54b5b77ec8c7a0064ffa93b2fd16cb0130ba177c # # This file is autogenerated by pip-compile-multi # To update, run: # # pip-compile-multi # -r docs.txt -r tests.txt -r typing.txt build==0.10.0 # via pip-tools cachetools==5.3.1 # via tox cfgv==3.3.1 # via pre-commit chardet==5.1.0 # via tox click==8.1.3 # via # pip-compile-multi # pip-tools colorama==0.4.6 # via tox distlib==0.3.6 # via virtualenv filelock==3.12.2 # via # tox # virtualenv identify==2.5.24 # via pre-commit pip-compile-multi==2.6.3 # via -r requirements/dev.in pip-tools==6.13.0 # via pip-compile-multi platformdirs==3.8.0 # via # tox # virtualenv pre-commit==3.3.3 # via -r requirements/dev.in pyproject-api==1.5.2 # via tox pyproject-hooks==1.0.0 # via build pyyaml==6.0 # via pre-commit toposort==1.10 # via pip-compile-multi tox==4.6.3 # via -r requirements/dev.in virtualenv==20.23.1 # via # pre-commit # tox wheel==0.40.0 # via pip-tools # The following packages are considered to be unsafe in a requirements file: # pip # setuptools asyncclick-8.1.7.0-async/requirements/docs.in000066400000000000000000000001211452710122500211170ustar00rootroot00000000000000Pallets-Sphinx-Themes Sphinx sphinx-issues sphinxcontrib-log-cabinet sphinx-tabs asyncclick-8.1.7.0-async/requirements/docs.txt000066400000000000000000000026021452710122500213360ustar00rootroot00000000000000# SHA1:34fd4ca6516e97c7348e6facdd9c4ebb68209d1c # # This file is autogenerated by pip-compile-multi # To update, run: # # pip-compile-multi # alabaster==0.7.13 # via sphinx babel==2.12.1 # via sphinx certifi==2023.5.7 # via requests charset-normalizer==3.1.0 # via requests docutils==0.18.1 # via # sphinx # sphinx-tabs idna==3.4 # via requests imagesize==1.4.1 # via sphinx jinja2==3.1.2 # via sphinx markupsafe==2.1.3 # via jinja2 packaging==23.1 # via # pallets-sphinx-themes # sphinx pallets-sphinx-themes==2.1.1 # via -r requirements/docs.in pygments==2.15.1 # via # sphinx # sphinx-tabs requests==2.31.0 # via sphinx snowballstemmer==2.2.0 # via sphinx sphinx==7.0.1 # via # -r requirements/docs.in # pallets-sphinx-themes # sphinx-issues # sphinx-tabs # sphinxcontrib-log-cabinet sphinx-issues==3.0.1 # via -r requirements/docs.in sphinx-tabs==3.4.1 # via -r requirements/docs.in sphinxcontrib-applehelp==1.0.4 # via sphinx sphinxcontrib-devhelp==1.0.2 # via sphinx sphinxcontrib-htmlhelp==2.0.1 # via sphinx sphinxcontrib-jsmath==1.0.1 # via sphinx sphinxcontrib-log-cabinet==1.0.1 # via -r requirements/docs.in sphinxcontrib-qthelp==1.0.3 # via sphinx sphinxcontrib-serializinghtml==1.1.5 # via sphinx urllib3==2.0.3 # via requests asyncclick-8.1.7.0-async/requirements/tests.in000066400000000000000000000000071452710122500213340ustar00rootroot00000000000000pytest asyncclick-8.1.7.0-async/requirements/tests.txt000066400000000000000000000004441452710122500215520ustar00rootroot00000000000000# SHA1:0eaa389e1fdb3a1917c0f987514bd561be5718ee # # This file is autogenerated by pip-compile-multi # To update, run: # # pip-compile-multi # iniconfig==2.0.0 # via pytest packaging==23.1 # via pytest pluggy==1.2.0 # via pytest pytest==7.4.0 # via -r requirements/tests.in asyncclick-8.1.7.0-async/requirements/typing.in000066400000000000000000000000151452710122500215030ustar00rootroot00000000000000mypy pyright asyncclick-8.1.7.0-async/requirements/typing.txt000066400000000000000000000007001452710122500217150ustar00rootroot00000000000000# SHA1:0d25c235a98f3c8c55aefb59b91c82834e185f0a # # This file is autogenerated by pip-compile-multi # To update, run: # # pip-compile-multi # mypy==1.4.1 # via -r requirements/typing.in mypy-extensions==1.0.0 # via mypy nodeenv==1.8.0 # via pyright pyright==1.1.317 # via -r requirements/typing.in typing-extensions==4.6.3 # via mypy # The following packages are considered to be unsafe in a requirements file: # setuptools asyncclick-8.1.7.0-async/setup.cfg000066400000000000000000000055001452710122500167430ustar00rootroot00000000000000[metadata] name = asyncclick # version = attr: click.__version__ url = https://palletsprojects.com/p/click/ project_urls = Source Code = https://github.com/python-trio/asyncclick Issue Tracker = https://github.com/python-trio/asyncclick/issues/ license = BSD-3-Clause license_files = LICENSE.rst author = Matthias Urlichs author_email = description = Composable command line interface toolkit, async version # Donate = https://palletsprojects.com/donate # Documentation = https://click.palletsprojects.com/ # Changes = https://click.palletsprojects.com/changes/ # Source Code = https://github.com/pallets/click/ # Issue Tracker = https://github.com/pallets/click/issues/ # Chat = https://discord.gg/pallets #license = BSD-3-Clause #license_files = LICENSE.rst #maintainer = Pallets #maintainer_email = contact@palletsprojects.com #description = Composable command line interface toolkit long_description = file: README.rst long_description_content_type = text/x-rst classifiers = Development Status :: 5 - Production/Stable Intended Audience :: Developers License :: OSI Approved :: BSD License Operating System :: OS Independent Programming Language :: Python [options] packages = find: package_dir = = src include_package_data = True python_requires = >= 3.7 # Dependencies are in setup.py for GitHub's dependency graph. [options.packages.find] where = src include = asyncclick [tool:pytest] testpaths = tests filterwarnings = error [coverage:run] branch = True source = asyncclick tests [coverage:paths] source = src */site-packages [flake8] # B = bugbear # E = pycodestyle errors # F = flake8 pyflakes # W = pycodestyle warnings # B9 = bugbear opinions # ISC = implicit str concat select = B, E, F, W, B9, ISC ignore = # slice notation whitespace, invalid E203 # line length, handled by bugbear B950 E501 # bare except, handled by bugbear B001 E722 # bin op line break, invalid W503 # zip with strict=, requires python >= 3.10 B905 # string formatting opinion, B028 renamed to B907 B028 B907 # up to 88 allowed by bugbear B950 max-line-length = 80 per-file-ignores = # __init__ exports names src/asyncclick/__init__.py: F401 [mypy] files = src/asyncclick python_version = 3.7 show_error_codes = True disallow_subclassing_any = True disallow_untyped_calls = True disallow_untyped_defs = True disallow_incomplete_defs = True disallow_any_generics = True check_untyped_defs = True no_implicit_optional = True local_partial_types = True no_implicit_reexport = True strict_equality = True warn_redundant_casts = True warn_unused_configs = True warn_unused_ignores = True warn_return_any = True warn_unreachable = True [mypy-colorama.*] ignore_missing_imports = True [mypy-importlib_metadata.*] ignore_missing_imports = True asyncclick-8.1.7.0-async/setup.py000066400000000000000000000005231452710122500166340ustar00rootroot00000000000000from setuptools import setup setup( name="asyncclick", use_scm_version={"version_scheme": "guess-next-dev", "local_scheme": "dirty-tag"}, setup_requires=["setuptools_scm"], install_requires=[ "anyio", "colorama; platform_system == 'Windows'", "importlib-metadata; python_version < '3.8'", ], ) asyncclick-8.1.7.0-async/src/000077500000000000000000000000001452710122500157115ustar00rootroot00000000000000asyncclick-8.1.7.0-async/src/asyncclick/000077500000000000000000000000001452710122500200345ustar00rootroot00000000000000asyncclick-8.1.7.0-async/src/asyncclick/__init__.py000066400000000000000000000061021452710122500221440ustar00rootroot00000000000000""" 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. """ from .core import Argument as Argument from .core import BaseCommand as BaseCommand from .core import Command as Command from .core import CommandCollection as CommandCollection from .core import Context as Context from .core import Group as Group from .core import MultiCommand as MultiCommand from .core import Option as Option from .core import Parameter as Parameter from .decorators import argument as argument from .decorators import command as command from .decorators import confirmation_option as confirmation_option from .decorators import group as group from .decorators import help_option as help_option from .decorators import make_pass_decorator as make_pass_decorator from .decorators import option as option from .decorators import pass_context as pass_context from .decorators import pass_obj as pass_obj from .decorators import password_option as password_option from .decorators import version_option as version_option from .exceptions import Abort as Abort from .exceptions import BadArgumentUsage as BadArgumentUsage from .exceptions import BadOptionUsage as BadOptionUsage from .exceptions import BadParameter as BadParameter from .exceptions import ClickException as ClickException from .exceptions import FileError as FileError from .exceptions import MissingParameter as MissingParameter from .exceptions import NoSuchOption as NoSuchOption from .exceptions import UsageError as UsageError from .formatting import HelpFormatter as HelpFormatter from .formatting import wrap_text as wrap_text from .globals import get_current_context as get_current_context from .parser import OptionParser as OptionParser from .termui import clear as clear from .termui import confirm as confirm from .termui import echo_via_pager as echo_via_pager from .termui import edit as edit from .termui import getchar as getchar from .termui import launch as launch from .termui import pause as pause from .termui import progressbar as progressbar from .termui import prompt as prompt from .termui import secho as secho from .termui import style as style from .termui import unstyle as unstyle from .types import BOOL as BOOL from .types import Choice as Choice from .types import DateTime as DateTime from .types import File as File from .types import FLOAT as FLOAT from .types import FloatRange as FloatRange from .types import INT as INT from .types import IntRange as IntRange from .types import ParamType as ParamType from .types import Path as Path from .types import STRING as STRING from .types import Tuple as Tuple from .types import UNPROCESSED as UNPROCESSED from .types import UUID as UUID from .utils import echo as echo from .utils import format_filename as format_filename from .utils import get_app_dir as get_app_dir from .utils import get_binary_stream as get_binary_stream from .utils import get_text_stream as get_text_stream from .utils import open_file as open_file __version__ = "8.1.7" asyncclick-8.1.7.0-async/src/asyncclick/_compat.py000066400000000000000000000444701452710122500220410ustar00rootroot00000000000000import codecs import io import os import re import sys import typing as t from weakref import WeakKeyDictionary CYGWIN = sys.platform.startswith("cygwin") WIN = sys.platform.startswith("win") auto_wrap_for_ansi: t.Optional[t.Callable[[t.TextIO], t.TextIO]] = None _ansi_re = re.compile(r"\033\[[;?0-9]*[a-zA-Z]") def _make_text_stream( stream: t.BinaryIO, encoding: t.Optional[str], errors: t.Optional[str], force_readable: bool = False, force_writable: bool = False, ) -> t.TextIO: 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: str) -> bool: """Checks if a given encoding is ascii.""" try: return codecs.lookup(encoding).name == "ascii" except LookupError: return False def get_best_encoding(stream: t.IO[t.Any]) -> str: """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: t.BinaryIO, encoding: t.Optional[str], errors: t.Optional[str], force_readable: bool = False, force_writable: bool = False, **extra: t.Any, ) -> None: self._stream = stream = t.cast( t.BinaryIO, _FixupStream(stream, force_readable, force_writable) ) super().__init__(stream, encoding, errors, **extra) def __del__(self) -> None: try: self.detach() except Exception: pass def isatty(self) -> bool: # https://bitbucket.org/pypy/pypy/issue/1803 return self._stream.isatty() class _FixupStream: """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: t.BinaryIO, force_readable: bool = False, force_writable: bool = False, ): self._stream = stream self._force_readable = force_readable self._force_writable = force_writable def __getattr__(self, name: str) -> t.Any: return getattr(self._stream, name) def read1(self, size: int) -> bytes: f = getattr(self._stream, "read1", None) if f is not None: return t.cast(bytes, f(size)) return self._stream.read(size) def readable(self) -> bool: if self._force_readable: return True x = getattr(self._stream, "readable", None) if x is not None: return t.cast(bool, x()) try: self._stream.read(0) except Exception: return False return True def writable(self) -> bool: if self._force_writable: return True x = getattr(self._stream, "writable", None) if x is not None: return t.cast(bool, x()) try: self._stream.write("") # type: ignore except Exception: try: self._stream.write(b"") except Exception: return False return True def seekable(self) -> bool: x = getattr(self._stream, "seekable", None) if x is not None: return t.cast(bool, x()) try: self._stream.seek(self._stream.tell()) except Exception: return False return True def _is_binary_reader(stream: t.IO[t.Any], default: bool = False) -> bool: 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: t.IO[t.Any], default: bool = False) -> bool: try: stream.write(b"") except Exception: try: stream.write("") return False except Exception: pass return default return True def _find_binary_reader(stream: t.IO[t.Any]) -> t.Optional[t.BinaryIO]: # 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 t.cast(t.BinaryIO, 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 t.cast(t.BinaryIO, buf) return None def _find_binary_writer(stream: t.IO[t.Any]) -> t.Optional[t.BinaryIO]: # 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_writer(stream, False): return t.cast(t.BinaryIO, 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 t.cast(t.BinaryIO, buf) return None def _stream_is_misconfigured(stream: t.TextIO) -> bool: """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_compat_stream_attr(stream: t.TextIO, attr: str, value: t.Optional[str]) -> bool: """A stream attribute is compatible if it is equal to the desired value or the desired value is unset and the attribute has a value. """ stream_value = getattr(stream, attr, None) return stream_value == value or (value is None and stream_value is not None) def _is_compatible_text_stream( stream: t.TextIO, encoding: t.Optional[str], errors: t.Optional[str] ) -> bool: """Check if a stream's encoding and errors attributes are compatible with the desired values. """ return _is_compat_stream_attr( stream, "encoding", encoding ) and _is_compat_stream_attr(stream, "errors", errors) def _force_correct_text_stream( text_stream: t.IO[t.Any], encoding: t.Optional[str], errors: t.Optional[str], is_binary: t.Callable[[t.IO[t.Any], bool], bool], find_binary: t.Callable[[t.IO[t.Any]], t.Optional[t.BinaryIO]], force_readable: bool = False, force_writable: bool = False, ) -> t.TextIO: if is_binary(text_stream, False): binary_reader = t.cast(t.BinaryIO, text_stream) else: text_stream = t.cast(t.TextIO, text_stream) # If the stream looks compatible, and won't default to a # misconfigured ascii encoding, return it as-is. if _is_compatible_text_stream(text_stream, encoding, errors) and not ( encoding is None and _stream_is_misconfigured(text_stream) ): return text_stream # Otherwise, get the underlying binary reader. possible_binary_reader = find_binary(text_stream) # If that's not possible, silently use the original reader # and get mojibake instead of exceptions. if possible_binary_reader is None: return text_stream binary_reader = possible_binary_reader # Default errors to replace instead of strict in order to get # something that works. if errors is None: errors = "replace" # Wrap the binary stream in a text stream with the correct # encoding parameters. return _make_text_stream( binary_reader, encoding, errors, force_readable=force_readable, force_writable=force_writable, ) def _force_correct_text_reader( text_reader: t.IO[t.Any], encoding: t.Optional[str], errors: t.Optional[str], force_readable: bool = False, ) -> t.TextIO: return _force_correct_text_stream( text_reader, encoding, errors, _is_binary_reader, _find_binary_reader, force_readable=force_readable, ) def _force_correct_text_writer( text_writer: t.IO[t.Any], encoding: t.Optional[str], errors: t.Optional[str], force_writable: bool = False, ) -> t.TextIO: return _force_correct_text_stream( text_writer, encoding, errors, _is_binary_writer, _find_binary_writer, force_writable=force_writable, ) def get_binary_stdin() -> t.BinaryIO: 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() -> t.BinaryIO: 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() -> t.BinaryIO: 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: t.Optional[str] = None, errors: t.Optional[str] = None ) -> t.TextIO: 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: t.Optional[str] = None, errors: t.Optional[str] = None ) -> t.TextIO: 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: t.Optional[str] = None, errors: t.Optional[str] = None ) -> t.TextIO: 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 _wrap_io_open( file: t.Union[str, "os.PathLike[str]", int], mode: str, encoding: t.Optional[str], errors: t.Optional[str], ) -> t.IO[t.Any]: """Handles not passing ``encoding`` and ``errors`` in binary mode.""" if "b" in mode: return open(file, mode) return open(file, mode, encoding=encoding, errors=errors) def open_stream( filename: "t.Union[str, os.PathLike[str]]", mode: str = "r", encoding: t.Optional[str] = None, errors: t.Optional[str] = "strict", atomic: bool = False, ) -> t.Tuple[t.IO[t.Any], bool]: binary = "b" in mode filename = os.fspath(filename) # Standard streams first. These are simple because they ignore the # atomic flag. Use fsdecode to handle Path("-"). if os.fsdecode(filename) == "-": if any(m in mode for m in ["w", "a", "x"]): if binary: return get_binary_stdout(), False return get_text_stdout(encoding=encoding, errors=errors), False if binary: 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: return _wrap_io_open(filename, mode, encoding, 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 errno import random try: perm: t.Optional[int] = os.stat(filename).st_mode except OSError: perm = None flags = os.O_RDWR | os.O_CREAT | os.O_EXCL if binary: flags |= getattr(os, "O_BINARY", 0) while True: tmp_filename = os.path.join( os.path.dirname(filename), f".__atomic-write{random.randrange(1 << 32):08x}", ) try: fd = os.open(tmp_filename, flags, 0o666 if perm is None else perm) break except OSError as e: if e.errno == errno.EEXIST or ( os.name == "nt" and e.errno == errno.EACCES and os.path.isdir(e.filename) and os.access(e.filename, os.W_OK) ): continue raise if perm is not None: os.chmod(tmp_filename, perm) # in case perm includes bits in umask f = _wrap_io_open(fd, mode, encoding, errors) af = _AtomicFile(f, tmp_filename, os.path.realpath(filename)) return t.cast(t.IO[t.Any], af), True class _AtomicFile: def __init__(self, f: t.IO[t.Any], tmp_filename: str, real_filename: str) -> None: self._f = f self._tmp_filename = tmp_filename self._real_filename = real_filename self.closed = False @property def name(self) -> str: return self._real_filename def close(self, delete: bool = False) -> None: if self.closed: return self._f.close() os.replace(self._tmp_filename, self._real_filename) self.closed = True def __getattr__(self, name: str) -> t.Any: return getattr(self._f, name) def __enter__(self) -> "_AtomicFile": return self def __exit__(self, exc_type: t.Optional[t.Type[BaseException]], *_: t.Any) -> None: self.close(delete=exc_type is not None) def __repr__(self) -> str: return repr(self._f) def strip_ansi(value: str) -> str: return _ansi_re.sub("", value) def _is_jupyter_kernel_output(stream: t.IO[t.Any]) -> bool: while isinstance(stream, (_FixupStream, _NonClosingTextIOWrapper)): stream = stream._stream return stream.__class__.__module__.startswith("ipykernel.") def should_strip_ansi( stream: t.Optional[t.IO[t.Any]] = None, color: t.Optional[bool] = None ) -> bool: if color is None: if stream is None: stream = sys.stdin return not isatty(stream) and not _is_jupyter_kernel_output(stream) return not color # On Windows, wrap the output streams with colorama to support ANSI # color codes. # NOTE: double check is needed so mypy does not analyze this on Linux if sys.platform.startswith("win") and WIN: from ._winconsole import _get_windows_console_stream def _get_argv_encoding() -> str: import locale return locale.getpreferredencoding() _ansi_stream_wrappers: t.MutableMapping[t.TextIO, t.TextIO] = WeakKeyDictionary() def auto_wrap_for_ansi( # noqa: F811 stream: t.TextIO, color: t.Optional[bool] = None ) -> t.TextIO: """Support ANSI color and style codes on Windows by wrapping a stream with colorama. """ try: cached = _ansi_stream_wrappers.get(stream) except Exception: cached = None if cached is not None: return cached import colorama strip = should_strip_ansi(stream, color) ansi_wrapper = colorama.AnsiToWin32(stream, strip=strip) rv = t.cast(t.TextIO, ansi_wrapper.stream) _write = rv.write def _safe_write(s): try: return _write(s) except BaseException: ansi_wrapper.reset_all() raise rv.write = _safe_write try: _ansi_stream_wrappers[stream] = rv except Exception: pass return rv else: def _get_argv_encoding() -> str: return getattr(sys.stdin, "encoding", None) or sys.getfilesystemencoding() def _get_windows_console_stream( f: t.TextIO, encoding: t.Optional[str], errors: t.Optional[str] ) -> t.Optional[t.TextIO]: return None def term_len(x: str) -> int: return len(strip_ansi(x)) def isatty(stream: t.IO[t.Any]) -> bool: try: return stream.isatty() except Exception: return False def _make_cached_stream_func( src_func: t.Callable[[], t.Optional[t.TextIO]], wrapper_func: t.Callable[[], t.TextIO], ) -> t.Callable[[], t.Optional[t.TextIO]]: cache: t.MutableMapping[t.TextIO, t.TextIO] = WeakKeyDictionary() def func() -> t.Optional[t.TextIO]: stream = src_func() if stream is None: return None try: rv = cache.get(stream) except Exception: rv = None if rv is not None: return rv rv = wrapper_func() try: 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: t.Mapping[str, t.Callable[[], t.BinaryIO]] = { "stdin": get_binary_stdin, "stdout": get_binary_stdout, "stderr": get_binary_stderr, } text_streams: t.Mapping[ str, t.Callable[[t.Optional[str], t.Optional[str]], t.TextIO] ] = { "stdin": get_text_stdin, "stdout": get_text_stdout, "stderr": get_text_stderr, } asyncclick-8.1.7.0-async/src/asyncclick/_termui_impl.py000066400000000000000000000570051452710122500231020ustar00rootroot00000000000000""" 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. """ import contextlib import math import os import sys import time import typing as t from gettext import gettext as _ from io import StringIO from types import TracebackType from ._compat import _default_text_stdout from ._compat import CYGWIN from ._compat import get_best_encoding from ._compat import isatty from ._compat import open_stream from ._compat import strip_ansi from ._compat import term_len from ._compat import WIN from .exceptions import ClickException from .utils import echo V = t.TypeVar("V") if os.name == "nt": BEFORE_BAR = "\r" AFTER_BAR = "\n" else: BEFORE_BAR = "\r\033[?25l" AFTER_BAR = "\033[?25h\n" class ProgressBar(t.Generic[V]): def __init__( self, iterable: t.Optional[t.Iterable[V]], length: t.Optional[int] = None, fill_char: str = "#", empty_char: str = " ", bar_template: str = "%(bar)s", info_sep: str = " ", show_eta: bool = True, show_percent: t.Optional[bool] = None, show_pos: bool = False, item_show_func: t.Optional[t.Callable[[t.Optional[V]], t.Optional[str]]] = None, label: t.Optional[str] = None, file: t.Optional[t.TextIO] = None, color: t.Optional[bool] = None, update_min_steps: int = 1, width: int = 30, ) -> None: 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: str = label or "" if file is None: file = _default_text_stdout() # There are no standard streams attached to write to. For example, # pythonw on Windows. if file is None: file = StringIO() self.file = file self.color = color self.update_min_steps = update_min_steps self._completed_intervals = 0 self.width: int = width self.autowidth: bool = width == 0 if length is None: from operator import length_hint length = length_hint(iterable, -1) if length == -1: length = None if iterable is None: if length is None: raise TypeError("iterable or length is required") iterable = t.cast(t.Iterable[V], range(length)) self.iter: t.Iterable[V] = iter(iterable) self.length = length self.pos = 0 self.avg: t.List[float] = [] self.last_eta: float self.start: float self.start = self.last_eta = time.time() self.eta_known: bool = False self.finished: bool = False self.max_width: t.Optional[int] = None self.entered: bool = False self.current_item: t.Optional[V] = None self.is_hidden: bool = not isatty(self.file) self._last_line: t.Optional[str] = None def __enter__(self) -> "ProgressBar[V]": self.entered = True self.render_progress() return self def __exit__( self, exc_type: t.Optional[t.Type[BaseException]], exc_value: t.Optional[BaseException], tb: t.Optional[TracebackType], ) -> None: self.render_finish() def __iter__(self) -> t.Iterator[V]: if not self.entered: raise RuntimeError("You need to use progress bars in a with block.") self.render_progress() return self.generator() def __next__(self) -> V: # Iteration is defined in terms of a generator function, # returned by iter(self); use that to define next(). This works # because `self.iter` is an iterable consumed by that generator, # so it is re-entry safe. Calling `next(self.generator())` # twice works and does "what you want". return next(iter(self)) def render_finish(self) -> None: if self.is_hidden: return self.file.write(AFTER_BAR) self.file.flush() @property def pct(self) -> float: if self.finished: return 1.0 return min(self.pos / (float(self.length or 1) or 1), 1.0) @property def time_per_iteration(self) -> float: if not self.avg: return 0.0 return sum(self.avg) / float(len(self.avg)) @property def eta(self) -> float: if self.length is not None and not self.finished: return self.time_per_iteration * (self.length - self.pos) return 0.0 def format_eta(self) -> str: 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: return f"{t}d {hours:02}:{minutes:02}:{seconds:02}" else: return f"{hours:02}:{minutes:02}:{seconds:02}" return "" def format_pos(self) -> str: pos = str(self.pos) if self.length is not None: pos += f"/{self.length}" return pos def format_pct(self) -> str: return f"{int(self.pct * 100): 4}%"[1:] def format_bar(self) -> str: if self.length is not None: 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: chars = list(self.empty_char * (self.width or 1)) if self.time_per_iteration != 0: chars[ int( (math.cos(self.pos * self.time_per_iteration) / 2.0 + 0.5) * self.width ) ] = self.fill_char bar = "".join(chars) return bar def format_progress_line(self) -> str: show_percent = self.show_percent info_bits = [] if self.length is not None 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) -> None: import shutil if self.is_hidden: # Only output the label as it changes if the output is not a # TTY. Use file=stderr if you expect to be piping stdout. if self._last_line != self.label: self._last_line = self.label echo(self.label, file=self.file, color=self.color) 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, shutil.get_terminal_size().columns - clutter_length) if new_width < old_width: buf.append(BEFORE_BAR) buf.append(" " * self.max_width) # type: ignore 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: self._last_line = line echo(line, file=self.file, color=self.color, nl=False) self.file.flush() def make_step(self, n_steps: int) -> None: self.pos += n_steps if self.length is not None 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 is not None def update(self, n_steps: int, current_item: t.Optional[V] = None) -> None: """Update the progress bar by advancing a specified number of steps, and optionally set the ``current_item`` for this new position. :param n_steps: Number of steps to advance. :param current_item: Optional item to set as ``current_item`` for the updated position. .. versionchanged:: 8.0 Added the ``current_item`` optional parameter. .. versionchanged:: 8.0 Only render when the number of steps meets the ``update_min_steps`` threshold. """ if current_item is not None: self.current_item = current_item self._completed_intervals += n_steps if self._completed_intervals >= self.update_min_steps: self.make_step(self._completed_intervals) self.render_progress() self._completed_intervals = 0 def finish(self) -> None: self.eta_known = False self.current_item = None self.finished = True def generator(self) -> t.Iterator[V]: """Return a generator which yields the items added to the bar during construction, and updates the progress bar *after* the yielded block returns. """ # WARNING: the iterator interface for `ProgressBar` relies on # this and only works because this is a simple generator which # doesn't create or manage additional state. If this function # changes, the impact should be evaluated both against # `iter(bar)` and `next(bar)`. `next()` in particular may call # `self.generator()` repeatedly, and this must remain safe in # order for that interface to work. if not self.entered: raise RuntimeError("You need to use progress bars in a with block.") if self.is_hidden: yield from self.iter else: for rv in self.iter: self.current_item = rv # This allows show_item_func to be updated before the # item is processed. Only trigger at the beginning of # the update interval. if self._completed_intervals == 0: self.render_progress() yield rv self.update(1) self.finish() self.render_progress() def pager(generator: t.Iterable[str], color: t.Optional[bool] = None) -> None: """Decide what method to use for paging through text.""" stdout = _default_text_stdout() # There are no standard streams attached to write to. For example, # pythonw on Windows. if stdout is None: stdout = StringIO() 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(f'more "{filename}"') == 0: return _pipepager(generator, "more", color) return _nullpager(stdout, generator, color) finally: os.unlink(filename) def _pipepager(generator: t.Iterable[str], cmd: str, color: t.Optional[bool]) -> None: """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 = f"{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) stdin = t.cast(t.BinaryIO, c.stdin) encoding = get_best_encoding(stdin) try: for text in generator: if not color: text = strip_ansi(text) stdin.write(text.encode(encoding, "replace")) except (OSError, KeyboardInterrupt): pass else: 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: t.Iterable[str], cmd: str, color: t.Optional[bool] ) -> None: """Page through text by invoking a program on a temporary file.""" import tempfile fd, filename = tempfile.mkstemp() # 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(f'{cmd} "{filename}"') finally: os.close(fd) os.unlink(filename) def _nullpager( stream: t.TextIO, generator: t.Iterable[str], color: t.Optional[bool] ) -> None: """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: def __init__( self, editor: t.Optional[str] = None, env: t.Optional[t.Mapping[str, str]] = None, require_save: bool = True, extension: str = ".txt", ) -> None: self.editor = editor self.env = env self.require_save = require_save self.extension = extension def get_editor(self) -> str: 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 "sensible-editor", "vim", "nano": if os.system(f"which {editor} >/dev/null 2>&1") == 0: return editor return "vi" def edit_file(self, filename: str) -> None: import subprocess editor = self.get_editor() environ: t.Optional[t.Dict[str, str]] = None if self.env: environ = os.environ.copy() environ.update(self.env) try: c = subprocess.Popen(f'{editor} "{filename}"', env=environ, shell=True) exit_code = c.wait() if exit_code != 0: raise ClickException( _("{editor}: Editing failed").format(editor=editor) ) except OSError as e: raise ClickException( _("{editor}: Editing failed: {e}").format(editor=editor, e=e) ) from e def edit(self, text: t.Optional[t.AnyStr]) -> t.Optional[t.AnyStr]: import tempfile if not text: data = b"" elif isinstance(text, (bytes, bytearray)): data = text else: if text and not text.endswith("\n"): text += "\n" if WIN: data = text.replace("\n", "\r\n").encode("utf-8-sig") else: data = text.encode("utf-8") fd, name = tempfile.mkstemp(prefix="editor-", suffix=self.extension) f: t.BinaryIO try: with os.fdopen(fd, "wb") as f: f.write(data) # If the filesystem resolution is 1 second, like Mac OS # 10.12 Extended, or 2 seconds, like FAT32, and the editor # closes very fast, require_save can fail. Set the modified # time to be 2 seconds in the past to work around this. os.utime(name, (os.path.getatime(name), os.path.getmtime(name) - 2)) # Depending on the resolution, the exact value might not be # recorded, so get the new recorded value. timestamp = os.path.getmtime(name) self.edit_file(name) if self.require_save and os.path.getmtime(name) == timestamp: return None with open(name, "rb") as f: rv = f.read() if isinstance(text, (bytes, bytearray)): return rv return rv.decode("utf-8-sig").replace("\r\n", "\n") # type: ignore finally: os.unlink(name) def open_url(url: str, wait: bool = False, locate: bool = False) -> int: import subprocess def _unquote_file(url: str) -> str: from urllib.parse import unquote if url.startswith("file://"): url = 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.replace('"', "")) args = f'explorer /select,"{url}"' else: url = url.replace('"', "") wait_str = "/WAIT" if wait else "" args = f'start {wait_str} "" "{url}"' return os.system(args) elif CYGWIN: if locate: url = os.path.dirname(_unquote_file(url).replace('"', "")) args = f'cygstart "{url}"' else: url = url.replace('"', "") wait_str = "-w" if wait else "" args = f'cygstart {wait_str} "{url}"' 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: str) -> t.Optional[BaseException]: if ch == "\x03": raise KeyboardInterrupt() if ch == "\x04" and not WIN: # Unix-like, Ctrl+D raise EOFError() if ch == "\x1a" and WIN: # Windows, Ctrl+Z raise EOFError() return None if WIN: import msvcrt @contextlib.contextmanager def raw_terminal() -> t.Iterator[int]: yield -1 def getchar(echo: bool) -> str: # 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`. func: t.Callable[[], str] if echo: func = msvcrt.getwche # type: ignore else: func = msvcrt.getwch # type: ignore rv = func() if rv in ("\x00", "\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() -> t.Iterator[int]: f: t.Optional[t.TextIO] fd: int 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: bool) -> str: with raw_terminal() as fd: ch = os.read(fd, 32).decode(get_best_encoding(sys.stdin), "replace") if echo and isatty(sys.stdout): sys.stdout.write(ch) _translate_ch_to_exc(ch) return ch asyncclick-8.1.7.0-async/src/asyncclick/_textwrap.py000066400000000000000000000025111452710122500224220ustar00rootroot00000000000000import textwrap import typing as t from contextlib import contextmanager class TextWrapper(textwrap.TextWrapper): def _handle_long_word( self, reversed_chunks: t.List[str], cur_line: t.List[str], cur_len: int, width: int, ) -> None: 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: str) -> t.Iterator[None]: 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: str) -> str: rv = [] for idx, line in enumerate(text.splitlines()): indent = self.initial_indent if idx > 0: indent = self.subsequent_indent rv.append(f"{indent}{line}") return "\n".join(rv) asyncclick-8.1.7.0-async/src/asyncclick/_winconsole.py000066400000000000000000000172641452710122500227370ustar00rootroot00000000000000# 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 prompt. import io import sys import time import typing as t from ctypes import byref from ctypes import c_char from ctypes import c_char_p from ctypes import c_int from ctypes import c_ssize_t from ctypes import c_ulong from ctypes import c_void_p from ctypes import POINTER from ctypes import py_object from ctypes import Structure from ctypes.wintypes import DWORD from ctypes.wintypes import HANDLE from ctypes.wintypes import LPCWSTR from ctypes.wintypes import LPWSTR from ._compat import _NonClosingTextIOWrapper assert sys.platform == "win32" import msvcrt # noqa: E402 from ctypes import windll # noqa: E402 from ctypes import WINFUNCTYPE # noqa: E402 c_ssize_p = POINTER(c_ssize_t) kernel32 = windll.kernel32 GetStdHandle = kernel32.GetStdHandle ReadConsoleW = kernel32.ReadConsoleW WriteConsoleW = kernel32.WriteConsoleW GetConsoleMode = kernel32.GetConsoleMode GetLastError = kernel32.GetLastError GetCommandLineW = WINFUNCTYPE(LPWSTR)(("GetCommandLineW", windll.kernel32)) CommandLineToArgvW = WINFUNCTYPE(POINTER(LPWSTR), LPCWSTR, POINTER(c_int))( ("CommandLineToArgvW", windll.shell32) ) LocalFree = WINFUNCTYPE(c_void_p, c_void_p)(("LocalFree", windll.kernel32)) 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 try: from ctypes import pythonapi except ImportError: # On PyPy we cannot get buffers so our ability to operate here is # severely limited. get_buffer = None else: class Py_buffer(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), ] PyObject_GetBuffer = pythonapi.PyObject_GetBuffer PyBuffer_Release = pythonapi.PyBuffer_Release 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): super().isatty() 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( HANDLE(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(f"Windows error: {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 f"Windows error {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( HANDLE(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: def __init__(self, text_stream: t.TextIO, byte_stream: t.BinaryIO) -> None: self._text_stream = text_stream self.buffer = byte_stream @property def name(self) -> str: return self.buffer.name def write(self, x: t.AnyStr) -> int: if isinstance(x, str): return self._text_stream.write(x) try: self.flush() except Exception: pass return self.buffer.write(x) def writelines(self, lines: t.Iterable[t.AnyStr]) -> None: for line in lines: self.write(line) def __getattr__(self, name: str) -> t.Any: return getattr(self._text_stream, name) def isatty(self) -> bool: return self.buffer.isatty() def __repr__(self): return f"" def _get_text_stdin(buffer_stream: t.BinaryIO) -> t.TextIO: text_stream = _NonClosingTextIOWrapper( io.BufferedReader(_WindowsConsoleReader(STDIN_HANDLE)), "utf-16-le", "strict", line_buffering=True, ) return t.cast(t.TextIO, ConsoleStream(text_stream, buffer_stream)) def _get_text_stdout(buffer_stream: t.BinaryIO) -> t.TextIO: text_stream = _NonClosingTextIOWrapper( io.BufferedWriter(_WindowsConsoleWriter(STDOUT_HANDLE)), "utf-16-le", "strict", line_buffering=True, ) return t.cast(t.TextIO, ConsoleStream(text_stream, buffer_stream)) def _get_text_stderr(buffer_stream: t.BinaryIO) -> t.TextIO: text_stream = _NonClosingTextIOWrapper( io.BufferedWriter(_WindowsConsoleWriter(STDERR_HANDLE)), "utf-16-le", "strict", line_buffering=True, ) return t.cast(t.TextIO, ConsoleStream(text_stream, buffer_stream)) _stream_factories: t.Mapping[int, t.Callable[[t.BinaryIO], t.TextIO]] = { 0: _get_text_stdin, 1: _get_text_stdout, 2: _get_text_stderr, } def _is_console(f: t.TextIO) -> bool: if not hasattr(f, "fileno"): return False try: fileno = f.fileno() except (OSError, io.UnsupportedOperation): return False handle = msvcrt.get_osfhandle(fileno) return bool(GetConsoleMode(handle, byref(DWORD()))) def _get_windows_console_stream( f: t.TextIO, encoding: t.Optional[str], errors: t.Optional[str] ) -> t.Optional[t.TextIO]: if ( get_buffer is not None and encoding in {"utf-16-le", None} and errors in {"strict", None} and _is_console(f) ): func = _stream_factories.get(f.fileno()) if func is not None: b = getattr(f, "buffer", None) if b is None: return None return func(b) asyncclick-8.1.7.0-async/src/asyncclick/core.py000066400000000000000000003417611452710122500213520ustar00rootroot00000000000000import anyio import enum import errno import inspect import os import sys import typing as t from collections import abc from contextlib import asynccontextmanager from contextlib import contextmanager from contextlib import AsyncExitStack from contextlib import ExitStack from functools import update_wrapper from gettext import gettext as _ from gettext import ngettext from inspect import iscoroutine from itertools import repeat from types import TracebackType from . import types from .exceptions import Abort from .exceptions import BadParameter from .exceptions import ClickException from .exceptions import Exit from .exceptions import MissingParameter from .exceptions import UsageError from .formatting import HelpFormatter from .formatting import join_options from .globals import pop_context from .globals import push_context from .parser import _flag_needs_value from .parser import OptionParser from .parser import split_opt from .termui import confirm from .termui import prompt from .termui import style from .utils import _detect_program_name from .utils import _expand_args from .utils import echo from .utils import make_default_short_help from .utils import make_str from .utils import PacifyFlushWrapper if t.TYPE_CHECKING: import typing_extensions as te from .shell_completion import CompletionItem F = t.TypeVar("F", bound=t.Callable[..., t.Any]) V = t.TypeVar("V") def _complete_visible_commands( ctx: "Context", incomplete: str ) -> t.Iterator[t.Tuple[str, "Command"]]: """List all the subcommands of a group that start with the incomplete value and aren't hidden. :param ctx: Invocation context for the group. :param incomplete: Value being completed. May be empty. """ multi = t.cast(MultiCommand, ctx.command) for name in multi.list_commands(ctx): if name.startswith(incomplete): command = multi.get_command(ctx, name) if command is not None and not command.hidden: yield name, command def _check_multicommand( base_command: "MultiCommand", cmd_name: str, cmd: "Command", register: bool = False ) -> None: 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( f"{hint}. Command {base_command.name!r} is set to chain and" f" {cmd_name!r} was added as a subcommand but it in itself is a" f" multi command. ({cmd_name!r} is a {type(cmd).__name__}" f" within a chained {type(base_command).__name__} named" f" {base_command.name!r})." ) def batch(iterable: t.Iterable[V], batch_size: int) -> t.List[t.Tuple[V, ...]]: return list(zip(*repeat(iter(iterable), batch_size))) @contextmanager def augment_usage_errors( ctx: "Context", param: t.Optional["Parameter"] = None ) -> t.Iterator[None]: """Context manager that attaches extra information to exceptions.""" 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: t.Sequence["Parameter"], declaration_order: t.Sequence["Parameter"], ) -> t.List["Parameter"]: """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: "Parameter") -> t.Tuple[bool, float]: try: idx: float = invocation_order.index(item) except ValueError: idx = float("inf") return not item.is_eager, idx return sorted(declaration_order, key=sort_key) class ParameterSource(enum.Enum): """This is an :class:`~enum.Enum` that indicates the source of a parameter's value. Use :meth:`click.Context.get_parameter_source` to get the source for a parameter by name. .. versionchanged:: 8.0 Use :class:`~enum.Enum` and drop the ``validate`` method. .. versionchanged:: 8.0 Added the ``PROMPT`` value. """ COMMANDLINE = enum.auto() """The value was provided by the command line args.""" ENVIRONMENT = enum.auto() """The value was provided with an environment variable.""" DEFAULT = enum.auto() """Used the default specified by the parameter.""" DEFAULT_MAP = enum.auto() """Used a default provided by :attr:`Context.default_map`.""" PROMPT = enum.auto() """Used a prompt to confirm a default or provide a value.""" class Context: """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 async context manager in which case it will close any managed contexts, and call :meth:`close` on teardown. :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. :param show_default: Show the default value for commands. If this value is not set, it defaults to the value from the parent context. ``Command.show_default`` overrides this default for the specific command. .. versionchanged:: 8.1 The ``show_default`` parameter is overridden by ``Command.show_default``, instead of the other way around. .. versionchanged:: 8.0 The ``show_default`` parameter defaults to the value from the parent context. .. versionchanged:: 7.1 Added the ``show_default`` parameter. .. versionchanged:: 4.0 Added the ``color``, ``ignore_unknown_options``, and ``max_content_width`` parameters. .. versionchanged:: 3.0 Added the ``allow_extra_args`` and ``allow_interspersed_args`` parameters. .. versionchanged:: 2.0 Added the ``resilient_parsing``, ``help_option_names``, and ``token_normalize_func`` parameters. """ #: The formatter class to create with :meth:`make_formatter`. #: #: .. versionadded:: 8.0 formatter_class: t.Type["HelpFormatter"] = HelpFormatter _async_mgr = None def __init__( self, command: "Command", parent: t.Optional["Context"] = None, info_name: t.Optional[str] = None, obj: t.Optional[t.Any] = None, auto_envvar_prefix: t.Optional[str] = None, default_map: t.Optional[t.MutableMapping[str, t.Any]] = None, terminal_width: t.Optional[int] = None, max_content_width: t.Optional[int] = None, resilient_parsing: bool = False, allow_extra_args: t.Optional[bool] = None, allow_interspersed_args: t.Optional[bool] = None, ignore_unknown_options: t.Optional[bool] = None, help_option_names: t.Optional[t.List[str]] = None, token_normalize_func: t.Optional[t.Callable[[str], str]] = None, color: t.Optional[bool] = None, show_default: t.Optional[bool] = None, ) -> 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 #: Map of parameter names to their parsed values. Parameters #: with ``expose_value=False`` are not stored. self.params: t.Dict[str, t.Any] = {} #: the leftover arguments. self.args: t.List[str] = [] #: 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: t.List[str] = [] #: the collected prefixes of the command's options. self._opt_prefixes: t.Set[str] = set(parent._opt_prefixes) if parent else set() if obj is None and parent is not None: obj = parent.obj #: the user object stored. self.obj: t.Any = obj self._meta: t.Dict[str, t.Any] = getattr(parent, "meta", {}) #: A dictionary (-like object) with defaults for parameters. if ( default_map is None and info_name is not None and parent is not None and parent.default_map is not None ): default_map = parent.default_map.get(info_name) self.default_map: t.Optional[t.MutableMapping[str, t.Any]] = 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:`result_callback`. self.invoked_subcommand: t.Optional[str] = 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: t.Optional[int] = 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: t.Optional[int] = 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: bool = 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: bool = 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: t.List[str] = 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: t.Optional[ t.Callable[[str], str] ] = 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: bool = 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 = ( f"{parent.auto_envvar_prefix}_{self.info_name.upper()}" ) else: auto_envvar_prefix = auto_envvar_prefix.upper() if auto_envvar_prefix is not None: auto_envvar_prefix = auto_envvar_prefix.replace("-", "_") self.auto_envvar_prefix: t.Optional[str] = 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: t.Optional[bool] = color if show_default is None and parent is not None: show_default = parent.show_default #: Show option default values when formatting help text. self.show_default: t.Optional[bool] = show_default self._close_callbacks: t.List[t.Callable[[], t.Any]] = [] self._depth = 0 self._parameter_source: t.Dict[str, ParameterSource] = {} self._exit_stack = ExitStack() async def to_info_dict(self) -> t.Dict[str, t.Any]: """Gather information that could be useful for a tool generating user-facing documentation. This traverses the entire CLI structure. .. code-block:: python with Context(cli) as ctx: info = ctx.to_info_dict() .. versionadded:: 8.0 """ return { "command": await self.command.to_info_dict(self), "info_name": self.info_name, "allow_extra_args": self.allow_extra_args, "allow_interspersed_args": self.allow_interspersed_args, "ignore_unknown_options": self.ignore_unknown_options, "auto_envvar_prefix": self.auto_envvar_prefix, } async def __aenter__(self) -> "AsyncContext": if self._async_mgr is None: self._async_mgr = AsyncExitStack() self._ctx_mgr = await self._async_mgr.__aenter__() self._depth += 1 push_context(self) return self async def __aexit__( self, exc_type: t.Optional[t.Type[BaseException]], exc_value: t.Optional[BaseException], tb: t.Optional[TracebackType], ) -> None: self._depth -= 1 if self._depth == 0: await self._async_mgr.__aexit__(exc_type, exc_value, tb) self.close() pop_context() def with_resource(self, ctx): """See :meth:contextlib.ExitStack.enter_context`.""" return self._ctx_mgr.enter_context(ctx) def with_async_resource(self, ctx): """See :meth:contextlib.ExitStack.enter_async_context`.""" return self._ctx_mgr.enter_async_context(ctx) @asynccontextmanager async def scope(self, cleanup: bool = True) -> t.AsyncIterator["Context"]: """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:: async with ctx.scope(): assert get_current_context() is ctx This is equivalent:: async 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: async with self as rv: yield rv finally: if not cleanup: self._depth -= 1 @property def meta(self) -> t.Dict[str, t.Any]: """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 = f'{__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) -> HelpFormatter: """Creates the :class:`~click.HelpFormatter` for the help and usage output. To quickly customize the formatter class used without overriding this method, set the :attr:`formatter_class` attribute. .. versionchanged:: 8.0 Added the :attr:`formatter_class` attribute. """ return self.formatter_class( width=self.terminal_width, max_width=self.max_content_width ) def with_resource(self, context_manager: t.ContextManager[V]) -> V: """Register a resource as if it were used in a ``with`` statement. The resource will be cleaned up when the context is popped. Uses :meth:`contextlib.ExitStack.enter_context`. It calls the resource's ``__enter__()`` method and returns the result. When the context is popped, it closes the stack, which calls the resource's ``__exit__()`` method. To register a cleanup function for something that isn't a context manager, use :meth:`call_on_close`. Or use something from :mod:`contextlib` to turn it into a context manager first. .. code-block:: python @click.group() @click.option("--name") @click.pass_context def cli(ctx): ctx.obj = ctx.with_resource(connect_db(name)) :param context_manager: The context manager to enter. :return: Whatever ``context_manager.__enter__()`` returns. .. versionadded:: 8.0 """ return self._exit_stack.enter_context(context_manager) def call_on_close(self, f: t.Callable[..., t.Any]) -> t.Callable[..., t.Any]: """Register a function to be called when the context tears down. This can be used to close resources opened during the script execution. Resources that support Python's context manager protocol which would be used in a ``with`` statement should be registered with :meth:`with_resource` instead. :param f: The function to execute on teardown. """ return self._exit_stack.callback(f) def close(self) -> None: """Invoke all close callbacks registered with :meth:`call_on_close`, and exit all context managers entered with :meth:`with_resource`. """ self._exit_stack.close() # In case the context is reused, create a new exit stack. self._exit_stack = ExitStack() @property def command_path(self) -> str: """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: parent_command_path = [self.parent.command_path] if isinstance(self.parent.command, Command): for param in self.parent.command.get_params(self): parent_command_path.extend(param.get_usage_pieces(self)) rv = f"{' '.join(parent_command_path)} {rv}" return rv.lstrip() def find_root(self) -> "Context": """Finds the outermost context.""" node = self while node.parent is not None: node = node.parent return node def find_object(self, object_type: t.Type[V]) -> t.Optional[V]: """Finds the closest object of a given type.""" node: t.Optional["Context"] = self while node is not None: if isinstance(node.obj, object_type): return node.obj node = node.parent return None def ensure_object(self, object_type: t.Type[V]) -> V: """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 @t.overload def lookup_default( self, name: str, call: "te.Literal[True]" = True ) -> t.Optional[t.Any]: ... @t.overload def lookup_default( self, name: str, call: "te.Literal[False]" = ... ) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]: ... def lookup_default(self, name: str, call: bool = True) -> t.Optional[t.Any]: """Get the default for a parameter from :attr:`default_map`. :param name: Name of the parameter. :param call: If the default is a callable, call it. Disable to return the callable instead. .. versionchanged:: 8.0 Added the ``call`` parameter. """ if self.default_map is not None: value = self.default_map.get(name) if call and callable(value): return value() return value return None def fail(self, message: str) -> "te.NoReturn": """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) -> "te.NoReturn": """Aborts the script.""" raise Abort() def exit(self, code: int = 0) -> "te.NoReturn": """Exits the application with a given exit code.""" raise Exit(code) def get_usage(self) -> str: """Helper method to get formatted usage string for the current context and command. """ return self.command.get_usage(self) def get_help(self) -> str: """Helper method to get formatted help page for the current context and command. """ return self.command.get_help(self) def _make_sub_context(self, command: "Command") -> "Context": """Create a new context of the same type as this context, but for a new command. :meta private: """ return type(self)(command, info_name=command.name, parent=self) @t.overload async def invoke( __self, # noqa: B902 __callback: "t.Callable[..., V]", *args: t.Any, **kwargs: t.Any, ) -> V: ... @t.overload async def invoke( __self, # noqa: B902 __callback: "Command", *args: t.Any, **kwargs: t.Any, ) -> t.Any: ... async def invoke( __self, # noqa: B902 __callback: t.Union["Command", "t.Callable[..., V]"], *args: t.Any, **kwargs: t.Any, ) -> t.Union[t.Any, V]: """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`. .. versionchanged:: 8.0 All ``kwargs`` are tracked in :attr:`params` so they will be passed if :meth:`forward` is called at multiple levels. """ if isinstance(__callback, Command): other_cmd = __callback if other_cmd.callback is None: raise TypeError( "The given command does not have a callback that can be invoked." ) else: __callback = t.cast("t.Callable[..., V]", other_cmd.callback) ctx = __self._make_sub_context(other_cmd) for param in other_cmd.params: if param.name not in kwargs and param.expose_value: kwargs[param.name] = param.type_cast_value( # type: ignore ctx, param.get_default(ctx) ) # Track all kwargs as params, so that forward() will pass # them on in subsequent calls. ctx.params.update(kwargs) else: ctx = __self with augment_usage_errors(__self): async with ctx: rv = __callback(*args, **kwargs) if iscoroutine(rv): rv = await rv return rv async def forward( __self, __cmd: "Command", *args: t.Any, **kwargs: t.Any # noqa: B902 ) -> t.Any: """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. .. versionchanged:: 8.0 All ``kwargs`` are tracked in :attr:`params` so they will be passed if ``forward`` is called at multiple levels. """ # Can only forward to other commands, not direct callbacks. 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 await __self.invoke(__cmd, *args, **kwargs) def set_parameter_source(self, name: str, source: ParameterSource) -> None: """Set the source of a parameter. This indicates the location from which the value of the parameter was obtained. :param name: The name of the parameter. :param source: A member of :class:`~click.core.ParameterSource`. """ self._parameter_source[name] = source def get_parameter_source(self, name: str) -> t.Optional[ParameterSource]: """Get the source of a parameter. This indicates the location from which the value of the parameter was obtained. This can be useful for determining when a user specified a value on the command line that is the same as the default value. It will be :attr:`~click.core.ParameterSource.DEFAULT` only if the value was actually taken from the default. :param name: The name of the parameter. :rtype: ParameterSource .. versionchanged:: 8.0 Returns ``None`` if the parameter was not provided from any source. """ return self._parameter_source.get(name) class BaseCommand: """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 context class to create with :meth:`make_context`. #: #: .. versionadded:: 8.0 context_class: t.Type[Context] = Context #: 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: t.Optional[str], context_settings: t.Optional[t.MutableMapping[str, t.Any]] = None, ) -> 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: t.MutableMapping[str, t.Any] = context_settings async def to_info_dict(self, ctx: Context) -> t.Dict[str, t.Any]: """Gather information that could be useful for a tool generating user-facing documentation. This traverses the entire structure below this command. Use :meth:`click.Context.to_info_dict` to traverse the entire CLI structure. :param ctx: A :class:`Context` representing this command. .. versionadded:: 8.0 """ return {"name": self.name} def __repr__(self) -> str: return f"<{self.__class__.__name__} {self.name}>" def get_usage(self, ctx: Context) -> str: raise NotImplementedError("Base commands cannot get usage") def get_help(self, ctx: Context) -> str: raise NotImplementedError("Base commands cannot get help") async def make_context( self, info_name: t.Optional[str], args: t.List[str], parent: t.Optional[Context] = None, **extra: t.Any, ) -> Context: """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. To quickly customize the context class used without overriding this method, set the :attr:`context_class` attribute. :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's usually the name of the script, for commands below it's the name of the command. :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. .. versionchanged:: 8.0 Added the :attr:`context_class` attribute. """ for key, value in self.context_settings.items(): if key not in extra: extra[key] = value ctx = self.context_class( self, info_name=info_name, parent=parent, **extra # type: ignore ) async with ctx.scope(cleanup=False): await self.parse_args(ctx, args) return ctx async def parse_args(self, ctx: Context, args: t.List[str]) -> t.List[str]: """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.") async def invoke(self, ctx: Context) -> t.Any: """Given a context, this invokes the command. The default implementation is raising a not implemented error. """ raise NotImplementedError("Base commands are not invocable by default") def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]: """Return a list of completions for the incomplete value. Looks at the names of chained multi-commands. Any command could be part of a chained multi-command, so sibling commands are valid at any point during command completion. Other command classes will return more completions. :param ctx: Invocation context for this command. :param incomplete: Value being completed. May be empty. .. versionadded:: 8.0 """ from .shell_completion import CompletionItem results: t.List["CompletionItem"] = [] while ctx.parent is not None: ctx = ctx.parent if isinstance(ctx.command, MultiCommand) and ctx.command.chain: results.extend( CompletionItem(name, help=command.get_short_help_str()) for name, command in _complete_visible_commands(ctx, incomplete) if name not in ctx.protected_args ) return results @t.overload async def main( self, args: t.Optional[t.Sequence[str]] = None, prog_name: t.Optional[str] = None, complete_var: t.Optional[str] = None, standalone_mode: "te.Literal[True]" = True, **extra: t.Any, ) -> "te.NoReturn": ... @t.overload async def main( self, args: t.Optional[t.Sequence[str]] = None, prog_name: t.Optional[str] = None, complete_var: t.Optional[str] = None, standalone_mode: bool = ..., **extra: t.Any, ) -> t.Any: ... async def main( self, args: t.Optional[t.Sequence[str]] = None, prog_name: t.Optional[str] = None, complete_var: t.Optional[str] = None, standalone_mode: bool = True, windows_expand_args: bool = True, **extra: t.Any, ) -> t.Any: """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`. :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 windows_expand_args: Expand glob patterns, user dir, and env vars in command line args on Windows. :param extra: extra keyword arguments are forwarded to the context constructor. See :class:`Context` for more information. .. versionchanged:: 8.0.1 Added the ``windows_expand_args`` parameter to allow disabling command line arg expansion on Windows. .. versionchanged:: 8.0 When taking arguments from ``sys.argv`` on Windows, glob patterns, user dir, and env vars are expanded. .. versionchanged:: 3.0 Added the ``standalone_mode`` parameter. """ if args is None: args = sys.argv[1:] if os.name == "nt" and windows_expand_args: args = _expand_args(args) else: args = list(args) if prog_name is None: prog_name = _detect_program_name() # Process shell completion requests and exit early. await self._main_shell_completion(extra, prog_name, complete_var) try: try: async with await self.make_context(prog_name, args, **extra) as ctx: rv = await 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) as e: echo(file=sys.stderr) raise Abort() from e except ClickException as e: if not standalone_mode: raise e.show() sys.exit(e.exit_code) except OSError as e: if e.errno == errno.EPIPE: sys.stdout = t.cast(t.TextIO, PacifyFlushWrapper(sys.stdout)) sys.stderr = t.cast(t.TextIO, 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) async def _main_shell_completion( self, ctx_args: t.MutableMapping[str, t.Any], prog_name: str, complete_var: t.Optional[str] = None, ) -> None: """Check if the shell is asking for tab completion, process that, then exit early. Called from :meth:`main` before the program is invoked. :param prog_name: Name of the executable in the shell. :param complete_var: Name of the environment variable that holds the completion instruction. Defaults to ``_{PROG_NAME}_COMPLETE``. .. versionchanged:: 8.2.0 Dots (``.``) in ``prog_name`` are replaced with underscores (``_``). """ if complete_var is None: complete_name = prog_name.replace("-", "_").replace(".", "_") complete_var = f"_{complete_name}_COMPLETE".upper() instruction = os.environ.get(complete_var) if not instruction: return from .shell_completion import shell_complete rv = await shell_complete(self, ctx_args, prog_name, complete_var, instruction) sys.exit(rv) def __call__(self, *args: t.Any, _anyio_backend: str = None, _anyio_backend_options: dict = {}, **kwargs: t.Any) -> t.Any: """Alias for :meth:`main`.""" main = self.main opts = {} if _anyio_backend: opts["backend"] = _anyio_backend if _anyio_backend_options: opts["backend_options"] = _anyio_backend_options return anyio.run(self._main, main, args, kwargs, **opts) async def _main(self, main, args, kwargs): return await 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. :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 no_args_is_help: this controls what happens if no arguments are provided. This option is disabled by default. If enabled this will add ``--help`` as argument if no arguments are passed :param hidden: hide this command from help outputs. :param deprecated: issues a message indicating that the command is deprecated. .. versionchanged:: 8.1 ``help``, ``epilog``, and ``short_help`` are stored unprocessed, all formatting is done when outputting help text, not at init, and is done even if not using the ``@command`` decorator. .. versionchanged:: 8.0 Added a ``repr`` showing the command name. .. versionchanged:: 7.1 Added the ``no_args_is_help`` parameter. .. versionchanged:: 2.0 Added the ``context_settings`` parameter. """ def __init__( self, name: t.Optional[str], context_settings: t.Optional[t.MutableMapping[str, t.Any]] = None, callback: t.Optional[t.Callable[..., t.Any]] = None, params: t.Optional[t.List["Parameter"]] = None, help: t.Optional[str] = None, epilog: t.Optional[str] = None, short_help: t.Optional[str] = None, options_metavar: t.Optional[str] = "[OPTIONS]", add_help_option: bool = True, no_args_is_help: bool = False, hidden: bool = False, deprecated: bool = False, ) -> None: super().__init__(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: t.List["Parameter"] = params or [] self.help = help self.epilog = epilog self.options_metavar = options_metavar self.short_help = short_help self.add_help_option = add_help_option self.no_args_is_help = no_args_is_help self.hidden = hidden self.deprecated = deprecated async def to_info_dict(self, ctx: Context) -> t.Dict[str, t.Any]: info_dict = await super().to_info_dict(ctx) info_dict.update( params=[await param.to_info_dict() for param in self.get_params(ctx)], help=self.help, epilog=self.epilog, short_help=self.short_help, hidden=self.hidden, deprecated=self.deprecated, ) return info_dict def get_usage(self, ctx: Context) -> str: """Formats the usage line into a string and returns it. Calls :meth:`format_usage` internally. """ formatter = ctx.make_formatter() self.format_usage(ctx, formatter) return formatter.getvalue().rstrip("\n") def get_params(self, ctx: Context) -> t.List["Parameter"]: 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: Context, formatter: HelpFormatter) -> None: """Writes the usage line into the formatter. This is a low-level method called by :meth:`get_usage`. """ pieces = self.collect_usage_pieces(ctx) formatter.write_usage(ctx.command_path, " ".join(pieces)) def collect_usage_pieces(self, ctx: Context) -> t.List[str]: """Returns all the pieces that go into the usage line and returns it as a list of strings. """ rv = [self.options_metavar] if self.options_metavar else [] for param in self.get_params(ctx): rv.extend(param.get_usage_pieces(ctx)) return rv def get_help_option_names(self, ctx: Context) -> t.List[str]: """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 list(all_names) def get_help_option(self, ctx: Context) -> t.Optional["Option"]: """Returns the help option object.""" help_options = self.get_help_option_names(ctx) if not help_options or not self.add_help_option: return None def show_help(ctx: Context, param: "Parameter", value: str) -> None: 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: Context) -> OptionParser: """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: Context) -> str: """Formats the help into a string and returns it. Calls :meth:`format_help` internally. """ formatter = ctx.make_formatter() self.format_help(ctx, formatter) return formatter.getvalue().rstrip("\n") def get_short_help_str(self, limit: int = 45) -> str: """Gets short help for the command or makes it by shortening the long help string. """ if self.short_help: text = inspect.cleandoc(self.short_help) elif self.help: text = make_default_short_help(self.help, limit) else: text = "" if self.deprecated: text = _("(Deprecated) {text}").format(text=text) return text.strip() def format_help(self, ctx: Context, formatter: HelpFormatter) -> None: """Writes the help into the formatter if it exists. This is a low-level method called by :meth:`get_help`. This calls 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: Context, formatter: HelpFormatter) -> None: """Writes the help text to the formatter if it exists.""" if self.help is not None: # truncate the help text to the first form feed text = inspect.cleandoc(self.help).partition("\f")[0] else: text = "" if self.deprecated: text = _("(Deprecated) {text}").format(text=text) if text: formatter.write_paragraph() with formatter.indentation(): formatter.write_text(text) def format_options(self, ctx: Context, formatter: HelpFormatter) -> None: """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: Context, formatter: HelpFormatter) -> None: """Writes the epilog into the formatter if it exists.""" if self.epilog: epilog = inspect.cleandoc(self.epilog) formatter.write_paragraph() with formatter.indentation(): formatter.write_text(epilog) async def parse_args(self, ctx: Context, args: t.List[str]) -> t.List[str]: if not args and self.no_args_is_help and not ctx.resilient_parsing: echo(ctx.get_help(), color=ctx.color) ctx.exit() parser = self.make_parser(ctx) opts, args, param_order = await parser.parse_args(args=args) for param in iter_params_for_processing(param_order, self.get_params(ctx)): value, args = await param.handle_parse_result(ctx, opts, args) if args and not ctx.allow_extra_args and not ctx.resilient_parsing: ctx.fail( ngettext( "Got unexpected extra argument ({args})", "Got unexpected extra arguments ({args})", len(args), ).format(args=" ".join(map(str, args))) ) ctx.args = args ctx._opt_prefixes.update(parser._opt_prefixes) return args async def invoke(self, ctx: Context) -> t.Any: """Given a context, this invokes the attached callback (if it exists) in the right way. """ if self.deprecated: message = _( "DeprecationWarning: The command {name!r} is deprecated." ).format(name=self.name) echo(style(message, fg="red"), err=True) if self.callback is not None: return await ctx.invoke(self.callback, **ctx.params) def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]: """Return a list of completions for the incomplete value. Looks at the names of options and chained multi-commands. :param ctx: Invocation context for this command. :param incomplete: Value being completed. May be empty. .. versionadded:: 8.0 """ from .shell_completion import CompletionItem results: t.List["CompletionItem"] = [] if incomplete and not incomplete[0].isalnum(): for param in self.get_params(ctx): if ( not isinstance(param, Option) or param.hidden or ( not param.multiple and ctx.get_parameter_source(param.name) # type: ignore is ParameterSource.COMMANDLINE ) ): continue results.extend( CompletionItem(name, help=param.help) for name in [*param.opts, *param.secondary_opts] if name.startswith(incomplete) ) results.extend(super().shell_complete(ctx, incomplete)) return results 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. This can be set or changed later with the :meth:`result_callback` decorator. :param attrs: Other command arguments described in :class:`Command`. """ allow_extra_args = True allow_interspersed_args = False def __init__( self, name: t.Optional[str] = None, invoke_without_command: bool = False, no_args_is_help: t.Optional[bool] = None, subcommand_metavar: t.Optional[str] = None, chain: bool = False, result_callback: t.Optional[t.Callable[..., t.Any]] = None, **attrs: t.Any, ) -> None: super().__init__(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 = "COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]..." else: subcommand_metavar = "COMMAND [ARGS]..." self.subcommand_metavar = subcommand_metavar self.chain = chain # The result callback that is stored. This can be set or # overridden with the :func:`result_callback` 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." ) async def to_info_dict(self, ctx: Context) -> t.Dict[str, t.Any]: info_dict = await super().to_info_dict(ctx) commands = {} for name in self.list_commands(ctx): command = self.get_command(ctx, name) if command is None: continue sub_ctx = ctx._make_sub_context(command) async with sub_ctx.scope(cleanup=False): commands[name] = await command.to_info_dict(sub_ctx) info_dict.update(commands=commands, chain=self.chain) return info_dict def collect_usage_pieces(self, ctx: Context) -> t.List[str]: rv = super().collect_usage_pieces(ctx) rv.append(self.subcommand_metavar) return rv def format_options(self, ctx: Context, formatter: HelpFormatter) -> None: super().format_options(ctx, formatter) self.format_commands(ctx, formatter) def result_callback(self, replace: bool = False) -> t.Callable[[F], F]: """Adds a result callback to the 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.result_callback() def process_result(result, input): return result + input :param replace: if set to `True` an already existing result callback will be removed. .. versionchanged:: 8.0 Renamed from ``resultcallback``. .. versionadded:: 3.0 """ def decorator(f: F) -> F: old_callback = self._result_callback if old_callback is None or replace: self._result_callback = f return f def function(__value, *args, **kwargs): # type: ignore inner = old_callback(__value, *args, **kwargs) return f(inner, *args, **kwargs) self._result_callback = rv = update_wrapper(t.cast(F, function), f) return rv return decorator def format_commands(self, ctx: Context, formatter: HelpFormatter) -> None: """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) async def parse_args(self, ctx: Context, args: t.List[str]) -> t.List[str]: if not args and self.no_args_is_help and not ctx.resilient_parsing: echo(ctx.get_help(), color=ctx.color) ctx.exit() rest = await super().parse_args(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 async def invoke(self, ctx: Context) -> t.Any: async def _process_result(value: t.Any) -> t.Any: if self._result_callback is not None: value = await ctx.invoke(self._result_callback, value, **ctx.params) return value if not ctx.protected_args: if self.invoke_without_command: # No subcommand was invoked, so the result callback is # invoked with the group return value for regular # groups, or an empty list for chained groups. async with ctx: rv = await super().invoke(ctx) return await _process_result([] if self.chain else rv) 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. async with ctx: cmd_name, cmd, args = await self.resolve_command(ctx, args) assert cmd is not None ctx.invoked_subcommand = cmd_name await super().invoke(ctx) sub_ctx = await cmd.make_context(cmd_name, args, parent=ctx) async with sub_ctx: return await _process_result(await 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. async with ctx: ctx.invoked_subcommand = "*" if args else None await super().invoke(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 = await self.resolve_command(ctx, args) assert cmd is not None sub_ctx = await 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: async with sub_ctx: rv.append(await sub_ctx.command.invoke(sub_ctx)) return await _process_result(rv) async def resolve_command( self, ctx: Context, args: t.List[str] ) -> t.Tuple[t.Optional[str], t.Optional[Command], t.List[str]]: 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]: await self.parse_args(ctx, ctx.args) ctx.fail(_("No such command {name!r}.").format(name=original_cmd_name)) return cmd_name if cmd else None, cmd, args[1:] def get_command(self, ctx: Context, cmd_name: str) -> t.Optional[Command]: """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: Context) -> t.List[str]: """Returns a list of subcommand names in the order they should appear. """ return [] def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]: """Return a list of completions for the incomplete value. Looks at the names of options, subcommands, and chained multi-commands. :param ctx: Invocation context for this command. :param incomplete: Value being completed. May be empty. .. versionadded:: 8.0 """ from .shell_completion import CompletionItem results = [ CompletionItem(name, help=command.get_short_help_str()) for name, command in _complete_visible_commands(ctx, incomplete) ] results.extend(super().shell_complete(ctx, incomplete)) return results class Group(MultiCommand): """A group allows a command to have subcommands attached. This is the most common way to implement nesting in Click. :param name: The name of the group command. :param commands: A dict mapping names to :class:`Command` objects. Can also be a list of :class:`Command`, which will use :attr:`Command.name` to create the dict. :param attrs: Other command arguments described in :class:`MultiCommand`, :class:`Command`, and :class:`BaseCommand`. .. versionchanged:: 8.0 The ``commands`` argument can be a list of command objects. """ #: If set, this is used by the group's :meth:`command` decorator #: as the default :class:`Command` class. This is useful to make all #: subcommands use a custom command class. #: #: .. versionadded:: 8.0 command_class: t.Optional[t.Type[Command]] = None #: If set, this is used by the group's :meth:`group` decorator #: as the default :class:`Group` class. This is useful to make all #: subgroups use a custom group class. #: #: If set to the special value :class:`type` (literally #: ``group_class = type``), this group's class will be used as the #: default class. This makes a custom group class continue to make #: custom groups. #: #: .. versionadded:: 8.0 group_class: t.Optional[t.Union[t.Type["Group"], t.Type[type]]] = None # Literal[type] isn't valid, so use Type[type] def __init__( self, name: t.Optional[str] = None, commands: t.Optional[ t.Union[t.MutableMapping[str, Command], t.Sequence[Command]] ] = None, **attrs: t.Any, ) -> None: super().__init__(name, **attrs) if commands is None: commands = {} elif isinstance(commands, abc.Sequence): commands = {c.name: c for c in commands if c.name is not None} #: The registered subcommands by their exported names. self.commands: t.MutableMapping[str, Command] = commands def add_command(self, cmd: Command, name: t.Optional[str] = None) -> 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 @t.overload def command(self, __func: t.Callable[..., t.Any]) -> Command: ... @t.overload def command( self, *args: t.Any, **kwargs: t.Any ) -> t.Callable[[t.Callable[..., t.Any]], Command]: ... def command( self, *args: t.Any, **kwargs: t.Any ) -> t.Union[t.Callable[[t.Callable[..., t.Any]], Command], Command]: """A shortcut decorator for declaring and attaching a command to the group. This takes the same arguments as :func:`command` and immediately registers the created command with this group by calling :meth:`add_command`. To customize the command class used, set the :attr:`command_class` attribute. .. versionchanged:: 8.1 This decorator can be applied without parentheses. .. versionchanged:: 8.0 Added the :attr:`command_class` attribute. """ from .decorators import command func: t.Optional[t.Callable[..., t.Any]] = None if args and callable(args[0]): assert ( len(args) == 1 and not kwargs ), "Use 'command(**kwargs)(callable)' to provide arguments." (func,) = args args = () if self.command_class and kwargs.get("cls") is None: kwargs["cls"] = self.command_class def decorator(f: t.Callable[..., t.Any]) -> Command: cmd: Command = command(*args, **kwargs)(f) self.add_command(cmd) return cmd if func is not None: return decorator(func) return decorator @t.overload def group(self, __func: t.Callable[..., t.Any]) -> "Group": ... @t.overload def group( self, *args: t.Any, **kwargs: t.Any ) -> t.Callable[[t.Callable[..., t.Any]], "Group"]: ... def group( self, *args: t.Any, **kwargs: t.Any ) -> t.Union[t.Callable[[t.Callable[..., t.Any]], "Group"], "Group"]: """A shortcut decorator for declaring and attaching a group to the group. This takes the same arguments as :func:`group` and immediately registers the created group with this group by calling :meth:`add_command`. To customize the group class used, set the :attr:`group_class` attribute. .. versionchanged:: 8.1 This decorator can be applied without parentheses. .. versionchanged:: 8.0 Added the :attr:`group_class` attribute. """ from .decorators import group func: t.Optional[t.Callable[..., t.Any]] = None if args and callable(args[0]): assert ( len(args) == 1 and not kwargs ), "Use 'group(**kwargs)(callable)' to provide arguments." (func,) = args args = () if self.group_class is not None and kwargs.get("cls") is None: if self.group_class is type: kwargs["cls"] = type(self) else: kwargs["cls"] = self.group_class def decorator(f: t.Callable[..., t.Any]) -> "Group": cmd: Group = group(*args, **kwargs)(f) self.add_command(cmd) return cmd if func is not None: return decorator(func) return decorator def get_command(self, ctx: Context, cmd_name: str) -> t.Optional[Command]: return self.commands.get(cmd_name) def list_commands(self, ctx: Context) -> t.List[str]: 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. See :class:`MultiCommand` and :class:`Command` for the description of ``name`` and ``attrs``. """ def __init__( self, name: t.Optional[str] = None, sources: t.Optional[t.List[MultiCommand]] = None, **attrs: t.Any, ) -> None: super().__init__(name, **attrs) #: The list of registered multi commands. self.sources: t.List[MultiCommand] = sources or [] def add_source(self, multi_cmd: MultiCommand) -> None: """Adds a new multi command to the chain dispatcher.""" self.sources.append(multi_cmd) def get_command(self, ctx: Context, cmd_name: str) -> t.Optional[Command]: 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 return None def list_commands(self, ctx: Context) -> t.List[str]: rv: t.Set[str] = set() for source in self.sources: rv.update(source.list_commands(ctx)) return sorted(rv) def _check_iter(value: t.Any) -> t.Iterator[t.Any]: """Check if the value is iterable but not a string. Raises a type error, or return an iterator over the value. """ if isinstance(value, str): raise TypeError return iter(value) class Parameter: 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. :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 latter 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 function to further process or validate the value after type conversion. It is called as ``f(ctx, param, value)`` and must return the value. It is called for all sources, including prompts. :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). If ``nargs=-1``, all remaining parameters are collected. :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 shell_complete: A function that returns custom shell completions. Used instead of the param's type completion if given. Takes ``ctx, param, incomplete`` and must return a list of :class:`~click.shell_completion.CompletionItem` or a list of strings. .. versionchanged:: 8.0 ``process_value`` validates required parameters and bounded ``nargs``, and invokes the parameter callback before returning the value. This allows the callback to validate prompts. ``full_process_value`` is removed. .. versionchanged:: 8.0 ``autocompletion`` is renamed to ``shell_complete`` and has new semantics described above. The old name is deprecated and will be removed in 8.1, until then it will be wrapped to match the new requirements. .. versionchanged:: 8.0 For ``multiple=True, nargs>1``, the default must be a list of tuples. .. versionchanged:: 8.0 Setting a default is no longer required for ``nargs>1``, it will default to ``None``. ``multiple=True`` or ``nargs=-1`` will default to ``()``. .. versionchanged:: 7.1 Empty environment variables are ignored rather than taking the empty string value. This makes it possible for scripts to clear variables if they can't unset them. .. versionchanged:: 2.0 Changed signature for parameter callback to also be passed the parameter. The old callback format will still work, but it will raise a warning to give you a chance to migrate the code easier. """ param_type_name = "parameter" def __init__( self, param_decls: t.Optional[t.Sequence[str]] = None, type: t.Optional[t.Union[types.ParamType, t.Any]] = None, required: bool = False, default: t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]] = None, callback: t.Optional[t.Callable[[Context, "Parameter", t.Any], t.Any]] = None, nargs: t.Optional[int] = None, multiple: bool = False, metavar: t.Optional[str] = None, expose_value: bool = True, is_eager: bool = False, envvar: t.Optional[t.Union[str, t.Sequence[str]]] = None, shell_complete: t.Optional[ t.Callable[ [Context, "Parameter", str], t.Union[t.List["CompletionItem"], t.List[str]], ] ] = None, ) -> None: self.name: t.Optional[str] self.opts: t.List[str] self.secondary_opts: t.List[str] self.name, self.opts, self.secondary_opts = self._parse_decls( param_decls or (), expose_value ) self.type: types.ParamType = types.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 = multiple self.expose_value = expose_value self.default = default self.is_eager = is_eager self.metavar = metavar self.envvar = envvar self._custom_shell_complete = shell_complete if __debug__: if self.type.is_composite and nargs != self.type.arity: raise ValueError( f"'nargs' must be {self.type.arity} (or None) for" f" type {self.type!r}, but it was {nargs}." ) # Skip no default or callable default. check_default = default if not callable(default) else None if check_default is not None: if multiple: try: # Only check the first value against nargs. check_default = next(_check_iter(check_default), None) except TypeError: raise ValueError( "'default' must be a list when 'multiple' is true." ) from None # Can be None for multiple with empty default. if nargs != 1 and check_default is not None: try: _check_iter(check_default) except TypeError: if multiple: message = ( "'default' must be a list of lists when 'multiple' is" " true and 'nargs' != 1." ) else: message = "'default' must be a list when 'nargs' != 1." raise ValueError(message) from None if nargs > 1 and len(check_default) != nargs: subject = "item length" if multiple else "length" raise ValueError( f"'default' {subject} must match nargs={nargs}." ) async def to_info_dict(self) -> t.Dict[str, t.Any]: """Gather information that could be useful for a tool generating user-facing documentation. Use :meth:`click.Context.to_info_dict` to traverse the entire CLI structure. .. versionadded:: 8.0 """ return { "name": self.name, "param_type_name": self.param_type_name, "opts": self.opts, "secondary_opts": self.secondary_opts, "type": await self.type.to_info_dict(), "required": self.required, "nargs": self.nargs, "multiple": self.multiple, "default": self.default, "envvar": self.envvar, } def __repr__(self) -> str: return f"<{self.__class__.__name__} {self.name}>" def _parse_decls( self, decls: t.Sequence[str], expose_value: bool ) -> t.Tuple[t.Optional[str], t.List[str], t.List[str]]: raise NotImplementedError() @property def human_readable_name(self) -> str: """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 # type: ignore def make_metavar(self) -> str: 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 @t.overload def get_default( self, ctx: Context, call: "te.Literal[True]" = True ) -> t.Optional[t.Any]: ... @t.overload def get_default( self, ctx: Context, call: bool = ... ) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]: ... def get_default( self, ctx: Context, call: bool = True ) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]: """Get the default for the parameter. Tries :meth:`Context.lookup_default` first, then the local default. :param ctx: Current context. :param call: If the default is a callable, call it. Disable to return the callable instead. .. versionchanged:: 8.0.2 Type casting is no longer performed when getting a default. .. versionchanged:: 8.0.1 Type casting can fail in resilient parsing mode. Invalid defaults will not prevent showing help text. .. versionchanged:: 8.0 Looks at ``ctx.default_map`` first. .. versionchanged:: 8.0 Added the ``call`` parameter. """ value = ctx.lookup_default(self.name, call=False) # type: ignore if value is None: value = self.default if call and callable(value): value = value() return value def add_to_parser(self, parser: OptionParser, ctx: Context) -> None: raise NotImplementedError() def consume_value( self, ctx: Context, opts: t.Mapping[str, t.Any] ) -> t.Tuple[t.Any, ParameterSource]: value = opts.get(self.name) # type: ignore source = ParameterSource.COMMANDLINE if value is None: value = self.value_from_envvar(ctx) source = ParameterSource.ENVIRONMENT if value is None: value = ctx.lookup_default(self.name) # type: ignore source = ParameterSource.DEFAULT_MAP if value is None: value = self.get_default(ctx) source = ParameterSource.DEFAULT return value, source def type_cast_value(self, ctx: Context, value: t.Any) -> t.Any: """Convert and validate a value against the option's :attr:`type`, :attr:`multiple`, and :attr:`nargs`. """ if value is None: return () if self.multiple or self.nargs == -1 else None def check_iter(value: t.Any) -> t.Iterator[t.Any]: try: return _check_iter(value) except TypeError: # This should only happen when passing in args manually, # the parser should construct an iterable when parsing # the command line. raise BadParameter( _("Value must be an iterable."), ctx=ctx, param=self ) from None if self.nargs == 1 or self.type.is_composite: def convert(value: t.Any) -> t.Any: return self.type(value, param=self, ctx=ctx) elif self.nargs == -1: def convert(value: t.Any) -> t.Any: # t.Tuple[t.Any, ...] return tuple(self.type(x, self, ctx) for x in check_iter(value)) else: # nargs > 1 def convert(value: t.Any) -> t.Any: # t.Tuple[t.Any, ...] value = tuple(check_iter(value)) if len(value) != self.nargs: raise BadParameter( ngettext( "Takes {nargs} values but 1 was given.", "Takes {nargs} values but {len} were given.", len(value), ).format(nargs=self.nargs, len=len(value)), ctx=ctx, param=self, ) return tuple(self.type(x, self, ctx) for x in value) if self.multiple: return tuple(convert(x) for x in check_iter(value)) return convert(value) def value_is_missing(self, value: t.Any) -> bool: if value is None: return True if (self.nargs != 1 or self.multiple) and value == (): return True return False def process_value(self, ctx: Context, value: t.Any) -> t.Any: value = self.type_cast_value(ctx, value) if self.required and self.value_is_missing(value): raise MissingParameter(ctx=ctx, param=self) if self.callback is not None: value = self.callback(ctx, self, value) return value def resolve_envvar_value(self, ctx: Context) -> t.Optional[str]: if self.envvar is None: return None if isinstance(self.envvar, str): rv = os.environ.get(self.envvar) if rv: return rv else: for envvar in self.envvar: rv = os.environ.get(envvar) if rv: return rv return None def value_from_envvar(self, ctx: Context) -> t.Optional[t.Any]: rv: t.Optional[t.Any] = self.resolve_envvar_value(ctx) if rv is not None and self.nargs != 1: rv = self.type.split_envvar_value(rv) return rv async def handle_parse_result( self, ctx: Context, opts: t.Mapping[str, t.Any], args: t.List[str] ) -> t.Tuple[t.Any, t.List[str]]: with augment_usage_errors(ctx, param=self): value, source = self.consume_value(ctx, opts) ctx.set_parameter_source(self.name, source) # type: ignore try: value = self.process_value(ctx, value) except Exception: if not ctx.resilient_parsing: raise value = None if self.expose_value: ctx.params[self.name] = value # type: ignore return value, args def get_help_record(self, ctx: Context) -> t.Optional[t.Tuple[str, str]]: pass def get_usage_pieces(self, ctx: Context) -> t.List[str]: return [] def get_error_hint(self, ctx: Context) -> str: """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(f"'{x}'" for x in hint_list) def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]: """Return a list of completions for the incomplete value. If a ``shell_complete`` function was given during init, it is used. Otherwise, the :attr:`type` :meth:`~click.types.ParamType.shell_complete` function is used. :param ctx: Invocation context for this command. :param incomplete: Value being completed. May be empty. .. versionadded:: 8.0 """ if self._custom_shell_complete is not None: results = self._custom_shell_complete(ctx, self, incomplete) if results and isinstance(results[0], str): from .shell_completion import CompletionItem results = [CompletionItem(c) for c in results] return t.cast(t.List["CompletionItem"], results) return self.type.shell_complete(ctx, self, incomplete) 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: Show the default value for this option in its help text. Values are not shown by default, unless :attr:`Context.show_default` is ``True``. If this value is a string, it shows that string in parentheses instead of the actual value. This is particularly useful for dynamic options. For single option boolean flags, the default remains hidden if its value is ``False``. :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: Prompt a second time to confirm the value if it was prompted for. Can be set to a string instead of ``True`` to customize the message. :param prompt_required: If set to ``False``, the user will be prompted for input only when the option was specified as a flag without a value. :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 attrs: Other command arguments described in :class:`Parameter`. .. versionchanged:: 8.1.0 Help text indentation is cleaned here instead of only in the ``@option`` decorator. .. versionchanged:: 8.1.0 The ``show_default`` parameter overrides ``Context.show_default``. .. versionchanged:: 8.1.0 The default of a single option boolean flag is not shown if the default value is ``False``. .. versionchanged:: 8.0.1 ``type`` is detected from ``flag_value`` if given. """ param_type_name = "option" def __init__( self, param_decls: t.Optional[t.Sequence[str]] = None, show_default: t.Union[bool, str, None] = None, prompt: t.Union[bool, str] = False, confirmation_prompt: t.Union[bool, str] = False, prompt_required: bool = True, hide_input: bool = False, is_flag: t.Optional[bool] = None, flag_value: t.Optional[t.Any] = None, multiple: bool = False, count: bool = False, allow_from_autoenv: bool = True, type: t.Optional[t.Union[types.ParamType, t.Any]] = None, help: t.Optional[str] = None, hidden: bool = False, show_choices: bool = True, show_envvar: bool = False, **attrs: t.Any, ) -> None: if help: help = inspect.cleandoc(help) default_is_missing = "default" not in attrs super().__init__(param_decls, type=type, multiple=multiple, **attrs) if prompt is True: if self.name is None: raise TypeError("'name' is required with 'prompt=True'.") prompt_text: t.Optional[str] = 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.prompt_required = prompt_required self.hide_input = hide_input self.hidden = hidden # If prompt is enabled but not required, then the option can be # used as a flag to indicate using prompt or flag_value. self._flag_needs_value = self.prompt is not None and not self.prompt_required if is_flag is None: if flag_value is not None: # Implicitly a flag because flag_value was set. is_flag = True elif self._flag_needs_value: # Not a flag, but when used as a flag it shows a prompt. is_flag = False else: # Implicitly a flag because flag options were given. is_flag = bool(self.secondary_opts) elif is_flag is False and not self._flag_needs_value: # Not a flag, and prompt is not enabled, can be used as a # flag if flag_value is set. self._flag_needs_value = flag_value is not None self.default: t.Union[t.Any, t.Callable[[], t.Any]] if is_flag and default_is_missing and not self.required: if multiple: self.default = () else: self.default = False if flag_value is None: flag_value = not self.default self.type: types.ParamType if is_flag and type is None: # Re-guess the type from the flag value instead of the # default. self.type = types.convert_type(None, flag_value) self.is_flag: bool = is_flag self.is_bool_flag: bool = is_flag and isinstance(self.type, types.BoolParamType) self.flag_value: t.Any = flag_value # Counting self.count = count if count: if type is None: self.type = types.IntRange(min=0) if default_is_missing: self.default = 0 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 if __debug__: if self.nargs == -1: raise TypeError("nargs=-1 is not supported for options.") if self.prompt and self.is_flag and not self.is_bool_flag: raise TypeError("'prompt' is not valid for non-boolean flag.") if not self.is_bool_flag and self.secondary_opts: raise TypeError("Secondary flag is not valid for non-boolean flag.") if self.is_bool_flag and self.hide_input and self.prompt is not None: raise TypeError( "'prompt' with 'hide_input' is not valid for boolean flag." ) if self.count: if self.multiple: raise TypeError("'count' is not valid with 'multiple'.") if self.is_flag: raise TypeError("'count' is not valid with 'is_flag'.") async def to_info_dict(self) -> t.Dict[str, t.Any]: info_dict = await super().to_info_dict() info_dict.update( help=self.help, prompt=self.prompt, is_flag=self.is_flag, flag_value=self.flag_value, count=self.count, hidden=self.hidden, ) return info_dict def _parse_decls( self, decls: t.Sequence[str], expose_value: bool ) -> t.Tuple[t.Optional[str], t.List[str], t.List[str]]: opts = [] secondary_opts = [] name = None possible_names = [] for decl in decls: if decl.isidentifier(): if name is not None: raise TypeError(f"Name '{name}' defined twice") name = decl else: split_char = ";" if decl[:1] == "/" else "/" 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()) if first == second: raise ValueError( f"Boolean option {decl!r} cannot use the" " same flag for true/false." ) 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 name.isidentifier(): 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( f"No options defined but a name was passed ({name})." " Did you mean to declare an argument instead? Did" f" you mean to pass '--{name}'?" ) return name, opts, secondary_opts def add_to_parser(self, parser: OptionParser, ctx: Context) -> None: if self.multiple: action = "append" elif self.count: action = "count" else: action = "store" if self.is_flag: action = f"{action}_const" if self.is_bool_flag and self.secondary_opts: parser.add_option( obj=self, opts=self.opts, dest=self.name, action=action, const=True ) parser.add_option( obj=self, opts=self.secondary_opts, dest=self.name, action=action, const=False, ) else: parser.add_option( obj=self, opts=self.opts, dest=self.name, action=action, const=self.flag_value, ) else: parser.add_option( obj=self, opts=self.opts, dest=self.name, action=action, nargs=self.nargs, ) def get_help_record(self, ctx: Context) -> t.Optional[t.Tuple[str, str]]: if self.hidden: return None any_prefix_is_slash = False def _write_opts(opts: t.Sequence[str]) -> str: nonlocal any_prefix_is_slash rv, any_slashes = join_options(opts) if any_slashes: any_prefix_is_slash = True if not self.is_flag and not self.count: rv += f" {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 and self.name is not None ): envvar = f"{ctx.auto_envvar_prefix}_{self.name.upper()}" if envvar is not None: var_str = ( envvar if isinstance(envvar, str) else ", ".join(str(d) for d in envvar) ) extra.append(_("env var: {var}").format(var=var_str)) # Temporarily enable resilient parsing to avoid type casting # failing for the default. Might be possible to extend this to # help formatting in general. resilient = ctx.resilient_parsing ctx.resilient_parsing = True try: default_value = self.get_default(ctx, call=False) finally: ctx.resilient_parsing = resilient show_default = False show_default_is_str = False if self.show_default is not None: if isinstance(self.show_default, str): show_default_is_str = show_default = True else: show_default = self.show_default elif ctx.show_default is not None: show_default = ctx.show_default if show_default_is_str or (show_default and (default_value is not None)): if show_default_is_str: default_string = f"({self.show_default})" elif isinstance(default_value, (list, tuple)): default_string = ", ".join(str(d) for d in default_value) elif inspect.isfunction(default_value): default_string = _("(dynamic)") elif self.is_bool_flag and self.secondary_opts: # For boolean flags that have distinct True/False opts, # use the opt without prefix instead of the value. default_string = split_opt( (self.opts if self.default else self.secondary_opts)[0] )[1] elif self.is_bool_flag and not self.secondary_opts and not default_value: default_string = "" else: default_string = str(default_value) if default_string: extra.append(_("default: {default}").format(default=default_string)) if ( isinstance(self.type, types._NumberRangeBase) # skip count with default range type and not (self.count and self.type.min == 0 and self.type.max is None) ): range_str = self.type._describe_range() if range_str: extra.append(range_str) if self.required: extra.append(_("required")) if extra: extra_str = "; ".join(extra) help = f"{help} [{extra_str}]" if help else f"[{extra_str}]" return ("; " if any_prefix_is_slash else " / ").join(rv), help @t.overload def get_default( self, ctx: Context, call: "te.Literal[True]" = True ) -> t.Optional[t.Any]: ... @t.overload def get_default( self, ctx: Context, call: bool = ... ) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]: ... def get_default( self, ctx: Context, call: bool = True ) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]: # If we're a non boolean flag our default is more complex because # we need to look at all flags in the same group to figure out # if we're 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 t.cast(Option, param).flag_value return None return super().get_default(ctx, call=call) def prompt_for_value(self, ctx: Context) -> t.Any: """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. """ assert self.prompt is not None # 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: Context) -> t.Optional[str]: rv = super().resolve_envvar_value(ctx) if rv is not None: return rv if ( self.allow_from_autoenv and ctx.auto_envvar_prefix is not None and self.name is not None ): envvar = f"{ctx.auto_envvar_prefix}_{self.name.upper()}" rv = os.environ.get(envvar) if rv: return rv return None def value_from_envvar(self, ctx: Context) -> t.Optional[t.Any]: rv: t.Optional[t.Any] = self.resolve_envvar_value(ctx) if rv is None: return None value_depth = (self.nargs != 1) + bool(self.multiple) if value_depth > 0: rv = self.type.split_envvar_value(rv) if self.multiple and self.nargs != 1: rv = batch(rv, self.nargs) return rv def consume_value( self, ctx: Context, opts: t.Mapping[str, "Parameter"] ) -> t.Tuple[t.Any, ParameterSource]: value, source = super().consume_value(ctx, opts) # The parser will emit a sentinel value if the option can be # given as a flag without a value. This is different from None # to distinguish from the flag not being given at all. if value is _flag_needs_value: if self.prompt is not None and not ctx.resilient_parsing: value = self.prompt_for_value(ctx) source = ParameterSource.PROMPT else: value = self.flag_value source = ParameterSource.COMMANDLINE elif ( self.multiple and value is not None and any(v is _flag_needs_value for v in value) ): value = [self.flag_value if v is _flag_needs_value else v for v in value] source = ParameterSource.COMMANDLINE # The value wasn't set, or used the param's default, prompt if # prompting is enabled. elif ( source in {None, ParameterSource.DEFAULT} and self.prompt is not None and (self.required or self.prompt_required) and not ctx.resilient_parsing ): value = self.prompt_for_value(ctx) source = ParameterSource.PROMPT return value, source 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 constructor of :class:`Parameter`. """ param_type_name = "argument" def __init__( self, param_decls: t.Sequence[str], required: t.Optional[bool] = None, **attrs: t.Any, ) -> None: if required is None: if attrs.get("default") is not None: required = False else: required = attrs.get("nargs", 1) > 0 if "multiple" in attrs: raise TypeError("__init__() got an unexpected keyword argument 'multiple'.") super().__init__(param_decls, required=required, **attrs) if __debug__: if self.default is not None and self.nargs == -1: raise TypeError("'default' is not supported for nargs=-1.") @property def human_readable_name(self) -> str: if self.metavar is not None: return self.metavar return self.name.upper() # type: ignore def make_metavar(self) -> str: if self.metavar is not None: return self.metavar var = self.type.get_metavar(self) if not var: var = self.name.upper() # type: ignore if not self.required: var = f"[{var}]" if self.nargs != 1: var += "..." return var def _parse_decls( self, decls: t.Sequence[str], expose_value: bool ) -> t.Tuple[t.Optional[str], t.List[str], t.List[str]]: 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" f" {len(decls)}." ) return name, [arg], [] def get_usage_pieces(self, ctx: Context) -> t.List[str]: return [self.make_metavar()] def get_error_hint(self, ctx: Context) -> str: return f"'{self.make_metavar()}'" def add_to_parser(self, parser: OptionParser, ctx: Context) -> None: parser.add_argument(dest=self.name, nargs=self.nargs, obj=self) asyncclick-8.1.7.0-async/src/asyncclick/decorators.py000066400000000000000000000444371452710122500225670ustar00rootroot00000000000000import inspect import types import typing as t from functools import update_wrapper from gettext import gettext as _ from .core import Argument from .core import Command from .core import Context from .core import Group from .core import Option from .core import Parameter from .globals import get_current_context from .utils import echo if t.TYPE_CHECKING: import typing_extensions as te P = te.ParamSpec("P") R = t.TypeVar("R") T = t.TypeVar("T") _AnyCallable = t.Callable[..., t.Any] FC = t.TypeVar("FC", bound=t.Union[_AnyCallable, Command]) def pass_context(f: "t.Callable[te.Concatenate[Context, P], R]") -> "t.Callable[P, R]": """Marks a callback as wanting to receive the current context object as first argument. """ def new_func(*args: "P.args", **kwargs: "P.kwargs") -> "R": return f(get_current_context(), *args, **kwargs) return update_wrapper(new_func, f) def pass_obj(f: "t.Callable[te.Concatenate[t.Any, P], R]") -> "t.Callable[P, R]": """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: "P.args", **kwargs: "P.kwargs") -> "R": return f(get_current_context().obj, *args, **kwargs) return update_wrapper(new_func, f) def make_pass_decorator( object_type: t.Type[T], ensure: bool = False ) -> t.Callable[["t.Callable[te.Concatenate[T, P], R]"], "t.Callable[P, R]"]: """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: "t.Callable[te.Concatenate[T, P], R]") -> "t.Callable[P, R]": def new_func(*args: "P.args", **kwargs: "P.kwargs") -> "R": ctx = get_current_context() obj: t.Optional[T] 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" f" object of type {object_type.__name__!r}" " existing." ) return ctx.invoke(f, obj, *args, **kwargs) return update_wrapper(new_func, f) return decorator # type: ignore[return-value] def pass_meta_key( key: str, *, doc_description: t.Optional[str] = None ) -> "t.Callable[[t.Callable[te.Concatenate[t.Any, P], R]], t.Callable[P, R]]": """Create a decorator that passes a key from :attr:`click.Context.meta` as the first argument to the decorated function. :param key: Key in ``Context.meta`` to pass. :param doc_description: Description of the object being passed, inserted into the decorator's docstring. Defaults to "the 'key' key from Context.meta". .. versionadded:: 8.0 """ def decorator(f: "t.Callable[te.Concatenate[t.Any, P], R]") -> "t.Callable[P, R]": def new_func(*args: "P.args", **kwargs: "P.kwargs") -> R: ctx = get_current_context() obj = ctx.meta[key] return ctx.invoke(f, obj, *args, **kwargs) return update_wrapper(new_func, f) if doc_description is None: doc_description = f"the {key!r} key from :attr:`click.Context.meta`" decorator.__doc__ = ( f"Decorator that passes {doc_description} as the first argument" " to the decorated function." ) return decorator # type: ignore[return-value] CmdType = t.TypeVar("CmdType", bound=Command) # variant: no call, directly as decorator for a function. @t.overload def command(name: _AnyCallable) -> Command: ... # variant: with positional name and with positional or keyword cls argument: # @command(namearg, CommandCls, ...) or @command(namearg, cls=CommandCls, ...) @t.overload def command( name: t.Optional[str], cls: t.Type[CmdType], **attrs: t.Any, ) -> t.Callable[[_AnyCallable], CmdType]: ... # variant: name omitted, cls _must_ be a keyword argument, @command(cls=CommandCls, ...) @t.overload def command( name: None = None, *, cls: t.Type[CmdType], **attrs: t.Any, ) -> t.Callable[[_AnyCallable], CmdType]: ... # variant: with optional string name, no cls argument provided. @t.overload def command( name: t.Optional[str] = ..., cls: None = None, **attrs: t.Any ) -> t.Callable[[_AnyCallable], Command]: ... def command( name: t.Union[t.Optional[str], _AnyCallable] = None, cls: t.Optional[t.Type[CmdType]] = None, **attrs: t.Any, ) -> t.Union[Command, t.Callable[[_AnyCallable], t.Union[Command, CmdType]]]: 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 with underscores replaced by dashes. 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. For the ``params`` argument, any decorated params are appended to the end of the list. 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`. .. versionchanged:: 8.1 This decorator can be applied without parentheses. .. versionchanged:: 8.1 The ``params`` argument can be used. Decorated params are appended to the end of the list. """ func: t.Optional[t.Callable[[_AnyCallable], t.Any]] = None if callable(name): func = name name = None assert cls is None, "Use 'command(cls=cls)(callable)' to specify a class." assert not attrs, "Use 'command(**kwargs)(callable)' to provide arguments." if cls is None: cls = t.cast(t.Type[CmdType], Command) def decorator(f: _AnyCallable) -> CmdType: if isinstance(f, Command): raise TypeError("Attempted to convert a callback into a command twice.") attr_params = attrs.pop("params", None) params = attr_params if attr_params is not None else [] try: decorator_params = f.__click_params__ # type: ignore except AttributeError: pass else: del f.__click_params__ # type: ignore params.extend(reversed(decorator_params)) if attrs.get("help") is None: attrs["help"] = f.__doc__ if t.TYPE_CHECKING: assert cls is not None assert not callable(name) cmd = cls( name=name or f.__name__.lower().replace("_", "-"), callback=f, params=params, **attrs, ) cmd.__doc__ = f.__doc__ return cmd if func is not None: return decorator(func) return decorator GrpType = t.TypeVar("GrpType", bound=Group) # variant: no call, directly as decorator for a function. @t.overload def group(name: _AnyCallable) -> Group: ... # variant: with positional name and with positional or keyword cls argument: # @group(namearg, GroupCls, ...) or @group(namearg, cls=GroupCls, ...) @t.overload def group( name: t.Optional[str], cls: t.Type[GrpType], **attrs: t.Any, ) -> t.Callable[[_AnyCallable], GrpType]: ... # variant: name omitted, cls _must_ be a keyword argument, @group(cmd=GroupCls, ...) @t.overload def group( name: None = None, *, cls: t.Type[GrpType], **attrs: t.Any, ) -> t.Callable[[_AnyCallable], GrpType]: ... # variant: with optional string name, no cls argument provided. @t.overload def group( name: t.Optional[str] = ..., cls: None = None, **attrs: t.Any ) -> t.Callable[[_AnyCallable], Group]: ... def group( name: t.Union[str, _AnyCallable, None] = None, cls: t.Optional[t.Type[GrpType]] = None, **attrs: t.Any, ) -> t.Union[Group, t.Callable[[_AnyCallable], t.Union[Group, GrpType]]]: """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`. .. versionchanged:: 8.1 This decorator can be applied without parentheses. """ if cls is None: cls = t.cast(t.Type[GrpType], Group) if callable(name): return command(cls=cls, **attrs)(name) return command(name, cls, **attrs) def _param_memo(f: t.Callable[..., t.Any], param: Parameter) -> None: if isinstance(f, Command): f.params.append(param) else: if not hasattr(f, "__click_params__"): f.__click_params__ = [] # type: ignore f.__click_params__.append(param) # type: ignore def argument( *param_decls: str, cls: t.Optional[t.Type[Argument]] = None, **attrs: t.Any ) -> t.Callable[[FC], FC]: """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. For the default argument class, refer to :class:`Argument` and :class:`Parameter` for descriptions of parameters. :param cls: the argument class to instantiate. This defaults to :class:`Argument`. :param param_decls: Passed as positional arguments to the constructor of ``cls``. :param attrs: Passed as keyword arguments to the constructor of ``cls``. """ if cls is None: cls = Argument def decorator(f: FC) -> FC: _param_memo(f, cls(param_decls, **attrs)) return f return decorator def option( *param_decls: str, cls: t.Optional[t.Type[Option]] = None, **attrs: t.Any ) -> t.Callable[[FC], FC]: """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. For the default option class, refer to :class:`Option` and :class:`Parameter` for descriptions of parameters. :param cls: the option class to instantiate. This defaults to :class:`Option`. :param param_decls: Passed as positional arguments to the constructor of ``cls``. :param attrs: Passed as keyword arguments to the constructor of ``cls``. """ if cls is None: cls = Option def decorator(f: FC) -> FC: _param_memo(f, cls(param_decls, **attrs)) return f return decorator def confirmation_option(*param_decls: str, **kwargs: t.Any) -> t.Callable[[FC], FC]: """Add a ``--yes`` option which shows a prompt before continuing if not passed. If the prompt is declined, the program will exit. :param param_decls: One or more option names. Defaults to the single value ``"--yes"``. :param kwargs: Extra arguments are passed to :func:`option`. """ def callback(ctx: Context, param: Parameter, value: bool) -> None: if not value: ctx.abort() if not param_decls: param_decls = ("--yes",) kwargs.setdefault("is_flag", True) kwargs.setdefault("callback", callback) kwargs.setdefault("expose_value", False) kwargs.setdefault("prompt", "Do you want to continue?") kwargs.setdefault("help", "Confirm the action without prompting.") return option(*param_decls, **kwargs) def password_option(*param_decls: str, **kwargs: t.Any) -> t.Callable[[FC], FC]: """Add a ``--password`` option which prompts for a password, hiding input and asking to enter the value again for confirmation. :param param_decls: One or more option names. Defaults to the single value ``"--password"``. :param kwargs: Extra arguments are passed to :func:`option`. """ if not param_decls: param_decls = ("--password",) kwargs.setdefault("prompt", True) kwargs.setdefault("confirmation_prompt", True) kwargs.setdefault("hide_input", True) return option(*param_decls, **kwargs) def version_option( version: t.Optional[str] = None, *param_decls: str, package_name: t.Optional[str] = None, prog_name: t.Optional[str] = None, message: t.Optional[str] = None, **kwargs: t.Any, ) -> t.Callable[[FC], FC]: """Add a ``--version`` option which immediately prints the version number and exits the program. If ``version`` is not provided, Click will try to detect it using :func:`importlib.metadata.version` to get the version for the ``package_name``. On Python < 3.8, the ``importlib_metadata`` backport must be installed. If ``package_name`` is not provided, Click will try to detect it by inspecting the stack frames. This will be used to detect the version, so it must match the name of the installed package. :param version: The version number to show. If not provided, Click will try to detect it. :param param_decls: One or more option names. Defaults to the single value ``"--version"``. :param package_name: The package name to detect the version from. If not provided, Click will try to detect it. :param prog_name: The name of the CLI to show in the message. If not provided, it will be detected from the command. :param message: The message to show. The values ``%(prog)s``, ``%(package)s``, and ``%(version)s`` are available. Defaults to ``"%(prog)s, version %(version)s"``. :param kwargs: Extra arguments are passed to :func:`option`. :raise RuntimeError: ``version`` could not be detected. .. versionchanged:: 8.0 Add the ``package_name`` parameter, and the ``%(package)s`` value for messages. .. versionchanged:: 8.0 Use :mod:`importlib.metadata` instead of ``pkg_resources``. The version is detected based on the package name, not the entry point name. The Python package name must match the installed package name, or be passed with ``package_name=``. """ if message is None: message = _("%(prog)s, version %(version)s") if version is None and package_name is None: frame = inspect.currentframe() f_back = frame.f_back if frame is not None else None f_globals = f_back.f_globals if f_back is not None else None # break reference cycle # https://docs.python.org/3/library/inspect.html#the-interpreter-stack del frame if f_globals is not None: package_name = f_globals.get("__name__") if package_name == "__main__": package_name = f_globals.get("__package__") if package_name: package_name = package_name.partition(".")[0] def callback(ctx: Context, param: Parameter, value: bool) -> None: if not value or ctx.resilient_parsing: return nonlocal prog_name nonlocal version if prog_name is None: prog_name = ctx.find_root().info_name if version is None and package_name is not None: metadata: t.Optional[types.ModuleType] try: from importlib import metadata # type: ignore except ImportError: # Python < 3.8 import importlib_metadata as metadata # type: ignore try: version = metadata.version(package_name) # type: ignore except metadata.PackageNotFoundError: # type: ignore raise RuntimeError( f"{package_name!r} is not installed. Try passing" " 'package_name' instead." ) from None if version is None: raise RuntimeError( f"Could not determine the version for {package_name!r} automatically." ) echo( message % {"prog": prog_name, "package": package_name, "version": version}, color=ctx.color, ) ctx.exit() if not param_decls: param_decls = ("--version",) kwargs.setdefault("is_flag", True) kwargs.setdefault("expose_value", False) kwargs.setdefault("is_eager", True) kwargs.setdefault("help", _("Show the version and exit.")) kwargs["callback"] = callback return option(*param_decls, **kwargs) def help_option(*param_decls: str, **kwargs: t.Any) -> t.Callable[[FC], FC]: """Add a ``--help`` option which immediately prints the help page and exits the program. This is usually unnecessary, as the ``--help`` option is added to each command automatically unless ``add_help_option=False`` is passed. :param param_decls: One or more option names. Defaults to the single value ``"--help"``. :param kwargs: Extra arguments are passed to :func:`option`. """ def callback(ctx: Context, param: Parameter, value: bool) -> None: if not value or ctx.resilient_parsing: return echo(ctx.get_help(), color=ctx.color) ctx.exit() if not param_decls: param_decls = ("--help",) kwargs.setdefault("is_flag", True) kwargs.setdefault("expose_value", False) kwargs.setdefault("is_eager", True) kwargs.setdefault("help", _("Show this message and exit.")) kwargs["callback"] = callback return option(*param_decls, **kwargs) asyncclick-8.1.7.0-async/src/asyncclick/exceptions.py000066400000000000000000000220711452710122500225710ustar00rootroot00000000000000import typing as t from gettext import gettext as _ from gettext import ngettext from ._compat import get_text_stderr from .utils import echo from .utils import format_filename if t.TYPE_CHECKING: from .core import Command from .core import Context from .core import Parameter def _join_param_hints( param_hint: t.Optional[t.Union[t.Sequence[str], str]] ) -> t.Optional[str]: if param_hint is not None and not isinstance(param_hint, str): return " / ".join(repr(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: str) -> None: super().__init__(message) self.message = message def format_message(self) -> str: return self.message def __str__(self) -> str: return self.message def show(self, file: t.Optional[t.IO[t.Any]] = None) -> None: if file is None: file = get_text_stderr() echo(_("Error: {message}").format(message=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: str, ctx: t.Optional["Context"] = None) -> None: super().__init__(message) self.ctx = ctx self.cmd: t.Optional["Command"] = self.ctx.command if self.ctx else None def show(self, file: t.Optional[t.IO[t.Any]] = None) -> None: if file is None: file = get_text_stderr() color = None hint = "" if ( self.ctx is not None and self.ctx.command.get_help_option(self.ctx) is not None ): hint = _("Try '{command} {option}' for help.").format( command=self.ctx.command_path, option=self.ctx.help_option_names[0] ) hint = f"{hint}\n" if self.ctx is not None: color = self.ctx.color echo(f"{self.ctx.get_usage()}\n{hint}", file=file, color=color) echo( _("Error: {message}").format(message=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: str, ctx: t.Optional["Context"] = None, param: t.Optional["Parameter"] = None, param_hint: t.Optional[str] = None, ) -> None: super().__init__(message, ctx) self.param = param self.param_hint = param_hint def format_message(self) -> str: 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) # type: ignore else: return _("Invalid value: {message}").format(message=self.message) return _("Invalid value for {param_hint}: {message}").format( param_hint=_join_param_hints(param_hint), message=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: t.Optional[str] = None, ctx: t.Optional["Context"] = None, param: t.Optional["Parameter"] = None, param_hint: t.Optional[str] = None, param_type: t.Optional[str] = None, ) -> None: super().__init__(message or "", ctx, param, param_hint) self.param_type = param_type def format_message(self) -> str: if self.param_hint is not None: param_hint: t.Optional[str] = self.param_hint elif self.param is not None: param_hint = self.param.get_error_hint(self.ctx) # type: ignore else: param_hint = None param_hint = _join_param_hints(param_hint) param_hint = f" {param_hint}" if param_hint else "" 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 += f". {msg_extra}" else: msg = msg_extra msg = f" {msg}" if msg else "" # Translate param_type for known types. if param_type == "argument": missing = _("Missing argument") elif param_type == "option": missing = _("Missing option") elif param_type == "parameter": missing = _("Missing parameter") else: missing = _("Missing {param_type}").format(param_type=param_type) return f"{missing}{param_hint}.{msg}" def __str__(self) -> str: if not self.message: param_name = self.param.name if self.param else None return _("Missing parameter: {param_name}").format(param_name=param_name) else: return self.message class NoSuchOption(UsageError): """Raised if click attempted to handle an option that does not exist. .. versionadded:: 4.0 """ def __init__( self, option_name: str, message: t.Optional[str] = None, possibilities: t.Optional[t.Sequence[str]] = None, ctx: t.Optional["Context"] = None, ) -> None: if message is None: message = _("No such option: {name}").format(name=option_name) super().__init__(message, ctx) self.option_name = option_name self.possibilities = possibilities def format_message(self) -> str: if not self.possibilities: return self.message possibility_str = ", ".join(sorted(self.possibilities)) suggest = ngettext( "Did you mean {possibility}?", "(Possible options: {possibilities})", len(self.possibilities), ).format(possibility=possibility_str, possibilities=possibility_str) return f"{self.message} {suggest}" 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: str, message: str, ctx: t.Optional["Context"] = None ) -> None: super().__init__(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 """ class FileError(ClickException): """Raised if a file cannot be opened.""" def __init__(self, filename: str, hint: t.Optional[str] = None) -> None: if hint is None: hint = _("unknown error") super().__init__(hint) self.ui_filename: str = format_filename(filename) self.filename = filename def format_message(self) -> str: return _("Could not open file {filename!r}: {message}").format( filename=self.ui_filename, message=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. """ __slots__ = ("exit_code",) def __init__(self, code: int = 0) -> None: self.exit_code: int = code asyncclick-8.1.7.0-async/src/asyncclick/formatting.py000066400000000000000000000227521452710122500225700ustar00rootroot00000000000000import typing as t from contextlib import contextmanager from gettext import gettext as _ from ._compat import term_len from .parser import split_opt # Can force a width. This is used by the test system FORCED_WIDTH: t.Optional[int] = None def measure_table(rows: t.Iterable[t.Tuple[str, str]]) -> t.Tuple[int, ...]: widths: t.Dict[int, int] = {} 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: t.Iterable[t.Tuple[str, str]], col_count: int ) -> t.Iterator[t.Tuple[str, ...]]: for row in rows: yield row + ("",) * (col_count - len(row)) def wrap_text( text: str, width: int = 78, initial_indent: str = "", subsequent_indent: str = "", preserve_paragraphs: bool = False, ) -> str: """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: t.List[t.Tuple[int, bool, str]] = [] buf: t.List[str] = [] indent = None def _flush_par() -> None: 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: """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: int = 2, width: t.Optional[int] = None, max_width: t.Optional[int] = None, ) -> None: import shutil 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(shutil.get_terminal_size().columns, max_width) - 2, 50) self.width = width self.current_indent = 0 self.buffer: t.List[str] = [] def write(self, string: str) -> None: """Writes a unicode string into the internal buffer.""" self.buffer.append(string) def indent(self) -> None: """Increases the indentation.""" self.current_indent += self.indent_increment def dedent(self) -> None: """Decreases the indentation.""" self.current_indent -= self.indent_increment def write_usage( self, prog: str, args: str = "", prefix: t.Optional[str] = None ) -> None: """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. Defaults to ``"Usage: "``. """ if prefix is None: prefix = f"{_('Usage:')} " usage_prefix = f"{prefix:>{self.current_indent}}{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: str) -> None: """Writes a heading into the buffer.""" self.write(f"{'':>{self.current_indent}}{heading}:\n") def write_paragraph(self) -> None: """Writes a paragraph into the buffer.""" if self.buffer: self.write("\n") def write_text(self, text: str) -> None: """Writes re-indented text into the buffer. This rewraps and preserves paragraphs. """ indent = " " * self.current_indent self.write( wrap_text( text, self.width, initial_indent=indent, subsequent_indent=indent, preserve_paragraphs=True, ) ) self.write("\n") def write_dl( self, rows: t.Sequence[t.Tuple[str, str]], col_max: int = 30, col_spacing: int = 2, ) -> None: """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(f"{'':>{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) wrapped_text = wrap_text(second, text_width, preserve_paragraphs=True) lines = wrapped_text.splitlines() if lines: self.write(f"{lines[0]}\n") for line in lines[1:]: self.write(f"{'':>{first_col + self.current_indent}}{line}\n") else: self.write("\n") @contextmanager def section(self, name: str) -> t.Iterator[None]: """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) -> t.Iterator[None]: """A context manager that increases the indentation.""" self.indent() try: yield finally: self.dedent() def getvalue(self) -> str: """Returns the buffer contents.""" return "".join(self.buffer) def join_options(options: t.Sequence[str]) -> t.Tuple[str, bool]: """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]) return ", ".join(x[1] for x in rv), any_prefix_is_slash asyncclick-8.1.7.0-async/src/asyncclick/globals.py000066400000000000000000000036511452710122500220360ustar00rootroot00000000000000import typing as t from threading import local if t.TYPE_CHECKING: import typing_extensions as te from .core import Context _local = local() @t.overload def get_current_context(silent: "te.Literal[False]" = False) -> "Context": ... @t.overload def get_current_context(silent: bool = ...) -> t.Optional["Context"]: ... def get_current_context(silent: bool = False) -> t.Optional["Context"]: """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: if set to `True` the return value is `None` if no context is available. The default behavior is to raise a :exc:`RuntimeError`. """ try: return t.cast("Context", _local.stack[-1]) except (AttributeError, IndexError) as e: if not silent: raise RuntimeError("There is no active click context.") from e return None def push_context(ctx: "Context") -> None: """Pushes a new context to the current stack.""" _local.__dict__.setdefault("stack", []).append(ctx) def pop_context() -> None: """Removes the top level from the stack.""" _local.stack.pop() def resolve_color_default(color: t.Optional[bool] = None) -> t.Optional[bool]: """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 return None asyncclick-8.1.7.0-async/src/asyncclick/parser.py000066400000000000000000000452011452710122500217040ustar00rootroot00000000000000""" 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. 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. """ # This code uses parts of optparse written by Gregory P. Ward and # maintained by the Python Software Foundation. # Copyright 2001-2006 Gregory P. Ward # Copyright 2002-2006 Python Software Foundation import typing as t from collections import deque from gettext import gettext as _ from gettext import ngettext from .exceptions import BadArgumentUsage from .exceptions import BadOptionUsage from .exceptions import NoSuchOption from .exceptions import UsageError if t.TYPE_CHECKING: import typing_extensions as te from .core import Argument as CoreArgument from .core import Context from .core import Option as CoreOption from .core import Parameter as CoreParameter V = t.TypeVar("V") # Sentinel value that indicates an option was passed as a flag without a # value but is not a flag option. Option.consume_value uses this to # prompt or use the flag_value. _flag_needs_value = object() def _unpack_args( args: t.Sequence[str], nargs_spec: t.Sequence[int] ) -> t.Tuple[t.Sequence[t.Union[str, t.Sequence[t.Optional[str]], None]], t.List[str]]: """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: t.List[t.Union[str, t.Tuple[t.Optional[str], ...], None]] = [] spos: t.Optional[int] = None def _fetch(c: "te.Deque[V]") -> t.Optional[V]: 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 is None: continue 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 split_opt(opt: str) -> t.Tuple[str, str]: 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: str, ctx: t.Optional["Context"]) -> str: if ctx is None or ctx.token_normalize_func is None: return opt prefix, opt = split_opt(opt) return f"{prefix}{ctx.token_normalize_func(opt)}" def split_arg_string(string: str) -> t.List[str]: """Split an argument string as with :func:`shlex.split`, but don't fail if the string is incomplete. Ignores a missing closing quote or incomplete escape sequence and uses the partial token as-is. .. code-block:: python split_arg_string("example 'my file") ["example", "my file"] split_arg_string("example my\\") ["example", "my"] :param string: String to split. """ import shlex lex = shlex.shlex(string, posix=True) lex.whitespace_split = True lex.commenters = "" out = [] try: for token in lex: out.append(token) except ValueError: # Raised when end-of-string is reached in an invalid state. Use # the partial token as-is. The quote or escape character is in # lex.state, not lex.token. out.append(lex.token) return out class Option: def __init__( self, obj: "CoreOption", opts: t.Sequence[str], dest: t.Optional[str], action: t.Optional[str] = None, nargs: int = 1, const: t.Optional[t.Any] = None, ): self._short_opts = [] self._long_opts = [] self.prefixes: t.Set[str] = set() for opt in opts: prefix, value = split_opt(opt) if not prefix: raise ValueError(f"Invalid start character for option ({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) -> bool: return self.action in ("store", "append") def process(self, value: t.Any, state: "ParsingState") -> None: if self.action == "store": state.opts[self.dest] = value # type: ignore elif self.action == "store_const": state.opts[self.dest] = self.const # type: ignore elif self.action == "append": state.opts.setdefault(self.dest, []).append(value) # type: ignore elif self.action == "append_const": state.opts.setdefault(self.dest, []).append(self.const) # type: ignore elif self.action == "count": state.opts[self.dest] = state.opts.get(self.dest, 0) + 1 # type: ignore else: raise ValueError(f"unknown action '{self.action}'") state.order.append(self.obj) class Argument: def __init__(self, obj: "CoreArgument", dest: t.Optional[str], nargs: int = 1): self.dest = dest self.nargs = nargs self.obj = obj def process( self, value: t.Union[t.Optional[str], t.Sequence[t.Optional[str]]], state: "ParsingState", ) -> None: if self.nargs > 1: assert value is not None holes = sum(1 for x in value if x is None) if holes == len(value): value = None elif holes != 0: raise BadArgumentUsage( _("Argument {name!r} takes {nargs} values.").format( name=self.dest, nargs=self.nargs ) ) if self.nargs == -1 and self.obj.envvar is not None and value == (): # Replace empty tuple with None so that a value from the # environment may be tried. value = None state.opts[self.dest] = value # type: ignore state.order.append(self.obj) class ParsingState: def __init__(self, rargs: t.List[str]) -> None: self.opts: t.Dict[str, t.Any] = {} self.largs: t.List[str] = [] self.rargs = rargs self.order: t.List["CoreParameter"] = [] class OptionParser: """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: t.Optional["Context"] = None) -> 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: bool = 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: bool = 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: t.Dict[str, Option] = {} self._long_opt: t.Dict[str, Option] = {} self._opt_prefixes = {"-", "--"} self._args: t.List[Argument] = [] def add_option( self, obj: "CoreOption", opts: t.Sequence[str], dest: t.Optional[str], action: t.Optional[str] = None, nargs: int = 1, const: t.Optional[t.Any] = None, ) -> 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``, ``append_const`` or ``count``. The `obj` can be used to identify the option in the order list that is returned from the parser. """ opts = [normalize_opt(opt, self.ctx) for opt in opts] option = Option(obj, opts, dest, action=action, nargs=nargs, const=const) 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, obj: "CoreArgument", dest: t.Optional[str], nargs: int = 1 ) -> 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. """ self._args.append(Argument(obj, dest=dest, nargs=nargs)) async def parse_args( self, args: t.List[str] ) -> t.Tuple[t.Dict[str, t.Any], t.List[str], t.List["CoreParameter"]]: """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: ParsingState) -> None: 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: ParsingState) -> None: 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: str, explicit_value: t.Optional[str], state: ParsingState ) -> None: if opt not in self._long_opt: from difflib import get_close_matches possibilities = get_close_matches(opt, self._long_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) value = self._get_value_from_state(opt, option, state) elif explicit_value is not None: raise BadOptionUsage( opt, _("Option {name!r} does not take a value.").format(name=opt) ) else: value = None option.process(value, state) def _match_short_opt(self, arg: str, state: ParsingState) -> None: stop = False i = 1 prefix = arg[0] unknown_options = [] for ch in arg[1:]: opt = normalize_opt(f"{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 value = self._get_value_from_state(opt, option, state) else: value = None option.process(value, state) if stop: break # If we got any unknown options we recombine 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(f"{prefix}{''.join(unknown_options)}") def _get_value_from_state( self, option_name: str, option: Option, state: ParsingState ) -> t.Any: nargs = option.nargs if len(state.rargs) < nargs: if option.obj._flag_needs_value: # Option allows omitting the value. value = _flag_needs_value else: raise BadOptionUsage( option_name, ngettext( "Option {name!r} requires an argument.", "Option {name!r} requires {nargs} arguments.", nargs, ).format(name=option_name, nargs=nargs), ) elif nargs == 1: next_rarg = state.rargs[0] if ( option.obj._flag_needs_value and isinstance(next_rarg, str) and next_rarg[:1] in self._opt_prefixes and len(next_rarg) > 1 ): # The next arg looks like the start of an option, don't # use it as the value if omitting the value is allowed. value = _flag_needs_value else: value = state.rargs.pop(0) else: value = tuple(state.rargs[:nargs]) del state.rargs[:nargs] return value def _process_opts(self, arg: str, state: ParsingState) -> None: 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: self._match_short_opt(arg, state) return if not self.ignore_unknown_options: raise state.largs.append(arg) asyncclick-8.1.7.0-async/src/asyncclick/py.typed000066400000000000000000000000001452710122500215210ustar00rootroot00000000000000asyncclick-8.1.7.0-async/src/asyncclick/shell_completion.py000066400000000000000000000441441452710122500237550ustar00rootroot00000000000000import os import re import typing as t from gettext import gettext as _ from .core import Argument from .core import BaseCommand from .core import Context from .core import MultiCommand from .core import Option from .core import Parameter from .core import ParameterSource from .parser import split_arg_string from .utils import echo async def shell_complete( cli: BaseCommand, ctx_args: t.MutableMapping[str, t.Any], prog_name: str, complete_var: str, instruction: str, ) -> int: """Perform shell completion for the given CLI program. :param cli: Command being called. :param ctx_args: Extra arguments to pass to ``cli.make_context``. :param prog_name: Name of the executable in the shell. :param complete_var: Name of the environment variable that holds the completion instruction. :param instruction: Value of ``complete_var`` with the completion instruction and shell, in the form ``instruction_shell``. :return: Status code to exit with. """ shell, _, instruction = instruction.partition("_") comp_cls = get_completion_class(shell) if comp_cls is None: return 1 comp = comp_cls(cli, ctx_args, prog_name, complete_var) if instruction == "source": echo(comp.source()) return 0 if instruction == "complete": echo(await comp.complete()) return 0 return 1 class CompletionItem: """Represents a completion value and metadata about the value. The default metadata is ``type`` to indicate special shell handling, and ``help`` if a shell supports showing a help string next to the value. Arbitrary parameters can be passed when creating the object, and accessed using ``item.attr``. If an attribute wasn't passed, accessing it returns ``None``. :param value: The completion suggestion. :param type: Tells the shell script to provide special completion support for the type. Click uses ``"dir"`` and ``"file"``. :param help: String shown next to the value if supported. :param kwargs: Arbitrary metadata. The built-in implementations don't use this, but custom type completions paired with custom shell support could use it. """ __slots__ = ("value", "type", "help", "_info") def __init__( self, value: t.Any, type: str = "plain", help: t.Optional[str] = None, **kwargs: t.Any, ) -> None: self.value: t.Any = value self.type: str = type self.help: t.Optional[str] = help self._info = kwargs def __getattr__(self, name: str) -> t.Any: return self._info.get(name) # Only Bash >= 4.4 has the nosort option. _SOURCE_BASH = """\ %(complete_func)s() { local IFS=$'\\n' local response response=$(env COMP_WORDS="${COMP_WORDS[*]}" COMP_CWORD=$COMP_CWORD \ %(complete_var)s=bash_complete $1) for completion in $response; do IFS=',' read type value <<< "$completion" if [[ $type == 'dir' ]]; then COMPREPLY=() compopt -o dirnames elif [[ $type == 'file' ]]; then COMPREPLY=() compopt -o default elif [[ $type == 'plain' ]]; then COMPREPLY+=($value) fi done return 0 } %(complete_func)s_setup() { complete -o nosort -F %(complete_func)s %(prog_name)s } %(complete_func)s_setup; """ _SOURCE_ZSH = """\ #compdef %(prog_name)s %(complete_func)s() { local -a completions local -a completions_with_descriptions local -a response (( ! $+commands[%(prog_name)s] )) && return 1 response=("${(@f)$(env COMP_WORDS="${words[*]}" COMP_CWORD=$((CURRENT-1)) \ %(complete_var)s=zsh_complete %(prog_name)s)}") for type key descr in ${response}; do if [[ "$type" == "plain" ]]; then if [[ "$descr" == "_" ]]; then completions+=("$key") else completions_with_descriptions+=("$key":"$descr") fi elif [[ "$type" == "dir" ]]; then _path_files -/ elif [[ "$type" == "file" ]]; then _path_files -f fi done if [ -n "$completions_with_descriptions" ]; then _describe -V unsorted completions_with_descriptions -U fi if [ -n "$completions" ]; then compadd -U -V unsorted -a completions fi } if [[ $zsh_eval_context[-1] == loadautofunc ]]; then # autoload from fpath, call function directly %(complete_func)s "$@" else # eval/source/. command, register function for later compdef %(complete_func)s %(prog_name)s fi """ _SOURCE_FISH = """\ function %(complete_func)s; set -l response (env %(complete_var)s=fish_complete COMP_WORDS=(commandline -cp) \ COMP_CWORD=(commandline -t) %(prog_name)s); for completion in $response; set -l metadata (string split "," $completion); if test $metadata[1] = "dir"; __fish_complete_directories $metadata[2]; else if test $metadata[1] = "file"; __fish_complete_path $metadata[2]; else if test $metadata[1] = "plain"; echo $metadata[2]; end; end; end; complete --no-files --command %(prog_name)s --arguments \ "(%(complete_func)s)"; """ class ShellComplete: """Base class for providing shell completion support. A subclass for a given shell will override attributes and methods to implement the completion instructions (``source`` and ``complete``). :param cli: Command being called. :param prog_name: Name of the executable in the shell. :param complete_var: Name of the environment variable that holds the completion instruction. .. versionadded:: 8.0 """ name: t.ClassVar[str] """Name to register the shell as with :func:`add_completion_class`. This is used in completion instructions (``{name}_source`` and ``{name}_complete``). """ source_template: t.ClassVar[str] """Completion script template formatted by :meth:`source`. This must be provided by subclasses. """ def __init__( self, cli: BaseCommand, ctx_args: t.MutableMapping[str, t.Any], prog_name: str, complete_var: str, ) -> None: self.cli = cli self.ctx_args = ctx_args self.prog_name = prog_name self.complete_var = complete_var @property def func_name(self) -> str: """The name of the shell function defined by the completion script. """ safe_name = re.sub(r"\W*", "", self.prog_name.replace("-", "_"), flags=re.ASCII) return f"_{safe_name}_completion" def source_vars(self) -> t.Dict[str, t.Any]: """Vars for formatting :attr:`source_template`. By default this provides ``complete_func``, ``complete_var``, and ``prog_name``. """ return { "complete_func": self.func_name, "complete_var": self.complete_var, "prog_name": self.prog_name, } def source(self) -> str: """Produce the shell script that defines the completion function. By default this ``%``-style formats :attr:`source_template` with the dict returned by :meth:`source_vars`. """ return self.source_template % self.source_vars() def get_completion_args(self) -> t.Tuple[t.List[str], str]: """Use the env vars defined by the shell script to return a tuple of ``args, incomplete``. This must be implemented by subclasses. """ raise NotImplementedError async def get_completions( self, args: t.List[str], incomplete: str ) -> t.List[CompletionItem]: """Determine the context and last complete command or parameter from the complete args. Call that object's ``shell_complete`` method to get the completions for the incomplete value. :param args: List of complete args before the incomplete value. :param incomplete: Value being completed. May be empty. """ ctx = await _resolve_context(self.cli, self.ctx_args, self.prog_name, args) obj, incomplete = _resolve_incomplete(ctx, args, incomplete) return obj.shell_complete(ctx, incomplete) def format_completion(self, item: CompletionItem) -> str: """Format a completion item into the form recognized by the shell script. This must be implemented by subclasses. :param item: Completion item to format. """ raise NotImplementedError async def complete(self) -> str: """Produce the completion data to send back to the shell. By default this calls :meth:`get_completion_args`, gets the completions, then calls :meth:`format_completion` for each completion. """ args, incomplete = self.get_completion_args() completions = await self.get_completions(args, incomplete) out = [self.format_completion(item) for item in completions] return "\n".join(out) class BashComplete(ShellComplete): """Shell completion for Bash.""" name = "bash" source_template = _SOURCE_BASH @staticmethod def _check_version() -> None: import subprocess output = subprocess.run( ["bash", "-c", 'echo "${BASH_VERSION}"'], stdout=subprocess.PIPE ) match = re.search(r"^(\d+)\.(\d+)\.\d+", output.stdout.decode()) if match is not None: major, minor = match.groups() if major < "4" or major == "4" and minor < "4": echo( _( "Shell completion is not supported for Bash" " versions older than 4.4." ), err=True, ) else: echo( _("Couldn't detect Bash version, shell completion is not supported."), err=True, ) def source(self) -> str: self._check_version() return super().source() def get_completion_args(self) -> t.Tuple[t.List[str], str]: 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 = "" return args, incomplete def format_completion(self, item: CompletionItem) -> str: return f"{item.type},{item.value}" class ZshComplete(ShellComplete): """Shell completion for Zsh.""" name = "zsh" source_template = _SOURCE_ZSH def get_completion_args(self) -> t.Tuple[t.List[str], str]: 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 = "" return args, incomplete def format_completion(self, item: CompletionItem) -> str: return f"{item.type}\n{item.value}\n{item.help if item.help else '_'}" class FishComplete(ShellComplete): """Shell completion for Fish.""" name = "fish" source_template = _SOURCE_FISH def get_completion_args(self) -> t.Tuple[t.List[str], str]: cwords = split_arg_string(os.environ["COMP_WORDS"]) incomplete = os.environ["COMP_CWORD"] args = cwords[1:] # Fish stores the partial word in both COMP_WORDS and # COMP_CWORD, remove it from complete args. if incomplete and args and args[-1] == incomplete: args.pop() return args, incomplete def format_completion(self, item: CompletionItem) -> str: if item.help: return f"{item.type},{item.value}\t{item.help}" return f"{item.type},{item.value}" ShellCompleteType = t.TypeVar("ShellCompleteType", bound=t.Type[ShellComplete]) _available_shells: t.Dict[str, t.Type[ShellComplete]] = { "bash": BashComplete, "fish": FishComplete, "zsh": ZshComplete, } def add_completion_class( cls: ShellCompleteType, name: t.Optional[str] = None ) -> ShellCompleteType: """Register a :class:`ShellComplete` subclass under the given name. The name will be provided by the completion instruction environment variable during completion. :param cls: The completion class that will handle completion for the shell. :param name: Name to register the class under. Defaults to the class's ``name`` attribute. """ if name is None: name = cls.name _available_shells[name] = cls return cls def get_completion_class(shell: str) -> t.Optional[t.Type[ShellComplete]]: """Look up a registered :class:`ShellComplete` subclass by the name provided by the completion instruction environment variable. If the name isn't registered, returns ``None``. :param shell: Name the class is registered under. """ return _available_shells.get(shell) def _is_incomplete_argument(ctx: Context, param: Parameter) -> bool: """Determine if the given parameter is an argument that can still accept values. :param ctx: Invocation context for the command represented by the parsed complete args. :param param: Argument object being checked. """ if not isinstance(param, Argument): return False assert param.name is not None # Will be None if expose_value is False. value = ctx.params.get(param.name) return ( param.nargs == -1 or ctx.get_parameter_source(param.name) is not ParameterSource.COMMANDLINE or ( param.nargs > 1 and isinstance(value, (tuple, list)) and len(value) < param.nargs ) ) def _start_of_option(ctx: Context, value: str) -> bool: """Check if the value looks like the start of an option.""" if not value: return False c = value[0] return c in ctx._opt_prefixes def _is_incomplete_option(ctx: Context, args: t.List[str], param: Parameter) -> bool: """Determine if the given parameter is an option that needs a value. :param args: List of complete args before the incomplete value. :param param: Option object being checked. """ if not isinstance(param, Option): return False if param.is_flag or param.count: return False last_option = None for index, arg in enumerate(reversed(args)): if index + 1 > param.nargs: break if _start_of_option(ctx, arg): last_option = arg return last_option is not None and last_option in param.opts async def _resolve_context( cli: BaseCommand, ctx_args: t.MutableMapping[str, t.Any], prog_name: str, args: t.List[str], ) -> Context: """Produce the context hierarchy starting with the command and traversing the complete arguments. This only follows the commands, it doesn't trigger input prompts or callbacks. :param cli: Command being called. :param prog_name: Name of the executable in the shell. :param args: List of complete args before the incomplete value. """ ctx_args["resilient_parsing"] = True ctx = await cli.make_context(prog_name, args.copy(), **ctx_args) args = ctx.protected_args + ctx.args while args: command = ctx.command if isinstance(command, MultiCommand): if not command.chain: name, cmd, args = await command.resolve_command(ctx, args) if cmd is None: return ctx ctx = await cmd.make_context(name, args, parent=ctx, resilient_parsing=True) args = ctx.protected_args + ctx.args else: sub_ctx = ctx while args: name, cmd, args = await command.resolve_command(ctx, args) if cmd is None: return ctx sub_ctx = await cmd.make_context( 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 _resolve_incomplete( ctx: Context, args: t.List[str], incomplete: str ) -> t.Tuple[t.Union[BaseCommand, Parameter], str]: """Find the Click object that will handle the completion of the incomplete value. Return the object and the incomplete value. :param ctx: Invocation context for the command represented by the parsed complete args. :param args: List of complete args before the incomplete value. :param incomplete: Value being completed. May be empty. """ # Different shells treat an "=" between a long option name and # value differently. Might keep the value joined, return the "=" # as a separate item, or return the split name and value. Always # split and discard the "=" to make completion easier. if incomplete == "=": incomplete = "" elif "=" in incomplete and _start_of_option(ctx, incomplete): name, _, incomplete = incomplete.partition("=") args.append(name) # The "--" marker tells Click to stop treating values as options # even if they start with the option character. If it hasn't been # given and the incomplete arg looks like an option, the current # command will provide option name completions. if "--" not in args and _start_of_option(ctx, incomplete): return ctx.command, incomplete params = ctx.command.get_params(ctx) # If the last complete arg is an option name with an incomplete # value, the option will provide value completions. for param in params: if _is_incomplete_option(ctx, args, param): return param, incomplete # It's not an option name or value. The first argument without a # parsed value will provide value completions. for param in params: if _is_incomplete_argument(ctx, param): return param, incomplete # There were no unparsed arguments, the command may be a group that # will provide command name completions. return ctx.command, incomplete asyncclick-8.1.7.0-async/src/asyncclick/termui.py000066400000000000000000000672441452710122500217300ustar00rootroot00000000000000import inspect import io import itertools import sys import typing as t from gettext import gettext as _ from ._compat import isatty from ._compat import strip_ansi from .exceptions import Abort from .exceptions import UsageError from .globals import resolve_color_default from .types import Choice from .types import convert_type from .types import ParamType from .utils import echo from .utils import LazyFile if t.TYPE_CHECKING: from ._termui_impl import ProgressBar V = t.TypeVar("V") # The prompt functions to use. The doc tools currently override these # functions to customize how they work. visible_prompt_func: t.Callable[[str], str] = 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: str) -> str: import getpass return getpass.getpass(prompt) def _build_prompt( text: str, suffix: str, show_default: bool = False, default: t.Optional[t.Any] = None, show_choices: bool = True, type: t.Optional[ParamType] = None, ) -> str: prompt = text if type is not None and show_choices and isinstance(type, Choice): prompt += f" ({', '.join(map(str, type.choices))})" if default is not None and show_default: prompt = f"{prompt} [{_format_default(default)}]" return f"{prompt}{suffix}" def _format_default(default: t.Any) -> t.Any: if isinstance(default, (io.IOBase, LazyFile)) and hasattr(default, "name"): return default.name return default def prompt( text: str, default: t.Optional[t.Any] = None, hide_input: bool = False, confirmation_prompt: t.Union[bool, str] = False, type: t.Optional[t.Union[ParamType, t.Any]] = None, value_proc: t.Optional[t.Callable[[str], t.Any]] = None, prompt_suffix: str = ": ", show_default: bool = True, err: bool = False, show_choices: bool = True, ) -> t.Any: """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 an interrupt signal, this function will catch it and raise a :exc:`Abort` exception. :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: Prompt a second time to confirm the value. Can be set to a string instead of ``True`` to customize the message. :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): ". .. versionadded:: 8.0 ``confirmation_prompt`` can be a custom string. .. 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. """ def prompt_func(text: str) -> str: f = hidden_prompt_func if hide_input else visible_prompt_func try: # Write the prompt separately so that we get nice # coloring through colorama on Windows echo(text.rstrip(" "), nl=False, err=err) # Echo a space to stdout to work around an issue where # readline causes backspace to clear the whole line. 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() from None if value_proc is None: value_proc = convert_type(type, default) prompt = _build_prompt( text, prompt_suffix, show_default, default, show_choices, type ) if confirmation_prompt: if confirmation_prompt is True: confirmation_prompt = _("Repeat for confirmation") confirmation_prompt = _build_prompt(confirmation_prompt, prompt_suffix) while True: while True: value = prompt_func(prompt) if value: break elif default is not None: value = default break try: result = value_proc(value) except UsageError as e: if hide_input: echo(_("Error: The value you entered was invalid."), err=err) else: echo(_("Error: {e.message}").format(e=e), err=err) # noqa: B306 continue if not confirmation_prompt: return result while True: value2 = prompt_func(confirmation_prompt) is_empty = not value and not value2 if value2 or is_empty: break if value == value2: return result echo(_("Error: The two entered values do not match."), err=err) def confirm( text: str, default: t.Optional[bool] = False, abort: bool = False, prompt_suffix: str = ": ", show_default: bool = True, err: bool = False, ) -> bool: """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. :param text: the question to ask. :param default: The default value to use when no input is given. If ``None``, repeat until input is given. :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. .. versionchanged:: 8.0 Repeat until input is given if ``default`` is ``None``. .. versionadded:: 4.0 Added the ``err`` parameter. """ prompt = _build_prompt( text, prompt_suffix, show_default, "y/n" if default is None else ("Y/n" if default else "y/N"), ) while True: try: # Write the prompt separately so that we get nice # coloring through colorama on Windows echo(prompt.rstrip(" "), nl=False, err=err) # Echo a space to stdout to work around an issue where # readline causes backspace to clear the whole line. value = visible_prompt_func(" ").lower().strip() except (KeyboardInterrupt, EOFError): raise Abort() from None if value in ("y", "yes"): rv = True elif value in ("n", "no"): rv = False elif default is not None and value == "": rv = default else: echo(_("Error: invalid input"), err=err) continue break if abort and not rv: raise Abort() return rv def echo_via_pager( text_or_generator: t.Union[t.Iterable[str], t.Callable[[], t.Iterable[str]], str], color: t.Optional[bool] = None, ) -> 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 = t.cast(t.Callable[[], t.Iterable[str]], text_or_generator)() elif isinstance(text_or_generator, str): i = [text_or_generator] else: i = iter(t.cast(t.Iterable[str], text_or_generator)) # convert every element of i to a text type if necessary text_generator = (el if isinstance(el, str) else str(el) for el in i) from ._termui_impl import pager return pager(itertools.chain(text_generator, "\n"), color) def progressbar( iterable: t.Optional[t.Iterable[V]] = None, length: t.Optional[int] = None, label: t.Optional[str] = None, show_eta: bool = True, show_percent: t.Optional[bool] = None, show_pos: bool = False, item_show_func: t.Optional[t.Callable[[t.Optional[V]], t.Optional[str]]] = None, fill_char: str = "#", empty_char: str = "-", bar_template: str = "%(label)s [%(bar)s] %(info)s", info_sep: str = " ", width: int = 36, file: t.Optional[t.TextIO] = None, color: t.Optional[bool] = None, update_min_steps: int = 1, ) -> "ProgressBar[V]": """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 created. 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. Note: The progress bar is currently designed for use cases where the total progress can be expected to take at least several seconds. Because of this, the ProgressBar class object won't display progress that is considered too fast, and progress where the time between steps is less than a second. 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) The ``update()`` method also takes an optional value specifying the ``current_item`` at the new position. This is useful when used together with ``item_show_func`` to customize the output for each manual step:: with click.progressbar( length=total_size, label='Unzipping archive', item_show_func=lambda a: a.filename ) as bar: for archive in zip_file: archive.extract() bar.update(archive.size, archive) :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 next to the progress bar. If the function returns ``None`` nothing is shown. The current item can be ``None``, such as when entering and exiting the bar. :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. :param update_min_steps: Render only when this many updates have completed. This allows tuning for very fast iterators. .. versionchanged:: 8.0 Output is shown even if execution time is less than 0.5 seconds. .. versionchanged:: 8.0 ``item_show_func`` shows the current item, not the previous one. .. versionchanged:: 8.0 Labels are echoed if the output is not a TTY. Reverts a change in 7.0 that removed all output. .. versionadded:: 8.0 Added the ``update_min_steps`` parameter. .. versionchanged:: 4.0 Added the ``color`` parameter. Added the ``update`` method to the object. .. versionadded:: 2.0 """ 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, update_min_steps=update_min_steps, ) def clear() -> None: """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 # ANSI escape \033[2J clears the screen, \033[1;1H moves the cursor echo("\033[2J\033[1;1H", nl=False) def _interpret_color( color: t.Union[int, t.Tuple[int, int, int], str], offset: int = 0 ) -> str: if isinstance(color, int): return f"{38 + offset};5;{color:d}" if isinstance(color, (tuple, list)): r, g, b = color return f"{38 + offset};2;{r:d};{g:d};{b:d}" return str(_ansi_colors[color] + offset) def style( text: t.Any, fg: t.Optional[t.Union[int, t.Tuple[int, int, int], str]] = None, bg: t.Optional[t.Union[int, t.Tuple[int, int, int], str]] = None, bold: t.Optional[bool] = None, dim: t.Optional[bool] = None, underline: t.Optional[bool] = None, overline: t.Optional[bool] = None, italic: t.Optional[bool] = None, blink: t.Optional[bool] = None, reverse: t.Optional[bool] = None, strikethrough: t.Optional[bool] = None, reset: bool = True, ) -> str: """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')) click.echo(click.style('More colors', fg=(255, 12, 128), bg=117)) 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) If the terminal supports it, color may also be specified as: - An integer in the interval [0, 255]. The terminal must support 8-bit/256-color mode. - An RGB tuple of three integers in [0, 255]. The terminal must support 24-bit/true-color mode. See https://en.wikipedia.org/wiki/ANSI_color and https://gist.github.com/XVilka/8346728 for more information. :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 overline: if provided this will enable or disable overline. :param italic: if provided this will enable or disable italic. :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 strikethrough: if provided this will enable or disable striking through text. :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. .. versionchanged:: 8.0 A non-string ``message`` is converted to a string. .. versionchanged:: 8.0 Added support for 256 and RGB color codes. .. versionchanged:: 8.0 Added the ``strikethrough``, ``italic``, and ``overline`` parameters. .. versionchanged:: 7.0 Added support for bright colors. .. versionadded:: 2.0 """ if not isinstance(text, str): text = str(text) bits = [] if fg: try: bits.append(f"\033[{_interpret_color(fg)}m") except KeyError: raise TypeError(f"Unknown color {fg!r}") from None if bg: try: bits.append(f"\033[{_interpret_color(bg, 10)}m") except KeyError: raise TypeError(f"Unknown color {bg!r}") from None if bold is not None: bits.append(f"\033[{1 if bold else 22}m") if dim is not None: bits.append(f"\033[{2 if dim else 22}m") if underline is not None: bits.append(f"\033[{4 if underline else 24}m") if overline is not None: bits.append(f"\033[{53 if overline else 55}m") if italic is not None: bits.append(f"\033[{3 if italic else 23}m") if blink is not None: bits.append(f"\033[{5 if blink else 25}m") if reverse is not None: bits.append(f"\033[{7 if reverse else 27}m") if strikethrough is not None: bits.append(f"\033[{9 if strikethrough else 29}m") bits.append(text) if reset: bits.append(_ansi_reset_all) return "".join(bits) def unstyle(text: str) -> str: """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: t.Optional[t.Any] = None, file: t.Optional[t.IO[t.AnyStr]] = None, nl: bool = True, err: bool = False, color: t.Optional[bool] = None, **styles: t.Any, ) -> None: """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. Non-string types will be converted to :class:`str`. However, :class:`bytes` are passed directly to :meth:`echo` without applying style. If you want to style bytes that represent text, call :meth:`bytes.decode` first. .. versionchanged:: 8.0 A non-string ``message`` is converted to a string. Bytes are passed through without style applied. .. versionadded:: 2.0 """ if message is not None and not isinstance(message, (bytes, bytearray)): message = style(message, **styles) return echo(message, file=file, nl=nl, err=err, color=color) def edit( text: t.Optional[t.AnyStr] = None, editor: t.Optional[str] = None, env: t.Optional[t.Mapping[str, str]] = None, require_save: bool = True, extension: str = ".txt", filename: t.Optional[str] = None, ) -> t.Optional[t.AnyStr]: 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 ed = Editor(editor=editor, env=env, require_save=require_save, extension=extension) if filename is None: return ed.edit(text) ed.edit_file(filename) return None def launch(url: str, wait: bool = False, locate: bool = False) -> int: """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: Wait for the program to exit before returning. This only works if the launched program blocks. In particular, ``xdg-open`` on Linux does not block. :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: t.Optional[t.Callable[[bool], str]] = None def getchar(echo: bool = False) -> str: """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. """ global _getchar if _getchar is None: from ._termui_impl import getchar as f _getchar = f return _getchar(echo) def raw_terminal() -> t.ContextManager[int]: from ._termui_impl import raw_terminal as f return f() def pause(info: t.Optional[str] = None, err: bool = False) -> None: """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 message to print before pausing. Defaults to ``"Press any key to continue..."``. :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 if info is None: info = _("Press any key to continue...") try: if info: echo(info, nl=False, err=err) try: getchar() except (KeyboardInterrupt, EOFError): pass finally: if info: echo(err=err) asyncclick-8.1.7.0-async/src/asyncclick/testing.py000066400000000000000000000377151452710122500221000ustar00rootroot00000000000000import contextlib import io import os import shlex import shutil import sys import tempfile import typing as t from types import TracebackType from . import formatting from . import termui from . import utils from ._compat import _find_binary_reader if t.TYPE_CHECKING: from .core import BaseCommand class EchoingStdin: def __init__(self, input: t.BinaryIO, output: t.BinaryIO) -> None: self._input = input self._output = output self._paused = False def __getattr__(self, x: str) -> t.Any: return getattr(self._input, x) def _echo(self, rv: bytes) -> bytes: if not self._paused: self._output.write(rv) return rv def read(self, n: int = -1) -> bytes: return self._echo(self._input.read(n)) def read1(self, n: int = -1) -> bytes: return self._echo(self._input.read1(n)) # type: ignore def readline(self, n: int = -1) -> bytes: return self._echo(self._input.readline(n)) def readlines(self) -> t.List[bytes]: return [self._echo(x) for x in self._input.readlines()] def __iter__(self) -> t.Iterator[bytes]: return iter(self._echo(x) for x in self._input) def __repr__(self) -> str: return repr(self._input) @contextlib.contextmanager def _pause_echo(stream: t.Optional[EchoingStdin]) -> t.Iterator[None]: if stream is None: yield else: stream._paused = True yield stream._paused = False class _NamedTextIOWrapper(io.TextIOWrapper): def __init__( self, buffer: t.BinaryIO, name: str, mode: str, **kwargs: t.Any ) -> None: super().__init__(buffer, **kwargs) self._name = name self._mode = mode @property def name(self) -> str: return self._name @property def mode(self) -> str: return self._mode def make_input_stream( input: t.Optional[t.Union[str, bytes, t.IO[t.Any]]], charset: str ) -> t.BinaryIO: # Is already an input stream. if hasattr(input, "read"): rv = _find_binary_reader(t.cast(t.IO[t.Any], 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 isinstance(input, str): input = input.encode(charset) return io.BytesIO(input) class Result: """Holds the captured result of an invoked CLI script.""" def __init__( self, runner: "CliRunner", stdout_bytes: bytes, stderr_bytes: t.Optional[bytes], return_value: t.Any, exit_code: int, exception: t.Optional[BaseException], exc_info: t.Optional[ t.Tuple[t.Type[BaseException], BaseException, TracebackType] ] = 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 None if not available self.stderr_bytes = stderr_bytes #: The value returned from the invoked command. #: #: .. versionadded:: 8.0 self.return_value = return_value #: 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) -> str: """The (standard) output as unicode string.""" return self.stdout @property def stdout(self) -> str: """The standard output as unicode string.""" return self.stdout_bytes.decode(self.runner.charset, "replace").replace( "\r\n", "\n" ) @property def stderr(self) -> str: """The standard error as unicode string.""" if self.stderr_bytes is None: raise ValueError("stderr not separately captured") return self.stderr_bytes.decode(self.runner.charset, "replace").replace( "\r\n", "\n" ) def __repr__(self) -> str: exc_str = repr(self.exception) if self.exception else "okay" return f"<{type(self).__name__} {exc_str}>" class CliRunner: """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. :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: str = "utf-8", env: t.Optional[t.Mapping[str, t.Optional[str]]] = None, echo_stdin: bool = False, mix_stderr: bool = True, ) -> None: self.charset = charset self.env: t.Mapping[str, t.Optional[str]] = env or {} self.echo_stdin = echo_stdin self.mix_stderr = mix_stderr def get_default_prog_name(self, cli: "BaseCommand") -> str: """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: t.Optional[t.Mapping[str, t.Optional[str]]] = None ) -> t.Mapping[str, t.Optional[str]]: """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: t.Optional[t.Union[str, bytes, t.IO[t.Any]]] = None, env: t.Optional[t.Mapping[str, t.Optional[str]]] = None, color: bool = False, ) -> t.Iterator[t.Tuple[io.BytesIO, t.Optional[io.BytesIO]]]: """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. :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. .. versionchanged:: 8.0 ``stderr`` is opened with ``errors="backslashreplace"`` instead of the default ``"strict"``. .. versionchanged:: 4.0 Added the ``color`` parameter. """ bytes_input = make_input_stream(input, self.charset) echo_input = None old_stdin = sys.stdin old_stdout = sys.stdout old_stderr = sys.stderr sys.old_stdin = sys.stdin sys.old_stdout = sys.stdout sys.old_stderr = sys.stderr old_forced_width = formatting.FORCED_WIDTH formatting.FORCED_WIDTH = 80 env = self.make_env(env) bytes_output = io.BytesIO() if self.echo_stdin: bytes_input = echo_input = t.cast( t.BinaryIO, EchoingStdin(bytes_input, bytes_output) ) sys.stdin = text_input = _NamedTextIOWrapper( bytes_input, encoding=self.charset, name="", mode="r" ) if self.echo_stdin: # Force unbuffered reads, otherwise TextIOWrapper reads a # large chunk which is echoed early. text_input._CHUNK_SIZE = 1 # type: ignore sys.stdout = _NamedTextIOWrapper( bytes_output, encoding=self.charset, name="", mode="w" ) bytes_error = None if self.mix_stderr: sys.stderr = sys.stdout else: bytes_error = io.BytesIO() sys.stderr = _NamedTextIOWrapper( bytes_error, encoding=self.charset, name="", mode="w", errors="backslashreplace", ) @_pause_echo(echo_input) # type: ignore def visible_input(prompt: t.Optional[str] = None) -> str: sys.stdout.write(prompt or "") val = text_input.readline().rstrip("\r\n") sys.stdout.write(f"{val}\n") sys.stdout.flush() return val @_pause_echo(echo_input) # type: ignore def hidden_input(prompt: t.Optional[str] = None) -> str: sys.stdout.write(f"{prompt or ''}\n") sys.stdout.flush() return text_input.readline().rstrip("\r\n") @_pause_echo(echo_input) # type: ignore def _getchar(echo: bool) -> str: char = sys.stdin.read(1) if echo: sys.stdout.write(char) sys.stdout.flush() return char default_color = color def should_strip_ansi( stream: t.Optional[t.IO[t.Any]] = None, color: t.Optional[bool] = None ) -> bool: if color is None: return not default_color return not color old_visible_prompt_func = termui.visible_prompt_func old_hidden_prompt_func = termui.hidden_prompt_func old__getchar_func = termui._getchar old_should_strip_ansi = utils.should_strip_ansi # type: ignore termui.visible_prompt_func = visible_input termui.hidden_prompt_func = hidden_input termui._getchar = _getchar utils.should_strip_ansi = should_strip_ansi # type: ignore old_env = {} try: for key, value in env.items(): 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, bytes_error) finally: for key, value in old_env.items(): if value is None: try: del os.environ[key] except Exception: pass else: os.environ[key] = value sys.stdout = sys.old_stdout sys.stderr = sys.old_stderr sys.stdin = sys.old_stdin sys.old_stdout = old_stdout sys.old_stderr = old_stderr sys.old_stdin = old_stdin termui.visible_prompt_func = old_visible_prompt_func termui.hidden_prompt_func = old_hidden_prompt_func termui._getchar = old__getchar_func utils.should_strip_ansi = old_should_strip_ansi # type: ignore formatting.FORCED_WIDTH = old_forced_width async def invoke( self, cli: "BaseCommand", args: t.Optional[t.Union[str, t.Sequence[str]]] = None, input: t.Optional[t.Union[str, bytes, t.IO[t.Any]]] = None, env: t.Optional[t.Mapping[str, t.Optional[str]]] = None, catch_exceptions: bool = True, color: bool = False, **extra: t.Any, ) -> Result: """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. :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. .. versionchanged:: 8.0 The result object has the ``return_value`` attribute with the value returned from the invoked command. .. versionchanged:: 4.0 Added the ``color`` parameter. .. versionchanged:: 3.0 Added the ``catch_exceptions`` parameter. .. versionchanged:: 3.0 The result object has the ``exc_info`` attribute with the traceback if available. """ exc_info = None with self.isolation(input=input, env=env, color=color) as outstreams: return_value = None exception: t.Optional[BaseException] = None exit_code = 0 if isinstance(args, str): args = shlex.split(args) try: prog_name = extra.pop("prog_name") except KeyError: prog_name = self.get_default_prog_name(cli) try: return_value = await cli.main(args=args or (), prog_name=prog_name, **extra) except SystemExit as e: exc_info = sys.exc_info() e_code = t.cast(t.Optional[t.Union[int, t.Any]], e.code) if e_code is None: e_code = 0 if e_code != 0: exception = e if not isinstance(e_code, int): sys.stdout.write(str(e_code)) sys.stdout.write("\n") e_code = 1 exit_code = e_code 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() if self.mix_stderr: stderr = None else: stderr = outstreams[1].getvalue() # type: ignore return Result( runner=self, stdout_bytes=stdout, stderr_bytes=stderr, return_value=return_value, exit_code=exit_code, exception=exception, exc_info=exc_info, # type: ignore ) @contextlib.contextmanager def isolated_filesystem( self, temp_dir: t.Optional[t.Union[str, "os.PathLike[str]"]] = None ) -> t.Iterator[str]: """A context manager that creates a temporary directory and changes the current working directory to it. This isolates tests that affect the contents of the CWD to prevent them from interfering with each other. :param temp_dir: Create the temporary directory under this directory. If given, the created directory is not removed when exiting. .. versionchanged:: 8.0 Added the ``temp_dir`` parameter. """ cwd = os.getcwd() dt = tempfile.mkdtemp(dir=temp_dir) os.chdir(dt) try: yield dt finally: os.chdir(cwd) if temp_dir is None: try: shutil.rmtree(dt) except OSError: # noqa: B014 pass asyncclick-8.1.7.0-async/src/asyncclick/types.py000066400000000000000000001071701452710122500215600ustar00rootroot00000000000000import os import stat import sys import typing as t from datetime import datetime from gettext import gettext as _ from gettext import ngettext from ._compat import _get_argv_encoding from ._compat import open_stream from .exceptions import BadParameter from .utils import format_filename from .utils import LazyFile from .utils import safecall if t.TYPE_CHECKING: import typing_extensions as te from .core import Context from .core import Parameter from .shell_completion import CompletionItem class ParamType: """Represents the type of a parameter. Validates and converts values from the command line or Python into the correct type. To implement a custom type, subclass and implement at least the following: - The :attr:`name` class attribute must be set. - Calling an instance of the type with ``None`` must return ``None``. This is already implemented by default. - :meth:`convert` must convert string values to the correct type. - :meth:`convert` must accept values that are already the correct type. - It must be able to convert a value if the ``ctx`` and ``param`` arguments are ``None``. This can occur when converting prompt input. """ is_composite: t.ClassVar[bool] = False arity: t.ClassVar[int] = 1 #: the descriptive name of this type name: str #: 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: t.ClassVar[t.Optional[str]] = None async def to_info_dict(self) -> t.Dict[str, t.Any]: """Gather information that could be useful for a tool generating user-facing documentation. Use :meth:`click.Context.to_info_dict` to traverse the entire CLI structure. .. versionadded:: 8.0 """ # The class name without the "ParamType" suffix. param_type = type(self).__name__.partition("ParamType")[0] param_type = param_type.partition("ParameterType")[0] # Custom subclasses might not remember to set a name. if hasattr(self, "name"): name = self.name else: name = param_type return {"param_type": param_type, "name": name} def __call__( self, value: t.Any, param: t.Optional["Parameter"] = None, ctx: t.Optional["Context"] = None, ) -> t.Any: if value is not None: return self.convert(value, param, ctx) def get_metavar(self, param: "Parameter") -> t.Optional[str]: """Returns the metavar default for this param if it provides one.""" def get_missing_message(self, param: "Parameter") -> t.Optional[str]: """Optionally might return extra information about a missing parameter. .. versionadded:: 2.0 """ def convert( self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"] ) -> t.Any: """Convert the value to the correct type. This is not called if the value is ``None`` (the missing value). This must accept string values from the command line, as well as values that are already the correct type. It may also convert other compatible types. The ``param`` and ``ctx`` arguments may be ``None`` in certain situations, such as when converting prompt input. If the value cannot be converted, call :meth:`fail` with a descriptive message. :param value: The value to convert. :param param: The parameter that is using this type to convert its value. May be ``None``. :param ctx: The current context that arrived at this value. May be ``None``. """ return value def split_envvar_value(self, rv: str) -> t.Sequence[str]: """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: str, param: t.Optional["Parameter"] = None, ctx: t.Optional["Context"] = None, ) -> "t.NoReturn": """Helper method to fail with an invalid value message.""" raise BadParameter(message, ctx=ctx, param=param) def shell_complete( self, ctx: "Context", param: "Parameter", incomplete: str ) -> t.List["CompletionItem"]: """Return a list of :class:`~click.shell_completion.CompletionItem` objects for the incomplete value. Most types do not provide completions, but some do, and this allows custom types to provide custom completions as well. :param ctx: Invocation context for this command. :param param: The parameter that is requesting completion. :param incomplete: Value being completed. May be empty. .. versionadded:: 8.0 """ return [] class CompositeParamType(ParamType): is_composite = True @property def arity(self) -> int: # type: ignore raise NotImplementedError() class FuncParamType(ParamType): def __init__(self, func: t.Callable[[t.Any], t.Any]) -> None: self.name: str = func.__name__ self.func = func async def to_info_dict(self) -> t.Dict[str, t.Any]: info_dict = await super().to_info_dict() info_dict["func"] = self.func return info_dict def convert( self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"] ) -> t.Any: try: return self.func(value) except ValueError: try: value = str(value) except UnicodeError: value = value.decode("utf-8", "replace") self.fail(value, param, ctx) class UnprocessedParamType(ParamType): name = "text" def convert( self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"] ) -> t.Any: return value def __repr__(self) -> str: return "UNPROCESSED" class StringParamType(ParamType): name = "text" def convert( self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"] ) -> t.Any: if isinstance(value, bytes): enc = _get_argv_encoding() try: value = value.decode(enc) except UnicodeError: fs_enc = sys.getfilesystemencoding() if fs_enc != enc: try: value = value.decode(fs_enc) except UnicodeError: value = value.decode("utf-8", "replace") else: value = value.decode("utf-8", "replace") return value return str(value) def __repr__(self) -> str: 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. The resulting value will always be one of the originally passed choices regardless of ``case_sensitive`` or any ``ctx.token_normalize_func`` being specified. 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: t.Sequence[str], case_sensitive: bool = True) -> None: self.choices = choices self.case_sensitive = case_sensitive async def to_info_dict(self) -> t.Dict[str, t.Any]: info_dict = await super().to_info_dict() info_dict["choices"] = self.choices info_dict["case_sensitive"] = self.case_sensitive return info_dict def get_metavar(self, param: "Parameter") -> str: choices_str = "|".join(self.choices) # Use curly braces to indicate a required argument. if param.required and param.param_type_name == "argument": return f"{{{choices_str}}}" # Use square braces to indicate an option or optional argument. return f"[{choices_str}]" def get_missing_message(self, param: "Parameter") -> str: return _("Choose from:\n\t{choices}").format(choices=",\n\t".join(self.choices)) def convert( self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"] ) -> t.Any: # 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 = {choice: choice for choice in 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(normed_choice): original for normed_choice, original in normed_choices.items() } if not self.case_sensitive: normed_value = normed_value.casefold() normed_choices = { normed_choice.casefold(): original for normed_choice, original in normed_choices.items() } if normed_value in normed_choices: return normed_choices[normed_value] choices_str = ", ".join(map(repr, self.choices)) self.fail( ngettext( "{value!r} is not {choice}.", "{value!r} is not one of {choices}.", len(self.choices), ).format(value=value, choice=choices_str, choices=choices_str), param, ctx, ) def __repr__(self) -> str: return f"Choice({list(self.choices)})" def shell_complete( self, ctx: "Context", param: "Parameter", incomplete: str ) -> t.List["CompletionItem"]: """Complete choices that start with the incomplete value. :param ctx: Invocation context for this command. :param param: The parameter that is requesting completion. :param incomplete: Value being completed. May be empty. .. versionadded:: 8.0 """ from .shell_completion import CompletionItem str_choices = map(str, self.choices) if self.case_sensitive: matched = (c for c in str_choices if c.startswith(incomplete)) else: incomplete = incomplete.lower() matched = (c for c in str_choices if c.lower().startswith(incomplete)) return [CompletionItem(c) for c in matched] 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: t.Optional[t.Sequence[str]] = None): self.formats: t.Sequence[str] = formats or [ "%Y-%m-%d", "%Y-%m-%dT%H:%M:%S", "%Y-%m-%d %H:%M:%S", ] async def to_info_dict(self) -> t.Dict[str, t.Any]: info_dict = await super().to_info_dict() info_dict["formats"] = self.formats return info_dict def get_metavar(self, param: "Parameter") -> str: return f"[{'|'.join(self.formats)}]" def _try_to_convert_date(self, value: t.Any, format: str) -> t.Optional[datetime]: try: return datetime.strptime(value, format) except ValueError: return None def convert( self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"] ) -> t.Any: if isinstance(value, datetime): return value for format in self.formats: converted = self._try_to_convert_date(value, format) if converted is not None: return converted formats_str = ", ".join(map(repr, self.formats)) self.fail( ngettext( "{value!r} does not match the format {format}.", "{value!r} does not match the formats {formats}.", len(self.formats), ).format(value=value, format=formats_str, formats=formats_str), param, ctx, ) def __repr__(self) -> str: return "DateTime" class _NumberParamTypeBase(ParamType): _number_class: t.ClassVar[t.Type[t.Any]] def convert( self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"] ) -> t.Any: try: return self._number_class(value) except ValueError: self.fail( _("{value!r} is not a valid {number_type}.").format( value=value, number_type=self.name ), param, ctx, ) class _NumberRangeBase(_NumberParamTypeBase): def __init__( self, min: t.Optional[float] = None, max: t.Optional[float] = None, min_open: bool = False, max_open: bool = False, clamp: bool = False, ) -> None: self.min = min self.max = max self.min_open = min_open self.max_open = max_open self.clamp = clamp async def to_info_dict(self) -> t.Dict[str, t.Any]: info_dict = await super().to_info_dict() info_dict.update( min=self.min, max=self.max, min_open=self.min_open, max_open=self.max_open, clamp=self.clamp, ) return info_dict def convert( self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"] ) -> t.Any: import operator rv = super().convert(value, param, ctx) lt_min: bool = self.min is not None and ( operator.le if self.min_open else operator.lt )(rv, self.min) gt_max: bool = self.max is not None and ( operator.ge if self.max_open else operator.gt )(rv, self.max) if self.clamp: if lt_min: return self._clamp(self.min, 1, self.min_open) # type: ignore if gt_max: return self._clamp(self.max, -1, self.max_open) # type: ignore if lt_min or gt_max: self.fail( _("{value} is not in the range {range}.").format( value=rv, range=self._describe_range() ), param, ctx, ) return rv def _clamp(self, bound: float, dir: "te.Literal[1, -1]", open: bool) -> float: """Find the valid value to clamp to bound in the given direction. :param bound: The boundary value. :param dir: 1 or -1 indicating the direction to move. :param open: If true, the range does not include the bound. """ raise NotImplementedError def _describe_range(self) -> str: """Describe the range for use in help text.""" if self.min is None: op = "<" if self.max_open else "<=" return f"x{op}{self.max}" if self.max is None: op = ">" if self.min_open else ">=" return f"x{op}{self.min}" lop = "<" if self.min_open else "<=" rop = "<" if self.max_open else "<=" return f"{self.min}{lop}x{rop}{self.max}" def __repr__(self) -> str: clamp = " clamped" if self.clamp else "" return f"<{type(self).__name__} {self._describe_range()}{clamp}>" class IntParamType(_NumberParamTypeBase): name = "integer" _number_class = int def __repr__(self) -> str: return "INT" class IntRange(_NumberRangeBase, IntParamType): """Restrict an :data:`click.INT` value to a range of accepted values. See :ref:`ranges`. If ``min`` or ``max`` are not passed, any value is accepted in that direction. If ``min_open`` or ``max_open`` are enabled, the corresponding boundary is not included in the range. If ``clamp`` is enabled, a value outside the range is clamped to the boundary instead of failing. .. versionchanged:: 8.0 Added the ``min_open`` and ``max_open`` parameters. """ name = "integer range" def _clamp( # type: ignore self, bound: int, dir: "te.Literal[1, -1]", open: bool ) -> int: if not open: return bound return bound + dir class FloatParamType(_NumberParamTypeBase): name = "float" _number_class = float def __repr__(self) -> str: return "FLOAT" class FloatRange(_NumberRangeBase, FloatParamType): """Restrict a :data:`click.FLOAT` value to a range of accepted values. See :ref:`ranges`. If ``min`` or ``max`` are not passed, any value is accepted in that direction. If ``min_open`` or ``max_open`` are enabled, the corresponding boundary is not included in the range. If ``clamp`` is enabled, a value outside the range is clamped to the boundary instead of failing. This is not supported if either boundary is marked ``open``. .. versionchanged:: 8.0 Added the ``min_open`` and ``max_open`` parameters. """ name = "float range" def __init__( self, min: t.Optional[float] = None, max: t.Optional[float] = None, min_open: bool = False, max_open: bool = False, clamp: bool = False, ) -> None: super().__init__( min=min, max=max, min_open=min_open, max_open=max_open, clamp=clamp ) if (min_open or max_open) and clamp: raise TypeError("Clamping is not supported for open bounds.") def _clamp(self, bound: float, dir: "te.Literal[1, -1]", open: bool) -> float: if not open: return bound # Could use Python 3.9's math.nextafter here, but clamping an # open float range doesn't seem to be particularly useful. It's # left up to the user to write a callback to do it if needed. raise RuntimeError("Clamping is not supported for open bounds.") class BoolParamType(ParamType): name = "boolean" def convert( self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"] ) -> t.Any: if value in {False, True}: return bool(value) norm = value.strip().lower() if norm in {"1", "true", "t", "yes", "y", "on"}: return True if norm in {"0", "false", "f", "no", "n", "off"}: return False self.fail( _("{value!r} is not a valid boolean.").format(value=value), param, ctx ) def __repr__(self) -> str: return "BOOL" class UUIDParameterType(ParamType): name = "uuid" def convert( self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"] ) -> t.Any: import uuid if isinstance(value, uuid.UUID): return value value = value.strip() try: return uuid.UUID(value) except ValueError: self.fail( _("{value!r} is not a valid UUID.").format(value=value), param, ctx ) def __repr__(self) -> str: 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: t.ClassVar[str] = os.path.pathsep def __init__( self, mode: str = "r", encoding: t.Optional[str] = None, errors: t.Optional[str] = "strict", lazy: t.Optional[bool] = None, atomic: bool = False, ) -> None: self.mode = mode self.encoding = encoding self.errors = errors self.lazy = lazy self.atomic = atomic async def to_info_dict(self) -> t.Dict[str, t.Any]: info_dict = await super().to_info_dict() info_dict.update(mode=self.mode, encoding=self.encoding) return info_dict def resolve_lazy_flag(self, value: "t.Union[str, os.PathLike[str]]") -> bool: if self.lazy is not None: return self.lazy if os.fspath(value) == "-": return False elif "w" in self.mode: return True return False def convert( self, value: t.Union[str, "os.PathLike[str]", t.IO[t.Any]], param: t.Optional["Parameter"], ctx: t.Optional["Context"], ) -> t.IO[t.Any]: if _is_file_like(value): return value value = t.cast("t.Union[str, os.PathLike[str]]", value) try: lazy = self.resolve_lazy_flag(value) if lazy: lf = LazyFile( value, self.mode, self.encoding, self.errors, atomic=self.atomic ) if ctx is not None: ctx.call_on_close(lf.close_intelligently) return t.cast(t.IO[t.Any], lf) 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 OSError as e: # noqa: B014 self.fail(f"'{format_filename(value)}': {e.strerror}", param, ctx) def shell_complete( self, ctx: "Context", param: "Parameter", incomplete: str ) -> t.List["CompletionItem"]: """Return a special completion marker that tells the completion system to use the shell to provide file path completions. :param ctx: Invocation context for this command. :param param: The parameter that is requesting completion. :param incomplete: Value being completed. May be empty. .. versionadded:: 8.0 """ from .shell_completion import CompletionItem return [CompletionItem(incomplete, type="file")] def _is_file_like(value: t.Any) -> "te.TypeGuard[t.IO[t.Any]]": return hasattr(value, "read") or hasattr(value, "write") class Path(ParamType): """The ``Path`` type is similar to the :class:`File` type, but returns the filename instead of an open file. Various checks can be enabled to validate the type of file and permissions. :param exists: The file or directory needs to exist for the value to be valid. If this is not set to ``True``, and the file does not exist, then all further checks are silently skipped. :param file_okay: Allow a file as a value. :param dir_okay: Allow a directory as a value. :param readable: if true, a readable check is performed. :param writable: if true, a writable check is performed. :param executable: if true, an executable check is performed. :param resolve_path: Make the value absolute and resolve any symlinks. A ``~`` is not expanded, as this is supposed to be done by the shell only. :param allow_dash: Allow a single dash as a value, which indicates a standard stream (but does not open it). Use :func:`~click.open_file` to handle opening this value. :param path_type: Convert the incoming path value to this type. If ``None``, keep Python's default, which is ``str``. Useful to convert to :class:`pathlib.Path`. .. versionchanged:: 8.1 Added the ``executable`` parameter. .. versionchanged:: 8.0 Allow passing ``path_type=pathlib.Path``. .. versionchanged:: 6.0 Added the ``allow_dash`` parameter. """ envvar_list_splitter: t.ClassVar[str] = os.path.pathsep def __init__( self, exists: bool = False, file_okay: bool = True, dir_okay: bool = True, writable: bool = False, readable: bool = True, resolve_path: bool = False, allow_dash: bool = False, path_type: t.Optional[t.Type[t.Any]] = None, executable: bool = False, ): self.exists = exists self.file_okay = file_okay self.dir_okay = dir_okay self.readable = readable self.writable = writable self.executable = executable 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: str = _("file") elif self.dir_okay and not self.file_okay: self.name = _("directory") else: self.name = _("path") async def to_info_dict(self) -> t.Dict[str, t.Any]: info_dict = await super().to_info_dict() info_dict.update( exists=self.exists, file_okay=self.file_okay, dir_okay=self.dir_okay, writable=self.writable, readable=self.readable, allow_dash=self.allow_dash, ) return info_dict def coerce_path_result( self, value: "t.Union[str, os.PathLike[str]]" ) -> "t.Union[str, bytes, os.PathLike[str]]": if self.type is not None and not isinstance(value, self.type): if self.type is str: return os.fsdecode(value) elif self.type is bytes: return os.fsencode(value) else: return t.cast("os.PathLike[str]", self.type(value)) return value def convert( self, value: "t.Union[str, os.PathLike[str]]", param: t.Optional["Parameter"], ctx: t.Optional["Context"], ) -> "t.Union[str, bytes, os.PathLike[str]]": rv = value is_dash = self.file_okay and self.allow_dash and rv in (b"-", "-") if not is_dash: if self.resolve_path: # os.path.realpath doesn't resolve symlinks on Windows # until Python 3.8. Use pathlib for now. import pathlib rv = os.fsdecode(pathlib.Path(rv).resolve()) try: st = os.stat(rv) except OSError: if not self.exists: return self.coerce_path_result(rv) self.fail( _("{name} {filename!r} does not exist.").format( name=self.name.title(), filename=format_filename(value) ), param, ctx, ) if not self.file_okay and stat.S_ISREG(st.st_mode): self.fail( _("{name} {filename!r} is a file.").format( name=self.name.title(), filename=format_filename(value) ), param, ctx, ) if not self.dir_okay and stat.S_ISDIR(st.st_mode): self.fail( _("{name} '{filename}' is a directory.").format( name=self.name.title(), filename=format_filename(value) ), param, ctx, ) if self.readable and not os.access(rv, os.R_OK): self.fail( _("{name} {filename!r} is not readable.").format( name=self.name.title(), filename=format_filename(value) ), param, ctx, ) if self.writable and not os.access(rv, os.W_OK): self.fail( _("{name} {filename!r} is not writable.").format( name=self.name.title(), filename=format_filename(value) ), param, ctx, ) if self.executable and not os.access(value, os.X_OK): self.fail( _("{name} {filename!r} is not executable.").format( name=self.name.title(), filename=format_filename(value) ), param, ctx, ) return self.coerce_path_result(rv) def shell_complete( self, ctx: "Context", param: "Parameter", incomplete: str ) -> t.List["CompletionItem"]: """Return a special completion marker that tells the completion system to use the shell to provide path completions for only directories or any paths. :param ctx: Invocation context for this command. :param param: The parameter that is requesting completion. :param incomplete: Value being completed. May be empty. .. versionadded:: 8.0 """ from .shell_completion import CompletionItem type = "dir" if self.dir_okay and not self.file_okay else "file" return [CompletionItem(incomplete, type=type)] 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: t.Sequence[t.Union[t.Type[t.Any], ParamType]]) -> None: self.types: t.Sequence[ParamType] = [convert_type(ty) for ty in types] async def to_info_dict(self) -> t.Dict[str, t.Any]: info_dict = await super().to_info_dict() info_dict["types"] = [await t.to_info_dict() for t in self.types] return info_dict @property def name(self) -> str: # type: ignore return f"<{' '.join(ty.name for ty in self.types)}>" @property def arity(self) -> int: # type: ignore return len(self.types) def convert( self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"] ) -> t.Any: len_type = len(self.types) len_value = len(value) if len_value != len_type: self.fail( ngettext( "{len_type} values are required, but {len_value} was given.", "{len_type} values are required, but {len_value} were given.", len_value, ).format(len_type=len_type, len_value=len_value), param=param, ctx=ctx, ) return tuple(ty(x, param, ctx) for ty, x in zip(self.types, value)) def convert_type(ty: t.Optional[t.Any], default: t.Optional[t.Any] = None) -> ParamType: """Find the most appropriate :class:`ParamType` for the given Python type. If the type isn't provided, it can be inferred from a default value. """ guessed_type = False if ty is None and default is not None: if isinstance(default, (tuple, list)): # If the default is empty, ty will remain None and will # return STRING. if default: item = default[0] # A tuple of tuples needs to detect the inner types. # Can't call convert recursively because that would # incorrectly unwind the tuple to a single type. if isinstance(item, (tuple, list)): ty = tuple(map(type, item)) else: ty = type(item) else: ty = type(default) guessed_type = True if isinstance(ty, tuple): return Tuple(ty) if isinstance(ty, ParamType): return ty if ty is str or ty is None: return STRING if ty is int: return INT if ty is float: return FLOAT if ty is bool: return BOOL if guessed_type: return STRING if __debug__: try: if issubclass(ty, ParamType): raise AssertionError( f"Attempted to use an uninstantiated parameter type ({ty})." ) except TypeError: # ty is an instance (correct), so issubclass fails. 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 if the input was bytes. #: 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() asyncclick-8.1.7.0-async/src/asyncclick/utils.py000066400000000000000000000475121452710122500215570ustar00rootroot00000000000000import os import re import sys import typing as t from functools import update_wrapper from types import ModuleType from types import TracebackType from ._compat import _default_text_stderr from ._compat import _default_text_stdout from ._compat import _find_binary_writer from ._compat import auto_wrap_for_ansi from ._compat import binary_streams from ._compat import open_stream from ._compat import should_strip_ansi from ._compat import strip_ansi from ._compat import text_streams from ._compat import WIN from .globals import resolve_color_default if t.TYPE_CHECKING: import typing_extensions as te P = te.ParamSpec("P") R = t.TypeVar("R") def _posixify(name: str) -> str: return "-".join(name.split()).lower() def safecall(func: "t.Callable[P, R]") -> "t.Callable[P, t.Optional[R]]": """Wraps a function so that it swallows exceptions.""" def wrapper(*args: "P.args", **kwargs: "P.kwargs") -> t.Optional[R]: try: return func(*args, **kwargs) except Exception: pass return None return update_wrapper(wrapper, func) def make_str(value: t.Any) -> str: """Converts a value into a valid string.""" if isinstance(value, bytes): try: return value.decode(sys.getfilesystemencoding()) except UnicodeError: return value.decode("utf-8", "replace") return str(value) def make_default_short_help(help: str, max_length: int = 45) -> str: """Returns a condensed version of help string.""" # Consider only the first paragraph. paragraph_end = help.find("\n\n") if paragraph_end != -1: help = help[:paragraph_end] # Collapse newlines, tabs, and spaces. words = help.split() if not words: return "" # The first paragraph started with a "no rewrap" marker, ignore it. if words[0] == "\b": words = words[1:] total_length = 0 last_index = len(words) - 1 for i, word in enumerate(words): total_length += len(word) + (i > 0) if total_length > max_length: # too long, truncate break if word[-1] == ".": # sentence end, truncate without "..." return " ".join(words[: i + 1]) if total_length == max_length and i != last_index: break # not at sentence end, truncate with "..." else: return " ".join(words) # no truncation needed # Account for the length of the suffix. total_length += len("...") # remove words until the length is short enough while i > 0: total_length -= len(words[i]) + (i > 0) if total_length <= max_length: break i -= 1 return " ".join(words[:i]) + "..." class LazyFile: """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: t.Union[str, "os.PathLike[str]"], mode: str = "r", encoding: t.Optional[str] = None, errors: t.Optional[str] = "strict", atomic: bool = False, ): self.name: str = os.fspath(filename) self.mode = mode self.encoding = encoding self.errors = errors self.atomic = atomic self._f: t.Optional[t.IO[t.Any]] self.should_close: bool if self.name == "-": 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: str) -> t.Any: return getattr(self.open(), name) def __repr__(self) -> str: if self._f is not None: return repr(self._f) return f"" def open(self) -> t.IO[t.Any]: """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 OSError as e: # noqa: E402 from .exceptions import FileError raise FileError(self.name, hint=e.strerror) from e self._f = rv return rv def close(self) -> None: """Closes the underlying file, no matter what.""" if self._f is not None: self._f.close() def close_intelligently(self) -> None: """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) -> "LazyFile": return self def __exit__( self, exc_type: t.Optional[t.Type[BaseException]], exc_value: t.Optional[BaseException], tb: t.Optional[TracebackType], ) -> None: self.close_intelligently() def __iter__(self) -> t.Iterator[t.AnyStr]: self.open() return iter(self._f) # type: ignore class KeepOpenFile: def __init__(self, file: t.IO[t.Any]) -> None: self._file: t.IO[t.Any] = file def __getattr__(self, name: str) -> t.Any: return getattr(self._file, name) def __enter__(self) -> "KeepOpenFile": return self def __exit__( self, exc_type: t.Optional[t.Type[BaseException]], exc_value: t.Optional[BaseException], tb: t.Optional[TracebackType], ) -> None: pass def __repr__(self) -> str: return repr(self._file) def __iter__(self) -> t.Iterator[t.AnyStr]: return iter(self._file) def echo( message: t.Optional[t.Any] = None, file: t.Optional[t.IO[t.Any]] = None, nl: bool = True, err: bool = False, color: t.Optional[bool] = None, ) -> None: """Print a message and newline to stdout or a file. This should be used instead of :func:`print` because it provides better support for different data, files, and environments. Compared to :func:`print`, this does the following: - Ensures that the output encoding is not misconfigured on Linux. - Supports Unicode in the Windows console. - Supports writing to binary outputs, and supports writing bytes to text outputs. - Supports colors and styles on Windows. - Removes ANSI color and style codes if the output does not look like an interactive terminal. - Always flushes the output. :param message: The string or bytes to output. Other objects are converted to strings. :param file: The file to write to. Defaults to ``stdout``. :param err: Write to ``stderr`` instead of ``stdout``. :param nl: Print a newline after the message. Enabled by default. :param color: Force showing or hiding colors and other styles. By default Click will remove color if the output does not look like an interactive terminal. .. versionchanged:: 6.0 Support Unicode output on the Windows console. Click does not modify ``sys.stdout``, so ``sys.stdout.write()`` and ``print()`` will still not support Unicode. .. versionchanged:: 4.0 Added the ``color`` parameter. .. versionadded:: 3.0 Added the ``err`` parameter. .. versionchanged:: 2.0 Support colors on Windows if colorama is installed. """ if file is None: if err: file = _default_text_stderr() else: file = _default_text_stdout() # There are no standard streams attached to write to. For example, # pythonw on Windows. if file is None: return # Convert non bytes/text into the native string type. if message is not None and not isinstance(message, (str, bytes, bytearray)): out: t.Optional[t.Union[str, bytes]] = str(message) else: out = message if nl: out = out or "" if isinstance(out, str): out += "\n" else: out += b"\n" if not out: file.flush() return # If there is a message 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 isinstance(out, (bytes, bytearray)): binary_file = _find_binary_writer(file) if binary_file is not None: file.flush() binary_file.write(out) binary_file.flush() return # ANSI style code support. For no message or bytes, nothing happens. # When outputting to a file instead of a terminal, strip codes. else: color = resolve_color_default(color) if should_strip_ansi(file, color): out = strip_ansi(out) elif WIN: if auto_wrap_for_ansi is not None: file = auto_wrap_for_ansi(file) # type: ignore elif not color: out = strip_ansi(out) file.write(out) # type: ignore file.flush() def get_binary_stream(name: "te.Literal['stdin', 'stdout', 'stderr']") -> t.BinaryIO: """Returns a system stream for byte processing. :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(f"Unknown standard stream '{name}'") return opener() def get_text_stream( name: "te.Literal['stdin', 'stdout', 'stderr']", encoding: t.Optional[str] = None, errors: t.Optional[str] = "strict", ) -> t.TextIO: """Returns a system stream for text processing. This usually returns a wrapped stream around a binary stream returned from :func:`get_binary_stream` but it also can take shortcuts for already correctly configured streams. :param name: the name of the stream to open. Valid names are ``'stdin'``, ``'stdout'`` and ``'stderr'`` :param encoding: overrides the detected default encoding. :param errors: overrides the default error mode. """ opener = text_streams.get(name) if opener is None: raise TypeError(f"Unknown standard stream '{name}'") return opener(encoding, errors) def open_file( filename: str, mode: str = "r", encoding: t.Optional[str] = None, errors: t.Optional[str] = "strict", lazy: bool = False, atomic: bool = False, ) -> t.IO[t.Any]: """Open a file, with extra behavior to handle ``'-'`` to indicate a standard stream, lazy open on write, and atomic write. Similar to the behavior of the :class:`~click.File` param type. If ``'-'`` is given to open ``stdout`` or ``stdin``, the stream is wrapped so that using it in a context manager will not close it. This makes it possible to use the function without accidentally closing a standard stream: .. code-block:: python with open_file(filename) as f: ... :param filename: The name of the file to open, or ``'-'`` for ``stdin``/``stdout``. :param mode: The mode in which to open the file. :param encoding: The encoding to decode or encode a file opened in text mode. :param errors: The error handling mode. :param lazy: Wait to open the file until it is accessed. For read mode, the file is temporarily opened to raise access errors early, then closed until it is read again. :param atomic: Write to a temporary file and replace the given file on close. .. versionadded:: 3.0 """ if lazy: return t.cast( t.IO[t.Any], LazyFile(filename, mode, encoding, errors, atomic=atomic) ) f, should_close = open_stream(filename, mode, encoding, errors, atomic=atomic) if not should_close: f = t.cast(t.IO[t.Any], KeepOpenFile(f)) return f def format_filename( filename: "t.Union[str, bytes, os.PathLike[str], os.PathLike[bytes]]", shorten: bool = False, ) -> str: """Format a filename as a string for display. Ensures the filename can be displayed by replacing any invalid bytes or surrogate escapes in the name with the replacement character ``�``. Invalid bytes or surrogate escapes will raise an error when written to a stream with ``errors="strict". This will typically happen with ``stdout`` when the locale is something like ``en_GB.UTF-8``. Many scenarios *are* safe to write surrogates though, due to PEP 538 and PEP 540, including: - Writing to ``stderr``, which uses ``errors="backslashreplace"``. - The system has ``LANG=C.UTF-8``, ``C``, or ``POSIX``. Python opens stdout and stderr with ``errors="surrogateescape"``. - None of ``LANG/LC_*`` are set. Python assumes ``LANG=C.UTF-8``. - Python is started in UTF-8 mode with ``PYTHONUTF8=1`` or ``-X utf8``. Python opens stdout and stderr with ``errors="surrogateescape"``. :param filename: formats a filename for UI display. This will also convert the filename into unicode without failing. :param shorten: this optionally shortens the filename to strip of the path that leads up to it. """ if shorten: filename = os.path.basename(filename) else: filename = os.fspath(filename) if isinstance(filename, bytes): filename = filename.decode(sys.getfilesystemencoding(), "replace") else: filename = filename.encode("utf-8", "surrogateescape").decode( "utf-8", "replace" ) return filename def get_app_dir(app_name: str, roaming: bool = True, force_posix: bool = False) -> str: 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`` Windows (roaming): ``C:\Users\\AppData\Roaming\Foo Bar`` Windows (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 effect otherwise. :param force_posix: if this is set to `True` then on any POSIX system the folder will be stored in the home folder with a leading dot instead of the XDG config home or darwin's application support folder. """ if WIN: key = "APPDATA" if roaming else "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(f"~/.{_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: """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: t.IO[t.Any]) -> None: self.wrapped = wrapped def flush(self) -> None: try: self.wrapped.flush() except OSError as e: import errno if e.errno != errno.EPIPE: raise def __getattr__(self, attr: str) -> t.Any: return getattr(self.wrapped, attr) def _detect_program_name( path: t.Optional[str] = None, _main: t.Optional[ModuleType] = None ) -> str: """Determine the command used to run the program, for use in help text. If a file or entry point was executed, the file name is returned. If ``python -m`` was used to execute a module or package, ``python -m name`` is returned. This doesn't try to be too precise, the goal is to give a concise name for help text. Files are only shown as their name without the path. ``python`` is only shown for modules, and the full path to ``sys.executable`` is not shown. :param path: The Python file being executed. Python puts this in ``sys.argv[0]``, which is used by default. :param _main: The ``__main__`` module. This should only be passed during internal testing. .. versionadded:: 8.0 Based on command args detection in the Werkzeug reloader. :meta private: """ if _main is None: _main = sys.modules["__main__"] if not path: path = sys.argv[0] # The value of __package__ indicates how Python was called. It may # not exist if a setuptools script is installed as an egg. It may be # set incorrectly for entry points created with pip on Windows. # It is set to "" inside a Shiv or PEX zipapp. if getattr(_main, "__package__", None) in {None, ""} or ( os.name == "nt" and _main.__package__ == "" and not os.path.exists(path) and os.path.exists(f"{path}.exe") ): # Executed a file, like "python app.py". return os.path.basename(path) # Executed a module, like "python -m example". # Rewritten by Python from "-m script" to "/path/to/script.py". # Need to look at main module to determine how it was executed. py_module = t.cast(str, _main.__package__) name = os.path.splitext(os.path.basename(path))[0] # A submodule like "example.cli". if name != "__main__": py_module = f"{py_module}.{name}" return f"python -m {py_module.lstrip('.')}" def _expand_args( args: t.Iterable[str], *, user: bool = True, env: bool = True, glob_recursive: bool = True, ) -> t.List[str]: """Simulate Unix shell expansion with Python functions. See :func:`glob.glob`, :func:`os.path.expanduser`, and :func:`os.path.expandvars`. This is intended for use on Windows, where the shell does not do any expansion. It may not exactly match what a Unix shell would do. :param args: List of command line arguments to expand. :param user: Expand user home directory. :param env: Expand environment variables. :param glob_recursive: ``**`` matches directories recursively. .. versionchanged:: 8.1 Invalid glob patterns are treated as empty expansions rather than raising an error. .. versionadded:: 8.0 :meta private: """ from glob import glob out = [] for arg in args: if user: arg = os.path.expanduser(arg) if env: arg = os.path.expandvars(arg) try: matches = glob(arg, recursive=glob_recursive) except re.error: matches = [] if not matches: out.append(arg) else: out.extend(matches) return out asyncclick-8.1.7.0-async/tests/000077500000000000000000000000001452710122500162645ustar00rootroot00000000000000asyncclick-8.1.7.0-async/tests/conftest.py000066400000000000000000000013211452710122500204600ustar00rootroot00000000000000import pytest import anyio from functools import partial from threading import Thread from asyncclick.testing import CliRunner class SyncCliRunner(CliRunner): def invoke(self,*a,_sync=False,**k): fn = super().invoke if _sync: return fn(*a,**k) # anyio now protects against nested calls, so we use a thread result = None def f(): nonlocal result,fn async def r(): return await fn(*a,**k) result = anyio.run(r) ## , backend="trio") t=Thread(target=f, name="TEST") t.start() t.join() return result @pytest.fixture(scope="function") def runner(request): return SyncCliRunner() asyncclick-8.1.7.0-async/tests/test_arguments.py000066400000000000000000000257431452710122500217150ustar00rootroot00000000000000import sys from unittest import mock import pytest import asyncclick as click PY2 = False # churn def test_nargs_star(runner): @click.command() @click.argument("src", nargs=-1) @click.argument("dst") def copy(src, dst): click.echo(f"src={'|'.join(src)}") click.echo(f"dst={dst}") result = runner.invoke(copy, ["foo.txt", "bar.txt", "dir"]) if result.exception: raise result.exception assert not result.exception assert result.output.splitlines() == ["src=foo.txt|bar.txt", "dst=dir"] def test_argument_unbounded_nargs_cant_have_default(runner): with pytest.raises(TypeError, match="nargs=-1"): @click.command() @click.argument("src", nargs=-1, default=["42"]) def copy(src): pass 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(f"name={name}") x, y = point click.echo(f"point={x}/{y}") result = runner.invoke(copy, ["peter", "1", "2"]) assert not result.exception assert result.output.splitlines() == ["name=peter", "point=1/2"] @pytest.mark.parametrize( "opts", [ dict(type=(str, int)), dict(type=click.Tuple([str, int])), dict(nargs=2, type=click.Tuple([str, int])), dict(nargs=2, type=(str, int)), ], ) def test_nargs_tup_composite(runner, opts): @click.command() @click.argument("item", **opts) def copy(item): name, id = item click.echo(f"name={name} id={id:d}") result = runner.invoke(copy, ["peter", "1"]) assert result.exception is None 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_bytes_args(runner, monkeypatch): @click.command() @click.argument("arg") def from_bytes(arg): assert isinstance( arg, str ), "UTF-8 encoded argument should be implicitly converted to Unicode" # Simulate empty locale environment variables monkeypatch.setattr(sys, "getfilesystemencoding", lambda: "utf-8") monkeypatch.setattr(sys, "getdefaultencoding", lambda: "utf-8") # sys.stdin.encoding is readonly, needs some extra effort to patch. stdin = mock.Mock(wraps=sys.stdin) stdin.encoding = "utf-8" monkeypatch.setattr(sys, "stdin", stdin) runner.invoke( from_bytes, ["Something outside of ASCII range: 林".encode()], catch_exceptions=False, ) 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_allow_dash(runner): @click.command() @click.argument("input", type=click.Path(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" @pytest.mark.parametrize( ("nargs", "value", "expect"), [ (2, "", None), (2, "a", "Takes 2 values but 1 was given."), (2, "a b", ("a", "b")), (2, "a b c", "Takes 2 values but 3 were given."), (-1, "a b c", ("a", "b", "c")), (-1, "", ()), ], ) def test_nargs_envvar(runner, nargs, value, expect): if nargs == -1: param = click.argument("arg", envvar="X", nargs=nargs) else: param = click.option("--arg", envvar="X", nargs=nargs) @click.command() @param def cmd(arg): return arg result = runner.invoke(cmd, env={"X": value}, standalone_mode=False) if isinstance(expect, str): assert isinstance(result.exception, click.BadParameter) assert expect in result.exception.format_message() else: assert result.return_value == expect def test_nargs_envvar_only_if_values_empty(runner): @click.command() @click.argument("arg", envvar="X", nargs=-1) def cli(arg): return arg result = runner.invoke(cli, ["a", "b"], standalone_mode=False) assert result.return_value == ("a", "b") result = runner.invoke(cli, env={"X": "a"}, standalone_mode=False) assert result.return_value == ("a",) def test_empty_nargs(runner): @click.command() @click.argument("arg", nargs=-1) def cmd(arg): click.echo(f"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(f"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(f"arg:{arg}") result = runner.invoke(cmd, []) assert result.exit_code == 2 assert "Missing argument 'ARG'." in result.output def test_missing_argument_string_cast(): ctx = click.Context(click.Command("")) with pytest.raises(click.MissingParameter) as excinfo: click.Argument(["a"], required=True).process_value(ctx, None) assert str(excinfo.value) == "Missing parameter: a" 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() == ["('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() == ["('a', 'b', 'c')", "d", "('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) def test_multiple_not_allowed(): with pytest.raises(TypeError, match="multiple"): click.Argument(["a"], multiple=True) @pytest.mark.parametrize("value", [(), ("a",), ("a", "b", "c")]) def test_nargs_bad_default(runner, value): with pytest.raises(ValueError, match="nargs=2"): click.Argument(["a"], nargs=2, default=value) def test_subcommand_help(runner): @click.group() @click.argument("name") @click.argument("val") @click.option("--opt") @click.pass_context def cli(ctx, name, val, opt): ctx.obj = dict(name=name, val=val) @cli.command() @click.pass_obj def cmd(obj): click.echo(f"CMD for {obj['name']} with value {obj['val']}") result = runner.invoke(cli, ["foo", "bar", "cmd", "--help"]) if result.exception: raise result.exception assert "Usage: cli NAME VAL cmd [OPTIONS]" in result.output def test_nested_subcommand_help(runner): @click.group() @click.argument("arg1") @click.option("--opt1") def cli(arg1, opt1): pass @cli.group() @click.argument("arg2") @click.option("--opt2") def cmd(arg2, opt2): pass @cmd.command() def subcmd(): click.echo("subcommand") result = runner.invoke(cli, ["arg1", "cmd", "arg2", "subcmd", "--help"]) assert not result.exception assert "Usage: cli ARG1 cmd ARG2 subcmd [OPTIONS]" in result.output def test_when_argument_decorator_is_used_multiple_times_cls_is_preserved(): class CustomArgument(click.Argument): pass reusable_argument = click.argument("art", cls=CustomArgument) @click.command() @reusable_argument def foo(arg): pass @click.command() @reusable_argument def bar(arg): pass assert isinstance(foo.params[0], CustomArgument) assert isinstance(bar.params[0], CustomArgument) asyncclick-8.1.7.0-async/tests/test_basic.py000066400000000000000000000362631452710122500207700ustar00rootroot00000000000000import os from itertools import chain import pytest import asyncclick as 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_repr(): @click.command() def command(): pass @click.group() def group(): pass @group.command() def subcommand(): pass assert repr(command) == "" assert repr(group) == "" assert repr(subcommand) == "" @pytest.mark.anyio async def test_return_values(): @click.command() async def cli(): return 42 async with await cli.make_context("foo", []) as ctx: rv = await cli.invoke(ctx) assert rv == 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"]) if result.exception: raise result.exception assert result.exit_code == 0 assert "ROOT EXECUTED" in result.output assert "SUBCOMMAND EXECUTED" in result.output def test_group_commands_dict(runner): """A Group can be built with a dict of commands.""" @click.command() def sub(): click.echo("sub", nl=False) cli = click.Group(commands={"other": sub}) result = runner.invoke(cli, ["other"]) assert result.output == "sub" def test_group_from_list(runner): """A Group can be built with a list of commands.""" @click.command() def sub(): click.echo("sub", nl=False) cli = click.Group(commands=[sub]) result = runner.invoke(cli, ["sub"]) assert result.output == "sub" @pytest.mark.parametrize( ("args", "expect"), [ ([], "S:[no value]"), (["--s=42"], "S:[42]"), (["--s"], "Error: Option '--s' requires an argument."), (["--s="], "S:[]"), (["--s=\N{SNOWMAN}"], "S:[\N{SNOWMAN}]"), ], ) def test_string_option(runner, args, expect): @click.command() @click.option("--s", default="no value") def cli(s): click.echo(f"S:[{s}]") result = runner.invoke(cli, args) assert expect in result.output if expect.startswith("Error:"): assert result.exception is not None else: assert result.exception is None @pytest.mark.parametrize( ("args", "expect"), [ ([], "I:[84]"), (["--i=23"], "I:[46]"), (["--i=x"], "Error: Invalid value for '--i': 'x' is not a valid integer."), ], ) def test_int_option(runner, args, expect): @click.command() @click.option("--i", default=42) def cli(i): click.echo(f"I:[{i * 2}]") result = runner.invoke(cli, args) assert expect in result.output if expect.startswith("Error:"): assert result.exception is not None else: assert result.exception is None @pytest.mark.parametrize( ("args", "expect"), [ ([], "U:[ba122011-349f-423b-873b-9d6a79c688ab]"), ( ["--u=821592c1-c50e-4971-9cd6-e89dc6832f86"], "U:[821592c1-c50e-4971-9cd6-e89dc6832f86]", ), (["--u=x"], "Error: Invalid value for '--u': 'x' is not a valid UUID."), ], ) def test_uuid_option(runner, args, expect): @click.command() @click.option( "--u", default="ba122011-349f-423b-873b-9d6a79c688ab", type=click.UUID ) def cli(u): click.echo(f"U:[{u}]") result = runner.invoke(cli, args) assert expect in result.output if expect.startswith("Error:"): assert result.exception is not None else: assert result.exception is None @pytest.mark.parametrize( ("args", "expect"), [ ([], "F:[42.0]"), ("--f=23.5", "F:[23.5]"), ("--f=x", "Error: Invalid value for '--f': 'x' is not a valid float."), ], ) def test_float_option(runner, args, expect): @click.command() @click.option("--f", default=42.0) def cli(f): click.echo(f"F:[{f}]") result = runner.invoke(cli, args) assert expect in result.output if expect.startswith("Error:"): assert result.exception is not None else: assert result.exception is None @pytest.mark.parametrize("default", [True, False]) @pytest.mark.parametrize( ("args", "expect"), [(["--on"], True), (["--off"], False), ([], None)] ) def test_boolean_switch(runner, default, args, expect): @click.command() @click.option("--on/--off", default=default) def cli(on): return on if expect is None: expect = default result = runner.invoke(cli, args, standalone_mode=False) assert result.return_value is expect @pytest.mark.parametrize("default", [True, False]) @pytest.mark.parametrize(("args", "expect"), [(["--f"], True), ([], False)]) def test_boolean_flag(runner, default, args, expect): @click.command() @click.option("--f", is_flag=True, default=default) def cli(f): return f if default: expect = not expect result = runner.invoke(cli, args, standalone_mode=False) assert result.return_value is expect @pytest.mark.parametrize( ("value", "expect"), chain( ((x, "True") for x in ("1", "true", "t", "yes", "y", "on")), ((x, "False") for x in ("0", "false", "f", "no", "n", "off")), ), ) def test_boolean_conversion(runner, value, expect): @click.command() @click.option("--flag", type=bool) def cli(flag): click.echo(flag, nl=False) result = runner.invoke(cli, ["--flag", value]) assert result.output == expect result = runner.invoke(cli, ["--flag", value.title()]) assert result.output == expect 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': '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 "is a file" in result.output @click.command() @click.option("-f", type=click.Path(exists=True)) def showtype(f): click.echo(f"is_file={os.path.isfile(f)}") click.echo(f"is_dir={os.path.isdir(f)}") with runner.isolated_filesystem(): result = runner.invoke(showtype, ["-f", "xxx"]) assert "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(f"exists={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': 'meh' is not one of 'foo', 'bar', 'baz'." in result.output ) result = runner.invoke(cli, ["--help"]) assert "--method [foo|bar|baz]" in result.output def test_choice_argument(runner): @click.command() @click.argument("method", type=click.Choice(["foo", "bar", "baz"])) def cli(method): click.echo(method) result = runner.invoke(cli, ["foo"]) assert not result.exception assert result.output == "foo\n" result = runner.invoke(cli, ["meh"]) assert result.exit_code == 2 assert ( "Invalid value for '{foo|bar|baz}': 'meh' is not one of 'foo'," " 'bar', 'baz'." in result.output ) result = runner.invoke(cli, ["--help"]) assert "{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': '2015-09' does not match the formats" " '%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_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 def test_summary_line(runner): @click.group() def cli(): pass @cli.command() def cmd(): """ Summary line without period Here is a sentence. And here too. """ pass result = runner.invoke(cli, ["--help"]) assert "Summary line without period" in result.output assert "Here is a sentence." not in result.output def test_help_invalid_default(runner): cli = click.Command( "cli", params=[ click.Option( ["-a"], type=click.Path(exists=True), default="not found", show_default=True, ), ], ) result = runner.invoke(cli, ["--help"]) assert result.exit_code == 0 assert "default: not found" in result.output asyncclick-8.1.7.0-async/tests/test_chain.py000066400000000000000000000132661452710122500207670ustar00rootroot00000000000000import sys import pytest import asyncclick as click def debug(): click.echo( f"{sys._getframe(1).f_code.co_name}" f"={'|'.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", ] @pytest.mark.parametrize( ("args", "expect"), [ (["--help"], "COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]..."), (["--help"], "ROOT HELP"), (["sdist", "--help"], "SDIST HELP"), (["bdist", "--help"], "BDIST HELP"), (["bdist", "sdist", "--help"], "SDIST HELP"), ], ) def test_chaining_help(runner, args, expect): @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, args) assert not result.exception assert expect 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(f"sdist called {format}") @cli.command("bdist") @click.option("--format") def bdist(format): click.echo(f"bdist called {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"] @pytest.mark.parametrize(("chain", "expect"), [(False, "1"), (True, "[]")]) def test_no_command_result_callback(runner, chain, expect): """When a group has ``invoke_without_command=True``, the result callback is always invoked. A regular group invokes it with its return value, a chained group with ``[]``. """ @click.group(invoke_without_command=True, chain=chain) def cli(): return 1 @cli.result_callback() def process_result(result): click.echo(result, nl=False) result = runner.invoke(cli, []) assert result.output == expect def test_chaining_with_arguments(runner): @click.group(chain=True) def cli(): pass @cli.command("sdist") @click.argument("format") def sdist(format): click.echo(f"sdist called {format}") @cli.command("bdist") @click.argument("format") def bdist(format): click.echo(f"bdist called {format}") result = runner.invoke(cli, ["bdist", "1", "sdist", "2"]) assert not result.exception assert result.output.splitlines() == ["bdist called 1", "sdist called 2"] @pytest.mark.parametrize( ("args", "input", "expect"), [ (["-f", "-"], "foo\nbar", ["foo", "bar"]), (["-f", "-", "strip"], "foo \n bar", ["foo", "bar"]), (["-f", "-", "strip", "uppercase"], "foo \n bar", ["FOO", "BAR"]), ], ) def test_pipeline(runner, args, input, expect): @click.group(chain=True, invoke_without_command=True) @click.option("-f", type=click.File("r")) def cli(f): pass @cli.result_callback() def process_pipeline(processors, f): iterator = (x.rstrip("\r\n") for x in f) 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, args, input=input) assert not result.exception assert result.output.splitlines() == expect 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(f"cli:{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="] asyncclick-8.1.7.0-async/tests/test_command_decorators.py000066400000000000000000000030321452710122500235360ustar00rootroot00000000000000import pytest import asyncclick as click def test_command_no_parens(runner): @click.command def cli(): click.echo("hello") result = runner.invoke(cli) assert result.exception is None assert result.output == "hello\n" def test_custom_command_no_parens(runner): class CustomCommand(click.Command): pass class CustomGroup(click.Group): command_class = CustomCommand @click.group(cls=CustomGroup) def grp(): pass @grp.command def cli(): click.echo("hello custom command class") result = runner.invoke(cli) assert result.exception is None assert result.output == "hello custom command class\n" def test_group_no_parens(runner): @click.group def grp(): click.echo("grp1") @grp.command def cmd1(): click.echo("cmd1") @grp.group def grp2(): click.echo("grp2") @grp2.command def cmd2(): click.echo("cmd2") result = runner.invoke(grp, ["cmd1"]) assert result.exception is None assert result.output == "grp1\ncmd1\n" result = runner.invoke(grp, ["grp2", "cmd2"]) assert result.exception is None assert result.output == "grp1\ngrp2\ncmd2\n" def test_params_argument(runner): opt = click.Argument(["a"]) @click.command(params=[opt]) @click.argument("b") def cli(a, b): click.echo(f"{a} {b}") assert cli.params[0].name == "a" assert cli.params[1].name == "b" result = runner.invoke(cli, ["1", "2"]) assert result.output == "1 2\n" asyncclick-8.1.7.0-async/tests/test_commands.py000066400000000000000000000265641452710122500215130ustar00rootroot00000000000000import re from inspect import iscoroutine import pytest import asyncclick as click 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, []) if result.exception: raise result.exception assert result.output == "42\n" @pytest.mark.anyio async def test_other_command_forward(runner): cli = click.Group() @cli.command() @click.option("--count", default=1) def test(count): click.echo(f"Count: {count:d}") @cli.command() @click.option("--count", default=1) @click.pass_context async def dist(ctx, count): await ctx.forward(test) await ctx.invoke(test, count=42) result = await runner.invoke(cli, ["dist"], _sync=True) if result.exception: raise result.exception assert result.output == "Count: 1\nCount: 42\n" @pytest.mark.anyio async def test_forwarded_params_consistency(runner): cli = click.Group() @cli.command() @click.option("-a") @click.pass_context def first(ctx, **kwargs): click.echo(f"{ctx.params}") @cli.command() @click.option("-a") @click.option("-b") @click.pass_context async def second(ctx, **kwargs): click.echo(f"{ctx.params}") await ctx.forward(first) result = runner.invoke(cli, ["second", "-a", "foo", "-b", "bar"]) if result.exception: raise result.exception assert result.output == "{'a': 'foo', 'b': 'bar'}\n{'a': 'foo', 'b': 'bar'}\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" r"\.\.\.\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_no_args_is_help(runner): @click.command(no_args_is_help=True) def cli(): pass result = runner.invoke(cli, []) assert result.exit_code == 0 assert "Show this message and exit." in result.output 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"}}) if result.exception: raise result.exception assert result.output == "changed\n" @pytest.mark.parametrize( ("args", "exit_code", "expect"), [ (["obj1"], 2, "Error: Missing command."), (["obj1", "--help"], 0, "Show this message and exit."), (["obj1", "move"], 0, "obj=obj1\nmove\n"), ([], 0, "Show this message and exit."), ], ) def test_group_with_args(runner, args, exit_code, expect): @click.group() @click.argument("obj") def cli(obj): click.echo(f"obj={obj}") @cli.command() def move(): click.echo("move") result = runner.invoke(cli, args) assert result.exit_code == exit_code assert expect in result.output def test_base_command(runner): import optparse @click.group() def cli(): pass class OptParseCommand(click.BaseCommand): def __init__(self, name, parser, callback): super().__init__(name) self.parser = parser self.callback = callback async 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() async def invoke(self, ctx): rv = ctx.invoke(self.callback, ctx.args, **ctx.params) if iscoroutine(rv): await rv 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", "f.txt", "-q", "q1.txt", "q2.txt"]) if result.exception is not None: raise result.exception assert result.output.splitlines() == ["q1.txt q2.txt", "f.txt", "False"] result = runner.invoke(cli, ["test", "--help"]) if result.exception is not None: raise 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(f"Debug is {'on' if ctx.obj['DEBUG'] else '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("-a", type=click.INT, default=42) @click.option("-b", type=click.INT, default="15") @click.option("-c", multiple=True) @click.pass_context def other_cmd(ctx, a, b, c): return ctx.info_name, a, b, c result = runner.invoke(cli, standalone_mode=False) # invoke should type cast default values, str becomes int, empty # multiple should be empty tuple instead of None assert result.return_value == ("other-cmd", 42, 15, ()) def test_invoked_subcommand(runner): @click.group(invoke_without_command=True) @click.pass_context async def cli(ctx): if ctx.invoked_subcommand is None: click.echo("no subcommand, use default") await ctx.invoke(sync) else: click.echo("invoke subcommand") @cli.command() def sync(): click.echo("in subcommand") result = runner.invoke(cli, ["sync"]) if result.exception: raise result.exception assert result.output == "invoke subcommand\nin subcommand\n" result = runner.invoke(cli) if result.exception: raise result.exception assert result.output == "no subcommand, use default\nin subcommand\n" def test_aliased_command_canonical_name(runner): class AliasedGroup(click.Group): def get_command(self, ctx, cmd_name): return push async def resolve_command(self, ctx, args): _, command, args = await super().resolve_command(ctx, args) return command.name, command, args cli = AliasedGroup() @cli.command() def push(): click.echo("push command") result = runner.invoke(cli, ["pu", "--help"]) if result.exception: raise result.exception assert result.output.startswith("Usage: root push [OPTIONS]") def test_group_add_command_name(runner): cli = click.Group("cli") cmd = click.Command("a", params=[click.Option(["-x"], required=True)]) cli.add_command(cmd, "b") # Check that the command is accessed through the registered name, # not the original name. result = runner.invoke(cli, ["b"], default_map={"b": {"x": 3}}) assert result.exit_code == 0 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(f"Verbosity: {verbose}") click.echo(f"Args: {'|'.join(args)}") result = runner.invoke(cli, ["-foo", "-vvvvx", "--muhaha", "x", "y", "-x"]) if result.exception: raise result.exception assert result.output.splitlines() == [ "Verbosity: 4", "Args: -foo|-x|--muhaha|x|y|-x", ] @pytest.mark.parametrize("doc", ["CLI HELP", None]) def test_deprecated_in_help_messages(runner, doc): @click.command(deprecated=True, help=doc) def cli(): pass result = runner.invoke(cli, ["--help"]) assert "(Deprecated)" in result.output def test_deprecated_in_invocation(runner): @click.command(deprecated=True) def deprecated_cmd(): pass result = runner.invoke(deprecated_cmd) assert "DeprecationWarning:" in result.output @pytest.mark.anyio async def test_command_parse_args_collects_option_prefixes(): @click.command() @click.option("+p", is_flag=True) @click.option("!e", is_flag=True) def test(p, e): pass ctx = click.Context(test) await test.parse_args(ctx, []) assert ctx._opt_prefixes == {"-", "--", "+", "!"} @pytest.mark.anyio async def test_group_parse_args_collects_base_option_prefixes(): @click.group() @click.option("~t", is_flag=True) def group(t): pass @group.command() @click.option("+p", is_flag=True) def command1(p): pass @group.command() @click.option("!e", is_flag=True) def command2(e): pass ctx = click.Context(group) await group.parse_args(ctx, ["command1", "+p"]) assert ctx._opt_prefixes == {"-", "--", "~"} def test_group_invoke_collects_used_option_prefixes(runner): opt_prefixes = set() @click.group() @click.option("~t", is_flag=True) def group(t): pass @group.command() @click.option("+p", is_flag=True) @click.pass_context def command1(ctx, p): nonlocal opt_prefixes opt_prefixes = ctx._opt_prefixes @group.command() @click.option("!e", is_flag=True) def command2(e): pass runner.invoke(group, ["command1"]) assert opt_prefixes == {"-", "--", "~", "+"} @pytest.mark.parametrize("exc", (EOFError, KeyboardInterrupt)) def test_abort_exceptions_with_disabled_standalone_mode(runner, exc): @click.command() def cli(): raise exc("catch me!") rv = runner.invoke(cli, standalone_mode=False) assert rv.exit_code == 1 assert isinstance(rv.exception.__cause__, exc) assert rv.exception.__cause__.args == ("catch me!",) asyncclick-8.1.7.0-async/tests/test_compat.py000066400000000000000000000004701452710122500211610ustar00rootroot00000000000000from asyncclick._compat import should_strip_ansi def test_is_jupyter_kernel_output(): class JupyterKernelFakeStream: pass # implementation detail, aka cheapskate test JupyterKernelFakeStream.__module__ = "ipykernel.faked" assert not should_strip_ansi(stream=JupyterKernelFakeStream()) asyncclick-8.1.7.0-async/tests/test_context.py000066400000000000000000000227671452710122500213770ustar00rootroot00000000000000from contextlib import asynccontextmanager from contextlib import contextmanager import pytest import asyncclick as click from asyncclick.core import ParameterSource from asyncclick.decorators import pass_meta_key def test_ensure_context_objects(runner): class Foo: 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: 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: 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: 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 async def cli(ctx): def callback(): called.append(True) ctx.call_on_close(callback) async with ctx: pass assert not called result = runner.invoke(cli, []) if result.exception: raise result.exception 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 = f"{__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_make_pass_meta_decorator(runner): @click.group() @click.pass_context def cli(ctx): ctx.meta["value"] = "good" @cli.command() @pass_meta_key("value") def show(value): return value result = runner.invoke(cli, ["show"], standalone_mode=False) assert result.return_value == "good" def test_make_pass_meta_decorator_doc(): pass_value = pass_meta_key("value") assert "the 'value' key from :attr:`click.Context.meta`" in pass_value.__doc__ pass_value = pass_meta_key("value", doc_description="the test value") assert "passes the test value" in pass_value.__doc__ @pytest.mark.anyio async def test_context_pushing(): rv = [] @click.command() def cli(): pass ctx = click.Context(cli) @ctx.call_on_close def test_callback(): rv.append(42) async with ctx.scope(cleanup=False): # Internal assert ctx._depth == 2 assert rv == [] async with ctx.scope(): # Internal assert ctx._depth == 1 assert rv == [42] @pytest.mark.anyio async def test_async_context_mgr(): @asynccontextmanager async def manager(): val = [1] yield val val[0] = 0 @click.command() def cli(): pass ctx = click.Context(cli) async with ctx.scope(): rv = await ctx.with_async_resource(manager()) assert rv[0] == 1, rv # Internal assert ctx._depth == 1 assert rv == [0], rv @pytest.mark.anyio async def test_context_mgr(): @contextmanager def manager(): val = [1] yield val val[0] = 0 @click.command() def cli(): pass ctx = click.Context(cli) async with ctx.scope(): rv = ctx.with_resource(manager()) assert rv[0] == 1, rv # Internal assert ctx._depth == 1 assert rv == [0], rv 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] @pytest.mark.anyio async def test_with_resource(): @contextmanager def manager(): val = [1] yield val val[0] = 0 ctx = click.Context(click.Command("test")) async with ctx.scope(): rv = ctx.with_resource(manager()) assert rv[0] == 1 assert rv == [0] def test_make_pass_decorator_args(runner): """ Test to check that make_pass_decorator doesn't consume arguments based on invocation order. """ class Foo: 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_propagate_show_default_setting(runner): """A context's ``show_default`` setting defaults to the value from the parent context. """ group = click.Group( commands={ "sub": click.Command("sub", params=[click.Option(["-a"], default="a")]), }, context_settings={"show_default": True}, ) result = runner.invoke(group, ["sub", "--help"]) assert "[default: a]" in result.output @pytest.mark.anyio async def test_exit_not_standalone(): @click.command() @click.pass_context def cli(ctx): ctx.exit(1) assert await cli.main([], "test_exit_not_standalone", standalone_mode=False) == 1 @click.command() @click.pass_context def cli(ctx): ctx.exit(0) assert await cli.main([], "test_exit_not_standalone", standalone_mode=False) == 0 @pytest.mark.parametrize( ("option_args", "invoke_args", "expect"), [ pytest.param({}, {}, ParameterSource.DEFAULT, id="default"), pytest.param( {}, {"default_map": {"option": 1}}, ParameterSource.DEFAULT_MAP, id="default_map", ), pytest.param( {}, {"args": ["-o", "1"]}, ParameterSource.COMMANDLINE, id="commandline short", ), pytest.param( {}, {"args": ["--option", "1"]}, ParameterSource.COMMANDLINE, id="commandline long", ), pytest.param( {}, {"auto_envvar_prefix": "TEST", "env": {"TEST_OPTION": "1"}}, ParameterSource.ENVIRONMENT, id="environment auto", ), pytest.param( {"envvar": "NAME"}, {"env": {"NAME": "1"}}, ParameterSource.ENVIRONMENT, id="environment manual", ), ], ) def test_parameter_source(runner, option_args, invoke_args, expect): @click.command() @click.pass_context @click.option("-o", "--option", default=1, **option_args) def cli(ctx, option): return ctx.get_parameter_source("option") rv = runner.invoke(cli, standalone_mode=False, **invoke_args) assert rv.return_value == expect def test_propagate_opt_prefixes(): parent = click.Context(click.Command("test")) parent._opt_prefixes = {"-", "--", "!"} ctx = click.Context(click.Command("test2"), parent=parent) assert ctx._opt_prefixes == {"-", "--", "!"} asyncclick-8.1.7.0-async/tests/test_custom_classes.py000066400000000000000000000060261452710122500227300ustar00rootroot00000000000000import asyncclick as click import pytest @pytest.mark.anyio async def test_command_context_class(): """A command with a custom ``context_class`` should produce a context using that type. """ class CustomContext(click.Context): pass class CustomCommand(click.Command): context_class = CustomContext command = CustomCommand("test") context = await command.make_context("test", []) assert isinstance(context, CustomContext) def test_context_invoke_type(runner): """A command invoked from a custom context should have a new context with the same type. """ class CustomContext(click.Context): pass class CustomCommand(click.Command): context_class = CustomContext @click.command() @click.argument("first_id", type=int) @click.pass_context def second(ctx, first_id): assert isinstance(ctx, CustomContext) assert id(ctx) != first_id @click.command(cls=CustomCommand) @click.pass_context async def first(ctx): assert isinstance(ctx, CustomContext) await ctx.invoke(second, first_id=id(ctx)) assert not runner.invoke(first).exception def test_context_formatter_class(): """A context with a custom ``formatter_class`` should format help using that type. """ class CustomFormatter(click.HelpFormatter): def write_heading(self, heading): heading = click.style(heading, fg="yellow") return super().write_heading(heading) class CustomContext(click.Context): formatter_class = CustomFormatter context = CustomContext( click.Command("test", params=[click.Option(["--value"])]), color=True ) assert "\x1b[33mOptions\x1b[0m:" in context.get_help() def test_group_command_class(runner): """A group with a custom ``command_class`` should create subcommands of that type by default. """ class CustomCommand(click.Command): pass class CustomGroup(click.Group): command_class = CustomCommand group = CustomGroup() subcommand = group.command()(lambda: None) assert type(subcommand) is CustomCommand subcommand = group.command(cls=click.Command)(lambda: None) assert type(subcommand) is click.Command def test_group_group_class(runner): """A group with a custom ``group_class`` should create subgroups of that type by default. """ class CustomSubGroup(click.Group): pass class CustomGroup(click.Group): group_class = CustomSubGroup group = CustomGroup() subgroup = group.group()(lambda: None) assert type(subgroup) is CustomSubGroup subgroup = group.command(cls=click.Group)(lambda: None) assert type(subgroup) is click.Group def test_group_group_class_self(runner): """A group with ``group_class = type`` should create subgroups of the same type as itself. """ class CustomGroup(click.Group): group_class = type group = CustomGroup() subgroup = group.group()(lambda: None) assert type(subgroup) is CustomGroup asyncclick-8.1.7.0-async/tests/test_defaults.py000066400000000000000000000034561452710122500215140ustar00rootroot00000000000000import asyncclick as 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(f"FOO:[{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 a, b in arg: click.echo(f"<{a:d}|{b:d}>") result = runner.invoke(cli, []) assert not result.exception assert result.output.splitlines() == ["<1|2>", "<3|4>"] def test_multiple_flag_default(runner): """Default default for flags when multiple=True should be empty tuple.""" @click.command # flag due to secondary token @click.option("-y/-n", multiple=True) # flag due to is_flag @click.option("-f", is_flag=True, multiple=True) # flag due to flag_value @click.option("-v", "v", flag_value=1, multiple=True) @click.option("-q", "v", flag_value=-1, multiple=True) def cli(y, f, v): return y, f, v result = runner.invoke(cli, standalone_mode=False) assert result.return_value == ((), (), ()) result = runner.invoke(cli, ["-y", "-n", "-f", "-v", "-q"], standalone_mode=False) assert result.return_value == ((True, False), (True,), (1, -1)) asyncclick-8.1.7.0-async/tests/test_formatting.py000066400000000000000000000223231452710122500220510ustar00rootroot00000000000000import asyncclick as 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(): # fmt: off """Top level command """ # fmt: on 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(f"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(f"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(f"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(f"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.", ] def test_truncating_docstring_no_help(runner): @click.command() @click.pass_context def cli(ctx): """ \f This text should be truncated. """ result = runner.invoke(cli, ["--help"], terminal_width=60) assert not result.exception assert result.output.splitlines() == [ "Usage: cli [OPTIONS]", "", "Options:", " --help Show this message and exit.", ] def test_removing_multiline_marker(runner): @click.group() def cli(): pass @cli.command() def cmd1(): """\b This is command with a multiline help text which should not be rewrapped. The output of the short help text should not contain the multiline marker. """ pass result = runner.invoke(cli, ["--help"]) assert "\b" not in result.output def test_global_show_default(runner): @click.command(context_settings=dict(show_default=True)) @click.option("-f", "in_file", default="out.txt", help="Output file name") def cli(): pass result = runner.invoke(cli, ["--help"]) # the default to "--help" is not shown because it is False assert result.output.splitlines() == [ "Usage: cli [OPTIONS]", "", "Options:", " -f TEXT Output file name [default: out.txt]", " --help Show this message and exit.", ] def test_formatting_with_options_metavar_empty(runner): cli = click.Command("cli", options_metavar="", params=[click.Argument(["var"])]) result = runner.invoke(cli, ["--help"]) assert "Usage: cli VAR\n" in result.output def test_help_formatter_write_text(): text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit" formatter = click.HelpFormatter(width=len(" Lorem ipsum dolor sit amet,")) formatter.current_indent = 2 formatter.write_text(text) actual = formatter.getvalue() expected = " Lorem ipsum dolor sit amet,\n consectetur adipiscing elit\n" assert actual == expected asyncclick-8.1.7.0-async/tests/test_imports.py000066400000000000000000000026431452710122500213770ustar00rootroot00000000000000import json import subprocess import sys from asyncclick._compat import WIN IMPORT_TEST = b"""\ 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 '__name__' in globals and globals['__name__'].startswith('asyncclick') and level == 0: found_imports.add(module) return rv builtins.__import__ = tracking_import import asyncclick rv = list(found_imports) import json asyncclick.echo(json.dumps(rv)) """ ALLOWED_IMPORTS = { "anyio", "weakref", "os", "struct", "collections", "sys", "contextlib", "functools", "stat", "re", "codecs", "inspect", "itertools", "io", "threading", "errno", "fcntl", "datetime", "enum", "typing", "types", "gettext", } if WIN: ALLOWED_IMPORTS.update(["ctypes", "ctypes.wintypes", "msvcrt", "time"]) def test_light_imports(): c = subprocess.Popen( [sys.executable, "-"], stdin=subprocess.PIPE, stdout=subprocess.PIPE ) rv = c.communicate(IMPORT_TEST)[0] rv = rv.decode("utf-8") imported = json.loads(rv) for module in imported: if module == "asyncclick" or module.startswith("asyncclick."): continue assert module in ALLOWED_IMPORTS asyncclick-8.1.7.0-async/tests/test_info_dict.py000066400000000000000000000176321452710122500216440ustar00rootroot00000000000000import pytest import asyncclick as click import asyncclick.types # Common (obj, expect) pairs used to construct multiple tests. STRING_PARAM_TYPE = (click.STRING, {"param_type": "String", "name": "text"}) INT_PARAM_TYPE = (click.INT, {"param_type": "Int", "name": "integer"}) BOOL_PARAM_TYPE = (click.BOOL, {"param_type": "Bool", "name": "boolean"}) HELP_OPTION = ( None, { "name": "help", "param_type_name": "option", "opts": ["--help"], "secondary_opts": [], "type": BOOL_PARAM_TYPE[1], "required": False, "nargs": 1, "multiple": False, "default": False, "envvar": None, "help": "Show this message and exit.", "prompt": None, "is_flag": True, "flag_value": True, "count": False, "hidden": False, }, ) NAME_ARGUMENT = ( click.Argument(["name"]), { "name": "name", "param_type_name": "argument", "opts": ["name"], "secondary_opts": [], "type": STRING_PARAM_TYPE[1], "required": True, "nargs": 1, "multiple": False, "default": None, "envvar": None, }, ) NUMBER_OPTION = ( click.Option(["-c", "--count", "number"], default=1), { "name": "number", "param_type_name": "option", "opts": ["-c", "--count"], "secondary_opts": [], "type": INT_PARAM_TYPE[1], "required": False, "nargs": 1, "multiple": False, "default": 1, "envvar": None, "help": None, "prompt": None, "is_flag": False, "flag_value": False, "count": False, "hidden": False, }, ) HELLO_COMMAND = ( click.Command("hello", params=[NUMBER_OPTION[0]]), { "name": "hello", "params": [NUMBER_OPTION[1], HELP_OPTION[1]], "help": None, "epilog": None, "short_help": None, "hidden": False, "deprecated": False, }, ) HELLO_GROUP = ( click.Group("cli", [HELLO_COMMAND[0]]), { "name": "cli", "params": [HELP_OPTION[1]], "help": None, "epilog": None, "short_help": None, "hidden": False, "deprecated": False, "commands": {"hello": HELLO_COMMAND[1]}, "chain": False, }, ) @pytest.mark.parametrize( ("obj", "expect"), [ pytest.param( click.types.FuncParamType(range), {"param_type": "Func", "name": "range", "func": range}, id="Func ParamType", ), pytest.param( click.UNPROCESSED, {"param_type": "Unprocessed", "name": "text"}, id="UNPROCESSED ParamType", ), pytest.param(*STRING_PARAM_TYPE, id="STRING ParamType"), pytest.param( click.Choice(["a", "b"]), { "param_type": "Choice", "name": "choice", "choices": ["a", "b"], "case_sensitive": True, }, id="Choice ParamType", ), pytest.param( click.DateTime(["%Y-%m-%d"]), {"param_type": "DateTime", "name": "datetime", "formats": ["%Y-%m-%d"]}, id="DateTime ParamType", ), pytest.param(*INT_PARAM_TYPE, id="INT ParamType"), pytest.param( click.IntRange(0, 10, clamp=True), { "param_type": "IntRange", "name": "integer range", "min": 0, "max": 10, "min_open": False, "max_open": False, "clamp": True, }, id="IntRange ParamType", ), pytest.param( click.FLOAT, {"param_type": "Float", "name": "float"}, id="FLOAT ParamType" ), pytest.param( click.FloatRange(-0.5, 0.5), { "param_type": "FloatRange", "name": "float range", "min": -0.5, "max": 0.5, "min_open": False, "max_open": False, "clamp": False, }, id="FloatRange ParamType", ), pytest.param(*BOOL_PARAM_TYPE, id="Bool ParamType"), pytest.param( click.UUID, {"param_type": "UUID", "name": "uuid"}, id="UUID ParamType" ), pytest.param( click.File(), {"param_type": "File", "name": "filename", "mode": "r", "encoding": None}, id="File ParamType", ), pytest.param( click.Path(), { "param_type": "Path", "name": "path", "exists": False, "file_okay": True, "dir_okay": True, "writable": False, "readable": True, "allow_dash": False, }, id="Path ParamType", ), pytest.param( click.Tuple((click.STRING, click.INT)), { "param_type": "Tuple", "name": "", "types": [STRING_PARAM_TYPE[1], INT_PARAM_TYPE[1]], }, id="Tuple ParamType", ), pytest.param(*NUMBER_OPTION, id="Option"), pytest.param( click.Option(["--cache/--no-cache", "-c/-u"]), { "name": "cache", "param_type_name": "option", "opts": ["--cache", "-c"], "secondary_opts": ["--no-cache", "-u"], "type": BOOL_PARAM_TYPE[1], "required": False, "nargs": 1, "multiple": False, "default": False, "envvar": None, "help": None, "prompt": None, "is_flag": True, "flag_value": True, "count": False, "hidden": False, }, id="Flag Option", ), pytest.param(*NAME_ARGUMENT, id="Argument"), ], ) @pytest.mark.anyio async def test_parameter(obj, expect): out = await obj.to_info_dict() assert out == expect @pytest.mark.parametrize( ("obj", "expect"), [ pytest.param(*HELLO_COMMAND, id="Command"), pytest.param(*HELLO_GROUP, id="Group"), pytest.param( click.Group( "base", [click.Command("test", params=[NAME_ARGUMENT[0]]), HELLO_GROUP[0]], ), { "name": "base", "params": [HELP_OPTION[1]], "help": None, "epilog": None, "short_help": None, "hidden": False, "deprecated": False, "commands": { "cli": HELLO_GROUP[1], "test": { "name": "test", "params": [NAME_ARGUMENT[1], HELP_OPTION[1]], "help": None, "epilog": None, "short_help": None, "hidden": False, "deprecated": False, }, }, "chain": False, }, id="Nested Group", ), ], ) @pytest.mark.anyio async def test_command(obj, expect): ctx = click.Context(obj) out = await obj.to_info_dict(ctx) assert out == expect @pytest.mark.anyio async def test_context(): ctx = click.Context(HELLO_COMMAND[0]) out = await ctx.to_info_dict() assert out == { "command": HELLO_COMMAND[1], "info_name": None, "allow_extra_args": False, "allow_interspersed_args": True, "ignore_unknown_options": False, "auto_envvar_prefix": None, } @pytest.mark.anyio async def test_paramtype_no_name(): class TestType(click.ParamType): pass assert (await TestType().to_info_dict())["name"] == "TestType" asyncclick-8.1.7.0-async/tests/test_normalization.py000066400000000000000000000017121452710122500225640ustar00rootroot00000000000000import asyncclick as 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(choice) 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" asyncclick-8.1.7.0-async/tests/test_options.py000066400000000000000000000676061452710122500214070ustar00rootroot00000000000000import re import os import asyncclick as click import pytest from asyncclick import Option 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(f"foo={foo} bar={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): with pytest.raises(TypeError, match="name was passed") as exc_info: click.Option(["foo"]) message = str(exc_info.value) assert "name was passed (foo)" in message assert "declare an argument" in message assert "'--foo'" in message def test_invalid_nargs(runner): with pytest.raises(TypeError, match="nargs=-1"): @click.command() @click.option("--foo", nargs=-1) def cli(foo): pass def test_nargs_tup_composite_mult(runner): @click.command() @click.option("--item", type=(str, int), multiple=True) def copy(item): for name, id in item: click.echo(f"name={name} id={id:d}") 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(f"verbosity={v:d}") 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 range 0<=x<=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 f"No such option: {unknown_flag}" in result.output @pytest.mark.parametrize( ("value", "expect"), [ ("--cat", "Did you mean --count?"), ("--bounds", "(Possible options: --bound, --count)"), ("--bount", "(Possible options: --bound, --count)"), ], ) def test_suggest_possible_options(runner, value, expect): cli = click.Command( "cli", params=[click.Option(["--bound"]), click.Option(["--count"])] ) result = runner.invoke(cli, [value]) assert expect 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 @pytest.mark.parametrize( ("multiple", "nargs", "default"), [ (True, 1, []), (True, 1, [1]), # (False, -1, []), # (False, -1, [1]), (False, 2, [1, 2]), # (True, -1, [[]]), # (True, -1, []), # (True, -1, [[1]]), (True, 2, []), (True, 2, [[1, 2]]), ], ) def test_init_good_default_list(runner, multiple, nargs, default): click.Option(["-a"], multiple=multiple, nargs=nargs, default=default) @pytest.mark.parametrize( ("multiple", "nargs", "default"), [ (True, 1, 1), # (False, -1, 1), (False, 2, [1]), (True, 2, [[1]]), ], ) def test_init_bad_default_list(runner, multiple, nargs, default): type = (str, str) if nargs == 2 else None with pytest.raises(ValueError, match="default"): click.Option(["-a"], type=type, multiple=multiple, nargs=nargs, default=default) @pytest.mark.parametrize("env_key", ["MYPATH", "AUTO_MYPATH"]) def test_empty_envvar(runner, env_key): @click.command() @click.option("--mypath", type=click.Path(exists=True), envvar="MYPATH") def cli(mypath): click.echo(f"mypath: {mypath}") result = runner.invoke(cli, env={env_key: ""}, auto_envvar_prefix="AUTO") assert result.exception is None assert result.output == "mypath: None\n" 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": f"foo{os.path.pathsep}bar"}, ) assert not result.exception assert result.output == "foo|bar\n" def test_trailing_blanks_boolean_envvar(runner): @click.command() @click.option("--shout/--no-shout", envvar="SHOUT") def cli(shout): click.echo(f"shout: {shout!r}") result = runner.invoke(cli, [], env={"SHOUT": " true "}) assert result.exit_code == 0 assert result.output == "shout: True\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_show_default_default_map(runner): @click.command() @click.option("--arg", default="a", show_default=True) def cmd(arg): click.echo(arg) result = runner.invoke(cmd, ["--help"], default_map={"arg": "b"}) assert not result.exception assert "[default: b]" in result.output def test_multiple_default_type(): opt = click.Option(["-a"], multiple=True, default=(1, 2)) assert opt.nargs == 1 assert opt.multiple assert opt.type is click.INT ctx = click.Context(click.Command("test")) assert opt.get_default(ctx) == (1, 2) def test_multiple_default_composite_type(): opt = click.Option(["-a"], multiple=True, default=[(1, "a")]) assert opt.nargs == 2 assert opt.multiple assert isinstance(opt.type, click.Tuple) assert opt.type.types == [click.INT, click.STRING] ctx = click.Context(click.Command("test")) assert opt.type_cast_value(ctx, opt.get_default(ctx)) == ((1, "a"),) def test_parse_multiple_default_composite_type(runner): @click.command() @click.option("-a", multiple=True, default=("a", "b")) @click.option("-b", multiple=True, default=[(1, "a")]) def cmd(a, b): click.echo(a) click.echo(b) # result = runner.invoke(cmd, "-a c -a 1 -a d -b 2 two -b 4 four".split()) # assert result.output == "('c', '1', 'd')\n((2, 'two'), (4, 'four'))\n" result = runner.invoke(cmd) assert result.output == "('a', 'b')\n((1, 'a'),)\n" 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_dynamic_default_help_special_method(runner): class Value: def __call__(self): return 42 def __str__(self): return "special value" opt = click.Option(["-a"], default=Value(), show_default=True) ctx = click.Context(click.Command("cli")) assert "special value" in opt.get_help_record(ctx)[1] @pytest.mark.parametrize( ("type", "expect"), [ (click.IntRange(1, 32), "1<=x<=32"), (click.IntRange(1, 32, min_open=True, max_open=True), "1=1"), (click.IntRange(max=32), "x<=32"), ], ) def test_intrange_default_help_text(type, expect): option = click.Option(["--num"], type=type, show_default=True, default=2) context = click.Context(click.Command("test")) result = option.get_help_record(context)[1] assert expect in result def test_count_default_type_help(): """A count option with the default type should not show >=0 in help.""" option = click.Option(["--count"], count=True, help="some words") context = click.Context(click.Command("test")) result = option.get_help_record(context)[1] assert result == "some words" def test_file_type_help_default(): """The default for a File type is a filename string. The string should be displayed in help, not an open file object. Type casting is only applied to defaults in processing, not when getting the default value. """ option = click.Option( ["--in"], type=click.File(), default=__file__, show_default=True ) context = click.Context(click.Command("test")) result = option.get_help_record(context)[1] assert __file__ in result 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_show_envvar_auto_prefix_dash_in_command(runner): @click.group() def cli(): pass @cli.command() @click.option("--baz", show_envvar=True) def foo_bar(baz): pass result = runner.invoke(cli, ["foo-bar", "--help"], auto_envvar_prefix="TEST") assert not result.exception assert "TEST_FOO_BAR_BAZ" 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_callback_validates_prompt(runner, monkeypatch): def validate(ctx, param, value): if value < 0: raise click.BadParameter("should be positive") return value @click.command() @click.option("-a", type=int, callback=validate, prompt=True) def cli(a): click.echo(a) result = runner.invoke(cli, input="-12\n60\n") assert result.output == "A: -12\nError: should be positive\nA: 60\n60\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_option_string_cast(): ctx = click.Context(click.Command("")) with pytest.raises(click.MissingParameter) as excinfo: click.Option(["-a"], required=True).process_value(ctx, None) assert str(excinfo.value) == "Missing parameter: a" def test_missing_required_flag(runner): cli = click.Command( "cli", params=[click.Option(["--on/--off"], is_flag=True, required=True)] ) result = runner.invoke(cli) assert result.exit_code == 2 assert "Error: Missing option '--on'." in result.output 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 assert result.output == "Apple\n" result = runner.invoke(cmd, ["--foo", "oRANGe"]) assert result.exit_code == 0 assert result.output == "Orange\n" result = runner.invoke(cmd, ["--foo", "Apple"]) assert result.exit_code == 0 assert result.output == "Apple\n" @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_case_insensitive_choice_returned_exactly(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 assert result.output == "Apple\n" def test_option_help_preserve_paragraphs(runner): @click.command() @click.option( "-C", "--config", type=click.Path(), help="""Configuration file to use. If not given, the environment variable CONFIG_FILE is consulted and used if set. If neither are given, a default configuration file is loaded.""", ) def cmd(config): pass result = runner.invoke(cmd, ["--help"]) assert result.exit_code == 0 i = " " * 21 assert ( " -C, --config PATH Configuration file to use.\n" f"{i}\n" f"{i}If not given, the environment variable CONFIG_FILE is\n" f"{i}consulted and used if set. If neither are given, a default\n" f"{i}configuration file is loaded." ) in result.output def test_argument_custom_class(runner): class CustomArgument(click.Argument): def get_default(self, ctx, call=True): """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_bool_flag_with_type(runner): @click.command() @click.option("--shout/--no-shout", default=False, type=bool) def cmd(shout): pass result = runner.invoke(cmd) assert not result.exception 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" def test_flag_duplicate_names(runner): with pytest.raises(ValueError, match="cannot use the same flag for true/false"): click.Option(["--foo/--foo"], default=False) @pytest.mark.parametrize(("default", "expect"), [(False, "no-cache"), (True, "cache")]) def test_show_default_boolean_flag_name(runner, default, expect): """When a boolean flag has distinct True/False opts, it should show the default opt name instead of the default value. It should only show one name even if multiple are declared. """ opt = click.Option( ("--cache/--no-cache", "--c/--nc"), default=default, show_default=True, help="Enable/Disable the cache.", ) ctx = click.Context(click.Command("test")) message = opt.get_help_record(ctx)[1] assert f"[default: {expect}]" in message def test_show_true_default_boolean_flag_value(runner): """When a boolean flag only has one opt and its default is True, it will show the default value, not the opt name. """ opt = click.Option( ("--cache",), is_flag=True, show_default=True, default=True, help="Enable the cache.", ) ctx = click.Context(click.Command("test")) message = opt.get_help_record(ctx)[1] assert "[default: True]" in message @pytest.mark.parametrize("default", [False, None]) def test_hide_false_default_boolean_flag_value(runner, default): """When a boolean flag only has one opt and its default is False or None, it will not show the default """ opt = click.Option( ("--cache",), is_flag=True, show_default=True, default=default, help="Enable the cache.", ) ctx = click.Context(click.Command("test")) message = opt.get_help_record(ctx)[1] assert "[default: " not in message def test_show_default_string(runner): """When show_default is a string show that value as default.""" opt = click.Option(["--limit"], show_default="unlimited") ctx = click.Context(click.Command("cli")) message = opt.get_help_record(ctx)[1] assert "[default: (unlimited)]" in message def test_do_not_show_no_default(runner): """When show_default is True and no default is set do not show None.""" opt = click.Option(["--limit"], show_default=True) ctx = click.Context(click.Command("cli")) message = opt.get_help_record(ctx)[1] assert "[default: None]" not in message def test_do_not_show_default_empty_multiple(): """When show_default is True and multiple=True is set, it should not print empty default value in --help output. """ opt = click.Option(["-a"], multiple=True, help="values", show_default=True) ctx = click.Context(click.Command("cli")) message = opt.get_help_record(ctx)[1] assert message == "values" @pytest.mark.parametrize( ("ctx_value", "opt_value", "expect"), [ (None, None, False), (None, False, False), (None, True, True), (False, None, False), (False, False, False), (False, True, True), (True, None, True), (True, False, False), (True, True, True), (False, "one", True), ], ) def test_show_default_precedence(ctx_value, opt_value, expect): ctx = click.Context(click.Command("test"), show_default=ctx_value) opt = click.Option("-a", default=1, help="value", show_default=opt_value) help = opt.get_help_record(ctx)[1] assert ("default:" in help) is expect @pytest.mark.parametrize( ("args", "expect"), [ (None, (None, None, ())), (["--opt"], ("flag", None, ())), (["--opt", "-a", 42], ("flag", "42", ())), (["--opt", "test", "-a", 42], ("test", "42", ())), (["--opt=test", "-a", 42], ("test", "42", ())), (["-o"], ("flag", None, ())), (["-o", "-a", 42], ("flag", "42", ())), (["-o", "test", "-a", 42], ("test", "42", ())), (["-otest", "-a", 42], ("test", "42", ())), (["a", "b", "c"], (None, None, ("a", "b", "c"))), (["--opt", "a", "b", "c"], ("a", None, ("b", "c"))), (["--opt", "test"], ("test", None, ())), (["-otest", "a", "b", "c"], ("test", None, ("a", "b", "c"))), (["--opt=test", "a", "b", "c"], ("test", None, ("a", "b", "c"))), ], ) def test_option_with_optional_value(runner, args, expect): @click.command() @click.option("-o", "--opt", is_flag=False, flag_value="flag") @click.option("-a") @click.argument("b", nargs=-1) def cli(opt, a, b): return opt, a, b result = runner.invoke(cli, args, standalone_mode=False, catch_exceptions=False) assert result.return_value == expect def test_multiple_option_with_optional_value(runner): cli = click.Command( "cli", params=[ click.Option(["-f"], is_flag=False, flag_value="flag", multiple=True), click.Option(["-a"]), click.Argument(["b"], nargs=-1), ], callback=lambda **kwargs: kwargs, ) result = runner.invoke( cli, ["-f", "-f", "other", "-f", "-a", "1", "a", "b"], standalone_mode=False, catch_exceptions=False, ) assert result.return_value == { "f": ("flag", "other", "flag"), "a": "1", "b": ("a", "b"), } def test_type_from_flag_value(): param = click.Option(["-a", "x"], default=True, flag_value=4) assert param.type is click.INT param = click.Option(["-b", "x"], flag_value=8) assert param.type is click.INT @pytest.mark.parametrize( ("option", "expected"), [ # Not boolean flags pytest.param(Option(["-a"], type=int), False, id="int option"), pytest.param(Option(["-a"], type=bool), False, id="bool non-flag [None]"), pytest.param(Option(["-a"], default=True), False, id="bool non-flag [True]"), pytest.param(Option(["-a"], default=False), False, id="bool non-flag [False]"), pytest.param(Option(["-a"], flag_value=1), False, id="non-bool flag_value"), # Boolean flags pytest.param(Option(["-a"], is_flag=True), True, id="is_flag=True"), pytest.param(Option(["-a/-A"]), True, id="secondary option [implicit flag]"), pytest.param(Option(["-a"], flag_value=True), True, id="bool flag_value"), ], ) def test_is_bool_flag_is_correctly_set(option, expected): assert option.is_bool_flag is expected @pytest.mark.parametrize( ("kwargs", "message"), [ ({"count": True, "multiple": True}, "'count' is not valid with 'multiple'."), ({"count": True, "is_flag": True}, "'count' is not valid with 'is_flag'."), ], ) def test_invalid_flag_combinations(runner, kwargs, message): with pytest.raises(TypeError) as e: click.Option(["-a"], **kwargs) assert message in str(e.value) asyncclick-8.1.7.0-async/tests/test_parser.py000066400000000000000000000016361452710122500211770ustar00rootroot00000000000000import pytest import asyncclick as click from asyncclick.parser import OptionParser from asyncclick.parser import split_arg_string @pytest.mark.parametrize( ("value", "expect"), [ ("cli a b c", ["cli", "a", "b", "c"]), ("cli 'my file", ["cli", "my file"]), ("cli 'my file'", ["cli", "my file"]), ("cli my\\", ["cli", "my"]), ("cli my\\ file", ["cli", "my file"]), ], ) def test_split_arg_string(value, expect): assert split_arg_string(value) == expect def test_parser_default_prefixes(): parser = OptionParser() assert parser._opt_prefixes == {"-", "--"} def test_parser_collects_prefixes(): ctx = click.Context(click.Command("test")) parser = OptionParser(ctx) click.Option("+p", is_flag=True).add_to_parser(parser, ctx) click.Option("!e", is_flag=True).add_to_parser(parser, ctx) assert parser._opt_prefixes == {"-", "--", "+", "!"} asyncclick-8.1.7.0-async/tests/test_shell_completion.py000066400000000000000000000355411452710122500232450ustar00rootroot00000000000000import pytest import asyncclick as click import asyncclick.shell_completion from asyncclick.core import Argument from asyncclick.core import Command from asyncclick.core import Group from asyncclick.core import Option from asyncclick.shell_completion import add_completion_class from asyncclick.shell_completion import CompletionItem from asyncclick.shell_completion import ShellComplete from asyncclick.types import Choice from asyncclick.types import File from asyncclick.types import Path async def _get_completions(cli, args, incomplete): comp = ShellComplete(cli, {}, cli.name, "_CLICK_COMPLETE") return await comp.get_completions(args, incomplete) async def _get_words(cli, args, incomplete): return [c.value for c in await _get_completions(cli, args, incomplete)] @pytest.mark.anyio async def test_command(): cli = Command("cli", params=[Option(["-t", "--test"])]) assert await _get_words(cli, [], "") == [] assert await _get_words(cli, [], "-") == ["-t", "--test", "--help"] assert await _get_words(cli, [], "--") == ["--test", "--help"] assert await _get_words(cli, [], "--t") == ["--test"] # -t has been seen, so --test isn't suggested assert await _get_words(cli, ["-t", "a"], "-") == ["--help"] @pytest.mark.anyio async def test_group(): cli = Group("cli", params=[Option(["-a"])], commands=[Command("x"), Command("y")]) assert await _get_words(cli, [], "") == ["x", "y"] assert await _get_words(cli, [], "-") == ["-a", "--help"] @pytest.mark.anyio async def test_group_command_same_option(): cli = Group( "cli", params=[Option(["-a"])], commands=[Command("x", params=[Option(["-a"])])] ) assert await _get_words(cli, [], "-") == ["-a", "--help"] assert await _get_words(cli, ["-a", "a"], "-") == ["--help"] assert await _get_words(cli, ["-a", "a", "x"], "-") == ["-a", "--help"] assert await _get_words(cli, ["-a", "a", "x", "-a", "a"], "-") == ["--help"] @pytest.mark.anyio async def test_chained(): cli = Group( "cli", chain=True, commands=[ Command("set", params=[Option(["-y"])]), Command("start"), Group("get", commands=[Command("full")]), ], ) assert await _get_words(cli, [], "") == ["get", "set", "start"] assert await _get_words(cli, [], "s") == ["set", "start"] assert await _get_words(cli, ["set", "start"], "") == ["get"] # subcommands and parent subcommands assert await _get_words(cli, ["get"], "") == ["full", "set", "start"] assert await _get_words(cli, ["get", "full"], "") == ["set", "start"] assert await _get_words(cli, ["get"], "s") == ["set", "start"] @pytest.mark.anyio async def test_help_option(): cli = Group("cli", commands=[Command("with"), Command("no", add_help_option=False)]) assert await _get_words(cli, ["with"], "--") == ["--help"] assert await _get_words(cli, ["no"], "--") == [] @pytest.mark.anyio async def test_argument_order(): cli = Command( "cli", params=[ Argument(["plain"]), Argument(["c1"], type=Choice(["a1", "a2", "b"])), Argument(["c2"], type=Choice(["c1", "c2", "d"])), ], ) # first argument has no completions assert await _get_words(cli, [], "") == [] assert await _get_words(cli, [], "a") == [] # first argument filled, now completion can happen assert await _get_words(cli, ["x"], "a") == ["a1", "a2"] assert await _get_words(cli, ["x", "b"], "d") == ["d"] @pytest.mark.anyio async def test_argument_default(): cli = Command( "cli", add_help_option=False, params=[ Argument(["a"], type=Choice(["a"]), default="a"), Argument(["b"], type=Choice(["b"]), default="b"), ], ) assert await _get_words(cli, [], "") == ["a"] assert await _get_words(cli, ["a"], "b") == ["b"] # ignore type validation assert await _get_words(cli, ["x"], "b") == ["b"] @pytest.mark.anyio async def test_type_choice(): cli = Command("cli", params=[Option(["-c"], type=Choice(["a1", "a2", "b"]))]) assert await _get_words(cli, ["-c"], "") == ["a1", "a2", "b"] assert await _get_words(cli, ["-c"], "a") == ["a1", "a2"] assert await _get_words(cli, ["-c"], "a2") == ["a2"] @pytest.mark.anyio async def test_choice_special_characters(): cli = Command("cli", params=[Option(["-c"], type=Choice(["!1", "!2", "+3"]))]) assert await _get_words(cli, ["-c"], "") == ["!1", "!2", "+3"] assert await _get_words(cli, ["-c"], "!") == ["!1", "!2"] assert await _get_words(cli, ["-c"], "!2") == ["!2"] @pytest.mark.anyio async def test_choice_conflicting_prefix(): cli = Command( "cli", params=[ Option(["-c"], type=Choice(["!1", "!2", "+3"])), Option(["+p"], is_flag=True), ], ) assert await _get_words(cli, ["-c"], "") == ["!1", "!2", "+3"] assert await _get_words(cli, ["-c"], "+") == ["+p"] @pytest.mark.anyio async def test_option_count(): cli = Command("cli", params=[Option(["-c"], count=True)]) assert await _get_words(cli, ["-c"], "") == [] assert await _get_words(cli, ["-c"], "-") == ["--help"] @pytest.mark.anyio async def test_option_optional(): cli = Command( "cli", add_help_option=False, params=[ Option(["--name"], is_flag=False, flag_value="value"), Option(["--flag"], is_flag=True), ], ) assert await _get_words(cli, ["--name"], "") == [] assert await _get_words(cli, ["--name"], "-") == ["--flag"] assert await _get_words(cli, ["--name", "--flag"], "-") == [] @pytest.mark.parametrize( ("type", "expect"), [(File(), "file"), (Path(), "file"), (Path(file_okay=False), "dir")], ) @pytest.mark.anyio async def test_path_types(type, expect): cli = Command("cli", params=[Option(["-f"], type=type)]) out = await _get_completions(cli, ["-f"], "ab") assert len(out) == 1 c = out[0] assert c.value == "ab" assert c.type == expect @pytest.mark.anyio async def test_absolute_path(): cli = Command("cli", params=[Option(["-f"], type=Path())]) out = await _get_completions(cli, ["-f"], "/ab") assert len(out) == 1 c = out[0] assert c.value == "/ab" @pytest.mark.anyio async def test_option_flag(): cli = Command( "cli", add_help_option=False, params=[ Option(["--on/--off"]), Argument(["a"], type=Choice(["a1", "a2", "b"])), ], ) assert await _get_words(cli, [], "--") == ["--on", "--off"] # flag option doesn't take value, use choice argument assert await _get_words(cli, ["--on"], "a") == ["a1", "a2"] @pytest.mark.anyio async def test_option_custom(): def custom(ctx, param, incomplete): return [incomplete.upper()] cli = Command( "cli", params=[ Argument(["x"]), Argument(["y"]), Argument(["z"], shell_complete=custom), ], ) assert await _get_words(cli, ["a", "b"], "") == [""] assert await _get_words(cli, ["a", "b"], "c") == ["C"] @pytest.mark.anyio async def test_option_multiple(): cli = Command( "type", params=[Option(["-m"], type=Choice(["a", "b"]), multiple=True), Option(["-f"])], ) assert await _get_words(cli, ["-m"], "") == ["a", "b"] assert "-m" in await _get_words(cli, ["-m", "a"], "-") assert await _get_words(cli, ["-m", "a", "-m"], "") == ["a", "b"] # used single options aren't suggested again assert "-c" not in await _get_words(cli, ["-c", "f"], "-") @pytest.mark.anyio async def test_option_nargs(): cli = Command("cli", params=[Option(["-c"], type=Choice(["a", "b"]), nargs=2)]) assert await _get_words(cli, ["-c"], "") == ["a", "b"] assert await _get_words(cli, ["-c", "a"], "") == ["a", "b"] assert await _get_words(cli, ["-c", "a", "b"], "") == [] @pytest.mark.anyio async def test_argument_nargs(): cli = Command( "cli", params=[ Argument(["x"], type=Choice(["a", "b"]), nargs=2), Argument(["y"], type=Choice(["c", "d"]), nargs=-1), Option(["-z"]), ], ) assert await _get_words(cli, [], "") == ["a", "b"] assert await _get_words(cli, ["a"], "") == ["a", "b"] assert await _get_words(cli, ["a", "b"], "") == ["c", "d"] assert await _get_words(cli, ["a", "b", "c"], "") == ["c", "d"] assert await _get_words(cli, ["a", "b", "c", "d"], "") == ["c", "d"] assert await _get_words(cli, ["a", "-z", "1"], "") == ["a", "b"] assert await _get_words(cli, ["a", "-z", "1", "b"], "") == ["c", "d"] @pytest.mark.anyio async def test_double_dash(): cli = Command( "cli", add_help_option=False, params=[ Option(["--opt"]), Argument(["name"], type=Choice(["name", "--", "-o", "--opt"])), ], ) assert await _get_words(cli, [], "-") == ["--opt"] assert await _get_words(cli, ["value"], "-") == ["--opt"] assert await _get_words(cli, [], "") == ["name", "--", "-o", "--opt"] assert await _get_words(cli, ["--"], "") == ["name", "--", "-o", "--opt"] @pytest.mark.anyio async def test_hidden(): cli = Group( "cli", commands=[ Command( "hidden", add_help_option=False, hidden=True, params=[ Option(["-a"]), Option(["-b"], type=Choice(["a", "b"]), hidden=True), ], ) ], ) assert "hidden" not in await _get_words(cli, [], "") assert "hidden" not in await _get_words(cli, [], "hidden") assert await _get_words(cli, ["hidden"], "-") == ["-a"] assert await _get_words(cli, ["hidden", "-b"], "") == ["a", "b"] @pytest.mark.anyio async def test_add_different_name(): cli = Group("cli", commands={"renamed": Command("original")}) words = await _get_words(cli, [], "") assert "renamed" in words assert "original" not in words def test_completion_item_data(): c = CompletionItem("test", a=1) assert c.a == 1 assert c.b is None @pytest.fixture() def _patch_for_completion(monkeypatch): monkeypatch.setattr( "asyncclick.shell_completion.BashComplete._check_version", lambda self: True ) @pytest.mark.parametrize("shell", ["bash", "zsh", "fish"]) @pytest.mark.usefixtures("_patch_for_completion") def test_full_source(runner, shell): cli = Group("cli", commands=[Command("a"), Command("b")]) result = runner.invoke(cli, env={"_CLI_COMPLETE": f"{shell}_source"}) assert f"_CLI_COMPLETE={shell}_complete" in result.output @pytest.mark.parametrize( ("shell", "env", "expect"), [ ("bash", {"COMP_WORDS": "", "COMP_CWORD": "0"}, "plain,a\nplain,b\n"), ("bash", {"COMP_WORDS": "a b", "COMP_CWORD": "1"}, "plain,b\n"), ("zsh", {"COMP_WORDS": "", "COMP_CWORD": "0"}, "plain\na\n_\nplain\nb\nbee\n"), ("zsh", {"COMP_WORDS": "a b", "COMP_CWORD": "1"}, "plain\nb\nbee\n"), ("fish", {"COMP_WORDS": "", "COMP_CWORD": ""}, "plain,a\nplain,b\tbee\n"), ("fish", {"COMP_WORDS": "a b", "COMP_CWORD": "b"}, "plain,b\tbee\n"), ], ) @pytest.mark.usefixtures("_patch_for_completion") def test_full_complete(runner, shell, env, expect): cli = Group("cli", commands=[Command("a"), Command("b", help="bee")]) env["_CLI_COMPLETE"] = f"{shell}_complete" result = runner.invoke(cli, env=env) assert result.output == expect @pytest.mark.usefixtures("_patch_for_completion") def test_context_settings(runner): def complete(ctx, param, incomplete): return ctx.obj["choices"] cli = Command("cli", params=[Argument("x", shell_complete=complete)]) result = runner.invoke( cli, obj={"choices": ["a", "b"]}, env={"COMP_WORDS": "", "COMP_CWORD": "0", "_CLI_COMPLETE": "bash_complete"}, ) assert result.output == "plain,a\nplain,b\n" @pytest.mark.parametrize(("value", "expect"), [(False, ["Au", "al"]), (True, ["al"])]) @pytest.mark.anyio async def test_choice_case_sensitive(value, expect): cli = Command( "cli", params=[Option(["-a"], type=Choice(["Au", "al", "Bc"], case_sensitive=value))], ) completions = await _get_words(cli, ["-a"], "a") assert completions == expect @pytest.fixture() def _restore_available_shells(tmpdir): prev_available_shells = click.shell_completion._available_shells.copy() click.shell_completion._available_shells.clear() yield click.shell_completion._available_shells.clear() click.shell_completion._available_shells.update(prev_available_shells) @pytest.mark.usefixtures("_restore_available_shells") def test_add_completion_class(): # At first, "mysh" is not in available shells assert "mysh" not in click.shell_completion._available_shells class MyshComplete(ShellComplete): name = "mysh" source_template = "dummy source" # "mysh" still not in available shells because it is not registered assert "mysh" not in click.shell_completion._available_shells # Adding a completion class should return that class assert add_completion_class(MyshComplete) is MyshComplete # Now, "mysh" is finally in available shells assert "mysh" in click.shell_completion._available_shells assert click.shell_completion._available_shells["mysh"] is MyshComplete @pytest.mark.usefixtures("_restore_available_shells") def test_add_completion_class_with_name(): # At first, "mysh" is not in available shells assert "mysh" not in click.shell_completion._available_shells assert "not_mysh" not in click.shell_completion._available_shells class MyshComplete(ShellComplete): name = "not_mysh" source_template = "dummy source" # "mysh" and "not_mysh" are still not in available shells because # it is not registered yet assert "mysh" not in click.shell_completion._available_shells assert "not_mysh" not in click.shell_completion._available_shells # Adding a completion class should return that class. # Because we are using the "name" parameter, the name isn't taken # from the class. assert add_completion_class(MyshComplete, name="mysh") is MyshComplete # Now, "mysh" is finally in available shells assert "mysh" in click.shell_completion._available_shells assert "not_mysh" not in click.shell_completion._available_shells assert click.shell_completion._available_shells["mysh"] is MyshComplete @pytest.mark.usefixtures("_restore_available_shells") def test_add_completion_class_decorator(): # At first, "mysh" is not in available shells assert "mysh" not in click.shell_completion._available_shells @add_completion_class class MyshComplete(ShellComplete): name = "mysh" source_template = "dummy source" # Using `add_completion_class` as a decorator adds the new shell immediately assert "mysh" in click.shell_completion._available_shells assert click.shell_completion._available_shells["mysh"] is MyshComplete asyncclick-8.1.7.0-async/tests/test_termui.py000066400000000000000000000332011452710122500212010ustar00rootroot00000000000000import platform import time import pytest import asyncclick as click import asyncclick._termui_impl from asyncclick._compat import WIN class FakeClock: def __init__(self): self.now = time.time() def advance_time(self, seconds=1): self.now += seconds def time(self): return self.now def _create_progress(length=10, **kwargs): progress = click.progressbar(tuple(range(length))) for key, value in kwargs.items(): setattr(progress, key, value) return progress def test_progressbar_strip_regression(runner, monkeypatch): label = " padded line" @click.command() def cli(): with _create_progress(label=label) as progress: for _ in progress: pass monkeypatch.setattr(click._termui_impl, "isatty", lambda _: True) assert ( label in runner.invoke(cli, [], standalone_mode=False, catch_exceptions=False).output ) def test_progressbar_length_hint(runner, monkeypatch): class Hinted: 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__ @click.command() def cli(): with click.progressbar(Hinted(10), label="test") as progress: for _ in progress: pass monkeypatch.setattr(click._termui_impl, "isatty", lambda _: True) result = runner.invoke(cli, []) assert result.exception is None def test_progressbar_hidden(runner, monkeypatch): @click.command() def cli(): with _create_progress(label="working") as progress: for _ in progress: pass monkeypatch.setattr(click._termui_impl, "isatty", lambda _: False) assert runner.invoke(cli, []).output == "working\n" @pytest.mark.parametrize("avg, expected", [([], 0.0), ([1, 4], 2.5)]) def test_progressbar_time_per_iteration(runner, avg, expected): with _create_progress(2, avg=avg) as progress: assert progress.time_per_iteration == expected @pytest.mark.parametrize("finished, expected", [(False, 5), (True, 0)]) def test_progressbar_eta(runner, finished, expected): with _create_progress(2, finished=finished, avg=[1, 4]) as progress: assert progress.eta == expected @pytest.mark.parametrize( "eta, expected", [ (0, "00:00:00"), (30, "00:00:30"), (90, "00:01:30"), (900, "00:15:00"), (9000, "02:30:00"), (99999999999, "1157407d 09:46:39"), (None, ""), ], ) def test_progressbar_format_eta(runner, eta, expected): with _create_progress(1, eta_known=eta is not None, avg=[eta]) as progress: assert progress.format_eta() == expected @pytest.mark.parametrize("pos, length", [(0, 5), (-1, 1), (5, 5), (6, 5), (4, 0)]) def test_progressbar_format_pos(runner, pos, length): with _create_progress(length, pos=pos) as progress: result = progress.format_pos() assert result == f"{pos}/{length}" @pytest.mark.parametrize( "length, finished, pos, avg, expected", [ (8, False, 7, 0, "#######-"), (0, True, 8, 0, "########"), ], ) def test_progressbar_format_bar(runner, length, finished, pos, avg, expected): with _create_progress( length, width=8, pos=pos, finished=finished, avg=[avg] ) as progress: assert progress.format_bar() == expected @pytest.mark.parametrize( "length, show_percent, show_pos, pos, expected", [ (0, True, True, 0, " [--------] 0/0 0%"), (0, False, True, 0, " [--------] 0/0"), (0, False, False, 0, " [--------]"), (0, False, False, 0, " [--------]"), (8, True, True, 8, " [########] 8/8 100%"), ], ) def test_progressbar_format_progress_line( runner, length, show_percent, show_pos, pos, expected ): with _create_progress( length, width=8, show_percent=show_percent, pos=pos, show_pos=show_pos, ) as progress: assert progress.format_progress_line() == expected @pytest.mark.parametrize("test_item", ["test", None]) def test_progressbar_format_progress_line_with_show_func(runner, test_item): def item_show_func(item): return item with _create_progress( item_show_func=item_show_func, current_item=test_item ) as progress: if test_item: assert progress.format_progress_line().endswith(test_item) else: assert progress.format_progress_line().endswith(progress.format_pct()) def test_progressbar_init_exceptions(runner): with pytest.raises(TypeError, match="iterable or length is required"): click.progressbar() def test_progressbar_iter_outside_with_exceptions(runner): progress = click.progressbar(length=2) with pytest.raises(RuntimeError, match="with block"): iter(progress) def test_progressbar_is_iterator(runner, monkeypatch): @click.command() def cli(): with click.progressbar(range(10), label="test") as progress: while True: try: next(progress) except StopIteration: break monkeypatch.setattr(click._termui_impl, "isatty", lambda _: True) result = runner.invoke(cli, []) assert result.exception is None 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 @pytest.mark.parametrize( "file_kwargs", [{"mode": "rt"}, {"mode": "rb"}, {"lazy": True}] ) def test_file_prompt_default_format(runner, file_kwargs): @click.command() @click.option("-f", default=__file__, prompt="file", type=click.File(**file_kwargs)) def cli(f): click.echo(f.name) result = runner.invoke(cli) assert result.output == f"file [{__file__}]: \n{__file__}\n" def test_secho(runner): with runner.isolation() as outstreams: click.secho(None, nl=False) bytes = outstreams[0].getvalue() assert bytes == b"" @pytest.mark.skipif(platform.system() == "Windows", reason="No style on Windows.") @pytest.mark.parametrize( ("value", "expect"), [(123, b"\x1b[45m123\x1b[0m"), (b"test", b"test")] ) def test_secho_non_text(runner, value, expect): with runner.isolation() as (out, _): click.secho(value, nl=False, color=True, bg="magenta") result = out.getvalue() assert result == expect 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(asyncclick._termui_impl, "isatty", lambda _: True) output = runner.invoke(cli, []).output lines = [line for line in output.split("\n") if "[" in line] assert " 0%" in lines[0] assert " 25% 00:00:03" in lines[1] assert " 50% 00:00:02" in lines[2] assert " 75% 00:00:01" in lines[3] assert "100% " in lines[4] def test_progressbar_item_show_func(runner, monkeypatch): """item_show_func should show the current item being yielded.""" @click.command() def cli(): with click.progressbar(range(3), item_show_func=lambda x: str(x)) as progress: for item in progress: click.echo(f" item {item}") monkeypatch.setattr(click._termui_impl, "isatty", lambda _: True) lines = runner.invoke(cli).output.splitlines() for i, line in enumerate(x for x in lines if "item" in x): assert f"{i} item {i}" in line def test_progressbar_update_with_item_show_func(runner, monkeypatch): @click.command() def cli(): with click.progressbar( length=6, item_show_func=lambda x: f"Custom {x}" ) as progress: while not progress.finished: progress.update(2, progress.pos) click.echo() 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 "Custom 0" in lines[0] assert "Custom 2" in lines[1] assert "Custom 4" in lines[2] def test_progress_bar_update_min_steps(runner): bar = _create_progress(update_min_steps=5) bar.update(3) assert bar._completed_intervals == 3 assert bar.pos == 0 bar.update(2) assert bar._completed_intervals == 0 assert bar.pos == 5 @pytest.mark.parametrize("key_char", ("h", "H", "é", "À", " ", "字", "àH", "àR")) @pytest.mark.parametrize("echo", [True, False]) @pytest.mark.skipif(not WIN, reason="Tests user-input using the msvcrt module.") def test_getchar_windows(runner, monkeypatch, key_char, echo): monkeypatch.setattr(asyncclick._termui_impl.msvcrt, "getwche", lambda: key_char) monkeypatch.setattr(asyncclick._termui_impl.msvcrt, "getwch", lambda: key_char) monkeypatch.setattr(click.termui, "_getchar", None) assert click.getchar(echo) == key_char @pytest.mark.parametrize( "special_key_char, key_char", [("\x00", "a"), ("\x00", "b"), ("\xe0", "c")] ) @pytest.mark.skipif( not WIN, reason="Tests special character inputs using the msvcrt module." ) def test_getchar_special_key_windows(runner, monkeypatch, special_key_char, key_char): ordered_inputs = [key_char, special_key_char] monkeypatch.setattr( asyncclick._termui_impl.msvcrt, "getwch", lambda: ordered_inputs.pop() ) monkeypatch.setattr(click.termui, "_getchar", None) assert click.getchar() == f"{special_key_char}{key_char}" @pytest.mark.parametrize( ("key_char", "exc"), [("\x03", KeyboardInterrupt), ("\x1a", EOFError)] ) @pytest.mark.skipif(not WIN, reason="Tests user-input using the msvcrt module.") def test_getchar_windows_exceptions(runner, monkeypatch, key_char, exc): monkeypatch.setattr(asyncclick._termui_impl.msvcrt, "getwch", lambda: key_char) monkeypatch.setattr(click.termui, "_getchar", None) with pytest.raises(exc): click.getchar() @pytest.mark.skipif(platform.system() == "Windows", reason="No sed on Windows.") def test_fast_edit(runner): result = click.edit("a\nb", editor="sed -i~ 's/$/Test/'") assert result == "aTest\nbTest\n" @pytest.mark.parametrize( ("prompt_required", "required", "args", "expect"), [ (True, False, None, "prompt"), (True, False, ["-v"], "Option '-v' requires an argument."), (False, True, None, "prompt"), (False, True, ["-v"], "prompt"), ], ) def test_prompt_required_with_required(runner, prompt_required, required, args, expect): @click.command() @click.option("-v", prompt=True, prompt_required=prompt_required, required=required) def cli(v): click.echo(str(v)) result = runner.invoke(cli, args, input="prompt") assert expect in result.output @pytest.mark.parametrize( ("args", "expect"), [ # Flag not passed, don't prompt. pytest.param(None, None, id="no flag"), # Flag and value passed, don't prompt. pytest.param(["-v", "value"], "value", id="short sep value"), pytest.param(["--value", "value"], "value", id="long sep value"), pytest.param(["-vvalue"], "value", id="short join value"), pytest.param(["--value=value"], "value", id="long join value"), # Flag without value passed, prompt. pytest.param(["-v"], "prompt", id="short no value"), pytest.param(["--value"], "prompt", id="long no value"), # Don't use next option flag as value. pytest.param(["-v", "-o", "42"], ("prompt", "42"), id="no value opt"), ], ) def test_prompt_required_false(runner, args, expect): @click.command() @click.option("-v", "--value", prompt=True, prompt_required=False) @click.option("-o") def cli(value, o): if o is not None: return value, o return value result = runner.invoke(cli, args=args, input="prompt", standalone_mode=False) assert result.exception is None assert result.return_value == expect @pytest.mark.parametrize( ("prompt", "input", "default", "expect"), [ (True, "password\npassword", None, "password"), ("Confirm Password", "password\npassword\n", None, "password"), (True, "", "", ""), (False, None, None, None), ], ) def test_confirmation_prompt(runner, prompt, input, default, expect): @click.command() @click.option( "--password", prompt=prompt, hide_input=True, default=default, confirmation_prompt=prompt, ) def cli(password): return password result = runner.invoke(cli, input=input, standalone_mode=False) assert result.exception is None assert result.return_value == expect if prompt == "Confirm Password": assert "Confirm Password: " in result.output asyncclick-8.1.7.0-async/tests/test_testing.py000066400000000000000000000270561452710122500213640ustar00rootroot00000000000000import os import sys from io import BytesIO import pytest import asyncclick as click from asyncclick._compat import WIN from asyncclick.testing import CliRunner @pytest.mark.anyio async def test_runner(): @click.command() def test(): i = click.get_binary_stream("stdin") o = click.get_binary_stream("stdout") while True: chunk = i.read(4096) if not chunk: break o.write(chunk) o.flush() runner = CliRunner() result = await runner.invoke(test, input="Hello World!\n") if result.exception: raise result.exception assert result.output == "Hello World!\n" @pytest.mark.anyio async def test_echo_stdin_stream(): @click.command() def test(): i = click.get_binary_stream("stdin") o = click.get_binary_stream("stdout") while True: chunk = i.read(4096) if not chunk: break o.write(chunk) o.flush() runner = CliRunner(echo_stdin=True) result = await runner.invoke(test, input="Hello World!\n") if result.exception: raise result.exception assert result.output == "Hello World!\nHello World!\n" @pytest.mark.anyio async def test_echo_stdin_prompts(): @click.command() def test_python_input(): foo = input("Foo: ") click.echo(f"foo={foo}") runner = CliRunner(echo_stdin=True) result = await runner.invoke(test_python_input, input="bar bar\n") if result.exception: raise result.exception assert result.output == "Foo: bar bar\nfoo=bar bar\n" @click.command() @click.option("--foo", prompt=True) def test_prompt(foo): click.echo(f"foo={foo}") result = await runner.invoke(test_prompt, input="bar bar\n") if result.exception: raise result.exception assert result.output == "Foo: bar bar\nfoo=bar bar\n" @click.command() @click.option("--foo", prompt=True, hide_input=True) def test_hidden_prompt(foo): click.echo(f"foo={foo}") result = await runner.invoke(test_hidden_prompt, input="bar bar\n") if result.exception: raise result.exception assert result.output == "Foo: \nfoo=bar bar\n" @click.command() @click.option("--foo", prompt=True) @click.option("--bar", prompt=True) def test_multiple_prompts(foo, bar): click.echo(f"foo={foo}, bar={bar}") result = await runner.invoke(test_multiple_prompts, input="one\ntwo\n") if result.exception: raise result.exception assert result.output == "Foo: one\nBar: two\nfoo=one, bar=two\n" @pytest.mark.anyio async def test_runner_with_stream(): @click.command() def test(): i = click.get_binary_stream("stdin") o = click.get_binary_stream("stdout") while True: chunk = i.read(4096) if not chunk: break o.write(chunk) o.flush() runner = CliRunner() result = await runner.invoke(test, input=BytesIO(b"Hello World!\n")) if result.exception: raise result.exception assert result.output == "Hello World!\n" runner = CliRunner(echo_stdin=True) result = await runner.invoke(test, input=BytesIO(b"Hello World!\n")) if result.exception: raise result.exception assert result.output == "Hello World!\nHello World!\n" @pytest.mark.anyio async def test_prompts(): @click.command() @click.option("--foo", prompt=True) def test(foo): click.echo(f"foo={foo}") runner = CliRunner() result = await runner.invoke(test, input="wau wau\n") if result.exception: raise 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(f"foo={foo}") runner = CliRunner() result = await runner.invoke(test, input="wau wau\n") if result.exception: raise result.exception assert result.output == "Foo: \nfoo=wau wau\n" @pytest.mark.anyio async def test_getchar(): @click.command() def continue_it(): click.echo(click.getchar()) runner = CliRunner() result = await runner.invoke(continue_it, input="y") if result.exception: raise result.exception assert result.output == "y\n" runner = CliRunner(echo_stdin=True) result = await runner.invoke(continue_it, input="y") if result.exception: raise result.exception assert result.output == "y\n" @click.command() def getchar_echo(): click.echo(click.getchar(echo=True)) runner = CliRunner() result = await runner.invoke(getchar_echo, input="y") if result.exception: raise result.exception assert result.output == "yy\n" runner = CliRunner(echo_stdin=True) result = await runner.invoke(getchar_echo, input="y") if result.exception: raise result.exception assert result.output == "yy\n" @pytest.mark.anyio async def test_catch_exceptions(): class CustomError(Exception): pass @click.command() def cli(): raise CustomError(1) runner = CliRunner() result = await 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): await runner.invoke(cli, catch_exceptions=False) CustomError = SystemExit result = await runner.invoke(cli) assert result.exit_code == 1 @pytest.mark.skipif(WIN, reason="Test does not make sense on Windows.") @pytest.mark.anyio async def test_with_color(): @click.command() def cli(): click.secho("hello world", fg="blue") runner = CliRunner() result = await runner.invoke(cli) assert result.output == "hello world\n" if result.exception: raise result.exception result = await runner.invoke(cli, color=True) assert result.output == f"{click.style('hello world', fg='blue')}\n" if result.exception: raise result.exception @pytest.mark.anyio async def test_with_color_but_pause_not_blocking(): @click.command() def cli(): click.pause() runner = CliRunner() result = await runner.invoke(cli, color=True) if result.exception: raise result.exception assert result.output == "" @pytest.mark.anyio async 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 = await runner.invoke(cli_string) assert result.exit_code == 1 assert result.output == "hello world\nerror\n" result = await runner.invoke(cli_string_ctx_exit) assert result.exit_code == 1 assert result.output == "hello world\nerror\n" result = await runner.invoke(cli_int) assert result.exit_code == 1 assert result.output == "hello world\n" result = await runner.invoke(cli_int_ctx_exit) assert result.exit_code == 1 assert result.output == "hello world\n" result = await runner.invoke(cli_float) assert result.exit_code == 1 assert result.output == "hello world\n1.0\n" result = await runner.invoke(cli_float_ctx_exit) assert result.exit_code == 1 assert result.output == "hello world\n1.0\n" result = await runner.invoke(cli_no_error) assert result.exit_code == 0 assert result.output == "hello world\n" @pytest.mark.anyio async def test_env(): @click.command() def cli_env(): click.echo(f"ENV={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 = await runner.invoke(cli_env, env=env) assert result.exit_code == 0 assert result.output == "ENV=some_value\n" assert os.environ == env_orig @pytest.mark.anyio async def test_stderr(): @click.command() def cli_stderr(): click.echo("stdout") click.echo("stderr", err=True) runner = CliRunner(mix_stderr=False) result = await 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 = await 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 @click.command() def cli_empty_stderr(): click.echo("stdout") runner = CliRunner(mix_stderr=False) result = await runner.invoke(cli_empty_stderr) assert result.output == "stdout\n" assert result.stdout == "stdout\n" assert result.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"), ], ) @pytest.mark.anyio async def test_args(args, expected_output): @click.command() @click.option("--foo", default="bar") def cli_args(foo): click.echo(foo) runner = CliRunner() result = await runner.invoke(cli_args, args=args) assert result.exit_code == 0 assert result.output == expected_output @pytest.mark.anyio async def test_setting_prog_name_in_extra(): @click.command() def cli(): click.echo("ok") runner = CliRunner() result = await runner.invoke(cli, prog_name="foobar") if result.exception: raise result.exception assert result.output == "ok\n" @pytest.mark.anyio async def test_command_standalone_mode_returns_value(): @click.command() def cli(): click.echo("ok") return "Hello, World!" runner = CliRunner() result = await runner.invoke(cli, standalone_mode=False) assert result.output == "ok\n" assert result.return_value == "Hello, World!" assert result.exit_code == 0 @pytest.mark.anyio async def test_file_stdin_attrs(runner): @click.command() @click.argument("f", type=click.File()) def cli(f): click.echo(f.name) click.echo(f.mode, nl=False) result = runner.invoke(cli, ["-"]) assert result.output == "\nr" def test_isolated_runner(runner): with runner.isolated_filesystem() as d: assert os.path.exists(d) assert not os.path.exists(d) def test_isolated_runner_custom_tempdir(runner, tmp_path): with runner.isolated_filesystem(temp_dir=tmp_path) as d: assert os.path.exists(d) assert os.path.exists(d) os.rmdir(d) def test_isolation_stderr_errors(): """Writing to stderr should escape invalid characters instead of raising a UnicodeEncodeError. """ runner = CliRunner(mix_stderr=False) with runner.isolation() as (_, err): click.echo("\udce2", err=True, nl=False) assert err.getvalue() == b"\\udce2" asyncclick-8.1.7.0-async/tests/test_types.py000066400000000000000000000160671452710122500210530ustar00rootroot00000000000000import os.path import pathlib import tempfile import pytest import asyncclick as click from asyncclick import FileError @pytest.mark.parametrize( ("type", "value", "expect"), [ (click.IntRange(0, 5), "3", 3), (click.IntRange(5), "5", 5), (click.IntRange(5), "100", 100), (click.IntRange(max=5), "5", 5), (click.IntRange(max=5), "-100", -100), (click.IntRange(0, clamp=True), "-1", 0), (click.IntRange(max=5, clamp=True), "6", 5), (click.IntRange(0, min_open=True, clamp=True), "0", 1), (click.IntRange(max=5, max_open=True, clamp=True), "5", 4), (click.FloatRange(0.5, 1.5), "1.2", 1.2), (click.FloatRange(0.5, min_open=True), "0.51", 0.51), (click.FloatRange(max=1.5, max_open=True), "1.49", 1.49), (click.FloatRange(0.5, clamp=True), "-0.0", 0.5), (click.FloatRange(max=1.5, clamp=True), "inf", 1.5), ], ) def test_range(type, value, expect): assert type.convert(value, None, None) == expect @pytest.mark.parametrize( ("type", "value", "expect"), [ (click.IntRange(0, 5), "6", "6 is not in the range 0<=x<=5."), (click.IntRange(5), "4", "4 is not in the range x>=5."), (click.IntRange(max=5), "6", "6 is not in the range x<=5."), (click.IntRange(0, 5, min_open=True), 0, "00.5"), (click.FloatRange(max=1.5, max_open=True), 1.5, "x<1.5"), ], ) def test_range_fail(type, value, expect): with pytest.raises(click.BadParameter) as exc_info: type.convert(value, None, None) assert expect in exc_info.value.message def test_float_range_no_clamp_open(): with pytest.raises(TypeError): click.FloatRange(0, 1, max_open=True, clamp=True) sneaky = click.FloatRange(0, 1, max_open=True) sneaky.clamp = True with pytest.raises(RuntimeError): sneaky.convert("1.5", None, None) @pytest.mark.parametrize( ("nargs", "multiple", "default", "expect"), [ (2, False, None, None), (2, False, (None, None), (None, None)), (None, True, None, ()), (None, True, (None, None), (None, None)), (2, True, None, ()), (2, True, [(None, None)], ((None, None),)), (-1, None, None, ()), ], ) def test_cast_multi_default(runner, nargs, multiple, default, expect): if nargs == -1: param = click.Argument(["a"], nargs=nargs, default=default) else: param = click.Option(["-a"], nargs=nargs, multiple=multiple, default=default) cli = click.Command("cli", params=[param], callback=lambda a: a) result = runner.invoke(cli, standalone_mode=False) assert result.exception is None assert result.return_value == expect @pytest.mark.parametrize( ("cls", "expect"), [ (None, "a/b/c.txt"), (str, "a/b/c.txt"), (bytes, b"a/b/c.txt"), (pathlib.Path, pathlib.Path("a", "b", "c.txt")), ], ) def test_path_type(runner, cls, expect): cli = click.Command( "cli", params=[click.Argument(["p"], type=click.Path(path_type=cls))], callback=lambda p: p, ) result = runner.invoke(cli, ["a/b/c.txt"], standalone_mode=False) assert result.exception is None assert result.return_value == expect def _symlinks_supported(): with tempfile.TemporaryDirectory(prefix="click-pytest-") as tempdir: target = os.path.join(tempdir, "target") open(target, "w").close() link = os.path.join(tempdir, "link") try: os.symlink(target, link) return True except OSError: return False @pytest.mark.skipif( not _symlinks_supported(), reason="The current OS or FS doesn't support symlinks." ) def test_path_resolve_symlink(tmp_path, runner): test_file = tmp_path / "file" test_file_str = os.fspath(test_file) test_file.write_text("") path_type = click.Path(resolve_path=True) param = click.Argument(["a"], type=path_type) ctx = click.Context(click.Command("cli", params=[param])) test_dir = tmp_path / "dir" test_dir.mkdir() abs_link = test_dir / "abs" abs_link.symlink_to(test_file) abs_rv = path_type.convert(os.fspath(abs_link), param, ctx) assert abs_rv == test_file_str rel_link = test_dir / "rel" rel_link.symlink_to(pathlib.Path("..") / "file") rel_rv = path_type.convert(os.fspath(rel_link), param, ctx) assert rel_rv == test_file_str def _non_utf8_filenames_supported(): with tempfile.TemporaryDirectory(prefix="click-pytest-") as tempdir: try: f = open(os.path.join(tempdir, "\udcff"), "w") except OSError: return False f.close() return True @pytest.mark.skipif( not _non_utf8_filenames_supported(), reason="The current OS or FS doesn't support non-UTF-8 filenames.", ) def test_path_surrogates(tmp_path, monkeypatch): monkeypatch.chdir(tmp_path) type = click.Path(exists=True) path = pathlib.Path("\udcff") with pytest.raises(click.BadParameter, match="'�' does not exist"): type.convert(path, None, None) type = click.Path(file_okay=False) path.touch() with pytest.raises(click.BadParameter, match="'�' is a file"): type.convert(path, None, None) path.unlink() type = click.Path(dir_okay=False) path.mkdir() with pytest.raises(click.BadParameter, match="'�' is a directory"): type.convert(path, None, None) path.rmdir() def no_access(*args, **kwargs): """Test environments may be running as root, so we have to fake the result of the access tests that use os.access """ p = args[0] assert p == path, f"unexpected os.access call on file not under test: {p!r}" return False path.touch() type = click.Path(readable=True) with pytest.raises(click.BadParameter, match="'�' is not readable"): with monkeypatch.context() as m: m.setattr(os, "access", no_access) type.convert(path, None, None) type = click.Path(readable=False, writable=True) with pytest.raises(click.BadParameter, match="'�' is not writable"): with monkeypatch.context() as m: m.setattr(os, "access", no_access) type.convert(path, None, None) type = click.Path(readable=False, executable=True) with pytest.raises(click.BadParameter, match="'�' is not executable"): with monkeypatch.context() as m: m.setattr(os, "access", no_access) type.convert(path, None, None) path.unlink() @pytest.mark.parametrize( "type", [ click.File(mode="r"), click.File(mode="r", lazy=True), ], ) def test_file_surrogates(type, tmp_path): path = tmp_path / "\udcff" with pytest.raises(click.BadParameter, match="�': No such file or directory"): type.convert(path, None, None) def test_file_error_surrogates(): message = FileError(filename="\udcff").format_message() assert message == "Could not open file '�': unknown error" asyncclick-8.1.7.0-async/tests/test_utils.py000066400000000000000000000375531452710122500210520ustar00rootroot00000000000000import os import pathlib import stat import sys from io import StringIO import pytest import asyncclick as click import asyncclick._termui_impl import asyncclick.utils from asyncclick._compat import WIN def test_echo(runner): with runner.isolation() as outstreams: click.echo("\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 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("hello", file=f) assert f.getvalue() == "hello\n" def test_echo_no_streams(monkeypatch, runner): """echo should not fail when stdout and stderr are None with pythonw on Windows.""" with runner.isolation(): sys.stdout = None sys.stderr = None click.echo("test") click.echo("test", err=True) @pytest.mark.parametrize( ("styles", "ref"), [ ({"fg": "black"}, "\x1b[30mx y\x1b[0m"), ({"fg": "red"}, "\x1b[31mx y\x1b[0m"), ({"fg": "green"}, "\x1b[32mx y\x1b[0m"), ({"fg": "yellow"}, "\x1b[33mx y\x1b[0m"), ({"fg": "blue"}, "\x1b[34mx y\x1b[0m"), ({"fg": "magenta"}, "\x1b[35mx y\x1b[0m"), ({"fg": "cyan"}, "\x1b[36mx y\x1b[0m"), ({"fg": "white"}, "\x1b[37mx y\x1b[0m"), ({"bg": "black"}, "\x1b[40mx y\x1b[0m"), ({"bg": "red"}, "\x1b[41mx y\x1b[0m"), ({"bg": "green"}, "\x1b[42mx y\x1b[0m"), ({"bg": "yellow"}, "\x1b[43mx y\x1b[0m"), ({"bg": "blue"}, "\x1b[44mx y\x1b[0m"), ({"bg": "magenta"}, "\x1b[45mx y\x1b[0m"), ({"bg": "cyan"}, "\x1b[46mx y\x1b[0m"), ({"bg": "white"}, "\x1b[47mx y\x1b[0m"), ({"bg": 91}, "\x1b[48;5;91mx y\x1b[0m"), ({"bg": (135, 0, 175)}, "\x1b[48;2;135;0;175mx y\x1b[0m"), ({"bold": True}, "\x1b[1mx y\x1b[0m"), ({"dim": True}, "\x1b[2mx y\x1b[0m"), ({"underline": True}, "\x1b[4mx y\x1b[0m"), ({"overline": True}, "\x1b[53mx y\x1b[0m"), ({"italic": True}, "\x1b[3mx y\x1b[0m"), ({"blink": True}, "\x1b[5mx y\x1b[0m"), ({"reverse": True}, "\x1b[7mx y\x1b[0m"), ({"strikethrough": True}, "\x1b[9mx y\x1b[0m"), ({"bold": False}, "\x1b[22mx y\x1b[0m"), ({"dim": False}, "\x1b[22mx y\x1b[0m"), ({"underline": False}, "\x1b[24mx y\x1b[0m"), ({"overline": False}, "\x1b[55mx y\x1b[0m"), ({"italic": False}, "\x1b[23mx y\x1b[0m"), ({"blink": False}, "\x1b[25mx y\x1b[0m"), ({"reverse": False}, "\x1b[27mx y\x1b[0m"), ({"strikethrough": False}, "\x1b[29mx y\x1b[0m"), ({"fg": "black", "reset": False}, "\x1b[30mx y"), ], ) def test_styling(styles, ref): assert click.style("x y", **styles) == ref assert click.unstyle(ref) == "x y" @pytest.mark.parametrize(("text", "expect"), [("\x1b[?25lx y\x1b[?25h", "x y")]) def test_unstyle_other_ansi(text, expect): assert click.unstyle(text) == expect 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("/x/foo.txt") == "/x/foo.txt" assert click.format_filename("/x/foo.txt", shorten=True) == "foo.txt" assert click.format_filename(b"/x/\xff.txt", shorten=True) == "�.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" def test_confirm_repeat(runner): cli = click.Command( "cli", params=[click.Option(["--a/--no-a"], default=None, prompt=True)] ) result = runner.invoke(cli, input="\ny\n") assert result.output == "A [y/n]: \nError: invalid input\nA [y/n]: y\n" @pytest.mark.skipif(WIN, reason="Different behavior on windows.") def test_prompts_abort(monkeypatch, capsys): def f(_): raise KeyboardInterrupt() monkeypatch.setattr("asyncclick.termui.hidden_prompt_func", f) try: click.prompt("Password", hide_input=True) except click.Abort: click.echo("interrupted") out, err = capsys.readouterr() assert out == "Password:\ninterrupted\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(asyncclick._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 == f"{text}\n" click.echo(styled_text, color=True) out, err = capfd.readouterr() assert out == f"{styled_text}\n" isatty = True click.echo(styled_text) out, err = capfd.readouterr() assert out == f"{styled_text}\n" isatty = False click.echo(styled_text) out, err = capfd.readouterr() assert out == f"{text}\n" def test_prompt_cast_default(capfd, monkeypatch): monkeypatch.setattr(sys, "stdin", StringIO("\n")) value = click.prompt("value", default="100", type=int) capfd.readouterr() assert type(value) is int @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.""" 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_echo_with_capsys(capsys): click.echo("Capture me.") out, err = capsys.readouterr() assert out == "Capture me.\n" def test_open_file(runner): @click.command() @click.argument("filename") def cli(filename): with click.open_file(filename) as f: click.echo(f.read()) click.echo("meep") with runner.isolated_filesystem(): with open("hello.txt", "w") as f: f.write("Cool stuff") 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" def test_open_file_pathlib_dash(runner): @click.command() @click.argument( "filename", type=click.Path(allow_dash=True, path_type=pathlib.Path) ) def cli(filename): click.echo(str(type(filename))) with click.open_file(filename) as f: click.echo(f.read()) result = runner.invoke(cli, ["-"], input="value") assert result.exception is None assert result.output == "pathlib.Path\nvalue\n" def test_open_file_ignore_errors_stdin(runner): @click.command() @click.argument("filename") def cli(filename): with click.open_file(filename, errors="ignore") as f: click.echo(f.read()) result = runner.invoke(cli, ["-"], input=os.urandom(16)) assert result.exception is None def test_open_file_respects_ignore(runner): with runner.isolated_filesystem(): with open("test.txt", "w") as f: f.write("Hello world!") with click.open_file("test.txt", encoding="utf8", errors="ignore") as f: assert f.errors == "ignore" def test_open_file_ignore_invalid_utf8(runner): with runner.isolated_filesystem(): with open("test.txt", "wb") as f: f.write(b"\xe2\x28\xa1") with click.open_file("test.txt", encoding="utf8", errors="ignore") as f: f.read() def test_open_file_ignore_no_encoding(runner): with runner.isolated_filesystem(): with open("test.bin", "wb") as f: f.write(os.urandom(16)) with click.open_file("test.bin", errors="ignore") as f: f.read() @pytest.mark.skipif(WIN, reason="os.chmod() is not fully supported on Windows.") @pytest.mark.parametrize("permissions", [0o400, 0o444, 0o600, 0o644]) def test_open_file_atomic_permissions_existing_file(runner, permissions): with runner.isolated_filesystem(): with open("existing.txt", "w") as f: f.write("content") os.chmod("existing.txt", permissions) @click.command() @click.argument("filename") def cli(filename): click.open_file(filename, "w", atomic=True).close() result = runner.invoke(cli, ["existing.txt"]) assert result.exception is None assert stat.S_IMODE(os.stat("existing.txt").st_mode) == permissions @pytest.mark.skipif(WIN, reason="os.stat() is not fully supported on Windows.") def test_open_file_atomic_permissions_new_file(runner): with runner.isolated_filesystem(): @click.command() @click.argument("filename") def cli(filename): click.open_file(filename, "w", atomic=True).close() # Create a test file to get the expected permissions for new files # according to the current umask. with open("test.txt", "w"): pass permissions = stat.S_IMODE(os.stat("test.txt").st_mode) result = runner.invoke(cli, ["new.txt"]) assert result.exception is None assert stat.S_IMODE(os.stat("new.txt").st_mode) == permissions def test_iter_keepopenfile(tmpdir): expected = list(map(str, range(10))) p = tmpdir.mkdir("testdir").join("testfile") p.write("\n".join(expected)) with p.open() as f: for e_line, a_line in zip(expected, asyncclick.utils.KeepOpenFile(f)): assert e_line == a_line.strip() def test_iter_lazyfile(tmpdir): expected = list(map(str, range(10))) p = tmpdir.mkdir("testdir").join("testfile") p.write("\n".join(expected)) with p.open() as f: with asyncclick.utils.LazyFile(f.name) as lf: for e_line, a_line in zip(expected, lf): assert e_line == a_line.strip() class MockMain: __slots__ = "__package__" def __init__(self, package_name): self.__package__ = package_name @pytest.mark.parametrize( ("path", "main", "expected"), [ ("example.py", None, "example.py"), (str(pathlib.Path("/foo/bar/example.py")), None, "example.py"), ("example", None, "example"), (str(pathlib.Path("example/__main__.py")), "example", "python -m example"), (str(pathlib.Path("example/cli.py")), "example", "python -m example.cli"), (str(pathlib.Path("./example")), "", "example"), ], ) def test_detect_program_name(path, main, expected): assert click.utils._detect_program_name(path, _main=MockMain(main)) == expected def test_expand_args(monkeypatch): user = os.path.expanduser("~") assert user in click.utils._expand_args(["~"]) monkeypatch.setenv("CLICK_TEST", "hello") assert "hello" in click.utils._expand_args(["$CLICK_TEST"]) assert "setup.cfg" in click.utils._expand_args(["*.cfg"]) assert os.path.join("docs", "conf.py") in click.utils._expand_args(["**/conf.py"]) assert "*.not-found" in click.utils._expand_args(["*.not-found"]) # a bad glob pattern, such as a pytest identifier, should return itself assert click.utils._expand_args(["test.py::test_bad"])[0] == "test.py::test_bad" @pytest.mark.parametrize( ("value", "max_length", "expect"), [ pytest.param("", 10, "", id="empty"), pytest.param("123 567 90", 10, "123 567 90", id="equal length, no dot"), pytest.param("123 567 9. aaaa bbb", 10, "123 567 9.", id="sentence < max"), pytest.param("123 567\n\n 9. aaaa bbb", 10, "123 567", id="paragraph < max"), pytest.param("123 567 90123.", 10, "123 567...", id="truncate"), pytest.param("123 5678 xxxxxx", 10, "123...", id="length includes suffix"), pytest.param( "token in ~/.netrc ciao ciao", 20, "token in ~/.netrc...", id="ignore dot in word", ), ], ) @pytest.mark.parametrize( "alter", [ pytest.param(None, id=""), pytest.param( lambda text: "\n\b\n" + " ".join(text.split(" ")) + "\n", id="no-wrap mark" ), ], ) def test_make_default_short_help(value, max_length, alter, expect): assert len(expect) <= max_length if alter: value = alter(value) out = click.utils.make_default_short_help(value, max_length) assert out == expect asyncclick-8.1.7.0-async/tests/typing/000077500000000000000000000000001452710122500175765ustar00rootroot00000000000000asyncclick-8.1.7.0-async/tests/typing/typing_aliased_group.py000066400000000000000000000022461452710122500243640ustar00rootroot00000000000000"""Example from https://click.palletsprojects.com/en/8.1.x/advanced/#command-aliases""" from __future__ import annotations from typing_extensions import assert_type import click class AliasedGroup(click.Group): def get_command(self, ctx: click.Context, cmd_name: str) -> click.Command | None: 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(f"Too many matches: {', '.join(sorted(matches))}") def resolve_command( self, ctx: click.Context, args: list[str] ) -> tuple[str | None, click.Command, list[str]]: # always return the full command name _, cmd, args = super().resolve_command(ctx, args) assert cmd is not None return cmd.name, cmd, args @click.command(cls=AliasedGroup) def cli() -> None: pass assert_type(cli, AliasedGroup) @cli.command() def push() -> None: pass @cli.command() def pop() -> None: pass asyncclick-8.1.7.0-async/tests/typing/typing_confirmation_option.py000066400000000000000000000005051452710122500256220ustar00rootroot00000000000000"""From https://click.palletsprojects.com/en/8.1.x/options/#yes-parameters""" from typing_extensions import assert_type import click @click.command() @click.confirmation_option(prompt="Are you sure you want to drop the db?") def dropdb() -> None: click.echo("Dropped all tables!") assert_type(dropdb, click.Command) asyncclick-8.1.7.0-async/tests/typing/typing_group_kw_options.py000066400000000000000000000002341452710122500251510ustar00rootroot00000000000000from typing_extensions import assert_type import click @click.group(context_settings={}) def hello() -> None: pass assert_type(hello, click.Group) asyncclick-8.1.7.0-async/tests/typing/typing_help_option.py000066400000000000000000000004061452710122500240620ustar00rootroot00000000000000from typing_extensions import assert_type import click @click.command() @click.help_option("-h", "--help") def hello() -> None: """Simple program that greets NAME for a total of COUNT times.""" click.echo("Hello!") assert_type(hello, click.Command) asyncclick-8.1.7.0-async/tests/typing/typing_options.py000066400000000000000000000006051452710122500232360ustar00rootroot00000000000000"""From https://click.palletsprojects.com/en/8.1.x/quickstart/#adding-parameters""" from typing_extensions import assert_type import click @click.command() @click.option("--count", default=1, help="number of greetings") @click.argument("name") def hello(count: int, name: str) -> None: for _ in range(count): click.echo(f"Hello {name}!") assert_type(hello, click.Command) asyncclick-8.1.7.0-async/tests/typing/typing_password_option.py000066400000000000000000000003771452710122500250030ustar00rootroot00000000000000import codecs from typing_extensions import assert_type import click @click.command() @click.password_option() def encrypt(password: str) -> None: click.echo(f"encoded: to {codecs.encode(password, 'rot13')}") assert_type(encrypt, click.Command) asyncclick-8.1.7.0-async/tests/typing/typing_simple_example.py000066400000000000000000000007731452710122500245550ustar00rootroot00000000000000"""The simple example from https://github.com/pallets/click#a-simple-example.""" from typing_extensions import assert_type 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: int, name: str) -> None: """Simple program that greets NAME for a total of COUNT times.""" for _ in range(count): click.echo(f"Hello, {name}!") assert_type(hello, click.Command) asyncclick-8.1.7.0-async/tests/typing/typing_version_option.py000066400000000000000000000004361452710122500246220ustar00rootroot00000000000000""" From https://click.palletsprojects.com/en/8.1.x/options/#callbacks-and-eager-options. """ from typing_extensions import assert_type import click @click.command() @click.version_option("0.1") def hello() -> None: click.echo("Hello World!") assert_type(hello, click.Command) asyncclick-8.1.7.0-async/tox.ini000066400000000000000000000011461452710122500164370ustar00rootroot00000000000000[tox] envlist = py3{12,11,10,9,8,7} pypy310 style typing docs skip_missing_interpreters = true [testenv] package = wheel wheel_build_env = .pkg deps = -r requirements/tests.txt commands = pytest -v --tb=short --basetemp={envtmpdir} {posargs} [testenv:style] deps = pre-commit skip_install = true commands = pre-commit run --all-files [testenv:typing] deps = -r requirements/typing.txt commands = mypy pyright --verifytypes click pyright tests/typing [testenv:docs] deps = -r requirements/docs.txt commands = sphinx-build -W -b html -d {envtmpdir}/doctrees docs {envtmpdir}/html