hippius 0.2.9__tar.gz → 0.2.10__tar.gz

{hippius-0.2.9 → hippius-0.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hippius
-Version: 0.2.9
+Version: 0.2.10
 Summary: Python SDK and CLI for Hippius blockchain storage
 Home-page: https://github.com/thenervelab/hippius-sdk
 Author: Dubs

{hippius-0.2.9 → hippius-0.2.10}/hippius_sdk/__init__.py

@@ -26,7 +26,7 @@ from hippius_sdk.config import (
 from hippius_sdk.ipfs import IPFSClient
 from hippius_sdk.utils import format_cid, format_size, hex_to_ipfs_cid
 
-__version__ = "0.2.9"
+__version__ = "0.2.10"
 __all__ = [
     "HippiusClient",
     "IPFSClient",

{hippius-0.2.9 → hippius-0.2.10}/hippius_sdk/cli_handlers.py

@@ -1032,8 +1032,7 @@ async def handle_ec_files(
             with tempfile.NamedTemporaryFile() as temp:
                 temp_path = temp.name
 
-                # Download the metadata file without logging
-                await client.ipfs_client.download_file(metadata_cid, temp_path)
+                await client.download_file(metadata_cid, temp_path)
 
                 # Open and parse the metadata file
                 with open(temp_path, "r") as f:

{hippius-0.2.9 → hippius-0.2.10}/hippius_sdk/client.py

@@ -169,7 +169,7 @@ class HippiusClient:
             requests.RequestException: If the download fails
             ValueError: If decryption is requested but fails
         """
-        return await self.ipfs_client.download_file(cid, output_path, decrypt=decrypt)
+        return await self.ipfs_client.download_file(cid, output_path, _=decrypt)
 
     async def cat(
         self,

{hippius-0.2.9 → hippius-0.2.10}/hippius_sdk/ipfs.py

@@ -441,20 +441,17 @@ class IPFSClient:
         self,
         cid: str,
         output_path: str,
-        decrypt: Optional[bool] = None,
+        _: Optional[bool] = None,
         max_retries: int = 3,
-        skip_directory_check: bool = False,
     ) -> Dict[str, Any]:
         """
         Download a file from IPFS with optional decryption.
-        Supports downloading directories - in that case, a directory structure will be created.
 
         Args:
             cid: Content Identifier (CID) of the file to download
-            output_path: Path where the downloaded file/directory will be saved
-            decrypt: Whether to decrypt the file (overrides default)
+            output_path: Path where the downloaded file will be saved
+            _: Whether to decrypt the file (overrides default)
             max_retries: Maximum number of retry attempts (default: 3)
-            skip_directory_check: If True, skips directory check (treats as file)
 
         Returns:
             Dict[str, Any]: Dictionary containing download results:
@@ -464,7 +461,6 @@ class IPFSClient:
                 - size_formatted: Human-readable file size
                 - elapsed_seconds: Time taken for the download in seconds
                 - decrypted: Whether the file was decrypted
-                - is_directory: Whether the download was a directory
 
         Raises:
             requests.RequestException: If the download fails
@@ -472,117 +468,40 @@ class IPFSClient:
         """
         start_time = time.time()
 
-        # Skip directory check if requested (important for erasure code chunks)
-        is_directory = False
-        if not skip_directory_check:
-            # Use the improved ls function to properly detect directories
-            try:
-                # The ls function now properly detects directories
-                ls_result = await self.client.ls(cid)
-                is_directory = ls_result.get("is_directory", False)
-            except Exception:
-                # If ls fails, we'll proceed as if it's a file
-                pass
-
-        # If it's a directory, handle it differently
-        if is_directory:
-            # For directories, we don't need to decrypt each file during the initial download
-            # We'll use the AsyncIPFSClient's download_directory method directly
+        retries = 0
+        while retries < max_retries:
             try:
-                await self.client.download_directory(cid, output_path)
+                url = f"{self.gateway}/ipfs/{cid}"
+                async with self.client.client.stream(url=url, method="GET") as response:
+                    response.raise_for_status()
 
-                # Calculate the total size of the directory
-                total_size = 0
-                for root, _, files in os.walk(output_path):
-                    for file in files:
-                        file_path = os.path.join(root, file)
-                        total_size += os.path.getsize(file_path)
-
-                elapsed_time = time.time() - start_time
-
-                return {
-                    "success": True,
-                    "output_path": output_path,
-                    "size_bytes": total_size,
-                    "size_formatted": self.format_size(total_size),
-                    "elapsed_seconds": round(elapsed_time, 2),
-                    "decrypted": False,  # Directories aren't decrypted as a whole
-                    "is_directory": True,
-                }
-            except Exception as e:
-                raise RuntimeError(f"Failed to download directory: {str(e)}")
-
-        # For regular files, use the existing logic
-        # Determine if we should decrypt
-        should_decrypt = self.encrypt_by_default if decrypt is None else decrypt
-
-        # Check if decryption is available if requested
-        if should_decrypt and not self.encryption_available:
-            raise ValueError(
-                "Decryption requested but not available. Check that PyNaCl is installed and a valid encryption key is provided."
-            )
-
-        # Create a temporary file if we'll be decrypting
-        temp_file_path = None
-        try:
-            if should_decrypt:
-                # Create a temporary file for the encrypted data
-                temp_file = tempfile.NamedTemporaryFile(delete=False)
-                temp_file_path = temp_file.name
-                temp_file.close()
-                download_path = temp_file_path
-            else:
-                download_path = output_path
-
-            # Pass the skip_directory_check parameter to the core client
-            await self.client.download_file(
-                cid, download_path, skip_directory_check=skip_directory_check
-            )
-            download_success = True
-
-            if not download_success:
-                raise RuntimeError("Failed to download file after multiple attempts")
-
-            # Decrypt if needed
-            if should_decrypt:
-                try:
-                    # Read the encrypted data
-                    with open(temp_file_path, "rb") as f:
-                        encrypted_data = f.read()
-
-                    # Decrypt the data
-                    decrypted_data = self.decrypt_data(encrypted_data)
-
-                    # Write the decrypted data to the output path
-                    os.makedirs(
-                        os.path.dirname(os.path.abspath(output_path)), exist_ok=True
-                    )
                     with open(output_path, "wb") as f:
-                        f.write(decrypted_data)
-
-                    # Use output_path for size measurement
-                    file_size_bytes = len(decrypted_data)
-                except Exception as e:
-                    raise ValueError(f"Failed to decrypt file: {str(e)}")
-            else:
-                file_size_bytes = os.path.getsize(output_path)
+                        async for chunk in response.aiter_bytes(chunk_size=8192):
+                            f.write(chunk)
+                    break
+
+            except (httpx.HTTPError, IOError) as e:
+                retries += 1
+
+                if retries < max_retries:
+                    wait_time = 2**retries
+                    print(f"Download attempt {retries} failed: {str(e)}")
+                    print(f"Retrying in {wait_time} seconds...")
+                    time.sleep(wait_time)
+                else:
+                    raise
 
-            elapsed_time = time.time() - start_time
+        file_size_bytes = os.path.getsize(output_path)
+        elapsed_time = time.time() - start_time
 
-            return {
-                "success": True,
-                "output_path": output_path,
-                "size_bytes": file_size_bytes,
-                "size_formatted": self.format_size(file_size_bytes),
-                "elapsed_seconds": round(elapsed_time, 2),
-                "decrypted": should_decrypt,
-                "is_directory": False,
-            }
-
-        finally:
-            # Clean up temporary file if created
-            if temp_file_path and os.path.exists(temp_file_path):
-                os.unlink(temp_file_path)
+        return {
+            "success": True,
+            "output_path": output_path,
+            "size_bytes": file_size_bytes,
+            "size_formatted": self.format_size(file_size_bytes),
+            "elapsed_seconds": round(elapsed_time, 2),
+            "decrypted": _,
+        }
 
     async def cat(
         self,

{hippius-0.2.9 → hippius-0.2.10}/hippius_sdk/ipfs_core.py

@@ -36,7 +36,7 @@ class AsyncIPFSClient:
                 api_url = "http://localhost:5001"
         self.api_url = api_url
         self.gateway = gateway
-        self.client = httpx.AsyncClient(timeout=60.0)
+        self.client = httpx.AsyncClient(timeout=300, follow_redirects=True)
 
     async def close(self):
         """Close the httpx client."""

{hippius-0.2.9 → hippius-0.2.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "hippius"
-version = "0.2.9"
+version = "0.2.10"
 description = "Python SDK and CLI for Hippius blockchain storage"
 authors = ["Dubs <dubs@dubs.rs>"]
 readme = "README.md"