tacklebox-cli 0.2.6__tar.gz → 0.3.0__tar.gz

{tacklebox_cli-0.2.6 → tacklebox_cli-0.3.0}/LICENSE.md

@@ -1,5 +1,4 @@
-The MIT License (MIT)
-=====================
+# The MIT License (MIT)
 
 Copyright © 2025 cswimr
 

{tacklebox_cli-0.2.6 → tacklebox_cli-0.3.0}/PKG-INFO

@@ -1,19 +1,17 @@
 Metadata-Version: 2.4
 Name: tacklebox-cli
-Version: 0.2.6
+Version: 0.3.0
 Summary: A small collection of CLI utilities.
 Project-URL: Homepage, https://c.csw.im/cswimr/tacklebox
 Project-URL: Issues, https://c.csw.im/cswimr/tacklebox/issues
-Project-URL: source_archive, https://c.csw.im/cswimr/tacklebox/archive/7d8c5beaa8fce3cf47c233f13720ed44548464bd.tar.gz
+Project-URL: Source Archive, https://c.csw.im/cswimr/tacklebox/archive/951186f80430bac4501fe5167aabef121dfbb457.tar.gz
 Author-email: cswimr <seaswimmerthefsh@gmail.com>
 License-Expression: MIT
 License-File: LICENSE.md
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.11
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.14
 Requires-Dist: desktop-notifier>=6.1.0
 Requires-Dist: platformdirs>=4.3.0
 Requires-Dist: zipline-py[cli]>=0.27.0
@@ -24,14 +22,14 @@ Description-Content-Type: text/markdown
 [<img alt="Actions Status" src="https://c.csw.im/cswimr/tacklebox/badges/workflows/actions.yml/badge.svg?style=plastic">](https://c.csw.im/cswimr/tacklebox/actions?workflow=actions.yml)
 [<img alt="PyPI - Version" src="https://img.shields.io/pypi/v/tacklebox-cli?style=plastic">](https://pypi.org/project/tacklebox-cli/)
 [<img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/tacklebox-cli?style=plastic">](https://pypi.org/project/tacklebox-cli/)
-[<img alt="PyPI - License" src="https://img.shields.io/pypi/l/tacklebox-cli?style=plastic">](https://c.csw.im/cswimr/tacklebox/src/branch/main/LICENSE/)  
+[<img alt="PyPI - License" src="https://img.shields.io/pypi/l/tacklebox-cli?style=plastic">](https://c.csw.im/cswimr/tacklebox/src/tag/0.3.0/LICENSE.md)  
 tacklebox-cli offers a suite of useful CLI tools.
 
 ## Usage
 
 ### tacklebox copy / paste
 
-Cross-platform clipboard management tool. Uses system tools such as `wl-copy` on Linux Wayland or `clip.exe` on Windows, and [OSC 52](https://www.reddit.com/r/vim/comments/k1ydpn/a_guide_on_how_to_copy_text_from_anywhere/) escape codes when **copying** over SSH or when no other tools are available. See [`copy_with_tooling()`](https://c.csw.im/cswimr/tacklebox/src/branch/main/tacklebox/commands/clipboard.py) for all supported tools.
+Cross-platform clipboard management tool. Uses system tools such as `wl-copy` on Linux Wayland or `clip.exe` on Windows, and [OSC 52](https://www.reddit.com/r/vim/comments/k1ydpn/a_guide_on_how_to_copy_text_from_anywhere/) escape codes when **copying** over SSH or when no other tools are available. See [`copy_with_tooling()`](https://c.csw.im/cswimr/tacklebox/src/tag/0.3.0/tacklebox/commands/clipboard.py) for all supported tools.
 
 ```bash
 $ echo "a" | tacklebox copy --trim && tacklebox paste
@@ -58,3 +56,28 @@ $ tacklebox spectacle --mode region --record \
 ### tacklebox zipline
 
 Wraps the [zipline.py](https://pypi.org/project/zipline-py/) CLI. See the [zipline.py CLI documentation](https://ziplinepy.readthedocs.io/en/latest/cli.html) for more information.
+
+## License - The MIT License
+
+Copyright © 2025 cswimr
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the “Software”), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

tacklebox_cli-0.3.0/pyproject.toml

@@ -0,0 +1,74 @@
+[project]
+name = "tacklebox-cli"
+description = "A small collection of CLI utilities."
+requires-python = ">=3.14"
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+authors = [{ name = "cswimr", email = "seaswimmerthefsh@gmail.com" }]
+classifiers = [
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.14"
+]
+dependencies = [
+  "desktop-notifier>=6.1.0",
+  "platformdirs>=4.3.0",
+  "zipline.py[cli]>=0.27.0",
+]
+dynamic = ["readme", "urls", "version"]
+
+[project.scripts]
+tacklebox = "tacklebox.entrypoint:app"
+tacklebox-cli = "tacklebox.entrypoint:app"  # for uvx / pipx, prefer tacklebox when possible
+
+[dependency-groups]
+dev = [
+  "basedpyright~=1.38.2",
+  "pyinstrument~=5.1.2",
+  "ruff~=0.15.4",
+]
+
+[build-system]
+requires = ["hatch-fancy-pypi-readme", "hatch-vcs", "hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.build]
+include = ["/tacklebox", "/LICENSE.md", "/pyproject.toml"]
+
+[tool.hatch.build.hooks.vcs]
+version-file = "tacklebox/version.py"
+
+[tool.hatch.metadata.hooks.vcs.urls]
+Homepage = "https://c.csw.im/cswimr/tacklebox"
+Issues = "https://c.csw.im/cswimr/tacklebox/issues"
+"Source Archive" = "https://c.csw.im/cswimr/tacklebox/archive/{commit_hash}.tar.gz"
+
+[tool.hatch.metadata.hooks.fancy-pypi-readme]
+content-type = "text/markdown"
+
+[[tool.hatch.metadata.hooks.fancy-pypi-readme.fragments]]
+path = "README.md"
+
+[[tool.hatch.metadata.hooks.fancy-pypi-readme.fragments]]
+text = "\n## License - The MIT License"
+
+[[tool.hatch.metadata.hooks.fancy-pypi-readme.fragments]]
+path = "LICENSE.md"
+start-after = "# The MIT License (MIT)"
+
+[[tool.hatch.metadata.hooks.fancy-pypi-readme.substitutions]]
+pattern = '\[(.+?)\]\(((?!https?://)\S+?)\)'
+replacement = '[\1](https://c.csw.im/cswimr/tacklebox/src/tag/$HFPR_VERSION\g<2>)'
+
+[tool.pyright]
+typeCheckingMode = "strict"
+reportMissingTypeStubs = false
+
+[tool.ruff]
+line-length = 145
+
+[tool.typos]
+files.extend-exclude = [".direnv/**", ".venv/**"]

{tacklebox_cli-0.2.6 → tacklebox_cli-0.3.0}/tacklebox/commands/__init__.py

@@ -4,9 +4,11 @@ from typer import Typer
 from zipline.cli.entrypoint import app as zipline
 
 from .clipboard import app as clipboard
+from .find_desktop_entry import app as find_desktop_entry
+from .prepend_to_file import app as prepend_to_file
 from .version import app as version
 
-commands: list[Typer] = [clipboard, version, zipline]
+commands: list[Typer] = [clipboard, find_desktop_entry, prepend_to_file, version, zipline]
 
 if platform.system() == "Linux":
     from .spectacle import app as spectacle

{tacklebox_cli-0.2.6 → tacklebox_cli-0.3.0}/tacklebox/commands/clipboard.py

@@ -9,7 +9,7 @@ from typing import Annotated, Literal
 
 from typer import Argument, Exit, Option, Typer, echo
 
-from tacklebox.utils import get_environment
+from tacklebox.utils import get_environment, stderr, stdout
 
 app = Typer()
 
@@ -140,14 +140,14 @@ def use_tooling(
 
             if in_wsl:
                 if verbose:
-                    echo("Detected Windows Subsystem for Linux.", err=True)
+                    stderr.print("Detected Windows Subsystem for Linux.")
                 commands.extend(tools[mode]["windows"])
 
             protocol: Literal["wayland", "x11"] | None = (
                 "wayland" if "WAYLAND_DISPLAY" in get_environment() else ("x11" if "DISPLAY" in get_environment() else None)
             )
             if verbose:
-                echo(f"Detected display protocol: {protocol}", err=True)
+                stderr.print(f"Detected display protocol: {protocol}")
 
             match protocol:
                 case "wayland":
@@ -157,10 +157,7 @@ def use_tooling(
                 case _:
                     if not in_wsl:
                         if verbose:
-                            echo(
-                                "Unknown display protocol: neither WAYLAND_DISPLAY nor DISPLAY set.",
-                                err=True,
-                            )
+                            stderr.print("Unknown display protocol: neither WAYLAND_DISPLAY nor DISPLAY set.")
                         return False, None
 
         case "darwin":
@@ -169,11 +166,11 @@ def use_tooling(
             commands.extend(tools[mode]["windows"])
         case _:
             if verbose:
-                echo(f"No suitable clipboard tool known for platform '{system}'", err=True)
+                stderr.print(f"No suitable clipboard tool known for platform '{system}'")
             return False, None
 
     if verbose:
-        echo("\nAttempting commands:\n" + "\n".join(" ".join(cmd) for cmd in commands) + "\n", err=True)
+        stderr.print("\nAttempting commands:\n" + "\n".join(" ".join(cmd) for cmd in commands) + "\n")
     for cmd in commands:
         if (success := _try_command(mode, cmd, verbose, data))[0]:
             return success
@@ -195,28 +192,27 @@ def encode_osc52(data: str, verbose: bool = False) -> str:
 
     if "TMUX" in os.environ:
         if verbose:
-            echo("Wrapping OSC 52 for tmux.")
+            stderr.print("Wrapping OSC 52 for tmux.")
         return f"\x1bPtmux;\x1b{osc_seq}\x1b\\"
     elif os.environ.get("TERM", "").startswith("screen"):
         if verbose:
-            echo("Wrapping OSC 52 for screen.")
+            stderr.print("Wrapping OSC 52 for screen.")
         return f"\x1bP{osc_seq}\x1b\\"
     else:
         if verbose:
-            echo("Using plain OSC 52.")
+            stderr.print("Using plain OSC 52.")
         return osc_seq
 
 
 def _maybe_print_environment_information(verbose: bool) -> None:
     if verbose:
-        echo(
+        stderr.print(
             (
                 f"Platform: {platform.system()}\n"
                 f"TERM: {os.environ.get('TERM')}\n"
                 f"TMUX: {'present' if 'TMUX' in os.environ else 'absent'}\n"
                 f"SCREEN: {'present' if os.environ.get('TERM', '').startswith('screen') else 'absent'}"
-            ),
-            err=True,
+            )
         )
 
 
@@ -250,8 +246,8 @@ def copy(
         data = sys.stdin.read()
 
     if not data:
-        echo("No input received from stdin.", err=True)
-        raise Exit(code=1)
+        stderr.print("No input received from stdin.")
+        raise Exit(1)
 
     if trim:
         data = data.rstrip("\r\n")
@@ -266,16 +262,16 @@ def copy(
         return
 
     if verbose:
-        echo("Clipboard tools failed; trying OSC 52...", err=True)
+        stderr.print("Clipboard tools failed; trying OSC 52...")
 
     osc = encode_osc52(data, verbose)
     try:
         with open("/dev/tty", "w") as tty:
             tty.write(osc)
         if verbose:
-            echo("Copied using OSC 52.")
+            stderr.print("Copied using OSC 52.")
     except Exception as e:
-        echo(f"OSC 52 failed: {e}", err=True)
+        stderr.print(f"OSC 52 failed: {e}")
         raise Exit(code=1)
 
 
@@ -307,11 +303,11 @@ def paste(
         if trim and string is not None:
             string = string.rstrip("\r\n")
 
-        echo(string)
+        stdout.out(string)
         return
 
-    echo(f"Paste command failed!\n{output}", err=True)
-    exit(code=1)
+    stderr.print(f"Paste command failed!\n{output}")
+    raise Exit(1)
 
 
 if __name__ == "__main__":

tacklebox_cli-0.3.0/tacklebox/commands/find_desktop_entry.py

@@ -0,0 +1,49 @@
+import os
+import subprocess
+from pathlib import Path
+from shutil import which
+
+from typer import Exit, Typer
+
+from tacklebox.utils import stderr, stdout
+
+app = Typer()
+
+
+@app.command()
+def find_desktop_entry(desktop_entry: str, show_all_paths: bool = False) -> None:
+    if not desktop_entry:
+        raise ValueError("Please provide the full filename of the desktop entry.")
+
+    if not desktop_entry.endswith(".desktop"):
+        desktop_entry += ".desktop"
+
+    entry_paths = []
+
+    if which("qtpaths"):
+        result = subprocess.run(
+            ["qtpaths", "--paths", "ApplicationsLocation"],
+            stdout=subprocess.PIPE,
+            text=True,
+        )
+        entry_paths = result.stdout.strip().split(":")
+    else:
+        stderr.print("qtpaths is not installed, falling back to XDG_DATA_DIRS.")
+        xdg_data_dirs = os.getenv("XDG_DATA_DIRS", "/usr/share:/usr/local/share").split(":")
+        entry_paths = [os.path.join(path, "applications") for path in xdg_data_dirs]
+        entry_paths.append(os.path.expanduser("~/.local/share/applications"))
+
+    if show_all_paths:
+        stderr.print(f"Checking the following paths for {desktop_entry}:\n{entry_paths}\n{'-' * 20}")
+
+    for entry_path in entry_paths:
+        entry_file = Path(entry_path) / f"{desktop_entry}"
+        if show_all_paths:
+            stderr.print(f"Checking for {entry_file}")
+        if entry_file.is_file():
+            stderr.print(f"{desktop_entry} found in {entry_path}")
+            stdout.out(entry_file)
+            return
+
+    stderr.print(f"Desktop entry {desktop_entry} could not be found.")
+    raise Exit(1)

tacklebox_cli-0.3.0/tacklebox/commands/prepend_to_file.py

@@ -0,0 +1,84 @@
+#! /usr/bin/env python3
+
+import os
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from tacklebox.utils import stderr
+
+app = typer.Typer()
+
+
+def check_file(file: Path, /, *, write: bool = True) -> None:
+    if not file.exists():
+        raise FileNotFoundError(f"{file} does not exist!")
+    if not file.is_file():
+        raise FileNotFoundError(f"{file} is not a file!")
+    if not os.access(file, os.R_OK):
+        raise PermissionError(f"Cannot read file {file}!")
+
+    if write:
+        if not os.access(file, os.W_OK):
+            raise PermissionError(f"Cannot write to file {file}!")
+        if not os.access(file.parent, os.W_OK | os.X_OK):
+            raise PermissionError(f"Cannot write to directory {file.parent}!")
+
+
+@app.command()
+def prepend_to_file(
+    source_file: Annotated[Path, typer.Argument(help="The file to read content from.")],
+    dest_file: Annotated[Path, typer.Argument(help="The target file to modify.")],
+    add_newline: Annotated[
+        bool,
+        typer.Option(
+            "--add-newline/--no-add-newline",
+            "-a/-n",
+            help="Automatically strip newlines and append a newline to the provided content.",
+        ),
+    ] = True,
+    check_for_existence: Annotated[
+        bool,
+        typer.Option(
+            "--check-existence/--no-check-existence",
+            "-c/-C",
+            help="Check if the file already starts with the provided text.",
+        ),
+    ] = True,
+) -> None:
+    """Prepend text to the top of a file."""
+
+    try:
+        check_file(source_file, write=False)
+        check_file(dest_file, write=True)
+    except (PermissionError, FileNotFoundError) as err:
+        stderr.print(f"[red]{err}[reset]")
+
+    source_content = source_file.read_text()
+    dest_content = dest_file.read_text()
+
+    tmp_path: Path | None = None
+
+    stripped = source_content.rstrip("\r\n")
+    if add_newline:
+        source_content = source_content + "\n"
+
+    if check_for_existence and dest_content.startswith(stripped):
+        stderr.print(
+            f"[red]File [purple]{dest_file}[red] already begins with the given content; skipping[reset]",
+        )
+        return
+
+    try:
+        with tempfile.NamedTemporaryFile("w", delete=False, dir=dest_file.parent) as tmp:
+            tmp.write(source_content)
+            tmp.write(dest_content)
+            tmp_path = Path(tmp.name)
+
+        shutil.move(tmp.name, dest_file)
+    finally:
+        if tmp_path and tmp_path.exists():
+            os.remove(tmp_path)

{tacklebox_cli-0.2.6 → tacklebox_cli-0.3.0}/tacklebox/commands/spectacle.py

@@ -12,7 +12,6 @@ from typing import Annotated
 
 from desktop_notifier import DEFAULT_SOUND, Attachment, DesktopNotifier, Urgency
 from platformdirs import user_config_dir
-from rich import print
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from typer import Exit, Option, Typer
 from zipline.cli.commands._handling import handle_api_errors
@@ -20,9 +19,10 @@ from zipline.cli.commands.upload import _complete_format  # pyright: ignore[repo
 from zipline.client import Client, FileData, NameFormat
 
 from tacklebox import sync
+from tacklebox.utils import stderr, stdout
 
 if not platform.system() == "Linux":
-    print("Spectacle is only supported on Linux.")
+    stderr.print("Spectacle is only supported on Linux.")
     raise Exit(code=1)
 
 app = Typer()
@@ -83,7 +83,7 @@ class SpectacleMode(StrEnum):
         record_argument = self.get_argument(True)
 
         completion_strings: dict[SpectacleMode, str] = {
-            SpectacleMode.REGION: f"Capture a retangular region of the desktop. ({argument} | {record_argument})",
+            SpectacleMode.REGION: f"Capture a rectangular region of the desktop. ({argument} | {record_argument})",
             SpectacleMode.DESKTOP: f"Capture the entire desktop (default). When recording, this will capture only the current monitor. ({argument} | {record_argument})",
             SpectacleMode.MONITOR: f"Capture the current monitor. ({argument} | {record_argument})",
             SpectacleMode.WINDOW: f"Capture the window currently under the cursor, including parents of pop-up menus. ({argument} | {record_argument})",
@@ -246,17 +246,18 @@ async def spectacle(
     ] = False,
 ) -> None:
     """Take a screenshot or record a video using Spectacle, then upload it to a remote Zipline instance using zipline.py."""
-    notifier = DesktopNotifier(app_name="Tacklebox - Spectacle")
+    notifier = DesktopNotifier(app_name="tacklebox-cli - Spectacle")
 
     with Progress(
         SpinnerColumn(),
         TextColumn("[progress.description]{task.description}"),
+        console=stderr,
         transient=True,
     ) as progress:
         task = progress.add_task(description="Setting up...", total=None)
 
         if not which("spectacle"):
-            print("spectacle is not installed!")
+            stderr.print("spectacle is not installed!")
             raise Exit(code=1)
 
         image_format, video_format = _read_spectacle_config()
@@ -281,12 +282,12 @@ async def spectacle(
         ]
 
         proc = await asyncio.create_subprocess_exec(*command, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
-        stdout, stderr = await proc.communicate()
+        _stdout, _stderr = await proc.communicate()
 
         if proc.returncode != 0:
             if file_path.exists():
                 file_path.unlink(missing_ok=True)
-            raise subprocess.CalledProcessError(proc.returncode or 1, command, output=stdout, stderr=stderr)
+            raise subprocess.CalledProcessError(proc.returncode or 1, command, output=_stdout, stderr=_stderr)
 
         if not file_path.stat().st_size:
             file_path.unlink(missing_ok=True)
@@ -313,9 +314,9 @@ async def spectacle(
                 handle_api_errors(exception, server_url, traceback=verbose)
 
         if print_object:
-            print(uploaded_file)
+            stdout.print(uploaded_file)
         else:
-            print(uploaded_file.files[0].url)
+            stdout.print(uploaded_file.files[0].url)
 
         await notifier.send(
             title="File Uploaded!",

{tacklebox_cli-0.2.6 → tacklebox_cli-0.3.0}/tacklebox/commands/version.py

@@ -1,9 +1,9 @@
 from importlib.metadata import version
 
-from rich import print
 from typer import Typer
 
 from tacklebox import __version__
+from tacklebox.utils import stdout
 
 app = Typer()
 
@@ -35,7 +35,7 @@ def show_versions() -> None:
         for name, version in versions.items()
     )
 
-    print(output)
+    stdout.print(output)
 
 
 if __name__ == "__main__":

{tacklebox_cli-0.2.6 → tacklebox_cli-0.3.0}/tacklebox/entrypoint.py

@@ -9,9 +9,9 @@ from tacklebox.commands import commands
 if platform.system() == "Darwin":
     from rubicon.objc.eventloop import EventLoopPolicy  # pyright: ignore[reportMissingImports, reportUnknownVariableType]
 
-    asyncio.set_event_loop_policy(EventLoopPolicy()) # pyright: ignore[reportUnknownArgumentType]
+    asyncio.set_event_loop_policy(EventLoopPolicy()) # pyright: ignore[reportUnknownArgumentType, reportDeprecated]
 
-app = Typer(name="Tacklebox", pretty_exceptions_show_locals=False)
+app = Typer(name="tacklebox", pretty_exceptions_show_locals=False)
 
 
 for typer_instance in commands:

{tacklebox_cli-0.2.6 → tacklebox_cli-0.3.0}/tacklebox/utils.py

@@ -1,5 +1,10 @@
 import os
 
+from rich.console import Console
+
+stdout = Console()
+stderr = Console(stderr=True)
+
 
 def get_environment() -> dict[str, str]:
     env = dict(os.environ)

tacklebox_cli-0.3.0/tacklebox/version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.3.0'
+__version_tuple__ = version_tuple = (0, 3, 0)
+
+__commit_id__ = commit_id = None

tacklebox_cli-0.2.6/README.md

@@ -1,39 +0,0 @@
-# tacklebox-cli
-
-[<img alt="Actions Status" src="https://c.csw.im/cswimr/tacklebox/badges/workflows/actions.yml/badge.svg?style=plastic">](https://c.csw.im/cswimr/tacklebox/actions?workflow=actions.yml)
-[<img alt="PyPI - Version" src="https://img.shields.io/pypi/v/tacklebox-cli?style=plastic">](https://pypi.org/project/tacklebox-cli/)
-[<img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/tacklebox-cli?style=plastic">](https://pypi.org/project/tacklebox-cli/)
-[<img alt="PyPI - License" src="https://img.shields.io/pypi/l/tacklebox-cli?style=plastic">](https://c.csw.im/cswimr/tacklebox/src/branch/main/LICENSE/)  
-tacklebox-cli offers a suite of useful CLI tools.
-
-## Usage
-
-### tacklebox copy / paste
-
-Cross-platform clipboard management tool. Uses system tools such as `wl-copy` on Linux Wayland or `clip.exe` on Windows, and [OSC 52](https://www.reddit.com/r/vim/comments/k1ydpn/a_guide_on_how_to_copy_text_from_anywhere/) escape codes when **copying** over SSH or when no other tools are available. See [`copy_with_tooling()`](https://c.csw.im/cswimr/tacklebox/src/branch/main/tacklebox/commands/clipboard.py) for all supported tools.
-
-```bash
-$ echo "a" | tacklebox copy --trim && tacklebox paste
-a
-```
-
-### tacklebox spectacle (Linux only)
-
-Uses the [zipline.py](https://pypi.org/project/zipline-py/) library alongside KDE's [Spectacle](https://invent.kde.org/plasma/spectacle) application to take a screenshot or screen recording and automatically upload it to a [Zipline](https://github.com/diced/zipline) instance. This automatically reads Spectacle's configuration files to determine file formats.
-
-```bash
-$ tacklebox spectacle --mode region \ 
-    --server "https://zipline.example.com" \ 
-    --token "$(cat /file/containing/zipline/token)" \ 
-    | tacklebox copy --trim
-
-# or to record a video
-$ tacklebox spectacle --mode region --record \ 
-    --server "https://zipline.example.com" \ 
-    --token "$(cat /file/containing/zipline/token)" \ 
-    | tacklebox copy --trim
-```
-
-### tacklebox zipline
-
-Wraps the [zipline.py](https://pypi.org/project/zipline-py/) CLI. See the [zipline.py CLI documentation](https://ziplinepy.readthedocs.io/en/latest/cli.html) for more information.

tacklebox_cli-0.2.6/pyproject.toml

@@ -1,60 +0,0 @@
-[project]
-name = "tacklebox-cli"
-description = "A small collection of CLI utilities."
-authors = [{ name = "cswimr", email = "seaswimmerthefsh@gmail.com" }]
-readme = "README.md"
-requires-python = ">=3.11"
-license = "MIT"
-license-files = ["LICEN[CS]E*"]
-classifiers = [
-    "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13",
-]
-dependencies = [
-    "desktop-notifier>=6.1.0",
-    "platformdirs>=4.3.0",
-    "zipline.py[cli]>=0.27.0",
-]
-dynamic = ["version", "urls"]
-
-[dependency-groups]
-dev = [
-    "basedpyright==1.29.2",
-    "pyinstrument==5.0.2",
-    "ruff==0.11.12",
-]
-
-[project.scripts]
-tacklebox = "tacklebox.entrypoint:app"
-tacklebox-cli = "tacklebox.entrypoint:app" # for uvx / pipx, prefer tacklebox when possible
-
-[tool.ruff]
-line-length = 145
-
-[tool.pyright]
-typeCheckingMode = "strict"
-reportMissingTypeStubs = false
-
-[tool.typos]
-files.extend-exclude = [".direnv/**", ".venv/**"]
-
-[tool.hatch.version]
-source = "vcs"
-
-[tool.hatch.build]
-include = ["/tacklebox", "/README.md", "/LICENSE.md", "/pyproject.toml"]
-
-[tool.hatch.build.hooks.vcs]
-version-file = "tacklebox/version.py"
-
-[tool.hatch.metadata.hooks.vcs.urls]
-Homepage = "https://c.csw.im/cswimr/tacklebox"
-Issues = "https://c.csw.im/cswimr/tacklebox/issues"
-source_archive = "https://c.csw.im/cswimr/tacklebox/archive/{commit_hash}.tar.gz"
-
-[build-system]
-requires = ["hatchling", "hatch-vcs"]
-build-backend = "hatchling.build"

tacklebox_cli-0.2.6/tacklebox/version.py

@@ -1,21 +0,0 @@
-# file generated by setuptools-scm
-# don't change, don't track in version control
-
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
-
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from typing import Tuple
-    from typing import Union
-
-    VERSION_TUPLE = Tuple[Union[int, str], ...]
-else:
-    VERSION_TUPLE = object
-
-version: str
-__version__: str
-__version_tuple__: VERSION_TUPLE
-version_tuple: VERSION_TUPLE
-
-__version__ = version = '0.2.6'
-__version_tuple__ = version_tuple = (0, 2, 6)