televault 0.1.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

televault/__init__.py

@@ -13,4 +13,4 @@ __version__ = "1.0.0"
 __author__ = "Yahya Toubali"
 __email__ = "yahya@yahyatoubali.me"
 __license__ = "MIT"
-__url__ = "https://github.com/yahyatoubali/televault"
+__url__ = "https://github.com/yahyatoubali/televault"

televault/chunker.py

@@ -1,9 +1,9 @@
 """File chunking utilities for TeleVault."""
 
 import os
-from pathlib import Path
-from typing import Iterator, BinaryIO
+from collections.abc import Iterator
 from dataclasses import dataclass
+from pathlib import Path
 
 import blake3
 
@@ -16,12 +16,12 @@ 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."""
@@ -53,20 +53,20 @@ def iter_chunks(
 ) -> 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,
@@ -94,7 +94,7 @@ def read_chunk(
         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,
@@ -106,37 +106,39 @@ def read_chunk(
 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):
+
+    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]
@@ -145,26 +147,26 @@ class ChunkWriter:
 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:]
-            
+            chunk_data = bytes(self.buffer[: self.chunk_size])
+            self.buffer = self.buffer[self.chunk_size :]
+
             yield Chunk(
                 index=self.index,
                 data=chunk_data,
@@ -172,15 +174,15 @@ class ChunkBuffer:
                 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,