sideload 0.1.0__py3-none-any.whl

sideload/__init__.py

@@ -0,0 +1,13 @@
+"""
+Sideload - Download large files via PyPI packages
+"""
+
+from .cli import main as cli_main
+
+__version__ = "1.0.0"
+__all__ = ["cli_main"]
+
+
+def main() -> None:
+    """Entry point for the CLI application"""
+    cli_main()

sideload/cli.py

@@ -0,0 +1,416 @@
+#!/usr/bin/env python3
+"""
+Sideload CLI Client
+A beautiful command-line interface for downloading files via the Sideload service.
+"""
+
+import os
+import sys
+import time
+import subprocess
+import tempfile
+import argparse
+from pathlib import Path
+from typing import List, Dict
+
+from rich.console import Console
+from rich.progress import (
+    Progress,
+    SpinnerColumn,
+    TextColumn,
+    BarColumn,
+    TaskProgressColumn,
+)
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+from rich.align import Align
+from rich.rule import Rule
+
+from sideload.jsonbin_old import JSONBinConnector, SideloadBinManager
+
+console = Console()
+
+
+class SideloadClient:
+    def __init__(self, jsonbin_token: str, collection_id: str):
+        self.collection_id = collection_id
+        self.connector = JSONBinConnector(jsonbin_token)
+        self.manager = SideloadBinManager(self.connector)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.connector.close()
+
+    def create_request(self, url: str) -> str:
+        """Create a new sideload request and return the bin ID"""
+        with console.status("[bold green]Creating sideload request..."):
+            bin_id = self.manager.create_sideload_request(url, self.collection_id)
+
+        console.print(f"✅ Created sideload request: [bold cyan]{bin_id}[/bold cyan]")
+        return bin_id
+
+    def monitor_request(self, bin_id: str) -> Dict:
+        """Monitor the sideload request progress"""
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+            console=console,
+            transient=True,
+        ) as progress:
+            download_task = progress.add_task("Monitoring request...", total=100)
+
+            while True:
+                try:
+                    data = self.manager.get_sideload_data(bin_id)
+
+                    status = data.get("status", "UNKNOWN")
+                    current_progress = data.get("progress", 0)
+
+                    if status == "DOWNLOADING":
+                        progress.update(
+                            download_task,
+                            description=f"📥 Downloading... ({current_progress}%)",
+                            completed=current_progress,
+                        )
+                    elif status == "BUILDING":
+                        progress.update(
+                            download_task,
+                            description="🔨 Building packages...",
+                            completed=90,
+                        )
+                    elif status == "UPLOADING":
+                        current_part = data.get("current_part", 1)
+                        total_parts = data.get("total_parts", 1)
+                        progress.update(
+                            download_task,
+                            description=f"📤 Uploading part {current_part}/{total_parts}...",
+                            completed=95,
+                        )
+                    elif status == "UPLOADED":
+                        progress.update(
+                            download_task,
+                            description="✅ Upload complete!",
+                            completed=100,
+                        )
+                        break
+                    elif status in ["FAILED", "REJECTED"]:
+                        reason = data.get("reason", "Unknown error")
+                        console.print(f"❌ Request failed: {reason}", style="bold red")
+                        return data
+
+                    time.sleep(2)
+
+                except KeyboardInterrupt:
+                    console.print("\n⚠️  Monitoring interrupted by user", style="yellow")
+                    break
+                except Exception as e:
+                    console.print(f"❌ Error monitoring request: {e}", style="red")
+                    break
+
+        # Get final data
+        return self.manager.get_sideload_data(bin_id)
+
+    def download_packages(
+        self, package_names: List[str], output_dir: Path
+    ) -> List[Path]:
+        """Download all packages to a temporary directory"""
+        downloaded_files = []
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+            console=console,
+        ) as progress:
+            download_task = progress.add_task(
+                "Downloading packages...", total=len(package_names)
+            )
+
+            for i, package_name in enumerate(package_names):
+                progress.update(
+                    download_task,
+                    description=f"📦 Downloading {package_name}...",
+                    completed=i,
+                )
+
+                # Download using pip to temporary directory
+                try:
+                    subprocess.run(
+                        [
+                            sys.executable,
+                            "-m",
+                            "pip",
+                            "download",
+                            "--no-deps",
+                            "--dest",
+                            str(output_dir),
+                            package_name,
+                        ],
+                        capture_output=True,
+                        text=True,
+                        check=True,
+                    )
+
+                    # Find the downloaded wheel file
+                    wheel_files = list(output_dir.glob(f"{package_name}*.whl"))
+                    if wheel_files:
+                        downloaded_files.append(wheel_files[0])
+
+                except subprocess.CalledProcessError as e:
+                    console.print(
+                        f"❌ Failed to download {package_name}: {e.stderr}", style="red"
+                    )
+                    continue
+
+            progress.update(
+                download_task,
+                description="✅ Download complete!",
+                completed=len(package_names),
+            )
+
+        return downloaded_files
+
+    def extract_and_reassemble(
+        self, wheel_files: List[Path], original_filename: str, output_path: Path
+    ):
+        """Extract parts from wheel files and reassemble the original file"""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+            part_files = []
+
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                BarColumn(),
+                TaskProgressColumn(),
+                console=console,
+            ) as progress:
+                extract_task = progress.add_task(
+                    "Extracting packages...", total=len(wheel_files)
+                )
+
+                # Extract each wheel file
+                for i, wheel_file in enumerate(wheel_files):
+                    progress.update(
+                        extract_task,
+                        description=f"📂 Extracting {wheel_file.name}...",
+                        completed=i,
+                    )
+
+                    # Extract wheel file (it's just a zip)
+                    import zipfile
+
+                    with zipfile.ZipFile(wheel_file, "r") as zip_ref:
+                        zip_ref.extractall(temp_path)
+
+                    # Find the part file in the wheel's data directory structure
+                    # Pattern: pkgname.data/data/share/pkgname/pkgname
+                    data_dirs = list(temp_path.glob("*.data/data/share/*/*"))
+                    for part_file in data_dirs:
+                        if part_file.is_file():
+                            part_files.append(part_file)
+
+                progress.update(
+                    extract_task,
+                    description="✅ Extraction complete!",
+                    completed=len(wheel_files),
+                )
+
+            # Sort part files to ensure correct order
+            part_files.sort(key=lambda x: x.name)
+
+            if len(part_files) == 1 and part_files[0].name == original_filename:
+                # Single file, just copy it
+                console.print("📄 Single file detected, copying...")
+                import shutil
+
+                shutil.copy2(part_files[0], output_path)
+            else:
+                # Multiple parts, concatenate them
+                console.print(f"🔗 Reassembling {len(part_files)} parts...")
+
+                with Progress(
+                    SpinnerColumn(),
+                    TextColumn("[progress.description]{task.description}"),
+                    BarColumn(),
+                    TaskProgressColumn(),
+                    console=console,
+                ) as progress:
+                    reassemble_task = progress.add_task(
+                        "Reassembling file...", total=len(part_files)
+                    )
+
+                    with open(output_path, "wb") as output_file:
+                        for i, part_file in enumerate(part_files):
+                            progress.update(
+                                reassemble_task,
+                                description=f"🔗 Assembling part {i + 1}/{len(part_files)}...",
+                                completed=i,
+                            )
+
+                            with open(part_file, "rb") as part:
+                                output_file.write(part.read())
+
+                    progress.update(
+                        reassemble_task,
+                        description="✅ Reassembly complete!",
+                        completed=len(part_files),
+                    )
+
+
+def display_header():
+    """Display the application header"""
+    header = Text("🚀 SIDELOAD", style="bold magenta")
+    subtitle = Text("Download large files via PyPI packages", style="dim")
+
+    panel = Panel(
+        Align.center(f"{header}\n{subtitle}"), border_style="magenta", padding=(1, 2)
+    )
+    console.print(panel)
+
+
+def display_summary(data: Dict):
+    """Display a summary of the completed request"""
+    table = Table(title="📊 Download Summary", style="cyan")
+    table.add_column("Property", style="bold")
+    table.add_column("Value")
+
+    table.add_row("Original Filename", data.get("filename", "Unknown"))
+    table.add_row("File Size", f"{data.get('file_size', 0):,} bytes")
+    table.add_row("Total Packages", str(data.get("total_packages", 0)))
+    table.add_row("Status", f"✅ {data.get('status', 'Unknown')}")
+
+    console.print(table)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Sideload CLI - Download large files via PyPI packages",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  sideload download https://example.com/largefile.zip
+  sideload download https://example.com/file.zip --output ./downloads/
+        """,
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # Download command
+    download_parser = subparsers.add_parser(
+        "download", help="Download a file via sideload"
+    )
+    download_parser.add_argument("url", help="URL of the file to download")
+    download_parser.add_argument(
+        "--output",
+        "-o",
+        type=Path,
+        default=Path.cwd(),
+        help="Output directory (default: current directory)",
+    )
+    download_parser.add_argument("--collection", help="JSONBin collection ID")
+    download_parser.add_argument("--token", help="JSONBin API token")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return
+
+    display_header()
+
+    if args.command == "download":
+        # Get credentials
+        jsonbin_token = args.token or os.environ.get("JSONBIN_TOKEN")
+        collection_id = args.collection or os.environ.get("SIDELOAD_COLLECTION_ID")
+
+        if not jsonbin_token:
+            console.print(
+                "❌ JSONBin token required. Set JSONBIN_TOKEN environment variable or use --token",
+                style="red",
+            )
+            return
+
+        if not collection_id:
+            console.print(
+                "❌ Collection ID required. Set SIDELOAD_COLLECTION_ID environment variable or use --collection",
+                style="red",
+            )
+            return
+
+        # Ensure output directory exists
+        args.output.mkdir(parents=True, exist_ok=True)
+
+        try:
+            with SideloadClient(jsonbin_token, collection_id) as client:
+                # Create the request
+                console.print(
+                    f"🌐 Requesting download for: [bold blue]{args.url}[/bold blue]"
+                )
+                bin_id = client.create_request(args.url)
+
+                # Monitor the request
+                console.print(Rule("📡 Monitoring Progress"))
+                data = client.monitor_request(bin_id)
+
+                if data.get("status") != "UPLOADED":
+                    console.print(
+                        "❌ Request did not complete successfully", style="red"
+                    )
+                    return
+
+                # Display summary
+                display_summary(data)
+
+                # Download packages
+                package_names = data.get("packages_names", [])
+                if not package_names:
+                    console.print("❌ No packages found in the response", style="red")
+                    return
+
+                console.print(Rule("📦 Downloading Packages"))
+
+                with tempfile.TemporaryDirectory() as temp_dir:
+                    temp_path = Path(temp_dir)
+                    wheel_files = client.download_packages(package_names, temp_path)
+
+                    if not wheel_files:
+                        console.print(
+                            "❌ No packages were downloaded successfully", style="red"
+                        )
+                        return
+
+                    # Extract and reassemble
+                    console.print(Rule("🔧 Reassembling File"))
+                    original_filename = data.get("filename", "downloaded_file")
+                    output_file = args.output / original_filename
+
+                    client.extract_and_reassemble(
+                        wheel_files, original_filename, output_file
+                    )
+
+                    # Success!
+                    console.print(Rule("✨ Complete"))
+                    console.print(
+                        f"🎉 File successfully downloaded to: [bold green]{output_file}[/bold green]"
+                    )
+                    console.print(
+                        f"📊 File size: [cyan]{output_file.stat().st_size:,} bytes[/cyan]"
+                    )
+
+        except KeyboardInterrupt:
+            console.print("\n⚠️  Download interrupted by user", style="yellow")
+        except Exception as e:
+            console.print(f"❌ Error: {e}", style="bold red")
+            raise
+
+
+if __name__ == "__main__":
+    main()

sideload/jsonbin_connector.py

@@ -0,0 +1,49 @@
+import os
+import httpx
+
+JSONBIN_TOKEN = os.environ["JSONBIN_TOKEN"]
+
+
+class JSONBinConnector:
+    def __init__(self):
+        self.client = httpx.Client(
+            base_url="https://api.jsonbin.io/v3",
+            headers={"X-Master-Key": JSONBIN_TOKEN, "Content-Type": "application/json"},
+        )
+
+    def get_collections(self) -> list:
+        response = self.client.get("/c")
+        response.raise_for_status()
+        return response.json()
+
+    def get_collection_bins(
+        self, collection_id: str, last_bin_id: str | None = None
+    ) -> list:
+        url = f"/c/{collection_id}/bins"
+        if last_bin_id:
+            url = f"{url}/{last_bin_id}"
+        response = self.client.get(
+            url,
+            headers={"X-Sort-Order": "ascending"},
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def create_bin(self, collection_id: str, bin_name: str, data: dict) -> str:
+        headers = {"X-Collection-Id": collection_id, "X-Bin-Name": bin_name}
+        response = self.client.post("/b", json=data, headers=headers)
+        response.raise_for_status()
+        return response.json()["metadata"]["id"]
+
+    def get_bin(self, bin_id: str) -> dict:
+        response = self.client.get(f"/b/{bin_id}", headers={"X-Bin-Name": bin_id})
+        response.raise_for_status()
+        return response.json()["record"]
+
+    def update_bin(self, bin_id: str, data: dict) -> None:
+        existing_data = self.get_bin(bin_id)
+        updated_data = {**existing_data, **data}
+        response = self.client.put(
+            f"/b/{bin_id}", json=updated_data, headers={"X-Bin-Name": bin_id}
+        )
+        response.raise_for_status()

sideload/jsonbin_old.py

@@ -0,0 +1,302 @@
+"""
+JSONBin API Connector
+A reusable connector for interacting with JSONBin.io API
+"""
+
+import time
+import httpx
+from typing import Dict, List, Optional, Any
+
+
+class JSONBinConnector:
+    """A connector for JSONBin.io API with httpx"""
+
+    def __init__(self, api_token: str, base_url: str = "https://api.jsonbin.io/v3"):
+        """
+        Initialize the JSONBin connector
+
+        Args:
+            api_token: JSONBin API token
+            base_url: JSONBin API base URL
+        """
+        self.api_token = api_token
+        self.base_url = base_url
+        self.client = httpx.Client(
+            base_url=base_url,
+            headers={"X-Master-Key": api_token, "Content-Type": "application/json"},
+        )
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.client.close()
+
+    def create_bin(
+        self, data: Dict[str, Any], collection_id: Optional[str] = None
+    ) -> str:
+        """
+        Create a new bin
+
+        Args:
+            data: The data to store in the bin
+            collection_id: Optional collection ID to add the bin to
+
+        Returns:
+            The created bin ID
+        """
+        headers = {}
+        if collection_id:
+            headers["X-Collection-Id"] = collection_id
+
+        response = self.client.post("/b", json=data, headers=headers)
+        response.raise_for_status()
+        return response.json()["metadata"]["id"]
+
+    def get_bin(self, bin_id: str) -> Dict[str, Any]:
+        """
+        Get bin data by ID
+
+        Args:
+            bin_id: The bin ID to retrieve
+
+        Returns:
+            The bin data
+        """
+        response = self.client.get(f"/b/{bin_id}", headers={"X-Bin-Name": bin_id})
+        response.raise_for_status()
+        return response.json()["record"]
+
+    def update_bin(self, bin_id: str, **data: Any) -> None:
+        """
+        Update bin data
+
+        Args:
+            bin_id: The bin ID to update
+            **data: Key-value pairs to update in the bin
+        """
+        # Get existing data first
+        existing_data = self.get_bin(bin_id)
+
+        # Merge with new data
+        updated_data = {**existing_data, **data}
+
+        # Update the bin
+        response = self.client.put(
+            f"/b/{bin_id}", json=updated_data, headers={"X-Bin-Name": bin_id}
+        )
+        response.raise_for_status()
+
+    def delete_bin(self, bin_id: str) -> None:
+        """
+        Delete a bin
+
+        Args:
+            bin_id: The bin ID to delete
+        """
+        response = self.client.delete(f"/b/{bin_id}", headers={"X-Bin-Name": bin_id})
+        response.raise_for_status()
+
+    def get_collections(self) -> List[Dict[str, Any]]:
+        """
+        Get all collections
+
+        Returns:
+            List of collections
+        """
+        response = self.client.get("/c")
+        response.raise_for_status()
+        return response.json()
+
+    def create_collection(self, name: str) -> str:
+        """
+        Create a new collection
+
+        Args:
+            name: The collection name
+
+        Returns:
+            The created collection ID
+        """
+        response = self.client.post("/c", json={"name": name})
+        response.raise_for_status()
+        return response.json()["metadata"]["id"]
+
+    def get_collection_bins(
+        self, collection_id: str, after_bin_id: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Get bins from a collection
+
+        Args:
+            collection_id: The collection ID
+            after_bin_id: Optional bin ID to get bins after (for pagination)
+
+        Returns:
+            List of bins in the collection
+        """
+        endpoint = f"/c/{collection_id}/bins"
+        if after_bin_id:
+            endpoint += f"/{after_bin_id}"
+
+        response = self.client.get(
+            endpoint,
+            headers={"X-Collection-Id": collection_id, "X-Sort-Order": "ascending"},
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def close(self):
+        """Close the HTTP client"""
+        self.client.close()
+
+
+class SideloadBinManager:
+    """High-level manager for Sideload-specific JSONBin operations"""
+
+    def __init__(self, connector: JSONBinConnector):
+        """
+        Initialize the sideload bin manager
+
+        Args:
+            connector: JSONBin connector instance
+        """
+        self.connector = connector
+
+    def create_sideload_request(
+        self, url: str, collection_id: Optional[str] = None
+    ) -> str:
+        """
+        Create a new sideload request
+
+        Args:
+            url: The URL to sideload
+            collection_id: Optional collection ID
+
+        Returns:
+            The created bin ID
+        """
+        data = {"url": url, "status": "CREATED", "created_at": time.time()}
+        return self.connector.create_bin(data, collection_id)
+
+    def update_sideload_status(
+        self, bin_id: str, status: str, **additional_data: Any
+    ) -> None:
+        """
+        Update sideload request status
+
+        Args:
+            bin_id: The bin ID to update
+            status: The new status
+            **additional_data: Additional data to update
+        """
+        self.connector.update_bin(bin_id, status=status, **additional_data)
+
+    def update_progress(self, bin_id: str, progress: int) -> None:
+        """
+        Update download progress
+
+        Args:
+            bin_id: The bin ID to update
+            progress: Progress percentage (0-100)
+        """
+        self.connector.update_bin(bin_id, progress=progress)
+
+    def mark_completed(
+        self,
+        bin_id: str,
+        package_names: List[str],
+        original_filename: str,
+        file_size: int,
+    ) -> None:
+        """
+        Mark sideload request as completed
+
+        Args:
+            bin_id: The bin ID to update
+            package_names: List of created package names
+            original_filename: Original filename
+            file_size: Original file size
+        """
+        self.connector.update_bin(
+            bin_id,
+            status="UPLOADED",
+            package_names=package_names,
+            total_packages=len(package_names),
+            original_filename=original_filename,
+            file_size=file_size,
+        )
+
+    def mark_failed(self, bin_id: str, reason: str) -> None:
+        """
+        Mark sideload request as failed
+
+        Args:
+            bin_id: The bin ID to update
+            reason: Failure reason
+        """
+        self.connector.update_bin(bin_id, status="FAILED", reason=reason)
+
+    def mark_rejected(self, bin_id: str, reason: str) -> None:
+        """
+        Mark sideload request as rejected
+
+        Args:
+            bin_id: The bin ID to update
+            reason: Rejection reason
+        """
+        self.connector.update_bin(bin_id, status="REJECTED", reason=reason)
+
+    def get_sideload_data(self, bin_id: str) -> Dict[str, Any]:
+        """
+        Get sideload request data
+
+        Args:
+            bin_id: The bin ID to retrieve
+
+        Returns:
+            The sideload data
+        """
+        return self.connector.get_bin(bin_id)
+
+    def find_sideload_collections(self) -> List[Dict[str, Any]]:
+        """
+        Find collections that start with 'sideload_'
+
+        Returns:
+            List of sideload collections
+        """
+        collections = self.connector.get_collections()
+        return [
+            collection
+            for collection in collections
+            if collection["collectionMeta"]["name"].startswith("sideload_")
+        ]
+
+    def get_pending_requests(
+        self, collection_id: str, after_bin_id: Optional[str] = None
+    ) -> List[str]:
+        """
+        Get pending sideload requests from a collection
+
+        Args:
+            collection_id: The collection ID to check
+            after_bin_id: Optional bin ID for pagination
+
+        Returns:
+            List of bin IDs that need processing
+        """
+        bins = self.connector.get_collection_bins(collection_id, after_bin_id)
+        pending_bins = []
+
+        for bin_data in bins:
+            bin_id = bin_data["record"]
+            try:
+                data = self.get_sideload_data(bin_id)
+                if data.get("status") == "CREATED":
+                    pending_bins.append(bin_id)
+            except Exception:
+                # Skip bins that can't be read
+                continue
+
+        return pending_bins

sideload/main.py

@@ -0,0 +1,237 @@
+import os
+from pathlib import Path
+import subprocess
+import tempfile
+import threading
+import time
+
+import requests
+
+from sideload.jsonbin_connector import JSONBinConnector
+
+JSONBIN_TOKEN = os.environ["JSONBIN_TOKEN"]
+PYPI_TOKEN = os.environ["PYPI_TOKEN"]
+MAX_PACKAGE_SIZE = 95 * 1024 * 1024  # 95 MB
+
+LAST_BINS: dict[str, str | None] = {}
+
+PYPROJECT_TEMPLATE = """
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "{package_name}"
+version = "1.0.0"
+description = "Sideloaded package"
+requires-python = ">=3.8"
+authors = [
+  {{name = "Null Void" }}
+]
+
+[tool.setuptools.data-files]
+"share/{package_name}" = ["{package_name}"]
+"""
+
+jsonbin_connector = JSONBinConnector()
+
+
+def package_build(directory: Path) -> bool:
+    result = subprocess.run(
+        ["python3", "-m", "build", "--wheel"], cwd=str(directory), check=True
+    )
+    return result.returncode == 0
+
+
+def twine_upload(directory: Path):
+    result = subprocess.run(
+        [
+            "twine",
+            "upload",
+            "dist/*",
+            "-u",
+            "__token__",
+            "-p",
+            PYPI_TOKEN,
+        ],
+        cwd=str(directory),
+        check=True,
+    )
+    return result.returncode == 0
+
+
+def download_file(bin_id: str, url: str):
+    try:
+        # Send a HTTP request to the server.
+        response = requests.get(url, stream=True)
+    except Exception as e:
+        jsonbin_connector.update_bin(
+            bin_id,
+            {
+                "status": "REJECTED",
+                "details": f"Failed to download file: [{e.__class__.__name__}]: {e}",
+            },
+        )
+        return
+    if not response.ok:
+        jsonbin_connector.update_bin(
+            bin_id,
+            {
+                "status": "REJECTED",
+                "details": f"URL returned code {response.status_code}: {response.reason}",
+            },
+        )
+        return
+    # Total size in bytes.
+    total_size = int(response.headers.get("content-length", 1))
+    try:
+        filename = response.headers["Content-Disposition"].split("; filename=")[1]
+    except Exception:
+        filename = response.url.removesuffix("/").split("/")[-1]
+
+    # Initialize variables to track progress.
+    downloaded = 0
+    chunk_size = 1024 * 1000  # Size of each chunk in bytes.
+    last_progress = 0
+    filename_root = filename.split(".")[0]
+    package_name = f"sideload_{filename_root}_bin_{bin_id}"
+    # replace all non-alphanumeric characters with an underscore
+    package_name = "".join(c if c.isalnum() else "_" for c in package_name)
+    parts: list[Path] = []
+
+    def make_part_name():
+        return f"{package_name}_p{len(parts)}"
+
+    def make_new_part():
+        part_name = make_part_name()
+        part_directory = Path(temp_dir) / package_name / part_name
+        part_directory.mkdir(parents=True, exist_ok=False)
+        part_path = part_directory / part_name
+        parts.append(part_path)
+        return open(part_path, "wb")
+
+    # Open a local file for writing in binary mode.
+    with tempfile.TemporaryDirectory() as temp_dir:
+        # temp_dir = "./dumptmp3"  # only for debugging
+        os.mkdir(os.path.join(temp_dir, package_name))
+        jsonbin_connector.update_bin(
+            bin_id,
+            {"status": "DOWNLOADING", "progress": 0},
+        )
+        current_part_fp = make_new_part()
+        try:
+            current_chunk_size = 0
+            for data in response.iter_content(chunk_size=chunk_size):
+                current_part_fp.write(data)
+                downloaded += len(data)
+                current_chunk_size += len(data)
+                if current_chunk_size >= MAX_PACKAGE_SIZE:
+                    current_part_fp.close()
+                    current_part_fp = make_new_part()
+                    current_chunk_size = 0
+                if total_size < downloaded:
+                    total_size = downloaded
+                    progress = 99
+                else:
+                    progress = int((downloaded / total_size) * 100)
+                if progress != last_progress:
+                    jsonbin_connector.update_bin(bin_id, {"progress": progress})
+                    last_progress = progress
+        finally:
+            current_part_fp.close()
+        jsonbin_connector.update_bin(bin_id, {"progress": 100, "status": "DOWNLOADED"})
+        for part_idx, path_part in enumerate(parts):
+            with open(
+                path_part.parent / "pyproject.toml",
+                "w",
+                encoding="utf-8",
+            ) as pyproject_file:
+                pyproject_file.write(
+                    PYPROJECT_TEMPLATE.format(package_name=path_part.name)
+                )
+
+            jsonbin_connector.update_bin(
+                bin_id,
+                {
+                    "status": "BUILDING",
+                    "details": f"Building package part {part_idx}/{len(parts)}.",
+                },
+            )
+            if not package_build(path_part.parent):
+                jsonbin_connector.update_bin(
+                    bin_id,
+                    {
+                        "status": "BULDING",
+                        "details": f"Failed to build package part {part_idx}/{len(parts)}.",
+                    },
+                )
+                return
+            jsonbin_connector.update_bin(
+                bin_id,
+                {
+                    "status": "UPLOADING",
+                    "details": f"Uploading package part {part_idx}/{len(parts)}.",
+                },
+            )
+            if not twine_upload(path_part.parent):
+                jsonbin_connector.update_bin(
+                    bin_id,
+                    {
+                        "status": "FAILED",
+                        "details": f"Failed to upload package part {part_idx}/{len(parts)}.",
+                    },
+                )
+                return
+        jsonbin_connector.update_bin(
+            bin_id,
+            {
+                "status": "UPLOADED",
+                "packages_names": [path_part.name for path_part in parts],
+                "filename": filename,
+                "file_size": total_size,
+                "total_packages": len(parts),
+            },
+        )
+
+
+def process_bin(bin_id: str):
+    url = f"https://api.jsonbin.io/v3/b/{bin_id}"
+    bin_data = requests.get(url, headers={"X-Master-Key": JSONBIN_TOKEN}).json()
+    bin_record = bin_data["record"]
+    if bin_record["status"] == "CREATED":
+        print("Processing bin:", bin_id)
+        download_file(bin_id, bin_record["url"])
+    elif bin_record["status"] != "UPLOADED":
+        jsonbin_connector.update_bin(
+            bin_id, {"status": "FAILED", "details": "Server interruption"}
+        )
+    else:
+        print("Bin already processed:", bin_id)
+
+
+def watch_collection(collection_id: str):
+    print("Watching collection:", collection_id)
+    while True:
+        collection_data = jsonbin_connector.get_collection_bins(
+            collection_id, LAST_BINS.get(collection_id)
+        )
+        last_bin: str | None = None
+        for bin_data in collection_data:
+            bin_id = bin_data["record"]
+            process_bin(bin_id)
+            last_bin = bin_id
+        if last_bin is not None:
+            LAST_BINS[collection_id] = last_bin
+        time.sleep(3)
+
+
+def main():
+    collections = jsonbin_connector.get_collections()
+    for collection in collections:
+        if collection["collectionMeta"]["name"].startswith("sideload_"):
+            threading.Thread(
+                target=watch_collection, args=(collection["record"],)
+            ).start()
+
+
+main()

sideload-0.1.0.dist-info/METADATA

@@ -0,0 +1,138 @@
+Metadata-Version: 2.3
+Name: sideload
+Version: 0.1.0
+Summary: Download large files via PyPI packages
+Author: Sygmei
+Author-email: Sygmei <3835355+Sygmei@users.noreply.github.com>
+Requires-Dist: build>=1.3.0
+Requires-Dist: twine>=6.2.0
+Requires-Dist: wheel>=0.45.1
+Requires-Dist: rich>=13.0.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pip>=25.2
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# 🚀 Sideload
+
+Download large files via PyPI packages! Sideload automatically splits large files into PyPI-compliant chunks and allows you to download them through a beautiful CLI interface.
+
+## Features
+
+- ✨ **Beautiful CLI** powered by Rich with progress bars and status updates
+- 📦 **Automatic file splitting** into 99MB PyPI-compliant chunks
+- 🔄 **Automatic reassembly** of downloaded parts
+- 🌐 **JSONBin integration** for request tracking
+- 🛡️ **Error handling** with detailed progress monitoring
+
+## Installation
+
+```bash
+git clone <repository-url>
+cd Sideload
+uv install
+```
+
+## Usage
+
+### Environment Variables
+
+Set up your credentials:
+
+```bash
+export JSONBIN_TOKEN="your_jsonbin_token"
+export SIDELOAD_COLLECTION_ID="your_collection_id"
+```
+
+### Download a File
+
+```bash
+# Basic usage
+uv run sideload download https://example.com/largefile.zip
+
+# Specify output directory
+uv run sideload download https://example.com/largefile.zip --output ./downloads/
+
+# Override credentials
+uv run sideload download https://example.com/largefile.zip --token YOUR_TOKEN --collection YOUR_COLLECTION
+```
+
+### How it Works
+
+1. **Submit Request**: The CLI creates a new request in your JSONBin collection
+2. **Monitor Progress**: Real-time progress monitoring with beautiful progress bars
+3. **Download Packages**: Automatically downloads all PyPI packages containing file parts
+4. **Reassemble**: Extracts and concatenates parts to rebuild the original file
+
+### CLI Interface
+
+The CLI provides:
+
+- 🌈 **Colorful output** with status indicators
+- 📊 **Progress bars** for downloads and processing
+- 📈 **Real-time monitoring** of server-side processing
+- ✅ **Success/error reporting** with detailed information
+- 📋 **Summary tables** showing download statistics
+
+### Example Output
+
+```
+🚀 SIDELOAD
+Download large files via PyPI packages
+
+🌐 Requesting download for: https://example.com/largefile.zip
+✅ Created sideload request: abc123def456
+
+📡 Monitoring Progress
+📥 Downloading... (45%) ████████████████▌                 
+🔨 Building packages...
+📤 Uploading part 1/3...
+
+📊 Download Summary
+┏━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+┃ Property          ┃ Value                           ┃
+┡━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
+│ Original Filename │ largefile.zip                   │
+│ File Size         │ 250,123,456 bytes               │
+│ Total Packages    │ 3                               │
+│ Status            │ ✅ UPLOADED                     │
+└───────────────────┴─────────────────────────────────┘
+
+📦 Downloading Packages
+📦 Downloading package 1/3... ████████████████████████████
+
+🔧 Reassembling File
+🔗 Assembling part 1/3... ████████████████████████████
+
+✨ Complete
+🎉 File successfully downloaded to: largefile.zip
+📊 File size: 250,123,456 bytes
+```
+
+## Development
+
+### Server Setup
+
+The server component handles file processing and PyPI uploads:
+
+```bash
+# Set environment variables
+export JSONBIN_TOKEN="your_token"
+export PYPI_TOKEN="your_pypi_token"
+
+# Run the server
+uv run python src/sideload/main.py
+```
+
+### Project Structure
+
+```
+src/sideload/
+├── __init__.py     # Package initialization
+├── main.py         # Server component
+└── cli.py          # CLI client
+```
+
+## License
+
+[Your License Here]

sideload-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+sideload/__init__.py,sha256=Y3rHLtR7n0sjLXrn-BEcrbIHx-9uE1tPZkooavo7xcA,222
+sideload/cli.py,sha256=2UQ_DgvB7S0MXmBhXwjx2T78-ZZzCUO4hN2YfCJ2hf8,15061
+sideload/jsonbin.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sideload/jsonbin_connector.py,sha256=HtR1Pwnpm5jfYcmnvcug9HaKxFpsyJBXYYlLuzWPiTE,1680
+sideload/jsonbin_old.py,sha256=ve21WsV7Ay60moFfrR4lSM_JRZNqo4z5v69cNw0Iqo0,8411
+sideload/main.py,sha256=5iAQQlHeCdCHxOWE9OPKHF9TNs0k45n9rnUbruleT8w,7589
+sideload-0.1.0.dist-info/WHEEL,sha256=-neZj6nU9KAMg2CnCY6T3w8J53nx1kFGw_9HfoSzM60,79
+sideload-0.1.0.dist-info/entry_points.txt,sha256=7ULrIjaVhrxMhuddTeoPjeIrqmIvVc9cSU3lZU2_YqE,44
+sideload-0.1.0.dist-info/METADATA,sha256=Ouf83o2V29NcOs2pEPWVxmhgzUBP1D-SvgDt69-jZlY,4247
+sideload-0.1.0.dist-info/RECORD,,

sideload-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.8.22
+Root-Is-Purelib: true
+Tag: py3-none-any

sideload-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+sideload = sideload:main
+