tempspace-cli 1.2.6__tar.gz → 1.2.7__tar.gz

{tempspace_cli-1.2.6 → tempspace_cli-1.2.7}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: tempspace-cli
-Version: 1.2.6
+Version: 1.2.7
 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
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: requests==2.32.5
 Requires-Dist: requests-toolbelt==1.0.0

{tempspace_cli-1.2.6 → tempspace_cli-1.2.7}/cli/tempspace.py

@@ -4,7 +4,7 @@ import os
 import sys
 import hashlib
 import multiprocessing
-from requests_toolbelt.multipart.encoder import MultipartEncoder, MultipartEncoderMonitor
+
 import math
 from rich.console import Console
 from rich.panel import Panel
@@ -13,8 +13,12 @@ from rich import box
 import qrcode
 from rich.prompt import Prompt, Confirm
 from rich.progress import Progress, BarColumn, TextColumn, TransferSpeedColumn, TimeRemainingColumn
-from rich.console import Group
+
 from rich.live import Live
+import shutil
+import tempfile
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
 
 # Default configuration
 DEFAULT_SERVER_URL = "https://tempspace.needrp.net"
@@ -85,6 +89,113 @@ def calculate_file_hash(filepath: str) -> str:
     return sha256_hash.hexdigest()
 
 
+
+
+def get_retry_session(retries=5, backoff_factor=1, status_forcelist=[500, 502, 503, 504]):
+    """Creates a requests Session with automatic retries."""
+    session = requests.Session()
+    retry = Retry(
+        total=retries,
+        read=retries,
+        connect=retries,
+        backoff_factor=backoff_factor,
+        status_forcelist=status_forcelist,
+    )
+    adapter = HTTPAdapter(max_retries=retry)
+    session.mount('http://', adapter)
+    session.mount('https://', adapter)
+    return session
+
+
+def zip_directory(path: str) -> str:
+    """Zips a directory and returns the path to the temporary zip file."""
+    # Create a temporary directory to store the zip
+    temp_dir = tempfile.mkdtemp()
+    # Use the original folder name for the zip file
+    base_name = os.path.basename(os.path.normpath(path))
+    archive_base = os.path.join(temp_dir, base_name)
+    
+    shutil.make_archive(archive_base, 'zip', path)
+    return archive_base + ".zip"
+
+
+def download_file(console, url, password=None):
+    """Downloads a file from Tempspace."""
+    session = get_retry_session()
+    
+    try:
+        # Check if it's a valid Tempspace URL and extract ID logic if needed, 
+        # but for now we'll assume the URL is the full download link or similar.
+        # Actually, the user provides the "Download Link" which usually leads to a landing page.
+        # The CLI needs to handle the actual file download.
+        # If the URL is http://site/DOWLOAD_ID, the direct download might be different.
+        # Let's assume the user passes the direct download link or we try to download from it.
+        # However, Tempspace likely has a landing page.
+        # If the user gives the landing page URL, we might need to scrape or use an API.
+        # Given I don't see the server code, I'll assume the user might provide a direct file URL 
+        # or the tool should try to GET the URL.
+        # If the server has an API like /api/download/<id>?password=..., that would be best.
+        # Looking at upload_file response: `download_link = data.get('url')`.
+        # Code audit earlier showed `DEFAULT_SERVER_URL`.
+        # Use regex to extract ID from URL if possible, or just try GET.
+        
+        # Simple approach: GET the URL. If it initiates a download (headers), good.
+        
+        session.head(url, allow_redirects=True)
+        # Check headers for content-disposition or just proceed
+        
+        if password:
+             # If password is needed, headers or query param might be required.
+             # Since I don't know the exact server auth mechanism for downloads,
+             # I will try passing it as a query param 'password' or header 'X-Password'.
+             # Better: ask the user to enter it if the server responds 401/403.
+             pass
+
+        # For a streaming download
+        response = session.get(url, stream=True, params={'password': password} if password else None)
+        response.raise_for_status()
+        
+        total_size = int(response.headers.get('content-length', 0))
+        disposition = response.headers.get('content-disposition')
+        # Try to get filename from Content-Disposition
+        filename = None
+        if disposition:
+            import re
+            # specific regex for filename="example.txt" or filename=example.txt
+            fname = re.findall(r'filename=["\']?([^"\';]+)["\']?', disposition)
+            if fname:
+                filename = fname[0]
+        
+        # Fallback to URL if no filename found from headers
+        if not filename:
+             from urllib.parse import unquote
+             parsed_path = unquote(url.split("?")[0])
+             filename = parsed_path.split("/")[-1]
+             
+        if not filename:
+            filename = "downloaded_file"
+
+        progress = Progress(
+            TextColumn("[bold blue]{task.description}", justify="right"),
+            BarColumn(bar_width=None),
+            "[progress.percentage]{task.percentage:>3.1f}%", "•",
+            TransferSpeedColumn(), "•",
+            TimeRemainingColumn(),
+        )
+        
+        with Live(Panel(progress, title="[cyan]Downloading[/cyan]", border_style="cyan", title_align="left")):
+            task_id = progress.add_task(filename, total=total_size)
+            with open(filename, 'wb') as f:
+                for chunk in response.iter_content(CHUNK_SIZE):
+                    f.write(chunk)
+                    progress.update(task_id, advance=len(chunk))
+                    
+        console.print(Panel(f"[bold green]Download successful![/] Saved to '{filename}'", border_style="green"))
+
+    except Exception as e:
+        console.print(Panel(f"[bold red]Download failed:[/] {e}", border_style="red"))
+
+
 def upload_file(console, filepath, hours, password, one_time, qr, url):
     """Handles the upload of a single file.
 
@@ -125,9 +236,10 @@ def upload_file(console, filepath, hours, password, one_time, qr, url):
 
     # --- Chunked Upload ---
     response = None
+    session = get_retry_session()
     try:
         # 1. Initiate Upload
-        initiate_response = requests.post(f"{upload_url}/upload/initiate")
+        initiate_response = session.post(f"{upload_url}/upload/initiate")
         initiate_response.raise_for_status()
         upload_id = initiate_response.json()['upload_id']
 
@@ -140,7 +252,7 @@ def upload_file(console, filepath, hours, password, one_time, qr, url):
             TimeRemainingColumn(),
         )
 
-        with Live(Panel(progress, title="[cyan]Uploading[/cyan]", border_style="cyan", title_align="left")) as live:
+        with Live(Panel(progress, title="[cyan]Uploading[/cyan]", border_style="cyan", title_align="left")):
             task_id = progress.add_task(filename, total=file_size)
             with open(filepath, 'rb') as f:
                 chunk_number = 0
@@ -152,7 +264,7 @@ def upload_file(console, filepath, hours, password, one_time, qr, url):
                     }
                     files = {'file': (f'chunk_{chunk_number}', chunk, 'application/octet-stream')}
 
-                    chunk_response = requests.post(
+                    chunk_response = session.post(
                         f"{upload_url}/upload/chunk",
                         data=chunk_data,
                         files=files
@@ -172,7 +284,7 @@ def upload_file(console, filepath, hours, password, one_time, qr, url):
         if password:
             finalize_data['password'] = password
 
-        response = requests.post(f"{upload_url}/upload/finalize", data=finalize_data)
+        response = session.post(f"{upload_url}/upload/finalize", data=finalize_data)
         response.raise_for_status()
 
     except FileNotFoundError:
@@ -183,7 +295,7 @@ def upload_file(console, filepath, hours, password, one_time, qr, url):
         if e.response:
             try:
                 error_message = e.response.json().get('detail', e.response.text)
-            except:
+            except Exception:
                 error_message = e.response.text
         console.print(Panel(f"[bold red]An error occurred:[/] {error_message}", title="[bold red]Error[/bold red]", border_style="red"))
         return
@@ -244,6 +356,21 @@ def main():
     """
     console = Console()
 
+    # --- Handle Download Command ---
+    if len(sys.argv) > 1 and sys.argv[1] == 'download':
+        parser = argparse.ArgumentParser(description="Download a file from Tempspace.")
+        parser.add_argument("url", help="The URL of the file to download.")
+        parser.add_argument("-p", "--password", help="The password for the file.")
+        
+        # We process only the download arguments
+        if len(sys.argv) == 2 and (sys.argv[1] == '-h' or sys.argv[1] == '--help'):
+             parser.print_help()
+             sys.exit(0)
+             
+        args = parser.parse_args(sys.argv[2:])
+        download_file(console, args.url, args.password)
+        return
+
     # --- Header ---
     console.print(Panel("[bold cyan]Tempspace File Uploader[/bold cyan]", expand=False, border_style="blue"))
 
@@ -285,11 +412,24 @@ def main():
         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)
 
+    # --- Process each file ---
     # --- Process each file ---
     for i, filepath in enumerate(filepaths):
+        actual_path = filepath
+        is_temp = False
+        
+        if os.path.isdir(filepath):
+            console.print(f"[bold yellow]Zipping directory '{os.path.basename(filepath)}'...[/]")
+            actual_path = zip_directory(filepath)
+            is_temp = True
+
         if len(filepaths) > 1:
-            console.print(f"\n[bold yellow]Uploading file {i+1} of {len(filepaths)}: {os.path.basename(filepath)}[/bold yellow]\n")
-        upload_file(console, filepath, hours, args.password, args.one_time, args.qr, args.url)
+            console.print(f"\n[bold yellow]Uploading file {i+1} of {len(filepaths)}: {os.path.basename(actual_path)}[/bold yellow]\n")
+        
+        upload_file(console, actual_path, hours, args.password, args.one_time, args.qr, args.url)
+        
+        if is_temp:
+            os.remove(actual_path)
 
 
 if __name__ == "__main__":

{tempspace_cli-1.2.6 → tempspace_cli-1.2.7}/pyproject.toml

@@ -7,14 +7,14 @@ packages = ["cli"]
 
 [project]
 name = "tempspace-cli"
-version = "1.2.6"
+version = "1.2.7"
 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"
+requires-python = ">=3.8"
 classifiers = [
     "Programming Language :: Python :: 3",
     "Operating System :: OS Independent",

{tempspace_cli-1.2.6 → tempspace_cli-1.2.7}/tempspace_cli.egg-info/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: tempspace-cli
-Version: 1.2.6
+Version: 1.2.7
 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
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: requests==2.32.5
 Requires-Dist: requests-toolbelt==1.0.0

tempspace_cli-1.2.7/tests/test_cli.py

@@ -0,0 +1,123 @@
+
+import os
+import shutil
+import tempfile
+import hashlib
+
+from unittest.mock import MagicMock, patch
+from cli.tempspace import parse_time, format_size, calculate_file_hash, zip_directory, upload_file, download_file
+
+
+# --- Unit Tests ---
+
+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
+
+def test_format_size():
+    assert format_size(0) == "0B"
+    assert format_size(1023) == "1023.0 B"
+    assert format_size(100) == "100.0 B"
+    assert format_size(1024) == "1.0 KB"
+    assert format_size(1024 * 1024) == "1.0 MB"
+    assert format_size(1024 * 1024 * 1024 * 2.5) == "2.5 GB"
+
+def test_calculate_file_hash():
+    with tempfile.NamedTemporaryFile(delete=False) as f:
+        f.write(b"hello world")
+        filepath = f.name
+    try:
+        expected_hash = hashlib.sha256(b"hello world").hexdigest()
+        assert calculate_file_hash(filepath) == expected_hash
+    finally:
+        os.remove(filepath)
+
+def test_zip_directory():
+    # Create a dummy directory structure
+    temp_dir = tempfile.mkdtemp()
+    try:
+        os.makedirs(os.path.join(temp_dir, "subdir"))
+        with open(os.path.join(temp_dir, "file1.txt"), "w") as f:
+            f.write("content1")
+        
+        # Call zip_directory
+        zip_path = zip_directory(temp_dir)
+        
+        assert os.path.exists(zip_path)
+        assert zip_path.endswith(".zip")
+        assert os.path.basename(temp_dir) in os.path.basename(zip_path)
+        
+        # Cleanup zip
+        os.remove(zip_path)
+    finally:
+        shutil.rmtree(temp_dir)
+
+# --- Mock Tests ---
+
+@patch('cli.tempspace.requests.Session')
+def test_upload_file_success(mock_session_cls, capsys):
+    mock_session = mock_session_cls.return_value
+    
+    # Mock Initiate
+    mock_session.post.side_effect = [
+        MagicMock(status_code=200, json=lambda: {'upload_id': '123'}), # Initiate
+        MagicMock(status_code=200), # Chunk 1
+        MagicMock(status_code=200, json=lambda: {'url': 'http://test.com/file', 'hash': 'abc', 'hash_verified': True}) # Finalize
+    ]
+    
+    with tempfile.NamedTemporaryFile(delete=False) as f:
+        f.write(b"test content")
+        filepath = f.name
+        
+    mock_console = MagicMock()
+    
+    try:
+        upload_file(mock_console, filepath, 24, None, False, False, "http://test-server")
+        
+        # Assert calls
+        assert mock_session.post.call_count == 3
+        # Verify initiate call
+        mock_session.post.call_args_list[0][0][0].endswith("/upload/initiate")
+        # Verify finalize call
+        mock_session.post.call_args_list[2][0][0].endswith("/upload/finalize")
+        
+        # Verify success message printed
+        # mock_console.print.assert_called() # Hard to check partial strings on rich objects without more complex matching
+        
+    finally:
+        os.remove(filepath)
+
+@patch('cli.tempspace.requests.Session')
+def test_download_file_success(mock_session_cls):
+    mock_session = mock_session_cls.return_value
+    
+    # Mock HEAD request (optional/handled in code?) Code does checks but uses same session
+    mock_session.head.return_value = MagicMock(status_code=200)
+    
+    # Mock GET request
+    content = b"downloaded content"
+    mock_response = MagicMock(status_code=200)
+    mock_response.headers = {'content-length': str(len(content)), 'content-disposition': 'attachment; filename="server_file.txt"'}
+    mock_response.iter_content.return_value = [content]
+    mock_session.get.return_value = mock_response
+    
+    mock_console = MagicMock()
+    
+    # Run download
+    try:
+        download_file(mock_console, "http://test-server/file")
+        
+        # Verify file saved
+        assert os.path.exists("server_file.txt")
+        with open("server_file.txt", "rb") as f:
+            assert f.read() == content
+    finally:
+        if os.path.exists("server_file.txt"):
+            os.remove("server_file.txt")
+

{tempspace_cli-1.2.6 → tempspace_cli-1.2.7}/tests/test_main.py

@@ -1,16 +1,19 @@
 import pytest
 from fastapi.testclient import TestClient
-from main import app, UPLOAD_DIR
+from main import (
+    app, UPLOAD_DIR, RateLimiter, RATE_LIMIT_UPLOADS, RATE_LIMIT_DOWNLOADS, 
+    RATE_LIMIT_WINDOW, cleanup_expired_files, shutdown_event, 
+    is_video, is_text, format_bytes
+)
 import os
 import shutil
 import asyncio
-import json
+import hashlib
+from datetime import datetime, timedelta, timezone
 
 # 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):
@@ -217,7 +220,7 @@ def test_duplicate_file_upload():
     # 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."""
@@ -343,8 +346,6 @@ def test_debug_wipe_authorized():
     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):
@@ -425,7 +426,7 @@ async def test_rate_limiter_timezone_aware_expiration(monkeypatch):
     Test that the RateLimiter correctly expires entries after its time window,
     using timezone-aware datetime objects to prevent DST or timezone issues.
     """
-    from datetime import datetime, timedelta, timezone
+
 
     # Use a local limiter instance for this test
     limiter = RateLimiter(max_requests=1, window_seconds=10)
@@ -653,7 +654,7 @@ def test_get_scheme_and_host_forwarded():
     assert data["url"].startswith("https://")
 
 
-from main import is_video, is_text, format_bytes
+
 
 def test_format_bytes():
     """Test the format_bytes helper function."""
@@ -719,3 +720,40 @@ def test_delete_file_missing_client_id():
         json={"some_other_key": "some_value"},
     )
     assert response.status_code == 400
+
+
+def test_upload_zip_file():
+    """Test uploading a zip file to verify MIME type detection and handling."""
+    # Create a dummy zip content (header for a zip file)
+    zip_header = b"PK\x03\x04"
+    response = client.post(
+        "/upload",
+        files={"file": ("archive.zip", zip_header + b"some content", "application/zip")},
+        data={"hours": "1"},
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["success"] is True
+    assert data["filename"] == "archive.zip"
+    # Depending on filetype library, it might guess zip or octet-stream for this partial content.
+    # The server logic uses filetype.guess.
+    assert "url" in data
+    
+def test_download_content_disposition():
+    """Test that the server sends the correct Content-Disposition header."""
+    filename = "disposition_test.txt"
+    # Use unique content to avoid deduplication returning an old filename
+    content = b"unique content for disposition test " + os.urandom(8)
+    upload_response = client.post(
+        "/upload",
+        files={"file": (filename, content, "text/plain")},
+        data={"hours": "1"},
+    )
+    path = upload_response.json()["url"].split("/", 3)[-1]
+    
+    response = client.get(path)
+    assert response.status_code == 200
+    assert "content-disposition" in response.headers
+    # Starlette/FastAPI FileResponse might use filename*=UTF-8''... for safety
+    cd = response.headers["content-disposition"]
+    assert filename in cd

tempspace_cli-1.2.6/tests/test_cli.py

@@ -1,12 +0,0 @@
-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