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

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

@@ -1,20 +1,18 @@
 Metadata-Version: 2.4
 Name: tacklebox-cli
-Version: 0.3.0
+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/951186f80430bac4501fe5167aabef121dfbb457.tar.gz
+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.14
-Requires-Dist: desktop-notifier>=6.1.0
-Requires-Dist: platformdirs>=4.3.0
-Requires-Dist: zipline-py[cli]>=0.27.0
+Requires-Python: >=3.13
+Requires-Dist: typer>=0.20.0
 Description-Content-Type: text/markdown
 
 # tacklebox-cli
@@ -22,40 +20,63 @@ 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/tag/0.3.0/LICENSE.md)  
+[<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.3.0/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.4.0/tacklebox/commands/clipboard.py) for all supported tools.
 
 ```bash
 $ echo "a" | tacklebox copy --trim && tacklebox paste
 a
 ```
 
-### tacklebox spectacle (Linux only)
+### tacklebox prepend-to-file
 
-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.
+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
-$ 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
+$ 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 zipline
+### tacklebox find-desktop-entry (Linux only)
 
-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.
+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
 

{tacklebox_cli-0.3.0 → tacklebox_cli-0.4.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "tacklebox-cli"
 description = "A small collection of CLI utilities."
-requires-python = ">=3.14"
+requires-python = ">=3.13"
 license = "MIT"
 license-files = ["LICEN[CS]E*"]
 authors = [{ name = "cswimr", email = "seaswimmerthefsh@gmail.com" }]
@@ -11,9 +11,7 @@ classifiers = [
   "Programming Language :: Python :: 3.14"
 ]
 dependencies = [
-  "desktop-notifier>=6.1.0",
-  "platformdirs>=4.3.0",
-  "zipline.py[cli]>=0.27.0",
+    "typer>=0.20.0",
 ]
 dynamic = ["readme", "urls", "version"]
 

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

@@ -1,16 +1,13 @@
 import platform
 
 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, find_desktop_entry, prepend_to_file, version, zipline]
+commands: list[Typer] = [clipboard, prepend_to_file, version]
 
 if platform.system() == "Linux":
-    from .spectacle import app as spectacle
-
-    commands.append(spectacle)
+    commands.extend([find_desktop_entry])

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.3.0 → tacklebox_cli-0.4.0}/tacklebox/commands/version.py

@@ -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"),

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

@@ -11,19 +11,11 @@ if platform.system() == "Darwin":
 
     asyncio.set_event_loop_policy(EventLoopPolicy()) # pyright: ignore[reportUnknownArgumentType, reportDeprecated]
 
-app = Typer(name="tacklebox", pretty_exceptions_show_locals=False)
+app = Typer(name="tacklebox", no_args_is_help=True, 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)
+    app.add_typer(typer_instance)
 
 if __name__ == "__main__":
     app()

{tacklebox_cli-0.3.0 → tacklebox_cli-0.4.0}/tacklebox/version.py

@@ -18,7 +18,7 @@ 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)
+__version__ = version = '0.4.0'
+__version_tuple__ = version_tuple = (0, 4, 0)
 
 __commit_id__ = commit_id = None

tacklebox_cli-0.3.0/tacklebox/commands/find_desktop_entry.py

@@ -1,49 +0,0 @@
-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/spectacle.py

@@ -1,334 +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.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
-from tacklebox.utils import stderr, stdout
-
-if not platform.system() == "Linux":
-    stderr.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 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})",
-            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-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"):
-            stderr.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:
-            stdout.print(uploaded_file)
-        else:
-            stdout.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()