televault 0.1.0__py3-none-any.whl

televault/__init__.py

@@ -0,0 +1,16 @@
+"""
+TeleVault - Unlimited cloud storage using Telegram MTProto.
+
+Features:
+- MTProto Direct (no bot API limits)
+- Zero Local DB (metadata on Telegram)
+- Client-side Encryption (AES-256-GCM)
+- Parallel Processing
+- Folder Support
+- TUI + CLI
+"""
+__version__ = "1.0.0"
+__author__ = "Yahya Toubali"
+__email__ = "yahya@yahyatoubali.me"
+__license__ = "MIT"
+__url__ = "https://github.com/yahyatoubali/televault"

televault/chunker.py

@@ -0,0 +1,189 @@
+"""File chunking utilities for TeleVault."""
+
+import os
+from pathlib import Path
+from typing import Iterator, BinaryIO
+from dataclasses import dataclass
+
+import blake3
+
+# Telegram limits: 2GB per file via MTProto
+# Using 100MB chunks for better parallelism and resume capability
+DEFAULT_CHUNK_SIZE = 100 * 1024 * 1024  # 100MB
+MAX_CHUNK_SIZE = 2000 * 1024 * 1024  # ~2GB (with margin)
+
+
+@dataclass
+class Chunk:
+    """A chunk of file data ready for upload."""
+    
+    index: int
+    data: bytes
+    hash: str
+    size: int
+    
+    @property
+    def filename(self) -> str:
+        """Generate chunk filename."""
+        return f"{self.index:04d}.chunk"
+
+
+def hash_data(data: bytes) -> str:
+    """Compute BLAKE3 hash of data (fast, secure)."""
+    return blake3.blake3(data).hexdigest()[:32]  # 128-bit prefix
+
+
+def hash_file(path: str | Path) -> str:
+    """Compute BLAKE3 hash of entire file (streaming)."""
+    hasher = blake3.blake3()
+    with open(path, "rb") as f:
+        while chunk := f.read(8192):
+            hasher.update(chunk)
+    return hasher.hexdigest()[:32]
+
+
+def get_file_size(path: str | Path) -> int:
+    """Get file size in bytes."""
+    return os.path.getsize(path)
+
+
+def iter_chunks(
+    file_path: str | Path,
+    chunk_size: int = DEFAULT_CHUNK_SIZE,
+) -> Iterator[Chunk]:
+    """
+    Split a file into chunks.
+    
+    Yields Chunk objects with index, data, hash, and size.
+    Memory-efficient: only one chunk in memory at a time.
+    """
+    if chunk_size > MAX_CHUNK_SIZE:
+        raise ValueError(f"Chunk size {chunk_size} exceeds max {MAX_CHUNK_SIZE}")
+    
+    with open(file_path, "rb") as f:
+        index = 0
+        while True:
+            data = f.read(chunk_size)
+            if not data:
+                break
+            
+            yield Chunk(
+                index=index,
+                data=data,
+                hash=hash_data(data),
+                size=len(data),
+            )
+            index += 1
+
+
+def count_chunks(file_size: int, chunk_size: int = DEFAULT_CHUNK_SIZE) -> int:
+    """Calculate number of chunks for a file."""
+    if file_size == 0:
+        return 0
+    return (file_size + chunk_size - 1) // chunk_size
+
+
+def read_chunk(
+    file_path: str | Path,
+    index: int,
+    chunk_size: int = DEFAULT_CHUNK_SIZE,
+) -> Chunk:
+    """Read a specific chunk by index."""
+    with open(file_path, "rb") as f:
+        f.seek(index * chunk_size)
+        data = f.read(chunk_size)
+        if not data:
+            raise ValueError(f"Chunk {index} is empty or out of range")
+        
+        return Chunk(
+            index=index,
+            data=data,
+            hash=hash_data(data),
+            size=len(data),
+        )
+
+
+class ChunkWriter:
+    """
+    Reassemble chunks into a file.
+    
+    Handles out-of-order chunks by writing to correct positions.
+    """
+    
+    def __init__(self, output_path: str | Path, total_size: int, chunk_size: int = DEFAULT_CHUNK_SIZE):
+        self.output_path = Path(output_path)
+        self.total_size = total_size
+        self.chunk_size = chunk_size
+        self.written_chunks: set[int] = set()
+        
+        # Pre-allocate file
+        self.output_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.output_path, "wb") as f:
+            f.truncate(total_size)
+    
+    def write_chunk(self, chunk: Chunk) -> None:
+        """Write a chunk to the correct position."""
+        if chunk.index in self.written_chunks:
+            return  # Already written
+        
+        offset = chunk.index * self.chunk_size
+        with open(self.output_path, "r+b") as f:
+            f.seek(offset)
+            f.write(chunk.data)
+        
+        self.written_chunks.add(chunk.index)
+    
+    def is_complete(self, expected_chunks: int) -> bool:
+        """Check if all chunks have been written."""
+        return len(self.written_chunks) == expected_chunks
+    
+    def missing_chunks(self, expected_chunks: int) -> list[int]:
+        """Get list of missing chunk indices."""
+        return [i for i in range(expected_chunks) if i not in self.written_chunks]
+
+
+class ChunkBuffer:
+    """
+    Buffer for streaming chunk creation.
+    
+    Useful when reading from a stream (network, compression, encryption)
+    rather than a file.
+    """
+    
+    def __init__(self, chunk_size: int = DEFAULT_CHUNK_SIZE):
+        self.chunk_size = chunk_size
+        self.buffer = bytearray()
+        self.index = 0
+    
+    def write(self, data: bytes) -> Iterator[Chunk]:
+        """
+        Write data to buffer, yielding complete chunks.
+        """
+        self.buffer.extend(data)
+        
+        while len(self.buffer) >= self.chunk_size:
+            chunk_data = bytes(self.buffer[:self.chunk_size])
+            self.buffer = self.buffer[self.chunk_size:]
+            
+            yield Chunk(
+                index=self.index,
+                data=chunk_data,
+                hash=hash_data(chunk_data),
+                size=len(chunk_data),
+            )
+            self.index += 1
+    
+    def flush(self) -> Chunk | None:
+        """Flush remaining data as final chunk."""
+        if not self.buffer:
+            return None
+        
+        chunk_data = bytes(self.buffer)
+        self.buffer.clear()
+        
+        return Chunk(
+            index=self.index,
+            data=chunk_data,
+            hash=hash_data(chunk_data),
+            size=len(chunk_data),
+        )

televault/cli.py

@@ -0,0 +1,445 @@
+"""TeleVault CLI - Command line interface."""
+
+import asyncio
+import sys
+from pathlib import Path
+from typing import Optional
+
+import click
+from rich.console import Console
+from rich.table import Table
+from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn, TimeRemainingColumn
+from rich import print as rprint
+
+from .core import TeleVault, UploadProgress, DownloadProgress
+from .config import Config, get_config_dir
+
+
+console = Console()
+
+
+def format_size(size: int) -> str:
+    """Format bytes as human readable."""
+    for unit in ["B", "KB", "MB", "GB", "TB"]:
+        if size < 1024:
+            return f"{size:.1f} {unit}"
+        size /= 1024
+    return f"{size:.1f} PB"
+
+
+def run_async(coro):
+    """Run async function."""
+    return asyncio.get_event_loop().run_until_complete(coro)
+
+
+@click.group(invoke_without_command=True)
+@click.option("-h", "--help", is_flag=True, help="Show this message and exit.")
+@click.pass_context
+def main(ctx, help):
+    """TeleVault - Unlimited cloud storage using Telegram."""
+    if help or ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+
+
+@main.command()
+@click.option("--phone", "-p", help="Phone number for login")
+def login(phone: Optional[str]):
+    """Login to Telegram."""
+    async def _login():
+        vault = TeleVault()
+        await vault.connect(skip_channel=True)  # Don't try to access channel yet
+        
+        console.print("[bold blue]TeleVault Login[/bold blue]")
+        console.print("You'll receive a code on Telegram.\n")
+        
+        session = await vault.login(phone)
+        
+        console.print("\n[bold green]✓ Login successful![/bold green]")
+        console.print(f"Session saved to: {get_config_dir() / 'telegram.json'}")
+        
+        # Now set up channel if configured
+        if vault.config.channel_id:
+            await vault.telegram.set_channel(vault.config.channel_id)
+            console.print(f"Channel configured: {vault.config.channel_id}")
+        
+        await vault.disconnect()
+    
+    run_async(_login())
+
+
+@main.command()
+def logout():
+    """Logout and clear session."""
+    config_dir = get_config_dir()
+    telegram_config = config_dir / "telegram.json"
+    
+    if telegram_config.exists():
+        telegram_config.unlink()
+        console.print("[green]✓ Logged out successfully[/green]")
+    else:
+        console.print("[yellow]Not logged in[/yellow]")
+
+
+@main.command()
+@click.option("--channel-id", "-c", type=int, help="Existing channel ID to use")
+def setup(channel_id: Optional[int]):
+    """Set up storage channel."""
+    async def _setup():
+        vault = TeleVault()
+        await vault.connect()
+        
+        if channel_id:
+            cid = await vault.setup_channel(channel_id)
+            console.print(f"[green]✓ Using channel: {cid}[/green]")
+        else:
+            console.print("[bold]Creating new storage channel...[/bold]")
+            cid = await vault.setup_channel()
+            console.print(f"[green]✓ Created channel: {cid}[/green]")
+        
+        await vault.disconnect()
+    
+    run_async(_setup())
+
+
+@main.command()
+@click.argument("file_path", type=click.Path(exists=True))
+@click.option("--password", "-p", help="Encryption password", envvar="TELEVAULT_PASSWORD")
+@click.option("--no-compress", is_flag=True, help="Disable compression")
+@click.option("--no-encrypt", is_flag=True, help="Disable encryption")
+@click.option("--recursive", "-r", is_flag=True, help="Upload directory recursively")
+def push(file_path: str, password: Optional[str], no_compress: bool, no_encrypt: bool, recursive: bool):
+    """Upload a file or directory to TeleVault."""
+    async def _push():
+        config = Config.load_or_create()
+        
+        if no_compress:
+            config.compression = False
+        if no_encrypt:
+            config.encryption = False
+        
+        if config.encryption and not password:
+            console.print("[yellow]Warning: Encryption enabled but no password provided.[/yellow]")
+            console.print("Set password with --password or TELEVAULT_PASSWORD env var.")
+            console.print("Use --no-encrypt to disable encryption.\n")
+        
+        vault = TeleVault(config=config, password=password)
+        await vault.connect()
+        
+        file_path_obj = Path(file_path)
+        
+        # Handle directory upload
+        if file_path_obj.is_dir():
+            if not recursive:
+                console.print(f"[red]'{file_path}' is a directory. Use --recursive (-r) to upload.[/red]")
+                await vault.disconnect()
+                return
+            
+            files = list(file_path_obj.rglob("*"))
+            files = [f for f in files if f.is_file()]
+            
+            if not files:
+                console.print("[yellow]No files found in directory.[/yellow]")
+                await vault.disconnect()
+                return
+            
+            console.print(f"[bold]Uploading {len(files)} files from {file_path_obj.name}/[/bold]\n")
+            
+            for i, f in enumerate(files, 1):
+                rel_path = f.relative_to(file_path_obj)
+                console.print(f"[{i}/{len(files)}] {rel_path}...", end=" ")
+                try:
+                    metadata = await vault.upload(f)
+                    console.print(f"[green]✓[/green] ({format_size(metadata.size)})")
+                except Exception as e:
+                    console.print(f"[red]✗ {e}[/red]")
+            
+            console.print(f"\n[bold green]✓ Uploaded {len(files)} files[/bold green]")
+        else:
+            # Single file upload with progress
+            file_size = file_path_obj.stat().st_size
+            
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                BarColumn(),
+                TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+                TextColumn("({task.fields[size]})"),
+                TimeRemainingColumn(),
+                console=console,
+                refresh_per_second=10,
+            ) as progress:
+                task = progress.add_task(
+                    f"Uploading {file_path_obj.name}", 
+                    total=100,
+                    size=format_size(file_size)
+                )
+                
+                def on_progress(p: UploadProgress):
+                    progress.update(task, completed=p.percent)
+                
+                metadata = await vault.upload(file_path, progress_callback=on_progress)
+                progress.update(task, completed=100)  # Ensure 100% at end
+            
+            console.print(f"\n[bold green]✓ Uploaded successfully![/bold green]")
+            console.print(f"  File ID: {metadata.id}")
+            console.print(f"  Size: {format_size(metadata.size)}")
+            console.print(f"  Chunks: {metadata.chunk_count}")
+            console.print(f"  Encrypted: {'Yes' if metadata.encrypted else 'No'}")
+            console.print(f"  Compressed: {'Yes' if metadata.compressed else 'No'}")
+        
+        await vault.disconnect()
+    
+    run_async(_push())
+
+
+@main.command()
+@click.argument("file_id_or_name")
+@click.option("--output", "-o", type=click.Path(), help="Output path")
+@click.option("--password", "-p", help="Decryption password", envvar="TELEVAULT_PASSWORD")
+def pull(file_id_or_name: str, output: Optional[str], password: Optional[str]):
+    """Download a file from TeleVault."""
+    async def _pull():
+        vault = TeleVault(password=password)
+        await vault.connect()
+        
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+            TimeRemainingColumn(),
+            console=console,
+            refresh_per_second=10,
+        ) as progress:
+            task = progress.add_task(f"Downloading {file_id_or_name}", total=100)
+            
+            def on_progress(p: DownloadProgress):
+                progress.update(task, completed=p.percent)
+            
+            try:
+                output_path = await vault.download(
+                    file_id_or_name,
+                    output_path=output,
+                    progress_callback=on_progress,
+                )
+                progress.update(task, completed=100)  # Ensure 100% at end
+            except FileNotFoundError:
+                console.print(f"[red]✗ File not found: {file_id_or_name}[/red]")
+                await vault.disconnect()
+                sys.exit(1)
+            except ValueError as e:
+                console.print(f"[red]✗ Error: {e}[/red]")
+                await vault.disconnect()
+                sys.exit(1)
+        
+        console.print(f"\n[bold green]✓ Downloaded to: {output_path}[/bold green]")
+        
+        await vault.disconnect()
+    
+    run_async(_pull())
+
+
+@main.command(name="ls")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+@click.option("--sort", type=click.Choice(["name", "size", "date"]), default="name")
+def list_files(as_json: bool, sort: str):
+    """List all files in the vault."""
+    async def _list():
+        vault = TeleVault()
+        await vault.connect()
+        
+        files = await vault.list_files()
+        
+        # Sort
+        if sort == "name":
+            files.sort(key=lambda f: f.name.lower())
+        elif sort == "size":
+            files.sort(key=lambda f: f.size, reverse=True)
+        elif sort == "date":
+            files.sort(key=lambda f: f.created_at, reverse=True)
+        
+        if as_json:
+            import json
+            output = [{"id": f.id, "name": f.name, "size": f.size} for f in files]
+            click.echo(json.dumps(output, indent=2))
+        else:
+            if not files:
+                console.print("[dim]No files in vault[/dim]")
+            else:
+                table = Table(title="TeleVault Files")
+                table.add_column("ID", style="dim")
+                table.add_column("Name")
+                table.add_column("Size", justify="right")
+                table.add_column("Chunks", justify="right")
+                table.add_column("Encrypted")
+                
+                for f in files:
+                    table.add_row(
+                        f.id[:8],
+                        f.name,
+                        format_size(f.size),
+                        str(f.chunk_count),
+                        "🔒" if f.encrypted else "📄",
+                    )
+                
+                console.print(table)
+                console.print(f"\n[dim]{len(files)} file(s), {format_size(sum(f.size for f in files))} total[/dim]")
+        
+        await vault.disconnect()
+    
+    run_async(_list())
+
+
+@main.command()
+@click.argument("query")
+def search(query: str):
+    """Search files by name."""
+    async def _search():
+        vault = TeleVault()
+        await vault.connect()
+        
+        files = await vault.search(query)
+        
+        if not files:
+            console.print(f"[dim]No files matching '{query}'[/dim]")
+        else:
+            for f in files:
+                console.print(f"[cyan]{f.id[:8]}[/cyan] {f.name} ({format_size(f.size)})")
+        
+        await vault.disconnect()
+    
+    run_async(_search())
+
+
+@main.command()
+@click.argument("file_id_or_name")
+def info(file_id_or_name: str):
+    """Show detailed file information."""
+    async def _info():
+        vault = TeleVault()
+        await vault.connect()
+        
+        try:
+            # Find file
+            files = await vault.search(file_id_or_name)
+            if not files:
+                # Try by ID
+                index = await vault.telegram.get_index()
+                for fid, msg_id in index.files.items():
+                    if fid.startswith(file_id_or_name):
+                        metadata = await vault.telegram.get_metadata(msg_id)
+                        files = [metadata]
+                        break
+            
+            if not files:
+                console.print(f"[red]File not found: {file_id_or_name}[/red]")
+                await vault.disconnect()
+                return
+            
+            f = files[0]
+            
+            console.print(f"[bold]{f.name}[/bold]\n")
+            console.print(f"  ID:          {f.id}")
+            console.print(f"  Size:        {format_size(f.size)}")
+            console.print(f"  Hash:        {f.hash}")
+            console.print(f"  Chunks:      {f.chunk_count}")
+            console.print(f"  Encrypted:   {'Yes 🔒' if f.encrypted else 'No'}")
+            console.print(f"  Compressed:  {'Yes' if f.compressed else 'No'}")
+            if f.compressed and f.compression_ratio:
+                console.print(f"  Comp. ratio: {f.compression_ratio:.1%}")
+            if f.mime_type:
+                console.print(f"  MIME type:   {f.mime_type}")
+            
+            from datetime import datetime
+            created = datetime.fromtimestamp(f.created_at)
+            console.print(f"  Created:     {created.strftime('%Y-%m-%d %H:%M')}")
+            
+            if f.chunks:
+                stored = sum(c.size for c in f.chunks)
+                console.print(f"  Stored size: {format_size(stored)}")
+        
+        except Exception as e:
+            console.print(f"[red]Error: {e}[/red]")
+        
+        await vault.disconnect()
+    
+    run_async(_info())
+
+
+@main.command()
+@click.argument("file_id_or_name")
+@click.option("--yes", "-y", is_flag=True, help="Skip confirmation")
+def rm(file_id_or_name: str, yes: bool):
+    """Delete a file from the vault."""
+    async def _rm():
+        vault = TeleVault()
+        await vault.connect()
+        
+        if not yes:
+            if not click.confirm(f"Delete '{file_id_or_name}'?"):
+                console.print("[dim]Cancelled[/dim]")
+                await vault.disconnect()
+                return
+        
+        deleted = await vault.delete(file_id_or_name)
+        
+        if deleted:
+            console.print(f"[green]✓ Deleted: {file_id_or_name}[/green]")
+        else:
+            console.print(f"[red]✗ File not found: {file_id_or_name}[/red]")
+        
+        await vault.disconnect()
+    
+    run_async(_rm())
+
+
+@main.command()
+def status():
+    """Show vault status."""
+    async def _status():
+        vault = TeleVault()
+        await vault.connect()
+        
+        try:
+            status = await vault.get_status()
+            
+            console.print("[bold]TeleVault Status[/bold]\n")
+            console.print(f"  Channel: {status['channel_id']}")
+            console.print(f"  Files: {status['file_count']}")
+            console.print(f"  Total size: {format_size(status['total_size'])}")
+            console.print(f"  Stored size: {format_size(status['stored_size'])}")
+            console.print(f"  Compression ratio: {status['compression_ratio']:.1%}")
+        except Exception as e:
+            console.print(f"[red]Error: {e}[/red]")
+            console.print("\n[dim]Have you run 'televault login' and 'televault setup'?[/dim]")
+        
+        await vault.disconnect()
+    
+    run_async(_status())
+
+
+@main.command()
+def whoami():
+    """Show current Telegram account."""
+    async def _whoami():
+        vault = TeleVault()
+        await vault.connect()
+        
+        me = await vault.telegram._client.get_me()
+        
+        console.print(f"[bold]{me.first_name}[/bold]", end="")
+        if me.last_name:
+            console.print(f" {me.last_name}", end="")
+        console.print()
+        
+        if me.username:
+            console.print(f"  @{me.username}")
+        console.print(f"  ID: {me.id}")
+        
+        await vault.disconnect()
+    
+    run_async(_whoami())
+
+
+if __name__ == "__main__":
+    main()