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

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

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

tacklebox_cli-0.4.0/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: tacklebox-cli
+Version: 0.4.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/9286755479cd8bf8d5ad51736ce7b519c01e1479.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.14
+Requires-Python: >=3.13
+Requires-Dist: typer>=0.20.0
+Description-Content-Type: text/markdown
+
+# 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/tag/0.4.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/tag/0.4.0/tacklebox/commands/clipboard.py) for all supported tools.
+
+```bash
+$ echo "a" | tacklebox copy --trim && tacklebox paste
+a
+```
+
+### tacklebox prepend-to-file
+
+Prepend the contents of one file to another, with support for adding a newline automatically and checking if the operation has already been performed on the destination file.
+
+```bash
+$ echo "template-example" > template
+$ echo "hello world" > hello-world.txt
+$ tacklebox prepend-to-file template hello-world.txt -n
+$ cat hello-world.txt
+template-example
+hello world
+```
+
+### tacklebox find-desktop-entry (Linux only)
+
+Checks all of the paths under `$XDG_DATA_DIRS` for an application desktop file with the given name.
+Prints the full path of the desktop file to stdout if found.
+
+```bash
+$ tacklebox find-desktop-entry kitty
+kitty.desktop found in /etc/profiles/per-user/cswimr/share/applications
+/etc/profiles/per-user/cswimr/share/applications/kitty.desktop
+
+$ tacklebox find-desktop-entry --read kitty
+kitty.desktop found in /etc/profiles/per-user/cswimr/share/applications
+# /etc/profiles/per-user/cswimr/share/applications/kitty.desktop
+[Desktop Entry]
+Version=1.0
+Type=Application
+Name=kitty
+GenericName=Terminal emulator
+Comment=Fast, feature-rich, GPU based terminal
+TryExec=kitty
+StartupNotify=true
+Exec=kitty
+Icon=kitty
+Categories=System;TerminalEmulator;
+X-TerminalArgExec=--
+X-TerminalArgTitle=--title
+X-TerminalArgAppId=--class
+X-TerminalArgDir=--working-directory
+X-TerminalArgHold=--hold
+```
+
+## 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.4.0/pyproject.toml

@@ -0,0 +1,72 @@
+[project]
+name = "tacklebox-cli"
+description = "A small collection of CLI utilities."
+requires-python = ">=3.13"
+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 = [
+    "typer>=0.20.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.4.0/tacklebox/commands/__init__.py

@@ -0,0 +1,13 @@
+import platform
+
+from typer import Typer
+
+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, prepend_to_file, version]
+
+if platform.system() == "Linux":
+    commands.extend([find_desktop_entry])

{tacklebox_cli-0.2.6 → tacklebox_cli-0.4.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.4.0/tacklebox/commands/find_desktop_entry.py

@@ -0,0 +1,55 @@
+import os
+from pathlib import Path
+from typing import Annotated
+
+from typer import Argument, Exit, Option, Typer
+
+from tacklebox.utils import stderr, stdout
+
+app = Typer()
+
+
+@app.command()
+def find_desktop_entry(
+    desktop_entry: Annotated[str, Argument(help="The name (application ID) of the desktop file to search for.")],
+    *,
+    read: Annotated[
+        bool,
+        Option(..., "--read", "-r", help="Print the contents of the desktop file, if found."),
+    ] = False,
+    print_paths: Annotated[bool, Option(..., "--print-paths", help="Print the paths that the command will check for desktop files.")] = False,
+    include_user_data_dir: Annotated[
+        bool,
+        Option(..., "--user-data-dir", "-u", help="Include the user data directory in the search, if not already included in `XDG_DATA_DIRS`."),
+    ] = False,
+) -> None:
+    """Locate a desktop entry according to the value of your `XDG_DATA_DIRS` environment variable."""
+    if not desktop_entry.endswith(".desktop"):
+        desktop_entry += ".desktop"
+
+    entry_paths = []
+
+    xdg_data_dirs = [Path(path) for path in os.getenv("XDG_DATA_DIRS", "/usr/share:/usr/local/share").split(":")]
+    entry_paths = [path / "applications" for path in xdg_data_dirs]
+    if include_user_data_dir:
+        data_home = Path(os.getenv("XDG_DATA_HOME", "~/.local/share")).expanduser()
+        application_path = data_home / "applications"
+        if application_path not in entry_paths:
+            entry_paths.append(application_path)
+
+    if print_paths:
+        stderr.print(f"Checking the following paths for {desktop_entry}:\n{[str(path) for path in entry_paths]}\n{'-' * 20}")
+
+    for entry_path in entry_paths:
+        entry_file = entry_path / f"{desktop_entry}"
+        if entry_file.is_file():
+            stderr.print(f"{desktop_entry} found in {entry_path}")
+            if read:
+                content = entry_file.read_text("utf-8")
+                stdout.out(f"# {entry_file}\n{content}")
+            else:
+                stdout.out(entry_file)
+            return
+
+    stderr.print(f"Desktop entry {desktop_entry} could not be found.")
+    raise Exit(1)

tacklebox_cli-0.4.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.4.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()
 
@@ -18,13 +18,9 @@ def _get_package_version(package_name: str) -> str | None:
 
 @app.command(name="version")
 def show_versions() -> None:
-    """Shows versions of the tacklebox, zipline-py, desktop-notifier, platformdirs, aiohttp, typer, click, and rich packages."""
+    """Shows versions of the tacklebox, typer, click, and rich packages."""
     versions: dict[str, str | None] = {
         "tacklebox": __version__,
-        "zipline-py": _get_package_version("zipline-py"),
-        "desktop-notifier": _get_package_version("desktop-notifier"),
-        "platformdirs": _get_package_version("platformdirs"),
-        "aiohttp": _get_package_version("aiohttp"),
         "typer": _get_package_version("typer"),
         "click": _get_package_version("click"),
         "rich": _get_package_version("rich"),
@@ -35,7 +31,7 @@ def show_versions() -> None:
         for name, version in versions.items()
     )
 
-    print(output)
+    stdout.print(output)
 
 
 if __name__ == "__main__":

tacklebox_cli-0.4.0/tacklebox/entrypoint.py

@@ -0,0 +1,21 @@
+import asyncio
+import platform
+
+from typer import Typer
+
+from tacklebox.commands import commands
+
+# fmt: off
+if platform.system() == "Darwin":
+    from rubicon.objc.eventloop import EventLoopPolicy  # pyright: ignore[reportMissingImports, reportUnknownVariableType]
+
+    asyncio.set_event_loop_policy(EventLoopPolicy()) # pyright: ignore[reportUnknownArgumentType, reportDeprecated]
+
+app = Typer(name="tacklebox", no_args_is_help=True, pretty_exceptions_show_locals=False)
+
+
+for typer_instance in commands:
+    app.add_typer(typer_instance)
+
+if __name__ == "__main__":
+    app()

{tacklebox_cli-0.2.6 → tacklebox_cli-0.4.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.4.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.4.0'
+__version_tuple__ = version_tuple = (0, 4, 0)
+
+__commit_id__ = commit_id = None

tacklebox_cli-0.2.6/PKG-INFO

@@ -1,60 +0,0 @@
-Metadata-Version: 2.4
-Name: tacklebox-cli
-Version: 0.2.6
-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
-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
-Requires-Dist: desktop-notifier>=6.1.0
-Requires-Dist: platformdirs>=4.3.0
-Requires-Dist: zipline-py[cli]>=0.27.0
-Description-Content-Type: text/markdown
-
-# 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/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/commands/__init__.py

@@ -1,14 +0,0 @@
-import platform
-
-from typer import Typer
-from zipline.cli.entrypoint import app as zipline
-
-from .clipboard import app as clipboard
-from .version import app as version
-
-commands: list[Typer] = [clipboard, version, zipline]
-
-if platform.system() == "Linux":
-    from .spectacle import app as spectacle
-
-    commands.append(spectacle)

tacklebox_cli-0.2.6/tacklebox/commands/spectacle.py

@@ -1,333 +0,0 @@
-import asyncio
-import configparser
-import platform
-import subprocess
-import sys
-import tempfile
-from datetime import datetime, timezone
-from enum import IntEnum, StrEnum
-from pathlib import Path
-from shutil import which
-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
-from zipline.cli.commands.upload import _complete_format  # pyright: ignore[reportPrivateUsage]
-from zipline.client import Client, FileData, NameFormat
-
-from tacklebox import sync
-
-if not platform.system() == "Linux":
-    print("Spectacle is only supported on Linux.")
-    raise Exit(code=1)
-
-app = Typer()
-
-
-class VideoFormat(IntEnum):
-    """Because Spectacle is weird and doesn't just use file extensions for storing video formats 😭"""
-
-    WEBM = 0
-    MP4 = 2
-    WEBP = 4
-    GIF = 8
-
-    @property
-    def ext(self) -> str:
-        return "." + self.__str__()
-
-    def __str__(self) -> str:
-        return self.name.lower()
-
-
-def _read_spectacle_config() -> tuple[str, VideoFormat]:
-    """Read the Spectacle config file and return the configured file formats."""
-    path = Path(user_config_dir("spectaclerc"))
-    if not path.exists():
-        return "png", VideoFormat.WEBM
-
-    config = configparser.ConfigParser(strict=False)
-    config.read(path)
-
-    preferred_image_format = config.get("ImageSave", "preferredImageFormat", fallback="png").lower()
-
-    preferred_video_format = VideoFormat(config.getint("VideoSave", "preferredVideoFormat", fallback=0))
-
-    return preferred_image_format, preferred_video_format
-
-
-class SpectacleMode(StrEnum):
-    REGION = "region"
-    DESKTOP = "desktop"
-    MONITOR = "monitor"
-    WINDOW = "window"
-    ACTIVEWINDOW = "activewindow"
-    TRANSIENT = "transient"
-
-    @classmethod
-    def complete_format(cls, incomplete: str) -> list[tuple[str, str] | str]:
-        """Generate autocompletion strings for Typer."""
-        completions: list[tuple[str, str] | str] = []
-        for mode in SpectacleMode:
-            if mode.startswith(incomplete):
-                completions.append((mode, mode.completion_string) if mode.completion_string else mode)
-        return completions
-
-    @property
-    def completion_string(self) -> str | None:
-        argument = self.get_argument()
-        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.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})",
-            SpectacleMode.ACTIVEWINDOW: f"Capture the currently selected window. ({argument} | {record_argument})",
-            SpectacleMode.TRANSIENT: f"Capture the window currently under the cursor, excluding parents of pop-up menus. ({argument} | {record_argument})",
-        }
-
-        return completion_strings.get(self, None)
-
-    def get_argument(self, record: bool = False) -> str:
-        match self:
-            case SpectacleMode.REGION:
-                return "--record=region" if record else "--region"
-            case SpectacleMode.DESKTOP:
-                return "--record=screen" if record else "--fullscreen"
-            case SpectacleMode.MONITOR:
-                return "--record=screen" if record else "--current"
-            case SpectacleMode.WINDOW:
-                return "--record=window" if record else "--windowundercursor"
-            case SpectacleMode.ACTIVEWINDOW:
-                return "--record=window" if record else "--activewindow"
-            case SpectacleMode.TRANSIENT:
-                return "--record=window" if record else "--transientonly"
-
-
-@app.command(name="spectacle")
-@sync
-async def spectacle(
-    server_url: Annotated[
-        str,
-        Option(
-            ...,
-            "--server",
-            "-s",
-            help="Specify the URL to your Zipline instance.",
-            envvar="ZIPLINE_SERVER",
-            prompt=True,
-        ),
-    ],
-    token: Annotated[
-        str,
-        Option(
-            ...,
-            "--token",
-            "-t",
-            help="Specify a token used for authentication against your chosen Zipline instance.",
-            envvar="ZIPLINE_TOKEN",
-            prompt=True,
-            hide_input=True,
-        ),
-    ],
-    print_object: Annotated[
-        bool,
-        Option(
-            ...,
-            "--object/--text",
-            "-o/-O",
-            default_factory=lambda: bool(sys.stdout.isatty()),
-            help=(
-                "Specify how to format the output. If --text (or piped), "
-                "you'll get a link to the uploaded file; if --object (or on a TTY), "
-                "you'll get the raw Python object."
-            ),
-            envvar="ZIPLINE_PRINT_OBJECT",
-        ),
-    ],
-    mode: Annotated[
-        SpectacleMode,
-        Option(..., "--mode", "-M", help="Specify what mode Spectacle should be launched in.", autocompletion=SpectacleMode.complete_format),
-    ] = SpectacleMode.DESKTOP,
-    record: Annotated[
-        bool, Option(..., "--record", "-r", help="Specify whether or not to record a video instead of taking a screenshot.")
-    ] = False,
-    format: Annotated[
-        NameFormat | None,
-        Option(
-            ...,
-            "--format",
-            "-f",
-            help="Specify what format Zipline should use to generate a link for this file.",
-            autocompletion=_complete_format,
-        ),
-    ] = None,
-    compression_percent: Annotated[
-        int,
-        Option(
-            ...,
-            "--compression-percent",
-            "-c",
-            help="Specify how much this file should be compressed.",
-        ),
-    ] = 0,
-    expiry: Annotated[
-        datetime | None,
-        Option(
-            ...,
-            "--expiry",
-            "-e",
-            help=(
-                "Specify when this file should expire.\n"
-                "When this time expires, the file will be deleted from the Zipline instance.\n"
-                "This argument uses your system's local timezone, not UTC dates."
-            ),
-        ),
-    ] = None,
-    password: Annotated[
-        str | None,
-        Option(
-            ...,
-            "--password",
-            "-p",
-            help="Specify a password for this file. Viewing this file from Zipline will then require having this password.",
-        ),
-    ] = None,
-    max_views: Annotated[
-        int | None,
-        Option(
-            ...,
-            "--max-views",
-            "-m",
-            help="Specify how many times this file can be viewed before it will be automatically deleted.",
-        ),
-    ] = None,
-    override_name: Annotated[
-        str | None,
-        Option(
-            ...,
-            "--name",
-            "-n",
-            help="Specify the name to give this file in Zipline. This overrides the --format option, if provided.",
-        ),
-    ] = None,
-    folder: Annotated[
-        str | None,
-        Option(
-            ...,
-            "--folder",
-            "-F",
-            help="Specify what folder the file should be added to after it is uploaded.",
-        ),
-    ] = None,
-    override_domain: Annotated[
-        str | None,
-        Option(
-            ...,
-            "--domain",
-            "-d",
-            help="Specify what domain should be used instead of the Zipline instance's core domain.",
-        ),
-    ] = None,
-    verbose: Annotated[
-        bool,
-        Option(
-            ...,
-            "--verbose",
-            "-v",
-            help="Specify whether or not the application should print tracebacks from exceptions to the console. If the application encounters an exception it doesn't expect, it will always be printed to the console regardless of this option.",
-            envvar="ZIPLINE_VERBOSE",
-        ),
-    ] = 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")
-
-    with Progress(
-        SpinnerColumn(),
-        TextColumn("[progress.description]{task.description}"),
-        transient=True,
-    ) as progress:
-        task = progress.add_task(description="Setting up...", total=None)
-
-        if not which("spectacle"):
-            print("spectacle is not installed!")
-            raise Exit(code=1)
-
-        image_format, video_format = _read_spectacle_config()
-        if record:
-            ext = video_format.ext
-        else:
-            ext = "." + image_format
-
-        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=ext)
-        file_path = Path(temp_file.name)
-        temp_file.close()
-
-        command: list[str] = [
-            "spectacle",
-            "--nonotify",
-            "--background",
-            "--pointer",
-            mode.get_argument(record),
-            "--copy-image",
-            "--output",
-            str(file_path),
-        ]
-
-        proc = await asyncio.create_subprocess_exec(*command, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
-        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)
-
-        if not file_path.stat().st_size:
-            file_path.unlink(missing_ok=True)
-            raise FileNotFoundError("The file was not created properly.")
-
-        progress.update(task, description="Reading file...", total=None)
-        file_data = FileData(data=file_path)
-
-        progress.update(task, description="Uploading file...", total=None)
-        async with Client(server_url, token) as client:
-            try:
-                uploaded_file = await client.upload_file(
-                    payload=file_data,
-                    compression_percent=compression_percent,
-                    expiry=expiry.astimezone(tz=timezone.utc) if expiry else None,
-                    format=format,
-                    password=password,
-                    max_views=max_views,
-                    override_name=override_name,
-                    override_domain=override_domain,
-                    folder=folder,
-                )
-            except Exception as exception:
-                handle_api_errors(exception, server_url, traceback=verbose)
-
-        if print_object:
-            print(uploaded_file)
-        else:
-            print(uploaded_file.files[0].url)
-
-        await notifier.send(
-            title="File Uploaded!",
-            message=f"File successfully uploaded to {uploaded_file.files[0].url}",
-            attachment=Attachment(path=file_path),
-            urgency=Urgency.Low,
-            timeout=5,
-            sound=DEFAULT_SOUND,
-        )
-
-        file_path.unlink(missing_ok=True)
-
-
-if __name__ == "__main__":
-    app()

tacklebox_cli-0.2.6/tacklebox/entrypoint.py

@@ -1,29 +0,0 @@
-import asyncio
-import platform
-
-from typer import Typer
-
-from tacklebox.commands import commands
-
-# fmt: off
-if platform.system() == "Darwin":
-    from rubicon.objc.eventloop import EventLoopPolicy  # pyright: ignore[reportMissingImports, reportUnknownVariableType]
-
-    asyncio.set_event_loop_policy(EventLoopPolicy()) # pyright: ignore[reportUnknownArgumentType]
-
-app = Typer(name="Tacklebox", pretty_exceptions_show_locals=False)
-
-
-for typer_instance in commands:
-    match typer_instance.info.name:
-        case "zipline.py":
-            app.add_typer(
-                typer_instance,
-                name="zipline",
-                help="Interact with a remote Zipline instance using the zipline.py library's CLI.",
-            )
-        case _:
-            app.add_typer(typer_instance)
-
-if __name__ == "__main__":
-    app()

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)