➖ Vendor Click and streamline Typer's functionality and code base

README.md

@@ -352,12 +352,17 @@ For a more complete example including more features, see the <a href="https://ty
 
 ## Dependencies
 
-**Typer** stands on the shoulders of giants. It has three required dependencies:
+**Typer** stands on the shoulders of giants. It has two required dependencies:
 
-* [Click](https://click.palletsprojects.com/): a popular tool for building CLIs in Python. Typer is based on it.
 * [`rich`](https://rich.readthedocs.io/en/stable/index.html): to show nicely formatted errors automatically.
 * [`shellingham`](https://github.com/sarugaku/shellingham): to automatically detect the current shell when installing completion.
 
+Typer used to depend on [Click](https://click.palletsprojects.com/) as well, a popular tool for building CLIs in Python.
+Since v0.26.0, Typer has vendored Click and has unified the two code bases for easier maintainability in the future.
+Note that some Click functionality will not be available anymore in the future, as we continue to improve and extend Typer's codebase.
+
+For Windows users, Typer also installs [`colorama`](https://github.com/tartley/colorama) for producing colored terminal text.
+
 ### `typer-slim`
 
 There used to be a slimmed-down version of Typer called `typer-slim`, which didn't include the dependencies `rich` and `shellingham`, nor the `typer` command.

docs/alternatives.md

@@ -70,11 +70,9 @@ It uses decorators on top of functions to modify the actual value of those funct
 
 It was built with some great ideas and design using the features available in the language at the time (Python 2.x).
 
-/// tip | **Typer** uses it for
+/// tip | **Typer** builds on top of Click functionality. It has vendored Click v8.3.1 and adds a layer on top of it.
 
-Everything. 🚀
-
-**Typer** mainly adds a layer on top of Click, making the code simpler and easier to use, with autocompletion everywhere, etc, but providing all the powerful features of Click underneath.
+Typer aims to make the code simpler and easier to use, with autocompletion everywhere, etc, while still providing many of the powerful features of Click underneath.
 
 As someone pointed out: <em>["Nice to see it is built on Click but adds the type stuff. Me gusta!"](https://twitter.com/fishnets88/status/1210126833745838080)</em>
 

docs/features.md

@@ -63,14 +63,6 @@ Auto completion works when you create a package (installable with `pip`). Or whe
 
 ///
 
-/// tip
-
-**Typer**'s completion is implemented internally, it uses ideas and components from Click and ideas from `click-completion`, but it doesn't use `click-completion` and re-implements some of the relevant parts of Click.
-
-Then it extends those ideas with features and bug fixes. For example, **Typer** programs also support modern versions of PowerShell (e.g. in Windows 10) among all the other shells.
-
-///
-
 ## Tested
 
 * 100% <abbr title="The amount of code that is automatically tested">test coverage</abbr>.

docs/help-typer.md

@@ -241,7 +241,7 @@ There you could buy me a coffee ☕️ to say thanks. 😄
 
 ## Sponsor the tools that power Typer
 
-As you have seen in the documentation, Typer is built on top of Click.
+As you have seen in the documentation, Typer has been built on top of Click.
 
 You can also sponsor:
 

docs/index.md

@@ -360,12 +360,17 @@ For a more complete example including more features, see the <a href="https://ty
 
 ## Dependencies
 
-**Typer** stands on the shoulders of giants. It has three required dependencies:
+**Typer** stands on the shoulders of giants. It has two required dependencies:
 
-* [Click](https://click.palletsprojects.com/): a popular tool for building CLIs in Python. Typer is based on it.
 * [`rich`](https://rich.readthedocs.io/en/stable/index.html): to show nicely formatted errors automatically.
 * [`shellingham`](https://github.com/sarugaku/shellingham): to automatically detect the current shell when installing completion.
 
+Typer used to depend on [Click](https://click.palletsprojects.com/) as well, a popular tool for building CLIs in Python.
+Since v0.26.0, Typer has vendored Click and has unified the two code bases for easier maintainability in the future.
+Note that some Click functionality will not be available anymore in the future, as we continue to improve and extend Typer's codebase.
+
+For Windows users, Typer also installs [`colorama`](https://github.com/tartley/colorama) for producing colored terminal text.
+
 ### `typer-slim`
 
 There used to be a slimmed-down version of Typer called `typer-slim`, which didn't include the dependencies `rich` and `shellingham`, nor the `typer` command.

docs/tutorial/printing.md

@@ -196,7 +196,7 @@ And for the cases where you want to display data more beautifully, or more advan
 
 ### Why `typer.echo`
 
-`typer.echo()` (which is actually just `click.echo()`) applies some checks to try and convert binary data to strings, and other similar things.
+`typer.echo()` applies some checks to try and convert binary data to strings, and other similar things.
 
 But in most of the cases you wouldn't need it, as in modern Python strings (`str`) already support and use Unicode, and you would rarely deal with pure `bytes` that you want to print on the screen.
 

pyproject.toml

@@ -33,10 +33,10 @@ classifiers = [
     "Programming Language :: Python :: 3.14",
 ]
 dependencies = [
-    "click >= 8.2.1, < 8.4",
     "shellingham >=1.3.0",
     "rich >=13.8.0",
     "annotated-doc >=0.0.2",
+    "colorama; platform_system == 'Windows'",
 ]
 readme = "README.md"
 
@@ -189,7 +189,7 @@ ignore = [
 "docs_src/*" = ["TID"]
 
 [tool.ruff.lint.isort]
-known-third-party = ["typer", "click"]
+known-third-party = ["typer"]
 # For docs_src/subcommands/tutorial003/
 known-first-party = ["reigns", "towns", "lands", "items", "users"]
 

tests/assets/completion_argument.py

@@ -1,10 +1,10 @@
-import click
 import typer
+from typer import _click
 
 app = typer.Typer()
 
 
-def shell_complete(ctx: click.Context, param: click.Parameter, incomplete: str):
+def shell_complete(ctx: _click.Context, param: _click.Parameter, incomplete: str):
     typer.echo(f"ctx: {ctx.info_name}", err=True)
     typer.echo(f"arg is: {param.name}", err=True)
     typer.echo(f"incomplete is: {incomplete}", err=True)

tests/atomic_write_example.py

@@ -0,0 +1,63 @@
+import time
+
+import typer
+
+app = typer.Typer()
+
+
+@app.command()
+def write_atomic(
+    config: typer.FileText = typer.Option(..., mode="w", atomic=True),
+    pause: float = typer.Option(0.3),
+) -> None:
+    config.write("atomic-content-1\n")
+    config.flush()
+    typer.echo("halfway")
+    time.sleep(pause)
+    config.write("atomic-content-2\n")
+    config.flush()
+    typer.echo("written atomically")
+
+
+@app.command()
+def write_atomic_binary(
+    config: typer.FileBinaryWrite = typer.Option(..., atomic=True, lazy=False),
+) -> None:
+    config.write(b"\x00\x01binary-atomic\n")
+    typer.echo("written binary atomically")
+
+
+@app.command()
+def api_atomic(
+    config: typer.FileText = typer.Option(..., mode="w", atomic=True, lazy=False),
+) -> None:
+    typer.echo(f"name={config.name}")
+    typer.echo(f"repr={repr(config)}")
+    with config as entered:
+        typer.echo(f"entered={entered is config}")
+        entered.write("atomic-api-done\n")
+
+
+@app.command()
+def invalid_atomic_append(
+    config: typer.FileText = typer.Option(..., mode="a", atomic=True, lazy=False),
+) -> None:
+    typer.echo(config.name)  # pragma: no cover
+
+
+@app.command()
+def invalid_atomic_exclusive(
+    config: typer.FileText = typer.Option(..., mode="x", atomic=True, lazy=False),
+) -> None:
+    typer.echo(config.name)  # pragma: no cover
+
+
+@app.command()
+def invalid_atomic_read(
+    config: typer.FileText = typer.Option(..., mode="r", atomic=True, lazy=False),
+) -> None:
+    typer.echo(config.name)  # pragma: no cover
+
+
+if __name__ == "__main__":
+    app()

tests/test_annotated.py

@@ -2,6 +2,7 @@
 from pathlib import Path
 from typing import Annotated
 
+import pytest
 import typer
 from typer.testing import CliRunner
 
@@ -95,3 +96,14 @@ def custom_parser(
 
     result = runner.invoke(app, "/some/quirky/path/implementation")
     assert result.exit_code == 0
+
+
+def test_annotated_option_invalid():
+    app = typer.Typer()
+
+    @app.command()
+    def cmd(value: Annotated[str, typer.Option(..., "foo-bar")]):
+        print(value)  # pragma: no cover
+
+    with pytest.raises(ValueError, match="Invalid start character for option"):
+        runner.invoke(app, ["--help"], catch_exceptions=False)

tests/test_atomic_file.py

@@ -0,0 +1,122 @@
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+from . import atomic_write_example as mod
+
+
+def test_atomic_write(tmp_path: Path) -> None:
+    original_content = "existing-content\n"
+    output_file = tmp_path / "atomic-write-target.txt"
+    output_file.write_text(original_content, encoding="utf-8")
+
+    process = subprocess.Popen(
+        [
+            sys.executable,
+            "-m",
+            "coverage",
+            "run",
+            mod.__file__,
+            "write-atomic",
+            f"--config={output_file}",
+        ],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+    )
+    assert process.stdout is not None
+
+    # Halfway of writing the file, check that the original content is still there
+    halfway_line = process.stdout.readline().strip()
+    assert halfway_line == "halfway"
+    assert output_file.read_text(encoding="utf-8") == original_content
+
+    # Only at the end, the full new content is visible
+    stdout, stderr = process.communicate(timeout=5)
+    assert process.returncode == 0, stderr
+    assert "written atomically" in stdout
+    assert (
+        output_file.read_text(encoding="utf-8")
+        == "atomic-content-1\natomic-content-2\n"
+    )
+
+
+def test_atomic_binary_write(tmp_path: Path) -> None:
+    output_file = tmp_path / "atomic-binary.bin"
+
+    result = subprocess.run(
+        [
+            sys.executable,
+            "-m",
+            "coverage",
+            "run",
+            mod.__file__,
+            "write-atomic-binary",
+            f"--config={output_file}",
+        ],
+        capture_output=True,
+        encoding="utf-8",
+    )
+
+    assert result.returncode == 0, result.stderr
+    assert "written binary atomically" in result.stdout
+    assert output_file.read_bytes() == b"\x00\x01binary-atomic\n"
+
+
+def test_atomic_api(tmp_path: Path) -> None:
+    output_file = tmp_path / "atomic-api.txt"
+
+    result = subprocess.run(
+        [
+            sys.executable,
+            "-m",
+            "coverage",
+            "run",
+            mod.__file__,
+            "api-atomic",
+            f"--config={output_file}",
+        ],
+        capture_output=True,
+        encoding="utf-8",
+    )
+
+    assert result.returncode == 0, result.stderr
+    assert f"name={output_file}" in result.stdout
+    assert "repr=<_io.TextIOWrapper" in result.stdout
+    assert "entered=True" in result.stdout
+    assert output_file.read_text(encoding="utf-8") == "atomic-api-done\n"
+
+
+@pytest.mark.parametrize(
+    ("command_name", "expected_message"),
+    [
+        ("invalid-atomic-append", "Appending to an existing file is not supported"),
+        ("invalid-atomic-exclusive", "Use the `overwrite`-parameter instead."),
+        ("invalid-atomic-read", "Atomic writes only make sense with `w`-mode."),
+    ],
+)
+def test_atomic_mode_invalid_options(
+    tmp_path: Path, command_name: str, expected_message: str
+) -> None:
+    output_file = tmp_path / "atomic-invalid-mode.txt"
+    output_file.write_text("existing-content\n", encoding="utf-8")
+
+    result = subprocess.run(
+        [
+            sys.executable,
+            "-m",
+            "coverage",
+            "run",
+            mod.__file__,
+            command_name,
+            f"--config={output_file}",
+        ],
+        capture_output=True,
+        encoding="utf-8",
+    )
+
+    assert result.returncode != 0
+    combined_output = f"{result.stdout}\n{result.stderr}"
+    assert expected_message in combined_output