tempspace-cli 1.1.1__tar.gz

tempspace_cli-1.1.1/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: tempspace-cli
+Version: 1.1.1
+Summary: A command-line tool for uploading files to Tempspace.
+Author-email: Tempspace <mcbplay1@gmail.com>
+License: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests==2.31.0
+Requires-Dist: tqdm==4.66.1
+Requires-Dist: requests-toolbelt==1.0.0
+Requires-Dist: rich==13.7.1
+Requires-Dist: qrcode==8.2
+
+# 🚀 Tempspace
+
+Tempspace is a terminal-style file sharing service that allows you to upload files and share them via a link, with features like password protection, one-time downloads, and automatic expiration.
+
+![Screenshot](https://i.imgur.com/your-screenshot.png)
+
+## ✨ Features
+
+- **Multiple Upload Methods:** Use the web interface, cURL, or the official CLI tool.
+- **Security:** Optional password protection, one-time downloads, and rate limiting.
+- **Modern UI:** A terminal-inspired design with QR code generation and upload history.
+- **File Management:** Support for large files, multiple expiry options, and automatic cleanup.
+
+## 🚀 Getting Started
+
+### Method 1: Using the Web Interface
+
+The easiest way to use Tempspace is through the web interface.
+
+1.  **Open** the service URL (e.g., `http://localhost:8000`) in your browser.
+2.  **Drag and drop** a file or click to browse.
+3.  **Configure** the expiry time and an optional password.
+4.  **Upload** and share the generated link.
+
+### Method 2: Using cURL
+
+You can use `cURL` to upload files directly from your terminal.
+
+```bash
+# Basic upload
+curl -F "file=@/path/to/file.txt" -F "hours=6" https://tempspace.fly.dev/upload
+
+# With a password
+curl -F "file=@/path/to/secret.txt" -F "password=secret123" https://tempspace.fly.dev/upload
+```
+
+### Method 3: Using the Official CLI Tool
+
+For a more integrated terminal experience, you can install the official CLI tool from PyPI.
+
+#### Installation
+```bash
+pip install tempspace-cli
+```
+
+#### Usage
+```bash
+# Basic upload
+tempspace /path/to/document.pdf -t 6h
+
+# With a password
+tempspace /path/to/secret.txt -p "mypassword"
+
+# Point to a self-hosted server
+tempspace /path/to/file.txt --url http://localhost:8000
+```
+
+## 🔧 Self-Hosting
+
+You can run your own instance of Tempspace.
+
+### Installation
+```bash
+# Clone the repository
+git clone https://github.com/your-repo/tempspace.git
+cd tempspace
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Configure
+cp .env.example .env
+nano .env  # Change the admin password
+```
+
+### Running the Server
+```bash
+python main.py
+```
+
+The server will be available at `http://localhost:8000`.
+
+## 🛡️ Admin & Configuration
+
+For advanced configuration, such as setting up a reverse proxy, managing admin endpoints, and more, please refer to the project's documentation or open an issue.
+
+## 🤝 Contributing
+
+Contributions are welcome! Please fork the repository and submit a pull request.
+
+## 📝 License
+
+This project is licensed under the MIT License.

tempspace_cli-1.1.1/README.md

@@ -0,0 +1,93 @@
+# 🚀 Tempspace
+
+Tempspace is a terminal-style file sharing service that allows you to upload files and share them via a link, with features like password protection, one-time downloads, and automatic expiration.
+
+![Screenshot](https://i.imgur.com/your-screenshot.png)
+
+## ✨ Features
+
+- **Multiple Upload Methods:** Use the web interface, cURL, or the official CLI tool.
+- **Security:** Optional password protection, one-time downloads, and rate limiting.
+- **Modern UI:** A terminal-inspired design with QR code generation and upload history.
+- **File Management:** Support for large files, multiple expiry options, and automatic cleanup.
+
+## 🚀 Getting Started
+
+### Method 1: Using the Web Interface
+
+The easiest way to use Tempspace is through the web interface.
+
+1.  **Open** the service URL (e.g., `http://localhost:8000`) in your browser.
+2.  **Drag and drop** a file or click to browse.
+3.  **Configure** the expiry time and an optional password.
+4.  **Upload** and share the generated link.
+
+### Method 2: Using cURL
+
+You can use `cURL` to upload files directly from your terminal.
+
+```bash
+# Basic upload
+curl -F "file=@/path/to/file.txt" -F "hours=6" https://tempspace.fly.dev/upload
+
+# With a password
+curl -F "file=@/path/to/secret.txt" -F "password=secret123" https://tempspace.fly.dev/upload
+```
+
+### Method 3: Using the Official CLI Tool
+
+For a more integrated terminal experience, you can install the official CLI tool from PyPI.
+
+#### Installation
+```bash
+pip install tempspace-cli
+```
+
+#### Usage
+```bash
+# Basic upload
+tempspace /path/to/document.pdf -t 6h
+
+# With a password
+tempspace /path/to/secret.txt -p "mypassword"
+
+# Point to a self-hosted server
+tempspace /path/to/file.txt --url http://localhost:8000
+```
+
+## 🔧 Self-Hosting
+
+You can run your own instance of Tempspace.
+
+### Installation
+```bash
+# Clone the repository
+git clone https://github.com/your-repo/tempspace.git
+cd tempspace
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Configure
+cp .env.example .env
+nano .env  # Change the admin password
+```
+
+### Running the Server
+```bash
+python main.py
+```
+
+The server will be available at `http://localhost:8000`.
+
+## 🛡️ Admin & Configuration
+
+For advanced configuration, such as setting up a reverse proxy, managing admin endpoints, and more, please refer to the project's documentation or open an issue.
+
+## 🤝 Contributing
+
+Contributions are welcome! Please fork the repository and submit a pull request.
+
+## 📝 License
+
+This project is licensed under the MIT License.

tempspace_cli-1.1.1/cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

tempspace_cli-1.1.1/cli/tempspace.py

@@ -0,0 +1,186 @@
+import argparse
+import requests
+import os
+import sys
+import hashlib
+import multiprocessing
+from tqdm import tqdm
+from requests_toolbelt.multipart.encoder import MultipartEncoder, MultipartEncoderMonitor
+import math
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich import box
+import qrcode
+from rich.prompt import Prompt, Confirm
+
+# Default configuration
+DEFAULT_SERVER_URL = "https://tempspace.fly.dev/"
+CHUNK_SIZE = 1024 * 1024  # 1MB
+
+def parse_time(time_str: str) -> int:
+    """
+    Parse a time string (e.g., '7d', '24h', '360') into an integer number of hours.
+    Returns the number of hours as an integer, or None if parsing fails.
+    """
+    time_str = time_str.lower().strip()
+    if time_str.endswith('d'):
+        try:
+            days = int(time_str[:-1])
+            return days * 24
+        except ValueError:
+            return None
+    elif time_str.endswith('h'):
+        try:
+            return int(time_str[:-1])
+        except ValueError:
+            return None
+    else:
+        try:
+            return int(time_str)
+        except ValueError:
+            return None
+
+def calculate_file_hash(filepath: str) -> str:
+    """Calculate the SHA256 hash of a file in chunks."""
+    sha256_hash = hashlib.sha256()
+    try:
+        with open(filepath, "rb") as f:
+            for byte_block in iter(lambda: f.read(CHUNK_SIZE), b""):
+                sha256_hash.update(byte_block)
+        return sha256_hash.hexdigest()
+    except IOError as e:
+        print(f"Error reading file for hashing: {e}", file=sys.stderr)
+        sys.exit(1)
+
+def format_size(size_bytes: int) -> str:
+    """Converts a size in bytes to a human-readable format."""
+    if size_bytes == 0:
+        return "0B"
+    size_name = ("B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
+    i = int(math.floor(math.log(size_bytes, 1024)))
+    p = math.pow(1024, i)
+    s = round(size_bytes / p, 2)
+    return f"{s} {size_name[i]}"
+
+def main():
+    """Main function to handle argument parsing and file upload."""
+    console = Console()
+
+    # --- Header ---
+    console.print(Panel("[bold cyan]Tempspace File Uploader[/bold cyan]", expand=False, border_style="blue"))
+
+
+    parser = argparse.ArgumentParser(
+        description="Upload a file to Tempspace.",
+        formatter_class=argparse.RawTextHelpFormatter
+    )
+
+    parser.add_argument("filepath", nargs='?', default=None, help="The path to the file you want to upload.")
+    parser.add_argument("-t", "--time", type=str, default='24', help="Set the file's expiration time. Examples: '24h', '7d', '360' (hours).\nDefault: '24' (24 hours).")
+    parser.add_argument("-p", "--password", type=str, help="Protect the file with a password.")
+    parser.add_argument("--one-time", action="store_true", help="The file will be deleted after the first download.")
+    parser.add_argument("--url", type=str, default=os.environ.get("TEMPSPACE_URL", DEFAULT_SERVER_URL), help=f"The URL of the Tempspace server.\nCan also be set with the TEMPSPACE_URL environment variable.\nDefault: {DEFAULT_SERVER_URL}")
+    parser.add_argument("--qr", action="store_true", help="Display a QR code of the download link.")
+    parser.add_argument("--it", action="store_true", help="Enable interactive mode.")
+
+    args = parser.parse_args()
+
+    # --- Interactive Mode ---
+    if args.it:
+        args.filepath = Prompt.ask("Enter the path to the file you want to upload")
+        args.time = Prompt.ask("Set the file's expiration time (e.g., '24h', '7d')", default='24')
+        args.password = Prompt.ask("Protect the file with a password?", default=None, password=True)
+        args.one_time = Confirm.ask("Delete the file after the first download?", default=False)
+        args.qr = Confirm.ask("Display a QR code of the download link?", default=False)
+
+
+    # --- Validate Inputs ---
+    if not args.filepath or not os.path.isfile(args.filepath):
+        console.print(Panel(f"[bold red]Error:[/] File not found at '{args.filepath}'", title="[bold red]Error[/bold red]", border_style="red"))
+        sys.exit(1)
+
+    hours = parse_time(args.time)
+    if hours is None:
+        console.print(Panel(f"[bold red]Error:[/] Invalid time format '{args.time}'. Use formats like '24h', '7d', or '360'.", title="[bold red]Error[/bold red]", border_style="red"))
+        sys.exit(1)
+
+    # --- Display File Details ---
+    table = Table(title="File Details", show_header=False, box=box.ROUNDED, border_style="cyan")
+    table.add_column("Field", style="bold")
+    table.add_column("Value")
+    table.add_row("File Name", os.path.basename(args.filepath))
+    table.add_row("File Size", format_size(os.path.getsize(args.filepath)))
+    table.add_row("Expiration", f"{hours} hours")
+    table.add_row("Password", "[green]Yes[/green]" if args.password else "[red]No[/red]")
+    table.add_row("One-Time Download", "[green]Yes[/green]" if args.one_time else "[red]No[/red]")
+    console.print(table)
+
+
+    # --- Hashing ---
+    console.print("[cyan]Calculating file hash...[/]")
+    client_hash = calculate_file_hash(args.filepath)
+    console.print(f"  [cyan]- Hash:[/] {client_hash}")
+
+    # --- Prepare Upload ---
+    upload_url = f"{args.url.rstrip('/')}/upload"
+    filename = os.path.basename(args.filepath)
+    file_size = os.path.getsize(args.filepath)
+
+    fields = {
+        'hours': str(hours),
+        'one_time': str(args.one_time).lower(),
+        'client_hash': client_hash,
+        'file': (filename, open(args.filepath, 'rb'), 'application/octet-stream')
+    }
+    if args.password:
+        fields['password'] = args.password
+
+    encoder = MultipartEncoder(fields=fields)
+    response = None
+
+    try:
+        bar_format = "{desc}: {percentage:3.0f}%|{bar}| {n_fmt}/{total_fmt} [Speed: {rate_fmt}, ETA: {remaining}]"
+        with tqdm(total=encoder.len, unit='B', unit_scale=True, desc=f"Uploading {filename}", bar_format=bar_format) as pbar:
+            monitor = MultipartEncoderMonitor(encoder, lambda m: pbar.update(m.bytes_read - pbar.n))
+            response = requests.post(upload_url, data=monitor, headers={'Content-Type': monitor.content_type})
+
+    except FileNotFoundError:
+        console.print(Panel(f"[bold red]Error:[/] The file '{args.filepath}' was not found.", title="[bold red]Error[/bold red]", border_style="red"))
+        sys.exit(1)
+    except requests.exceptions.RequestException as e:
+        console.print(Panel(f"[bold red]An error occurred while connecting to the server:[/]\n{e}", title="[bold red]Error[/bold red]", border_style="red"))
+        sys.exit(1)
+    except Exception as e:
+        console.print(Panel(f"[bold red]An unexpected error occurred:[/] {e}", title="[bold red]Error[/bold red]", border_style="red"))
+        sys.exit(1)
+    finally:
+        # Ensure the file handle is closed
+        if 'file' in fields and not fields['file'][1].closed:
+            fields['file'][1].close()
+
+    # --- Handle Response ---
+    if response is not None:
+        if response.status_code == 200:
+            download_link = response.text.strip()
+            success_panel = Panel(f"[bold green]Upload successful![/bold green]\n\nDownload Link: {download_link}",
+                                  title="[bold cyan]Success[/bold cyan]", border_style="green")
+            console.print(success_panel)
+
+            if args.qr:
+                qr = qrcode.QRCode()
+                qr.add_data(download_link)
+                qr.make(fit=True)
+                qr.print_ascii()
+        else:
+            try:
+                error_details = response.json()
+                error_message = error_details.get('detail', 'No details provided.')
+            except requests.exceptions.JSONDecodeError:
+                error_message = response.text
+            console.print(Panel(f"[bold red]Error:[/] Upload failed with status code {response.status_code}\n[red]Server message:[/] {error_message}", title="[bold red]Error[/bold red]", border_style="red"))
+            sys.exit(1)
+
+if __name__ == "__main__":
+    multiprocessing.freeze_support()
+    main()

tempspace_cli-1.1.1/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["cli"]
+
+[project]
+name = "tempspace-cli"
+version = "1.1.1"
+authors = [
+    { name="Tempspace", email="mcbplay1@gmail.com" },
+]
+description = "A command-line tool for uploading files to Tempspace."
+readme = "README.md"
+license = { text = "MIT License" }
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "requests==2.31.0",
+    "tqdm==4.66.1",
+    "requests-toolbelt==1.0.0",
+    "rich==13.7.1",
+    "qrcode==8.2",
+]
+
+[project.scripts]
+tempspace = "cli.tempspace:main"

tempspace_cli-1.1.1/setup.cfg

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

tempspace_cli-1.1.1/tempspace_cli.egg-info/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: tempspace-cli
+Version: 1.1.1
+Summary: A command-line tool for uploading files to Tempspace.
+Author-email: Tempspace <mcbplay1@gmail.com>
+License: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests==2.31.0
+Requires-Dist: tqdm==4.66.1
+Requires-Dist: requests-toolbelt==1.0.0
+Requires-Dist: rich==13.7.1
+Requires-Dist: qrcode==8.2
+
+# 🚀 Tempspace
+
+Tempspace is a terminal-style file sharing service that allows you to upload files and share them via a link, with features like password protection, one-time downloads, and automatic expiration.
+
+![Screenshot](https://i.imgur.com/your-screenshot.png)
+
+## ✨ Features
+
+- **Multiple Upload Methods:** Use the web interface, cURL, or the official CLI tool.
+- **Security:** Optional password protection, one-time downloads, and rate limiting.
+- **Modern UI:** A terminal-inspired design with QR code generation and upload history.
+- **File Management:** Support for large files, multiple expiry options, and automatic cleanup.
+
+## 🚀 Getting Started
+
+### Method 1: Using the Web Interface
+
+The easiest way to use Tempspace is through the web interface.
+
+1.  **Open** the service URL (e.g., `http://localhost:8000`) in your browser.
+2.  **Drag and drop** a file or click to browse.
+3.  **Configure** the expiry time and an optional password.
+4.  **Upload** and share the generated link.
+
+### Method 2: Using cURL
+
+You can use `cURL` to upload files directly from your terminal.
+
+```bash
+# Basic upload
+curl -F "file=@/path/to/file.txt" -F "hours=6" https://tempspace.fly.dev/upload
+
+# With a password
+curl -F "file=@/path/to/secret.txt" -F "password=secret123" https://tempspace.fly.dev/upload
+```
+
+### Method 3: Using the Official CLI Tool
+
+For a more integrated terminal experience, you can install the official CLI tool from PyPI.
+
+#### Installation
+```bash
+pip install tempspace-cli
+```
+
+#### Usage
+```bash
+# Basic upload
+tempspace /path/to/document.pdf -t 6h
+
+# With a password
+tempspace /path/to/secret.txt -p "mypassword"
+
+# Point to a self-hosted server
+tempspace /path/to/file.txt --url http://localhost:8000
+```
+
+## 🔧 Self-Hosting
+
+You can run your own instance of Tempspace.
+
+### Installation
+```bash
+# Clone the repository
+git clone https://github.com/your-repo/tempspace.git
+cd tempspace
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Configure
+cp .env.example .env
+nano .env  # Change the admin password
+```
+
+### Running the Server
+```bash
+python main.py
+```
+
+The server will be available at `http://localhost:8000`.
+
+## 🛡️ Admin & Configuration
+
+For advanced configuration, such as setting up a reverse proxy, managing admin endpoints, and more, please refer to the project's documentation or open an issue.
+
+## 🤝 Contributing
+
+Contributions are welcome! Please fork the repository and submit a pull request.
+
+## 📝 License
+
+This project is licensed under the MIT License.

tempspace_cli-1.1.1/tempspace_cli.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+cli/__init__.py
+cli/tempspace.py
+tempspace_cli.egg-info/PKG-INFO
+tempspace_cli.egg-info/SOURCES.txt
+tempspace_cli.egg-info/dependency_links.txt
+tempspace_cli.egg-info/entry_points.txt
+tempspace_cli.egg-info/requires.txt
+tempspace_cli.egg-info/top_level.txt
+tests/test_cli.py
+tests/test_main.py

tempspace_cli-1.1.1/tempspace_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tempspace_cli-1.1.1/tempspace_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tempspace = cli.tempspace:main

tempspace_cli-1.1.1/tempspace_cli.egg-info/requires.txt

@@ -0,0 +1,5 @@
+requests==2.31.0
+tqdm==4.66.1
+requests-toolbelt==1.0.0
+rich==13.7.1
+qrcode==8.2

tempspace_cli-1.1.1/tempspace_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+cli

tempspace_cli-1.1.1/tests/test_cli.py

@@ -0,0 +1,12 @@
+import pytest
+from cli.tempspace import parse_time
+
+def test_parse_time():
+    assert parse_time("7d") == 168
+    assert parse_time("24h") == 24
+    assert parse_time("360") == 360
+    assert parse_time("1D") == 24
+    assert parse_time("2H") == 2
+    assert parse_time(" 7d ") == 168
+    assert parse_time("invalid") is None
+    assert parse_time("1w") is None

tempspace_cli-1.1.1/tests/test_main.py

@@ -0,0 +1,405 @@
+import pytest
+from fastapi.testclient import TestClient
+from main import app, UPLOAD_DIR
+import os
+import shutil
+import asyncio
+import json
+
+# Create a client for testing
+client = TestClient(app)
+
+# Import RateLimiter to reset it
+from main import RateLimiter, RATE_LIMIT_UPLOADS, RATE_LIMIT_DOWNLOADS, RATE_LIMIT_WINDOW
+
+@pytest.fixture(autouse=True)
+def reset_rate_limiters(monkeypatch):
+    """Fixture to reset rate limiters before each test to prevent test interference."""
+    monkeypatch.setattr("main.upload_limiter", RateLimiter(RATE_LIMIT_UPLOADS, RATE_LIMIT_WINDOW))
+    monkeypatch.setattr("main.download_limiter", RateLimiter(RATE_LIMIT_DOWNLOADS, RATE_LIMIT_WINDOW))
+
+
+@pytest.fixture(scope="module", autouse=True)
+def setup_and_teardown():
+    """Fixture to set up a clean upload directory for tests and tear it down afterward."""
+    # Ensure a clean state before tests run
+    if UPLOAD_DIR.exists():
+        shutil.rmtree(UPLOAD_DIR)
+    UPLOAD_DIR.mkdir()
+
+    # Yield control to the tests
+    yield
+
+    # Teardown: clean up the uploads directory after all tests in the module are done
+    if UPLOAD_DIR.exists():
+        shutil.rmtree(UPLOAD_DIR)
+
+def test_upload_file():
+    """Test basic file upload."""
+    response = client.post(
+        "/upload",
+        files={"file": ("test_file.txt", b"hello world", "text/plain")},
+        data={"hours": "1"},
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["success"] is True
+    assert data["filename"] == "test_file.txt"
+    assert "url" in data
+    assert "file_id" in data
+
+def test_upload_with_password():
+    """Test file upload with a password."""
+    response = client.post(
+        "/upload",
+        files={"file": ("test_password.txt", b"secret content", "text/plain")},
+        data={"hours": "1", "password": "testpassword"},
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["success"] is True
+    assert data["password_protected"] is True
+
+def test_download_file_no_password():
+    """Test downloading a file that doesn't require a password."""
+    # First, upload a file
+    upload_response = client.post(
+        "/upload",
+        files={"file": ("download_test.txt", b"download content", "text/plain")},
+        data={"hours": "1"},
+    )
+    upload_data = upload_response.json()
+    file_url = upload_data["url"]
+
+    # Now, try to download it
+    # The URL contains the full host, so we need to extract the path
+    path = file_url.split("/", 3)[-1]
+    download_response = client.get(path)
+
+    assert download_response.status_code == 200
+    assert download_response.content == b"download content"
+
+def test_download_file_with_correct_password():
+    """Test downloading a password-protected file with the correct password."""
+    upload_response = client.post(
+        "/upload",
+        files={"file": ("protected_download.txt", b"protected", "text/plain")},
+        data={"hours": "1", "password": "supersecret"},
+    )
+    upload_data = upload_response.json()
+    path = upload_data["url"].split("/", 3)[-1]
+
+    download_response = client.get(f"{path}?password=supersecret")
+    assert download_response.status_code == 200
+    assert download_response.content == b"protected"
+
+def test_download_file_with_incorrect_password():
+    """Test downloading a password-protected file with an incorrect password."""
+    upload_response = client.post(
+        "/upload",
+        files={"file": ("protected_fail.txt", b"protected fail", "text/plain")},
+        data={"hours": "1", "password": "supersecret"},
+    )
+    upload_data = upload_response.json()
+    path = upload_data["url"].split("/", 3)[-1]
+
+    download_response = client.get(f"{path}?password=wrongpassword")
+    assert download_response.status_code == 403 # Forbidden
+
+def test_one_time_download():
+    """Test that a one-time download file is deleted after being accessed."""
+    upload_response = client.post(
+        "/upload",
+        files={"file": ("one_time.txt", b"one time content", "text/plain")},
+        data={"hours": "1", "one_time": "true"},
+    )
+    upload_data = upload_response.json()
+    path = upload_data["url"].split("/", 3)[-1]
+
+    # First download should succeed
+    first_download_response = client.get(path)
+    assert first_download_response.status_code == 200
+
+    # Let the async deletion task run
+    async def wait_for_deletion():
+        await asyncio.sleep(0.1)
+
+    asyncio.run(wait_for_deletion())
+
+    # Second download should fail
+    second_download_response = client.get(path)
+    assert second_download_response.status_code == 404 # Not Found
+
+def test_delete_file():
+    """Test deleting a file using the client_id."""
+    # Upload a file with a specific client_id
+    client_id = "test-client-123"
+    upload_response = client.post(
+        "/upload",
+        files={"file": ("to_be_deleted.txt", b"delete me", "text/plain")},
+        data={"hours": "1", "client_id": client_id},
+    )
+    upload_data = upload_response.json()
+    file_id = upload_data["file_id"]
+
+    # Now, delete the file with the correct client_id
+    delete_response = client.request(
+        "DELETE",
+        f"/delete/{file_id}",
+        json={"client_id": client_id},
+    )
+    assert delete_response.status_code == 200
+    assert delete_response.json()["success"] is True
+
+    # Verify the file is gone
+    path = upload_data["url"].split("/", 3)[-1]
+    get_response = client.get(path)
+    assert get_response.status_code == 404
+
+def test_delete_file_unauthorized():
+    """Test that deleting a file with the wrong client_id fails."""
+    # Upload a file with a specific client_id
+    owner_client_id = "owner-client"
+    upload_response = client.post(
+        "/upload",
+        files={"file": ("unauthorized_delete.txt", b"don't delete me", "text/plain")},
+        data={"hours": "1", "client_id": owner_client_id},
+    )
+    upload_data = upload_response.json()
+    file_id = upload_data["file_id"]
+
+    # Attempt to delete with a different client_id
+    attacker_client_id = "attacker-client"
+    delete_response = client.request(
+        "DELETE",
+        f"/delete/{file_id}",
+        json={"client_id": attacker_client_id},
+    )
+    assert delete_response.status_code == 403 # Forbidden
+
+def test_duplicate_file_upload():
+    """Test that uploading a file with the same content hash returns the original file's URL."""
+    # First upload
+    response1 = client.post(
+        "/upload",
+        files={"file": ("duplicate_content.txt", b"this content is the same", "text/plain")},
+        data={"hours": "1"},
+    )
+    assert response1.status_code == 200
+    data1 = response1.json()
+    assert data1["success"] is True
+
+    # Second upload with the same content
+    response2 = client.post(
+        "/upload",
+        files={"file": ("another_name.txt", b"this content is the same", "text/plain")},
+        data={"hours": "1"},
+    )
+    assert response2.status_code == 200
+    data2 = response2.json()
+    assert data2["success"] is True
+
+    # Check that the file_id is the same for both uploads
+    assert data1["file_id"] == data2["file_id"]
+
+import hashlib
+
+def calculate_hash(content: bytes) -> str:
+    """Helper function to calculate SHA256 hash."""
+    return hashlib.sha256(content).hexdigest()
+
+def test_upload_with_matching_hash():
+    """Test that a file upload with a matching client_hash is successful."""
+    file_content = b"content for hash test"
+    client_hash = calculate_hash(file_content)
+
+    response = client.post(
+        "/upload",
+        files={"file": ("hash_match.txt", file_content, "text/plain")},
+        data={"hours": "1", "client_hash": client_hash},
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["success"] is True
+    assert data["hash_verified"] is True
+
+def test_upload_with_mismatching_hash():
+    """Test that a file upload with a mismatching client_hash is rejected."""
+    file_content = b"content for hash mismatch test"
+    # Provide a deliberately incorrect hash
+    incorrect_hash = "thisisnotthecorrecthash" * 2
+
+    response = client.post(
+        "/upload",
+        files={"file": ("hash_mismatch.txt", file_content, "text/plain")},
+        data={"hours": "1", "client_hash": incorrect_hash},
+    )
+    assert response.status_code == 400  # Bad Request
+    data = response.json()
+    assert "Hash verification failed" in data["detail"]
+
+def test_upload_rate_limiting():
+    """Test that the upload rate limit is enforced."""
+    # The default rate limit is 10 uploads per hour. We'll exceed this.
+    for i in range(10):
+        response = client.post(
+            "/upload",
+            files={"file": (f"rate_limit_test_{i}.txt", b"rate limit content", "text/plain")},
+            data={"hours": "1"},
+        )
+        assert response.status_code == 200
+
+    # The 11th request should be rate-limited
+    response = client.post(
+        "/upload",
+        files={"file": ("rate_limit_exceeded.txt", b"this should fail", "text/plain")},
+        data={"hours": "1"},
+    )
+    assert response.status_code == 429
+
+def test_download_rate_limiting():
+    """Test that the download rate limit is enforced."""
+    # First, upload a file to download
+    upload_response = client.post(
+        "/upload",
+        files={"file": ("download_rate_limit.txt", b"download me", "text/plain")},
+        data={"hours": "1"},
+    )
+    upload_data = upload_response.json()
+    path = upload_data["url"].split("/", 3)[-1]
+
+    # The default download limit is 100 per hour.
+    # We will hit the endpoint 100 times, expecting success.
+    for _ in range(100):
+        download_response = client.get(path)
+        assert download_response.status_code == 200
+
+    # The 101st request should be rate-limited
+    final_download_response = client.get(path)
+    assert final_download_response.status_code == 429
+
+def test_debug_stats_unauthorized():
+    """Test that the /debug/stats endpoint requires authentication."""
+    response = client.get("/debug/stats")
+    assert response.status_code == 401  # Unauthorized
+
+def test_debug_stats_authorized():
+    """Test that the /debug/stats endpoint returns data with correct authentication."""
+    # First, upload a file to have some stats to check
+    client.post(
+        "/upload",
+        files={"file": ("stats_test_file.txt", b"some data", "text/plain")},
+        data={"hours": "1"},
+    )
+
+    response = client.get("/debug/stats", auth=("admin", "testpassword"))
+    assert response.status_code == 200
+    # Check for some expected keys in the HTML response content
+    assert b"Total Files" in response.content
+    assert b"Total Size" in response.content
+    assert b"stats_test_file.txt" in response.content
+
+def test_debug_wipe_unauthorized():
+    """Test that the /debug/wipe endpoint requires authentication."""
+    response = client.post("/debug/wipe")
+    assert response.status_code == 401  # Unauthorized
+
+def test_debug_wipe_authorized():
+    """Test that the /debug/wipe endpoint successfully deletes all data."""
+    # First, upload a file to ensure there is data to wipe
+    upload_response = client.post(
+        "/upload",
+        files={"file": ("wipe_test_file.txt", b"wipe me", "text/plain")},
+        data={"hours": "1"},
+    )
+    assert upload_response.status_code == 200
+    upload_data = upload_response.json()
+    path = upload_data["url"].split("/", 3)[-1]
+
+    # Now, wipe the data
+    wipe_response = client.post("/debug/wipe", auth=("admin", "testpassword"))
+    assert wipe_response.status_code == 200
+    wipe_data = wipe_response.json()
+    assert wipe_data["success"] is True
+    assert wipe_data["wiped_files"] > 0
+
+    # Verify that the previously uploaded file is gone
+    get_response = client.get(path)
+    assert get_response.status_code == 404
+
+# Import necessary modules for the expiration test
+from datetime import datetime, timedelta, timezone
+from main import cleanup_expired_files, shutdown_event
+
+@pytest.mark.asyncio
+async def test_file_expiration_and_cleanup(monkeypatch):
+    """Test that an expired file is automatically cleaned up by the background task."""
+    # Prevent the main app's cleanup task from running automatically
+    async def do_nothing():
+        pass
+    monkeypatch.setattr("main.cleanup_expired_files", do_nothing)
+
+    # Set a very short cleanup interval so we can trigger it manually
+    monkeypatch.setattr("main.CLEANUP_INTERVAL", 0.01)
+
+    # Upload a file with a 1-hour expiry
+    upload_response = client.post(
+        "/upload",
+        files={"file": ("cleanup_test.txt", b"I will be cleaned up", "text/plain")},
+        data={"hours": "1"},
+    )
+    assert upload_response.status_code == 200
+    upload_data = upload_response.json()
+    path = upload_data["url"].split("/", 3)[-1]
+    file_id = upload_data["file_id"]
+
+    # At this point, the file should exist in the metadata
+    from main import metadata
+    assert file_id in metadata
+
+    # A mock datetime class that is always 2 hours in the future
+    class MockDateTime(datetime):
+        @classmethod
+        def now(cls, tz=None):
+            return datetime.now(timezone.utc) + timedelta(hours=2)
+
+    # Now, patch the datetime object to simulate time passing
+    monkeypatch.setattr('main.datetime', MockDateTime)
+
+    # Manually run the cleanup task once
+    # Reset the shutdown event to allow the task to run
+    shutdown_event.clear()
+    cleanup_task = asyncio.create_task(cleanup_expired_files())
+    await asyncio.sleep(0.02) # Give it a moment to run
+    shutdown_event.set() # Stop the task
+    await cleanup_task # Wait for it to finish gracefully
+
+    # After cleanup, the file should be gone from metadata and disk
+    assert file_id not in metadata
+    download_response = client.get(path)
+    assert download_response.status_code == 404
+
+def test_upload_with_invalid_expiry():
+    """Test that uploading with an invalid expiry time fails."""
+    response = client.post(
+        "/upload",
+        files={"file": ("invalid_expiry.txt", b"some content", "text/plain")},
+        data={"hours": "999"},  # 999 is not a valid expiry option
+    )
+    assert response.status_code == 400
+    assert "Invalid expiry time" in response.json()["detail"]
+
+def test_upload_exceeding_max_size(monkeypatch):
+    """Test that uploading a file larger than MAX_FILE_SIZE fails."""
+    # Set a very small max file size for the test
+    monkeypatch.setattr("main.MAX_FILE_SIZE", 10) # 10 bytes
+
+    # Attempt to upload a file larger than the new max size
+    file_content = b"this file is definitely larger than ten bytes"
+    response = client.post(
+        "/upload",
+        files={"file": ("too_large.txt", file_content, "text/plain")},
+        data={"hours": "1"},
+    )
+    assert response.status_code == 413 # Payload Too Large
+    assert "File too large" in response.json()["detail"]