shrip 0.1.0__tar.gz

shrip-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 nbfrodri
+
+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.

shrip-0.1.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: shrip
+Version: 0.1.0
+Summary: Zip and share files from the terminal — no browser needed.
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.9.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# shrip
+
+**Zip and share files from the terminal — no browser needed.**
+
+`shrip` bundles files and folders into a compressed archive and uploads it to [gofile.io](https://gofile.io), giving you a temporary public download link instantly. No accounts, no configuration, no context-switching.
+
+## Installation
+
+**From PyPI (recommended):**
+
+```bash
+pip install shrip
+```
+
+**With [pipx](https://pipx.pypa.io/) (isolated install):**
+
+```bash
+pipx install shrip
+```
+
+**From GitHub:**
+
+```bash
+pip install git+https://github.com/nbfrodri/shrip.git
+```
+
+> Requires Python 3.9 or higher. Works on Windows, macOS, and Linux.
+
+## Usage
+
+```bash
+# Share a single file
+shrip report.pdf
+
+# Share multiple files and folders
+shrip ./src/ README.md logo.png --name project-handover
+
+# Custom archive name
+shrip ./build/ -n release-v2
+```
+
+**Example output:**
+
+```
+Compressing 3 items into project-handover.zip...
+⠋ Compressing ████████████████████████████████████ 3/3 files
+Uploading to gofile.io...
+⠋ Uploading   ████████████████████████████████████ 1.2/1.2 MB  850.3 kB/s
+
+Success! Your file is live:
+https://gofile.io/d/AbCd123
+
+(Files are automatically deleted after a period of inactivity.)
+```
+
+## Options
+
+| Flag | Short | Description | Default |
+|------|-------|-------------|---------|
+| `--name` | `-n` | Custom archive name (without `.zip`) | `shrip_archive` |
+| `--version` | `-v` | Show version and exit | |
+| `--help` | | Show usage help | |
+
+## How It Works
+
+1. Validates that all provided paths exist.
+2. Compresses everything into a temporary `.zip` archive — directories are walked recursively, preserving folder structure.
+3. Uploads the archive to [gofile.io](https://gofile.io) (anonymous, no account needed, no file size limit).
+4. Prints the download URL.
+5. Deletes the temporary zip file automatically — even if the upload fails or you hit Ctrl+C.
+
+## License
+
+MIT

shrip-0.1.0/README.md

@@ -0,0 +1,74 @@
+# shrip
+
+**Zip and share files from the terminal — no browser needed.**
+
+`shrip` bundles files and folders into a compressed archive and uploads it to [gofile.io](https://gofile.io), giving you a temporary public download link instantly. No accounts, no configuration, no context-switching.
+
+## Installation
+
+**From PyPI (recommended):**
+
+```bash
+pip install shrip
+```
+
+**With [pipx](https://pipx.pypa.io/) (isolated install):**
+
+```bash
+pipx install shrip
+```
+
+**From GitHub:**
+
+```bash
+pip install git+https://github.com/nbfrodri/shrip.git
+```
+
+> Requires Python 3.9 or higher. Works on Windows, macOS, and Linux.
+
+## Usage
+
+```bash
+# Share a single file
+shrip report.pdf
+
+# Share multiple files and folders
+shrip ./src/ README.md logo.png --name project-handover
+
+# Custom archive name
+shrip ./build/ -n release-v2
+```
+
+**Example output:**
+
+```
+Compressing 3 items into project-handover.zip...
+⠋ Compressing ████████████████████████████████████ 3/3 files
+Uploading to gofile.io...
+⠋ Uploading   ████████████████████████████████████ 1.2/1.2 MB  850.3 kB/s
+
+Success! Your file is live:
+https://gofile.io/d/AbCd123
+
+(Files are automatically deleted after a period of inactivity.)
+```
+
+## Options
+
+| Flag | Short | Description | Default |
+|------|-------|-------------|---------|
+| `--name` | `-n` | Custom archive name (without `.zip`) | `shrip_archive` |
+| `--version` | `-v` | Show version and exit | |
+| `--help` | | Show usage help | |
+
+## How It Works
+
+1. Validates that all provided paths exist.
+2. Compresses everything into a temporary `.zip` archive — directories are walked recursively, preserving folder structure.
+3. Uploads the archive to [gofile.io](https://gofile.io) (anonymous, no account needed, no file size limit).
+4. Prints the download URL.
+5. Deletes the temporary zip file automatically — even if the upload fails or you hit Ctrl+C.
+
+## License
+
+MIT

shrip-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "shrip"
+version = "0.1.0"
+description = "Zip and share files from the terminal — no browser needed."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+dependencies = [
+    "typer>=0.9.0",
+    "requests>=2.31.0",
+    "rich>=13.0.0",
+]
+
+[project.scripts]
+shrip = "shrip.cli:app"
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "pytest-mock", "ruff"]
+
+[tool.ruff]
+target-version = "py39"
+line-length = 100

shrip-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

shrip-0.1.0/shrip/__init__.py

@@ -0,0 +1,6 @@
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("shrip")
+except PackageNotFoundError:
+    __version__ = "0.0.0-dev"

shrip-0.1.0/shrip/__main__.py

@@ -0,0 +1,3 @@
+from shrip.cli import app
+
+app()

shrip-0.1.0/shrip/archive.py

@@ -0,0 +1,161 @@
+"""Archive creation module — zips files and directories into a temp file."""
+
+from __future__ import annotations
+
+import re
+import tempfile
+import zipfile
+from pathlib import Path
+from typing import Callable, Optional
+
+
+def sanitize_name(name: str) -> str:
+    """Strip dangerous characters and normalize an archive name."""
+    name = name.removesuffix(".zip")
+    name = re.sub(r'[/\\:*?"<>|]', "", name)
+    name = name.replace(" ", "_")
+    name = name.strip("._")
+    return name or "shrip_archive"
+
+
+def _resolve_safe(path: Path, allowed_roots: list[Path]) -> Path | None:
+    """Resolve a path and return it only if it lives under one of the allowed roots."""
+    try:
+        resolved = path.resolve()
+    except OSError:
+        return None
+    for root in allowed_roots:
+        try:
+            resolved.relative_to(root)
+            return resolved
+        except ValueError:
+            continue
+    return None
+
+
+def _collect_files(paths: list[Path]) -> list[tuple[Path, str]]:
+    """
+    Walk all input paths and return a list of (absolute_path, arcname) pairs.
+
+    - Files are stored with their filename only.
+    - Directories are walked recursively; files inside are stored relative to the
+      directory itself (e.g., mydir/sub/file.txt → mydir/sub/file.txt).
+    - Duplicate arcnames are made unique by prefixing with a counter.
+    """
+    entries: list[tuple[Path, str]] = []
+    seen_arcnames: dict[str, int] = {}
+    allowed_roots = [p.resolve().parent if p.is_file() else p.resolve() for p in paths]
+
+    for input_path in paths:
+        input_path = input_path.resolve()
+
+        if input_path.is_file():
+            arcname = input_path.name
+            arcname = _deduplicate_arcname(arcname, seen_arcnames)
+            entries.append((input_path, arcname))
+
+        elif input_path.is_dir():
+            dir_name = input_path.name
+            has_children = False
+            for child in sorted(input_path.rglob("*")):
+                if not child.is_file():
+                    continue
+                # Symlink safety: resolve and verify target is inside allowed roots
+                if child.is_symlink():
+                    safe = _resolve_safe(child, allowed_roots)
+                    if safe is None:
+                        continue
+                relative = child.relative_to(input_path)
+                arcname = str(Path(dir_name) / relative)
+                arcname = _deduplicate_arcname(arcname, seen_arcnames)
+                entries.append((child, arcname))
+                has_children = True
+
+            # Empty directory: add a directory entry
+            if not has_children:
+                entries.append((input_path, dir_name + "/"))
+
+    return entries
+
+
+def _deduplicate_arcname(arcname: str, seen: dict[str, int]) -> str:
+    """If arcname was already used, prefix with a counter to make it unique."""
+    if arcname not in seen:
+        seen[arcname] = 1
+        return arcname
+    seen[arcname] += 1
+    stem = Path(arcname)
+    new_name = (
+        f"{stem.parent}/{stem.stem}_{seen[arcname]}{stem.suffix}"
+        if str(stem.parent) != "."
+        else f"{stem.stem}_{seen[arcname]}{stem.suffix}"
+    )
+    # Recurse in case the new name also collides
+    return _deduplicate_arcname(new_name, seen)
+
+
+def create_archive(
+    paths: list[Path],
+    name: str = "shrip_archive",
+    progress_callback: Optional[Callable[[Path], None]] = None,
+) -> Path:
+    """
+    Create a temporary .zip archive containing all provided files and directories.
+
+    Args:
+        paths: Files and/or directories to include.
+        name: Archive base name (without .zip). Sanitized automatically.
+        progress_callback: Called with each file path after it is added to the archive.
+
+    Returns:
+        Path to the created temporary zip file.
+
+    Raises:
+        FileNotFoundError: If any input path does not exist.
+        PermissionError: If any input file cannot be read.
+        ValueError: If no files are found to archive.
+    """
+    safe_name = sanitize_name(name)
+
+    # Validate all paths exist and are readable upfront
+    for p in paths:
+        resolved = p.resolve()
+        if not resolved.exists():
+            raise FileNotFoundError(f"Path does not exist: {p}")
+        if resolved.is_file() and not _is_readable(resolved):
+            raise PermissionError(f"Cannot read file: {p}")
+
+    entries = _collect_files(paths)
+
+    # Check we have something to zip (allow empty dirs, but not zero entries)
+    if not entries:
+        raise ValueError("No files found to archive.")
+
+    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".zip", prefix=f".shrip_{safe_name}_")
+    tmp_path = Path(tmp.name)
+    tmp.close()
+
+    try:
+        with zipfile.ZipFile(tmp_path, "w", zipfile.ZIP_DEFLATED) as zf:
+            for file_path, arcname in entries:
+                if arcname.endswith("/"):
+                    # Empty directory entry
+                    zf.mkdir(arcname)
+                else:
+                    zf.write(file_path, arcname)
+                if progress_callback is not None:
+                    progress_callback(file_path)
+        return tmp_path
+    except Exception:
+        # Cleanup on failure
+        tmp_path.unlink(missing_ok=True)
+        raise
+
+
+def _is_readable(path: Path) -> bool:
+    """Check if a file can be opened for reading."""
+    try:
+        with open(path, "rb"):
+            return True
+    except (PermissionError, OSError):
+        return False

shrip-0.1.0/shrip/cli.py

@@ -0,0 +1,144 @@
+"""CLI entry point — Typer app with Rich progress bars."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+from rich.console import Console
+from rich.progress import (
+    BarColumn,
+    DownloadColumn,
+    Progress,
+    SpinnerColumn,
+    TextColumn,
+    TransferSpeedColumn,
+)
+
+from shrip import __version__
+from shrip.archive import create_archive, sanitize_name
+from shrip.upload import UploadError, upload_to_gofile
+
+app = typer.Typer(
+    name="shrip",
+    help="Zip and share files from the terminal.",
+    add_completion=False,
+)
+console = Console()
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        console.print(f"shrip {__version__}")
+        raise typer.Exit()
+
+
+@app.command()
+def main(
+    paths: Annotated[
+        list[Path],
+        typer.Argument(help="Files and/or folders to share."),
+    ],
+    name: Annotated[
+        str,
+        typer.Option("--name", "-n", help="Archive name (without .zip)."),
+    ] = "shrip_archive",
+    version: Annotated[
+        Optional[bool],
+        typer.Option(
+            "--version",
+            "-v",
+            help="Show version and exit.",
+            callback=_version_callback,
+            is_eager=True,
+        ),
+    ] = None,
+) -> None:
+    """Zip files and folders, upload to gofile.io, and get a download link."""
+    # Normalize name
+    if not name or not name.strip():
+        name = "shrip_archive"
+    safe_name = sanitize_name(name)
+
+    # Validate all paths upfront, report ALL invalid ones at once
+    invalid = [p for p in paths if not p.resolve().exists()]
+    if invalid:
+        for p in invalid:
+            console.print(f"[red]Error:[/red] Path does not exist: {p}")
+        raise typer.Exit(code=1)
+
+    # Count items for display
+    item_count = len(paths)
+    item_label = "item" if item_count == 1 else "items"
+
+    zip_path: Path | None = None
+    try:
+        # ── Compress ─────────────────────────────────────────────────
+        # Count total files for the progress bar
+        total_files = 0
+        for p in paths:
+            rp = p.resolve()
+            if rp.is_file():
+                total_files += 1
+            elif rp.is_dir():
+                total_files += sum(1 for f in rp.rglob("*") if f.is_file())
+                if total_files == 0:
+                    total_files = 1  # empty dir counts as 1 entry
+
+        console.print(
+            f"\n[cyan]Compressing {item_count} {item_label} into {safe_name}.zip...[/cyan]"
+        )
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TextColumn("{task.completed}/{task.total} files"),
+            console=console,
+        ) as progress:
+            task = progress.add_task("Compressing", total=total_files)
+
+            def on_file_compressed(file_path: Path) -> None:
+                progress.advance(task)
+
+            zip_path = create_archive(paths, name, progress_callback=on_file_compressed)
+
+        # ── Upload ───────────────────────────────────────────────────
+        zip_size = zip_path.stat().st_size
+        console.print("[cyan]Uploading to gofile.io...[/cyan]")
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            DownloadColumn(),
+            TransferSpeedColumn(),
+            console=console,
+        ) as progress:
+            task = progress.add_task("Uploading", total=zip_size)
+
+            def on_bytes_sent(cumulative: int) -> None:
+                progress.update(task, completed=cumulative)
+
+            download_url = upload_to_gofile(zip_path, progress_callback=on_bytes_sent)
+
+        # ── Success ──────────────────────────────────────────────────
+        console.print("\n[bold green]Success! Your file is live:[/bold green]")
+        console.print(f"[bold]{download_url}[/bold]")
+        console.print(
+            "\n[dim](Files are automatically deleted after a period of inactivity.)[/dim]\n"
+        )
+
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Interrupted.[/yellow]")
+        raise typer.Exit(code=130)
+    except UploadError as e:
+        console.print(f"\n[red]Error:[/red] {e}")
+        raise typer.Exit(code=1)
+    except (FileNotFoundError, PermissionError, ValueError) as e:
+        console.print(f"\n[red]Error:[/red] {e}")
+        raise typer.Exit(code=1)
+    finally:
+        if zip_path is not None:
+            zip_path.unlink(missing_ok=True)

shrip-0.1.0/shrip/upload.py

@@ -0,0 +1,114 @@
+"""Upload module — sends a file to gofile.io and returns the download URL."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Callable, Optional
+
+import requests
+
+GOFILE_UPLOAD_URL = "https://upload.gofile.io/uploadfile"
+CONNECT_TIMEOUT = 10  # seconds
+READ_TIMEOUT = 300  # seconds (5 min, generous for large files)
+
+
+class UploadError(Exception):
+    """Raised when the upload fails for any reason."""
+
+
+class _ProgressReader:
+    """Wraps a file object to track bytes read and call a progress callback."""
+
+    def __init__(self, fileobj, total_size: int, callback: Callable[[int], None]):
+        self._fileobj = fileobj
+        self._total_size = total_size
+        self._bytes_read = 0
+        self._callback = callback
+
+    def read(self, size: int = -1) -> bytes:
+        chunk = self._fileobj.read(size)
+        self._bytes_read += len(chunk)
+        self._callback(self._bytes_read)
+        return chunk
+
+    def __len__(self) -> int:
+        return self._total_size
+
+
+def upload_to_gofile(
+    file_path: Path,
+    progress_callback: Optional[Callable[[int], None]] = None,
+) -> str:
+    """
+    Upload a file to gofile.io and return the download page URL.
+
+    Args:
+        file_path: Path to the file to upload.
+        progress_callback: Called with cumulative bytes sent after each chunk.
+
+    Returns:
+        The download page URL (e.g., "https://gofile.io/d/AbCd123").
+
+    Raises:
+        UploadError: On any upload or API failure.
+        ValueError: If the file is empty (0 bytes).
+    """
+    file_path = file_path.resolve()
+    file_size = file_path.stat().st_size
+
+    if file_size == 0:
+        raise ValueError("Archive is empty, nothing to upload.")
+
+    try:
+        with open(file_path, "rb") as f:
+            if progress_callback is not None:
+                reader = _ProgressReader(f, file_size, progress_callback)
+                files = {"file": (file_path.name, reader)}
+            else:
+                files = {"file": (file_path.name, f)}
+
+            response = requests.post(
+                GOFILE_UPLOAD_URL,
+                files=files,
+                timeout=(CONNECT_TIMEOUT, READ_TIMEOUT),
+            )
+
+    except requests.exceptions.SSLError:
+        raise UploadError("SSL verification failed when connecting to gofile.io.")
+    except requests.exceptions.Timeout:
+        raise UploadError("Upload timed out — check your connection and try again.")
+    except requests.exceptions.ConnectionError:
+        raise UploadError("Could not reach gofile.io — check your internet connection.")
+    except requests.exceptions.RequestException as e:
+        raise UploadError(f"Upload failed: {e}")
+
+    if response.status_code == 429:
+        raise UploadError("Rate limited by gofile.io — wait a moment and try again.")
+    if response.status_code >= 500:
+        raise UploadError("gofile.io is temporarily unavailable — try again later.")
+    if response.status_code != 200:
+        raise UploadError(f"Upload failed with HTTP {response.status_code}.")
+
+    try:
+        body = response.json()
+    except (ValueError, requests.exceptions.JSONDecodeError):
+        raise UploadError("Invalid response from gofile.io.")
+
+    status = body.get("status")
+    if status != "ok":
+        msg = (
+            body.get("data", {}).get("message", "unknown error")
+            if isinstance(body.get("data"), dict)
+            else status
+        )
+        raise UploadError(f"gofile.io returned an error: {msg}")
+
+    data = body.get("data")
+    if not isinstance(data, dict):
+        raise UploadError("Unexpected response from gofile.io — the API may have changed.")
+
+    download_url = data.get("downloadPage")
+    if not download_url:
+        raise UploadError("Unexpected response from gofile.io — the API may have changed.")
+
+    return download_url