hippius 0.2.8__tar.gz → 0.2.10__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hippius
-Version: 0.2.8
+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.8 → 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.8"
+__version__ = "0.2.10"
 __all__ = [
     "HippiusClient",
     "IPFSClient",

{hippius-0.2.8 → 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.8 → 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.8 → 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.8 → 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."""
@@ -59,8 +59,14 @@ class AsyncIPFSClient:
             Dict containing the CID and other information
         """
         with open(file_path, "rb") as f:
-            files = {"file": f}
-            response = await self.client.post(f"{self.api_url}/api/v0/add", files=files)
+            file_content = f.read()
+            filename = os.path.basename(file_path)
+            # Specify file with name and content type to ensure consistent handling
+            files = {"file": (filename, file_content, "application/octet-stream")}
+            # Explicitly set wrap-with-directory=false to prevent wrapping in directory
+            response = await self.client.post(
+                f"{self.api_url}/api/v0/add?wrap-with-directory=false", files=files
+            )
             response.raise_for_status()
             return response.json()
 
@@ -75,8 +81,12 @@ class AsyncIPFSClient:
         Returns:
             Dict containing the CID and other information
         """
-        files = {"file": (filename, data)}
-        response = await self.client.post(f"{self.api_url}/api/v0/add", files=files)
+        # Specify file with name and content type to ensure consistent handling
+        files = {"file": (filename, data, "application/octet-stream")}
+        # Explicitly set wrap-with-directory=false to prevent wrapping in directory
+        response = await self.client.post(
+            f"{self.api_url}/api/v0/add?wrap-with-directory=false", files=files
+        )
         response.raise_for_status()
         return response.json()
 
@@ -149,59 +159,30 @@ class AsyncIPFSClient:
             cid: Content Identifier
 
         Returns:
-            Dict with links information and a is_directory flag
+            Dict with links information and is_directory flag
         """
-        try:
-            # Try using the direct IPFS API first (most reliable)
-            response = await self.client.post(f"{self.api_url}/api/v0/ls?arg={cid}")
-            response.raise_for_status()
-            result = response.json()
-
-            # Add a flag to indicate if this is a directory
-            # A directory has Links and typically more than one or has Type=1
-            is_directory = False
-            if "Objects" in result and len(result["Objects"]) > 0:
-                obj = result["Objects"][0]
-                if "Links" in obj and len(obj["Links"]) > 0:
-                    # It has links, likely a directory
-                    is_directory = True
-                    # Check if any links have Type=1 (directory)
-                    for link in obj["Links"]:
-                        if link.get("Type") == 1:
-                            is_directory = True
-                            break
-
-            # Add the flag to the result
-            result["is_directory"] = is_directory
-            return result
+        # Try using the direct IPFS API first (most reliable)
+        response = await self.client.post(f"{self.api_url}/api/v0/ls?arg={cid}")
+        response.raise_for_status()
+        result = response.json()
 
-        except Exception as e:
-            # If the IPFS API fails, try to get info from the gateway
-            try:
-                # Try to get a small sample of the content to check if it's a directory listing
-                content_sample = await self.cat(cid)
-                is_directory = False
-
-                # If it starts with HTML doctype and has IPFS title, it's probably a directory listing
-                if (
-                    content_sample.startswith(b"<!DOCTYPE html>")
-                    and b"<title>/ipfs/" in content_sample
-                ):
-                    is_directory = True
-
-                # Return a simplified result similar to what the ls API would return
-                return {
-                    "is_directory": is_directory,
-                    "Objects": [
-                        {
-                            "Hash": cid,
-                            "Links": [],  # We can't get links from HTML content easily
-                        }
-                    ],
-                }
-            except Exception as fallback_error:
-                # Re-raise the original error
-                raise e
+        # Add a flag to indicate if this is a directory.
+        # A directory has Links and typically more than one or has Type=1
+        is_directory = False
+        if "Objects" in result and len(result["Objects"]) > 0:
+            obj = result["Objects"][0]
+            if "Links" in obj and len(obj["Links"]) > 0:
+                # It has links, likely a directory
+                is_directory = True
+                # Check if any links have Type=1 (directory)
+                for link in obj["Links"]:
+                    if link.get("Type") == 1:
+                        is_directory = True
+                        break
+
+        # Add the flag to the result
+        result["is_directory"] = is_directory
+        return result
 
     async def exists(self, cid: str) -> bool:
         """
@@ -241,7 +222,7 @@ class AsyncIPFSClient:
                 ls_result = await self.ls(cid)
                 if ls_result.get("is_directory", False):
                     # It's a directory, use the get command to download it properly
-                    return await self.download_directory_with_get(cid, output_path)
+                    return await self.download_directory(cid, output_path)
             except Exception:
                 # If ls check fails, continue with regular file download
                 pass
@@ -259,80 +240,13 @@ class AsyncIPFSClient:
             # Only try directory fallback if not skipping directory check
             if not skip_directory_check:
                 try:
-                    return await self.download_directory_with_get(cid, output_path)
+                    return await self.download_directory(cid, output_path)
                 except Exception:
                     pass
             # Raise the original error
             raise e
 
     async def download_directory(self, cid: str, output_path: str) -> str:
-        """
-        Download a directory from IPFS.
-
-        Args:
-            cid: Content identifier of the directory
-            output_path: Path where to save the directory
-
-        Returns:
-            Path to the saved directory
-        """
-        # Try the more reliable get command first
-        try:
-            return await self.download_directory_with_get(cid, output_path)
-        except Exception as e:
-            # If get command fails, fall back to ls/cat method
-            try:
-                # Get directory listing
-                ls_result = await self.ls(cid)
-                if not ls_result.get("is_directory", False):
-                    raise ValueError(f"CID {cid} is not a directory")
-
-                # Create the directory if it doesn't exist
-                os.makedirs(output_path, exist_ok=True)
-
-                # Extract links from the updated response format
-                links = []
-                # The ls result format is: { "Objects": [ { "Hash": "...", "Links": [...] } ] }
-                if "Objects" in ls_result and len(ls_result["Objects"]) > 0:
-                    for obj in ls_result["Objects"]:
-                        if "Links" in obj:
-                            links.extend(obj["Links"])
-
-                # Download each file in the directory
-                for link in links:
-                    file_name = link.get("Name")
-                    file_cid = link.get("Hash")
-                    file_type = link.get("Type")
-
-                    # Skip entries without required data
-                    if not (file_name and file_cid):
-                        continue
-
-                    # Build the path for this file/directory
-                    file_path = os.path.join(output_path, file_name)
-
-                    if file_type == 1 or file_type == "dir":  # Directory type
-                        # Recursively download the subdirectory
-                        await self.download_directory(file_cid, file_path)
-                    else:  # File type
-                        # Download the file
-                        content = await self.cat(file_cid)
-                        os.makedirs(
-                            os.path.dirname(os.path.abspath(file_path)), exist_ok=True
-                        )
-                        with open(file_path, "wb") as f:
-                            f.write(content)
-
-                return output_path
-            except Exception as fallback_error:
-                # If both methods fail, raise a more detailed error
-                raise RuntimeError(
-                    f"Failed to download directory: get error: {e}, ls/cat error: {fallback_error}"
-                )
-
-        return output_path
-
-    async def download_directory_with_get(self, cid: str, output_path: str) -> str:
         """
         Download a directory from IPFS by recursively fetching its contents.
 
@@ -345,6 +259,13 @@ class AsyncIPFSClient:
         """
         # First, get the directory listing to find all contents
         try:
+            import uuid
+
+            # Handle potential file/directory collision
+            if os.path.exists(output_path) and not os.path.isdir(output_path):
+                # Generate unique path by adding a UUID suffix
+                output_path = f"{output_path}_{str(uuid.uuid4())[:8]}"
+
             ls_result = await self.ls(cid)
 
             # Create target directory
@@ -362,7 +283,6 @@ class AsyncIPFSClient:
                 link_name = link.get("Name")
                 link_hash = link.get("Hash")
                 link_type = link.get("Type")
-                link_size = link.get("Size", 0)
 
                 if not (link_name and link_hash):
                     continue  # Skip if missing essential data
@@ -372,7 +292,7 @@ class AsyncIPFSClient:
 
                 if link_type == 1 or str(link_type) == "1" or link_type == "dir":
                     # It's a directory - recursively download
-                    await self.download_directory_with_get(link_hash, target_path)
+                    await self.download_directory(link_hash, target_path)
                 else:
                     # It's a file - download it
                     try:

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

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