Add files using upload-large-folder tool

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options/test_name/test_tutorial003_an.py

@@ -0,0 +1,36 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.options.name import tutorial003_an as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_option_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "-n" in result.output
+    assert "TEXT" in result.output
+    assert "--user-name" not in result.output
+    assert "--name" not in result.output
+
+
+def test_call():
+    result = runner.invoke(app, ["-n", "Camila"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options/test_name/test_tutorial004.py

@@ -0,0 +1,42 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.options.name import tutorial004 as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_option_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "-n" in result.output
+    assert "--user-name" in result.output
+    assert "TEXT" in result.output
+    assert "--name" not in result.output
+
+
+def test_call():
+    result = runner.invoke(app, ["-n", "Camila"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+
+
+def test_call_long():
+    result = runner.invoke(app, ["--user-name", "Camila"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options/test_name/test_tutorial004_an.py

@@ -0,0 +1,42 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.options.name import tutorial004_an as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_option_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "-n" in result.output
+    assert "--user-name" in result.output
+    assert "TEXT" in result.output
+    assert "--name" not in result.output
+
+
+def test_call():
+    result = runner.invoke(app, ["-n", "Camila"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+
+
+def test_call_long():
+    result = runner.invoke(app, ["--user-name", "Camila"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options/test_name/test_tutorial005.py

@@ -0,0 +1,54 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.options.name import tutorial005 as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_option_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "-n" in result.output
+    assert "--name" in result.output
+    assert "TEXT" in result.output
+    assert "-f" in result.output
+    assert "--formal" in result.output
+
+
+def test_call():
+    result = runner.invoke(app, ["-n", "Camila"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+
+
+def test_call_formal():
+    result = runner.invoke(app, ["-n", "Camila", "-f"])
+    assert result.exit_code == 0
+    assert "Good day Ms. Camila." in result.output
+
+
+def test_call_formal_condensed():
+    result = runner.invoke(app, ["-fn", "Camila"])
+    assert result.exit_code == 0
+    assert "Good day Ms. Camila." in result.output
+
+
+def test_call_condensed_wrong_order():
+    result = runner.invoke(app, ["-nf", "Camila"])
+    assert result.exit_code != 0
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options/test_name/test_tutorial005_an.py

@@ -0,0 +1,54 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.options.name import tutorial005_an as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_option_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "-n" in result.output
+    assert "--name" in result.output
+    assert "TEXT" in result.output
+    assert "-f" in result.output
+    assert "--formal" in result.output
+
+
+def test_call():
+    result = runner.invoke(app, ["-n", "Camila"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+
+
+def test_call_formal():
+    result = runner.invoke(app, ["-n", "Camila", "-f"])
+    assert result.exit_code == 0
+    assert "Good day Ms. Camila." in result.output
+
+
+def test_call_formal_condensed():
+    result = runner.invoke(app, ["-fn", "Camila"])
+    assert result.exit_code == 0
+    assert "Good day Ms. Camila." in result.output
+
+
+def test_call_condensed_wrong_order():
+    result = runner.invoke(app, ["-nf", "Camila"])
+    assert result.exit_code != 0
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options/test_prompt/test_tutorial001.py

@@ -0,0 +1,42 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.options.prompt import tutorial001 as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_option_lastname():
+    result = runner.invoke(app, ["Camila", "--lastname", "Gutiérrez"])
+    assert result.exit_code == 0
+    assert "Hello Camila Gutiérrez" in result.output
+
+
+def test_option_lastname_prompt():
+    result = runner.invoke(app, ["Camila"], input="Gutiérrez")
+    assert result.exit_code == 0
+    assert "Lastname: " in result.output
+    assert "Hello Camila Gutiérrez" in result.output
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "--lastname" in result.output
+    assert "TEXT" in result.output
+    assert "[required]" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options/test_prompt/test_tutorial001_an.py

@@ -0,0 +1,42 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.options.prompt import tutorial001_an as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_option_lastname():
+    result = runner.invoke(app, ["Camila", "--lastname", "Gutiérrez"])
+    assert result.exit_code == 0
+    assert "Hello Camila Gutiérrez" in result.output
+
+
+def test_option_lastname_prompt():
+    result = runner.invoke(app, ["Camila"], input="Gutiérrez")
+    assert result.exit_code == 0
+    assert "Lastname: " in result.output
+    assert "Hello Camila Gutiérrez" in result.output
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "--lastname" in result.output
+    assert "TEXT" in result.output
+    assert "[required]" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options/test_prompt/test_tutorial002.py

@@ -0,0 +1,42 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.options.prompt import tutorial002 as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_option_lastname():
+    result = runner.invoke(app, ["Camila", "--lastname", "Gutiérrez"])
+    assert result.exit_code == 0
+    assert "Hello Camila Gutiérrez" in result.output
+
+
+def test_option_lastname_prompt():
+    result = runner.invoke(app, ["Camila"], input="Gutiérrez")
+    assert result.exit_code == 0
+    assert "Please tell me your last name: " in result.output
+    assert "Hello Camila Gutiérrez" in result.output
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "--lastname" in result.output
+    assert "TEXT" in result.output
+    assert "[required]" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options/test_prompt/test_tutorial002_an.py

@@ -0,0 +1,42 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.options.prompt import tutorial002_an as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_option_lastname():
+    result = runner.invoke(app, ["Camila", "--lastname", "Gutiérrez"])
+    assert result.exit_code == 0
+    assert "Hello Camila Gutiérrez" in result.output
+
+
+def test_option_lastname_prompt():
+    result = runner.invoke(app, ["Camila"], input="Gutiérrez")
+    assert result.exit_code == 0
+    assert "Please tell me your last name: " in result.output
+    assert "Hello Camila Gutiérrez" in result.output
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "--lastname" in result.output
+    assert "TEXT" in result.output
+    assert "[required]" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options/test_prompt/test_tutorial003.py

@@ -0,0 +1,51 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.options.prompt import tutorial003 as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_prompt():
+    result = runner.invoke(app, input="Old Project\nOld Project\n")
+    assert result.exit_code == 0
+    assert "Deleting project Old Project" in result.output
+
+
+def test_prompt_not_equal():
+    result = runner.invoke(
+        app, input="Old Project\nNew Spice\nOld Project\nOld Project\n"
+    )
+    assert result.exit_code == 0
+    assert "Error: The two entered values do not match" in result.output
+    assert "Deleting project Old Project" in result.output
+
+
+def test_option():
+    result = runner.invoke(app, ["--project-name", "Old Project"])
+    assert result.exit_code == 0
+    assert "Deleting project Old Project" in result.output
+    assert "Project name: " not in result.output
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "--project-name" in result.output
+    assert "TEXT" in result.output
+    assert "[required]" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options/test_prompt/test_tutorial003_an.py

@@ -0,0 +1,51 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.options.prompt import tutorial003_an as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_prompt():
+    result = runner.invoke(app, input="Old Project\nOld Project\n")
+    assert result.exit_code == 0
+    assert "Deleting project Old Project" in result.output
+
+
+def test_prompt_not_equal():
+    result = runner.invoke(
+        app, input="Old Project\nNew Spice\nOld Project\nOld Project\n"
+    )
+    assert result.exit_code == 0
+    assert "Error: The two entered values do not match" in result.output
+    assert "Deleting project Old Project" in result.output
+
+
+def test_option():
+    result = runner.invoke(app, ["--project-name", "Old Project"])
+    assert result.exit_code == 0
+    assert "Deleting project Old Project" in result.output
+    assert "Project name: " not in result.output
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "--project-name" in result.output
+    assert "TEXT" in result.output
+    assert "[required]" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options/test_required/test_tutorial001.py

@@ -0,0 +1,52 @@
+import subprocess
+import sys
+
+import pytest
+import typer
+import typer.core
+from typer.testing import CliRunner
+
+from docs_src.options.required import tutorial001 as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_1():
+    result = runner.invoke(app, ["Camila"])
+    assert result.exit_code != 0
+    assert "Missing option '--lastname'" in result.output
+
+
+def test_option_lastname():
+    result = runner.invoke(app, ["Camila", "--lastname", "Gutiérrez"])
+    assert result.exit_code == 0
+    assert "Hello Camila Gutiérrez" in result.output
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "--lastname" in result.output
+    assert "TEXT" in result.output
+    assert "[required]" in result.output
+
+
+def test_help_no_rich(monkeypatch: pytest.MonkeyPatch):
+    monkeypatch.setattr(typer.core, "HAS_RICH", False)
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "--lastname" in result.output
+    assert "TEXT" in result.output
+    assert "[required]" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options/test_required/test_tutorial001_an.py

@@ -0,0 +1,52 @@
+import subprocess
+import sys
+
+import pytest
+import typer
+import typer.core
+from typer.testing import CliRunner
+
+from docs_src.options.required import tutorial001_an as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_1():
+    result = runner.invoke(app, ["Camila"])
+    assert result.exit_code != 0
+    assert "Missing option '--lastname'" in result.output
+
+
+def test_option_lastname():
+    result = runner.invoke(app, ["Camila", "--lastname", "Gutiérrez"])
+    assert result.exit_code == 0
+    assert "Hello Camila Gutiérrez" in result.output
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "--lastname" in result.output
+    assert "TEXT" in result.output
+    assert "[required]" in result.output
+
+
+def test_help_no_rich(monkeypatch: pytest.MonkeyPatch):
+    monkeypatch.setattr(typer.core, "HAS_RICH", False)
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "--lastname" in result.output
+    assert "TEXT" in result.output
+    assert "[required]" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options/test_version/test_tutorial003.py

@@ -0,0 +1,56 @@
+import os
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.options.version import tutorial003 as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_1():
+    result = runner.invoke(app, ["--name", "Rick", "--version"])
+    assert result.exit_code == 0
+    assert "Awesome CLI Version: 0.1.0" in result.output
+
+
+def test_2():
+    result = runner.invoke(app, ["--name", "rick"])
+    assert result.exit_code != 0
+    assert "Invalid value for '--name'" in result.output
+    assert "Only Camila is allowed" in result.output
+
+
+def test_3():
+    result = runner.invoke(app, ["--name", "Camila"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout
+
+
+def test_completion():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, " "],
+        capture_output=True,
+        encoding="utf-8",
+        env={
+            **os.environ,
+            "_TUTORIAL003.PY_COMPLETE": "complete_bash",
+            "COMP_WORDS": "tutorial003.py --name Rick --v",
+            "COMP_CWORD": "3",
+        },
+    )
+    assert "--version" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options/test_version/test_tutorial003_an.py

@@ -0,0 +1,56 @@
+import os
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.options.version import tutorial003_an as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_1():
+    result = runner.invoke(app, ["--name", "Rick", "--version"])
+    assert result.exit_code == 0
+    assert "Awesome CLI Version: 0.1.0" in result.output
+
+
+def test_2():
+    result = runner.invoke(app, ["--name", "rick"])
+    assert result.exit_code != 0
+    assert "Invalid value for '--name'" in result.output
+    assert "Only Camila is allowed" in result.output
+
+
+def test_3():
+    result = runner.invoke(app, ["--name", "Camila"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout
+
+
+def test_completion():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, " "],
+        capture_output=True,
+        encoding="utf-8",
+        env={
+            **os.environ,
+            "_TUTORIAL003_AN.PY_COMPLETE": "complete_bash",
+            "COMP_WORDS": "tutorial003_an.py --name Rick --v",
+            "COMP_CWORD": "3",
+        },
+    )
+    assert "--version" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options_autocompletion/test_tutorial002.py

@@ -0,0 +1,40 @@
+import os
+import subprocess
+import sys
+
+from typer.testing import CliRunner
+
+from docs_src.options_autocompletion import tutorial002 as mod
+
+runner = CliRunner()
+
+
+def test_completion():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, " "],
+        capture_output=True,
+        encoding="utf-8",
+        env={
+            **os.environ,
+            "_TUTORIAL002.PY_COMPLETE": "complete_zsh",
+            "_TYPER_COMPLETE_ARGS": "tutorial002.py --name ",
+        },
+    )
+    assert "Camila" in result.stdout
+    assert "Carlos" in result.stdout
+    assert "Sebastian" in result.stdout
+
+
+def test_1():
+    result = runner.invoke(mod.app, ["--name", "Camila"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options_autocompletion/test_tutorial002_an.py

@@ -0,0 +1,40 @@
+import os
+import subprocess
+import sys
+
+from typer.testing import CliRunner
+
+from docs_src.options_autocompletion import tutorial002_an as mod
+
+runner = CliRunner()
+
+
+def test_completion():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, " "],
+        capture_output=True,
+        encoding="utf-8",
+        env={
+            **os.environ,
+            "_TUTORIAL002_AN.PY_COMPLETE": "complete_zsh",
+            "_TYPER_COMPLETE_ARGS": "tutorial002_an.py --name ",
+        },
+    )
+    assert "Camila" in result.stdout
+    assert "Carlos" in result.stdout
+    assert "Sebastian" in result.stdout
+
+
+def test_1():
+    result = runner.invoke(mod.app, ["--name", "Camila"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options_autocompletion/test_tutorial003.py

@@ -0,0 +1,57 @@
+import os
+import subprocess
+import sys
+
+from typer.testing import CliRunner
+
+from docs_src.options_autocompletion import tutorial003 as mod
+
+runner = CliRunner()
+
+
+def test_completion_zsh():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, " "],
+        capture_output=True,
+        encoding="utf-8",
+        env={
+            **os.environ,
+            "_TUTORIAL003.PY_COMPLETE": "complete_zsh",
+            "_TYPER_COMPLETE_ARGS": "tutorial003.py --name Seb",
+        },
+    )
+    assert "Camila" not in result.stdout
+    assert "Carlos" not in result.stdout
+    assert "Sebastian" in result.stdout
+
+
+def test_completion_powershell():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, " "],
+        capture_output=True,
+        encoding="utf-8",
+        env={
+            **os.environ,
+            "_TUTORIAL003.PY_COMPLETE": "complete_powershell",
+            "_TYPER_COMPLETE_ARGS": "tutorial003.py --name Seb",
+            "_TYPER_COMPLETE_WORD_TO_COMPLETE": "Seb",
+        },
+    )
+    assert "Camila" not in result.stdout
+    assert "Carlos" not in result.stdout
+    assert "Sebastian" in result.stdout
+
+
+def test_1():
+    result = runner.invoke(mod.app, ["--name", "Camila"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options_autocompletion/test_tutorial003_an.py

@@ -0,0 +1,57 @@
+import os
+import subprocess
+import sys
+
+from typer.testing import CliRunner
+
+from docs_src.options_autocompletion import tutorial003_an as mod
+
+runner = CliRunner()
+
+
+def test_completion_zsh():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, " "],
+        capture_output=True,
+        encoding="utf-8",
+        env={
+            **os.environ,
+            "_TUTORIAL003_AN.PY_COMPLETE": "complete_zsh",
+            "_TYPER_COMPLETE_ARGS": "tutorial003_an.py --name Seb",
+        },
+    )
+    assert "Camila" not in result.stdout
+    assert "Carlos" not in result.stdout
+    assert "Sebastian" in result.stdout
+
+
+def test_completion_powershell():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, " "],
+        capture_output=True,
+        encoding="utf-8",
+        env={
+            **os.environ,
+            "_TUTORIAL003_AN.PY_COMPLETE": "complete_powershell",
+            "_TYPER_COMPLETE_ARGS": "tutorial003.py --name Seb",
+            "_TYPER_COMPLETE_WORD_TO_COMPLETE": "Seb",
+        },
+    )
+    assert "Camila" not in result.stdout
+    assert "Carlos" not in result.stdout
+    assert "Sebastian" in result.stdout
+
+
+def test_1():
+    result = runner.invoke(mod.app, ["--name", "Camila"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options_autocompletion/test_tutorial004.py

@@ -0,0 +1,40 @@
+import os
+import subprocess
+import sys
+
+from typer.testing import CliRunner
+
+from docs_src.options_autocompletion import tutorial004 as mod
+
+runner = CliRunner()
+
+
+def test_completion():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, " "],
+        capture_output=True,
+        encoding="utf-8",
+        env={
+            **os.environ,
+            "_TUTORIAL004.PY_COMPLETE": "complete_zsh",
+            "_TYPER_COMPLETE_ARGS": "tutorial004_aux.py --name ",
+        },
+    )
+    assert '"Camila":"The reader of books."' in result.stdout
+    assert '"Carlos":"The writer of scripts."' in result.stdout
+    assert '"Sebastian":"The type hints guy."' in result.stdout
+
+
+def test_1():
+    result = runner.invoke(mod.app, ["--name", "Camila"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options_autocompletion/test_tutorial004_an.py

@@ -0,0 +1,40 @@
+import os
+import subprocess
+import sys
+
+from typer.testing import CliRunner
+
+from docs_src.options_autocompletion import tutorial004_an as mod
+
+runner = CliRunner()
+
+
+def test_completion():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, " "],
+        capture_output=True,
+        encoding="utf-8",
+        env={
+            **os.environ,
+            "_TUTORIAL004_AN.PY_COMPLETE": "complete_zsh",
+            "_TYPER_COMPLETE_ARGS": "tutorial004_an_aux.py --name ",
+        },
+    )
+    assert '"Camila":"The reader of books."' in result.stdout
+    assert '"Carlos":"The writer of scripts."' in result.stdout
+    assert '"Sebastian":"The type hints guy."' in result.stdout
+
+
+def test_1():
+    result = runner.invoke(mod.app, ["--name", "Camila"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options_autocompletion/test_tutorial007.py

@@ -0,0 +1,41 @@
+import os
+import subprocess
+import sys
+
+from typer.testing import CliRunner
+
+from docs_src.options_autocompletion import tutorial007 as mod
+
+runner = CliRunner()
+
+
+def test_completion():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, " "],
+        capture_output=True,
+        encoding="utf-8",
+        env={
+            **os.environ,
+            "_TUTORIAL007.PY_COMPLETE": "complete_zsh",
+            "_TYPER_COMPLETE_ARGS": "tutorial007.py --name Sebastian --name ",
+        },
+    )
+    assert '"Camila":"The reader of books."' in result.stdout
+    assert '"Carlos":"The writer of scripts."' in result.stdout
+    assert '"Sebastian":"The type hints guy."' not in result.stdout
+
+
+def test_1():
+    result = runner.invoke(mod.app, ["--name", "Camila", "--name", "Sebastian"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+    assert "Hello Sebastian" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options_autocompletion/test_tutorial007_an.py

@@ -0,0 +1,41 @@
+import os
+import subprocess
+import sys
+
+from typer.testing import CliRunner
+
+from docs_src.options_autocompletion import tutorial007_an as mod
+
+runner = CliRunner()
+
+
+def test_completion():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, " "],
+        capture_output=True,
+        encoding="utf-8",
+        env={
+            **os.environ,
+            "_TUTORIAL007_AN.PY_COMPLETE": "complete_zsh",
+            "_TYPER_COMPLETE_ARGS": "tutorial007_an.py --name Sebastian --name ",
+        },
+    )
+    assert '"Camila":"The reader of books."' in result.stdout
+    assert '"Carlos":"The writer of scripts."' in result.stdout
+    assert '"Sebastian":"The type hints guy."' not in result.stdout
+
+
+def test_1():
+    result = runner.invoke(mod.app, ["--name", "Camila", "--name", "Sebastian"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+    assert "Hello Sebastian" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options_autocompletion/test_tutorial008.py

@@ -0,0 +1,42 @@
+import os
+import subprocess
+import sys
+
+from typer.testing import CliRunner
+
+from docs_src.options_autocompletion import tutorial008 as mod
+
+runner = CliRunner()
+
+
+def test_completion():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, " "],
+        capture_output=True,
+        encoding="utf-8",
+        env={
+            **os.environ,
+            "_TUTORIAL008.PY_COMPLETE": "complete_zsh",
+            "_TYPER_COMPLETE_ARGS": "tutorial008.py --name ",
+        },
+    )
+    assert '"Camila":"The reader of books."' in result.stdout
+    assert '"Carlos":"The writer of scripts."' in result.stdout
+    assert '"Sebastian":"The type hints guy."' in result.stdout
+    assert "[]" in result.stderr
+
+
+def test_1():
+    result = runner.invoke(mod.app, ["--name", "Camila", "--name", "Sebastian"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+    assert "Hello Sebastian" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options_autocompletion/test_tutorial008_an.py

@@ -0,0 +1,42 @@
+import os
+import subprocess
+import sys
+
+from typer.testing import CliRunner
+
+from docs_src.options_autocompletion import tutorial008_an as mod
+
+runner = CliRunner()
+
+
+def test_completion():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, " "],
+        capture_output=True,
+        encoding="utf-8",
+        env={
+            **os.environ,
+            "_TUTORIAL008_AN.PY_COMPLETE": "complete_zsh",
+            "_TYPER_COMPLETE_ARGS": "tutorial008_an.py --name ",
+        },
+    )
+    assert '"Camila":"The reader of books."' in result.stdout
+    assert '"Carlos":"The writer of scripts."' in result.stdout
+    assert '"Sebastian":"The type hints guy."' in result.stdout
+    assert "[]" in result.stderr
+
+
+def test_1():
+    result = runner.invoke(mod.app, ["--name", "Camila", "--name", "Sebastian"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+    assert "Hello Sebastian" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options_autocompletion/test_tutorial009.py

@@ -0,0 +1,42 @@
+import os
+import subprocess
+import sys
+
+from typer.testing import CliRunner
+
+from docs_src.options_autocompletion import tutorial009 as mod
+
+runner = CliRunner()
+
+
+def test_completion():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, " "],
+        capture_output=True,
+        encoding="utf-8",
+        env={
+            **os.environ,
+            "_TUTORIAL009.PY_COMPLETE": "complete_zsh",
+            "_TYPER_COMPLETE_ARGS": "tutorial009.py --name Sebastian --name ",
+        },
+    )
+    assert '"Camila":"The reader of books."' in result.stdout
+    assert '"Carlos":"The writer of scripts."' in result.stdout
+    assert '"Sebastian":"The type hints guy."' not in result.stdout
+    assert "[]" in result.stderr
+
+
+def test_1():
+    result = runner.invoke(mod.app, ["--name", "Camila", "--name", "Sebastian"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+    assert "Hello Sebastian" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_options_autocompletion/test_tutorial009_an.py

@@ -0,0 +1,42 @@
+import os
+import subprocess
+import sys
+
+from typer.testing import CliRunner
+
+from docs_src.options_autocompletion import tutorial009_an as mod
+
+runner = CliRunner()
+
+
+def test_completion():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, " "],
+        capture_output=True,
+        encoding="utf-8",
+        env={
+            **os.environ,
+            "_TUTORIAL009_AN.PY_COMPLETE": "complete_zsh",
+            "_TYPER_COMPLETE_ARGS": "tutorial009_an.py --name Sebastian --name ",
+        },
+    )
+    assert '"Camila":"The reader of books."' in result.stdout
+    assert '"Carlos":"The writer of scripts."' in result.stdout
+    assert '"Sebastian":"The type hints guy."' not in result.stdout
+    assert "[]" in result.stderr
+
+
+def test_1():
+    result = runner.invoke(mod.app, ["--name", "Camila", "--name", "Sebastian"])
+    assert result.exit_code == 0
+    assert "Hello Camila" in result.output
+    assert "Hello Sebastian" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_parameter_types/test_bool/test_tutorial001.py

@@ -0,0 +1,46 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.parameter_types.bool import tutorial001 as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "--force" in result.output
+    assert "--no-force" not in result.output
+
+
+def test_no_force():
+    result = runner.invoke(app)
+    assert result.exit_code == 0
+    assert "Not forcing" in result.output
+
+
+def test_force():
+    result = runner.invoke(app, ["--force"])
+    assert result.exit_code == 0
+    assert "Forcing operation" in result.output
+
+
+def test_invalid_no_force():
+    result = runner.invoke(app, ["--no-force"])
+    assert result.exit_code != 0
+    assert "No such option: --no-force" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_parameter_types/test_bool/test_tutorial001_an.py

@@ -0,0 +1,46 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.parameter_types.bool import tutorial001_an as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "--force" in result.output
+    assert "--no-force" not in result.output
+
+
+def test_no_force():
+    result = runner.invoke(app)
+    assert result.exit_code == 0
+    assert "Not forcing" in result.output
+
+
+def test_force():
+    result = runner.invoke(app, ["--force"])
+    assert result.exit_code == 0
+    assert "Forcing operation" in result.output
+
+
+def test_invalid_no_force():
+    result = runner.invoke(app, ["--no-force"])
+    assert result.exit_code != 0
+    assert "No such option: --no-force" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_parameter_types/test_bool/test_tutorial002.py

@@ -0,0 +1,64 @@
+import subprocess
+import sys
+
+import pytest
+import typer
+import typer.core
+from typer.testing import CliRunner
+
+from docs_src.parameter_types.bool import tutorial002 as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "--accept" in result.output
+    assert "--reject" in result.output
+    assert "--no-accept" not in result.output
+
+
+def test_help_no_rich(monkeypatch: pytest.MonkeyPatch):
+    monkeypatch.setattr(typer.core, "HAS_RICH", False)
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "--accept" in result.output
+    assert "--reject" in result.output
+    assert "--no-accept" not in result.output
+
+
+def test_main():
+    result = runner.invoke(app)
+    assert result.exit_code == 0
+    assert "I don't know what you want yet" in result.output
+
+
+def test_accept():
+    result = runner.invoke(app, ["--accept"])
+    assert result.exit_code == 0
+    assert "Accepting!" in result.output
+
+
+def test_reject():
+    result = runner.invoke(app, ["--reject"])
+    assert result.exit_code == 0
+    assert "Rejecting!" in result.output
+
+
+def test_invalid_no_accept():
+    result = runner.invoke(app, ["--no-accept"])
+    assert result.exit_code != 0
+    assert "No such option: --no-accept" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_parameter_types/test_bool/test_tutorial002_an.py

@@ -0,0 +1,64 @@
+import subprocess
+import sys
+
+import pytest
+import typer
+import typer.core
+from typer.testing import CliRunner
+
+from docs_src.parameter_types.bool import tutorial002_an as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "--accept" in result.output
+    assert "--reject" in result.output
+    assert "--no-accept" not in result.output
+
+
+def test_help_no_rich(monkeypatch: pytest.MonkeyPatch):
+    monkeypatch.setattr(typer.core, "HAS_RICH", False)
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "--accept" in result.output
+    assert "--reject" in result.output
+    assert "--no-accept" not in result.output
+
+
+def test_main():
+    result = runner.invoke(app)
+    assert result.exit_code == 0
+    assert "I don't know what you want yet" in result.output
+
+
+def test_accept():
+    result = runner.invoke(app, ["--accept"])
+    assert result.exit_code == 0
+    assert "Accepting!" in result.output
+
+
+def test_reject():
+    result = runner.invoke(app, ["--reject"])
+    assert result.exit_code == 0
+    assert "Rejecting!" in result.output
+
+
+def test_invalid_no_accept():
+    result = runner.invoke(app, ["--no-accept"])
+    assert result.exit_code != 0
+    assert "No such option: --no-accept" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_parameter_types/test_bool/test_tutorial003.py

@@ -0,0 +1,42 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.parameter_types.bool import tutorial003 as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "-f" in result.output
+    assert "--force" in result.output
+    assert "-F" in result.output
+    assert "--no-force" in result.output
+
+
+def test_force():
+    result = runner.invoke(app, ["-f"])
+    assert result.exit_code == 0
+    assert "Forcing operation" in result.output
+
+
+def test_no_force():
+    result = runner.invoke(app, ["-F"])
+    assert result.exit_code == 0
+    assert "Not forcing" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_parameter_types/test_bool/test_tutorial003_an.py

@@ -0,0 +1,42 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.parameter_types.bool import tutorial003_an as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "-f" in result.output
+    assert "--force" in result.output
+    assert "-F" in result.output
+    assert "--no-force" in result.output
+
+
+def test_force():
+    result = runner.invoke(app, ["-f"])
+    assert result.exit_code == 0
+    assert "Forcing operation" in result.output
+
+
+def test_no_force():
+    result = runner.invoke(app, ["-F"])
+    assert result.exit_code == 0
+    assert "Not forcing" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_parameter_types/test_bool/test_tutorial004.py

@@ -0,0 +1,46 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.parameter_types.bool import tutorial004 as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "-d" in result.output
+    assert "--demo" in result.output
+
+
+def test_main():
+    result = runner.invoke(app)
+    assert result.exit_code == 0
+    assert "Running in production" in result.output
+
+
+def test_demo():
+    result = runner.invoke(app, ["--demo"])
+    assert result.exit_code == 0
+    assert "Running demo" in result.output
+
+
+def test_short_demo():
+    result = runner.invoke(app, ["-d"])
+    assert result.exit_code == 0
+    assert "Running demo" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_parameter_types/test_bool/test_tutorial004_an.py

@@ -0,0 +1,46 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.parameter_types.bool import tutorial004_an as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "-d" in result.output
+    assert "--demo" in result.output
+
+
+def test_main():
+    result = runner.invoke(app)
+    assert result.exit_code == 0
+    assert "Running in production" in result.output
+
+
+def test_demo():
+    result = runner.invoke(app, ["--demo"])
+    assert result.exit_code == 0
+    assert "Running demo" in result.output
+
+
+def test_short_demo():
+    result = runner.invoke(app, ["-d"])
+    assert result.exit_code == 0
+    assert "Running demo" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_parameter_types/test_custom_types/test_tutorial001.py

@@ -0,0 +1,38 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.parameter_types.custom_types import tutorial001 as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+
+
+def test_parse_custom_type():
+    result = runner.invoke(app, ["0", "--custom-opt", "1"])
+    assert "custom_arg is <CustomClass: value=00>" in result.output
+    assert "custom-opt is <CustomClass: value=11>" in result.output
+
+
+def test_parse_custom_type_with_default():
+    result = runner.invoke(app, ["0"])
+    assert "custom_arg is <CustomClass: value=00>" in result.output
+    assert "custom-opt is <CustomClass: value=FooFoo>" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_parameter_types/test_custom_types/test_tutorial001_an.py

@@ -0,0 +1,38 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.parameter_types.custom_types import tutorial001_an as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+
+
+def test_parse_custom_type():
+    result = runner.invoke(app, ["0", "--custom-opt", "1"])
+    assert "custom_arg is <CustomClass: value=00>" in result.output
+    assert "custom-opt is <CustomClass: value=11>" in result.output
+
+
+def test_parse_custom_type_with_default():
+    result = runner.invoke(app, ["0"])
+    assert "custom_arg is <CustomClass: value=00>" in result.output
+    assert "custom-opt is <CustomClass: value=FooFoo>" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_parameter_types/test_custom_types/test_tutorial002.py

@@ -0,0 +1,38 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.parameter_types.custom_types import tutorial002 as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+
+
+def test_parse_custom_type():
+    result = runner.invoke(app, ["0", "--custom-opt", "1"])
+    assert "custom_arg is <CustomClass: value=000>" in result.output
+    assert "custom-opt is <CustomClass: value=111>" in result.output
+
+
+def test_parse_custom_type_with_default():
+    result = runner.invoke(app, ["0"])
+    assert "custom_arg is <CustomClass: value=000>" in result.output
+    assert "custom-opt is <CustomClass: value=FooFooFoo>" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_parameter_types/test_custom_types/test_tutorial002_an.py

@@ -0,0 +1,38 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.parameter_types.custom_types import tutorial002_an as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+
+
+def test_parse_custom_type():
+    result = runner.invoke(app, ["0", "--custom-opt", "1"])
+    assert "custom_arg is <CustomClass: value=000>" in result.output
+    assert "custom-opt is <CustomClass: value=111>" in result.output
+
+
+def test_parse_custom_type_with_default():
+    result = runner.invoke(app, ["0"])
+    assert "custom_arg is <CustomClass: value=000>" in result.output
+    assert "custom-opt is <CustomClass: value=FooFooFoo>" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_parameter_types/test_datetime/test_tutorial001.py

@@ -0,0 +1,47 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.parameter_types.datetime import tutorial001 as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "[%Y-%m-%d|%Y-%m-%dT%H:%M:%S|%Y-%m-%d %H:%M:%S]" in result.output
+
+
+def test_main():
+    result = runner.invoke(app, ["1956-01-31T10:00:00"])
+    assert result.exit_code == 0
+    assert "Interesting day to be born: 1956-01-31 10:00:00" in result.output
+    assert "Birth hour: 10" in result.output
+
+
+def test_invalid():
+    result = runner.invoke(app, ["july-19-1989"])
+    assert result.exit_code != 0
+    assert (
+        "Invalid value for 'BIRTH:[%Y-%m-%d|%Y-%m-%dT%H:%M:%S|%Y-%m-%d %H:%M:%S]':"
+        in result.output
+    )
+    assert "'july-19-1989' does not match the formats" in result.output
+    assert "%Y-%m-%d" in result.output
+    assert "%Y-%m-%dT%H:%M:%S" in result.output
+    assert "%Y-%m-%d %H:%M:%S" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_parameter_types/test_datetime/test_tutorial002.py

@@ -0,0 +1,33 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.parameter_types.datetime import tutorial002 as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_main():
+    result = runner.invoke(app, ["1969-10-29"])
+    assert result.exit_code == 0
+    assert "Launch will be at: 1969-10-29 00:00:00" in result.output
+
+
+def test_usa_weird_date_format():
+    result = runner.invoke(app, ["10/29/1969"])
+    assert result.exit_code == 0
+    assert "Launch will be at: 1969-10-29 00:00:00" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout

miniconda3/pkgs/typer-0.20.0-py313h06a4308_1/info/test/typer/tests/test_tutorial/test_parameter_types/test_datetime/test_tutorial002_an.py

@@ -0,0 +1,33 @@
+import subprocess
+import sys
+
+import typer
+from typer.testing import CliRunner
+
+from docs_src.parameter_types.datetime import tutorial002_an as mod
+
+runner = CliRunner()
+
+app = typer.Typer()
+app.command()(mod.main)
+
+
+def test_main():
+    result = runner.invoke(app, ["1969-10-29"])
+    assert result.exit_code == 0
+    assert "Launch will be at: 1969-10-29 00:00:00" in result.output
+
+
+def test_usa_weird_date_format():
+    result = runner.invoke(app, ["10/29/1969"])
+    assert result.exit_code == 0
+    assert "Launch will be at: 1969-10-29 00:00:00" in result.output
+
+
+def test_script():
+    result = subprocess.run(
+        [sys.executable, "-m", "coverage", "run", mod.__file__, "--help"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    assert "Usage" in result.stdout