hippius 0.2.38__tar.gz → 0.2.40__tar.gz

{hippius-0.2.38 → hippius-0.2.40}/PKG-INFO

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

{hippius-0.2.38 → hippius-0.2.40}/hippius_sdk/__init__.py

@@ -23,15 +23,14 @@ from hippius_sdk.config import (
     set_encryption_key,
     set_seed_phrase,
 )
-from hippius_sdk.ipfs import IPFSClient, S3PublishResult, S3PublishPin, S3DownloadResult
+from hippius_sdk.ipfs import IPFSClient, S3PublishResult, S3DownloadResult
 from hippius_sdk.utils import format_cid, format_size, hex_to_ipfs_cid
 
-__version__ = "0.2.38"
+__version__ = "0.2.40"
 __all__ = [
     "HippiusClient",
     "IPFSClient",
     "S3PublishResult",
-    "S3PublishPin",
     "S3DownloadResult",
     "get_config_value",
     "set_config_value",

{hippius-0.2.38 → hippius-0.2.40}/hippius_sdk/client.py

@@ -118,7 +118,9 @@ class HippiusClient:
         """
         # Use the enhanced IPFSClient method directly with encryption parameter
         return await self.ipfs_client.upload_file(
-            file_path, encrypt=encrypt, seed_phrase=seed_phrase
+            file_path,
+            encrypt=encrypt,
+            seed_phrase=seed_phrase,
         )
 
     async def upload_directory(
@@ -522,6 +524,7 @@ class HippiusClient:
         seed_phrase: str,
         subaccount_id: str,
         bucket_name: str,
+        file_name: str = None,
         store_node: str = "http://localhost:5001",
         pin_node: str = "https://store.hippius.network",
         substrate_url: str = "wss://rpc.hippius.network",
@@ -535,6 +538,7 @@ class HippiusClient:
         2. Pins to pin_node (remote) for persistence and backup
 
         Args:
+            file_name: The original file name.
             file_path: Path to the file to publish
             encrypt: Whether to encrypt the file before uploading
             seed_phrase: Seed phrase for blockchain transaction signing
@@ -565,6 +569,7 @@ class HippiusClient:
             pin_node,
             substrate_url,
             publish,
+            file_name=file_name,
         )
 
     async def s3_download(

{hippius-0.2.38 → hippius-0.2.40}/hippius_sdk/ipfs.py

@@ -1,6 +1,7 @@
 """
 IPFS operations for the Hippius SDK.
 """
+
 import asyncio
 import base64
 import hashlib
@@ -129,7 +130,7 @@ class IPFSClient:
 
         try:
             self.client = AsyncIPFSClient(api_url=api_url, gateway=self.gateway)
-        except httpx.ConnectError as e:
+        except httpx.ConnectError:
             print(
                 f"Warning: Falling back to local IPFS daemon, but still using gateway={self.gateway}"
             )
@@ -241,6 +242,7 @@ class IPFSClient:
         encrypt: Optional[bool] = None,
         max_retries: int = 3,
         seed_phrase: Optional[str] = None,
+        file_name: str = None,
     ) -> Dict[str, Any]:
         """
         Upload a file to IPFS with optional encryption.
@@ -251,6 +253,7 @@ class IPFSClient:
             encrypt: Whether to encrypt the file (overrides default)
             max_retries: Maximum number of retry attempts (default: 3)
             seed_phrase: Optional seed phrase to use for blockchain interactions (uses config if None)
+            file_name: The original file name
 
         Returns:
             Dict[str, Any]: Dictionary containing:
@@ -278,7 +281,7 @@ class IPFSClient:
             )
 
         # Get file info before upload
-        filename = os.path.basename(file_path)
+        file_name = file_name if file_name else os.path.basename(file_path)
         size_bytes = os.path.getsize(file_path)
 
         # If encryption is requested, encrypt the file first
@@ -303,7 +306,10 @@ class IPFSClient:
                 # Use the original file for upload
                 upload_path = file_path
 
-            result = await self.client.add_file(upload_path)
+            result = await self.client.add_file(
+                upload_path,
+                file_name=file_name,
+            )
             cid = result["Hash"]
 
         finally:
@@ -314,7 +320,7 @@ class IPFSClient:
         # Format the result
         result = {
             "cid": cid,
-            "filename": filename,
+            "filename": file_name,
             "size_bytes": size_bytes,
             "encrypted": should_encrypt,
         }
@@ -1411,7 +1417,7 @@ class IPFSClient:
 
             for i, chunk in enumerate(reconstructed_chunks):
                 if verbose and i % 10 == 0:
-                    print(f"Processing chunk {i+1}/{len(reconstructed_chunks)}...")
+                    print(f"Processing chunk {i + 1}/{len(reconstructed_chunks)}...")
 
                 # For all chunks except the last one, use full chunk size
                 if i < len(reconstructed_chunks) - 1:
@@ -1750,8 +1756,9 @@ class IPFSClient:
                 # Record the child files that were processed
                 result["child_files"] = child_files
         except Exception as e:
-            print(f"Warning: Failed to check if CID is a directory: {e}")
-            # Continue with regular file unpin
+            print(
+                f"Warning: Failed to check if CID is a directory: {e}"
+            )  # Continue with regular file unpin
 
         # Now unpin the main file/directory
         if unpin:
@@ -1821,7 +1828,8 @@ class IPFSClient:
         cancel_from_blockchain: bool = True,
         parallel_limit: int = 20,
         seed_phrase: Optional[str] = None,
-        metadata_timeout: int = 30,  # Timeout in seconds for metadata fetch
+        metadata_timeout: int = 30,
+        # Timeout in seconds for metadata fetch
     ) -> bool:
         """
         Delete an erasure-coded file, including all its chunks in parallel.
@@ -1863,8 +1871,7 @@ class IPFSClient:
                 except asyncio.TimeoutError:
                     print(
                         f"Timed out after {metadata_timeout}s waiting for metadata download"
-                    )
-                    # We'll continue with blockchain cancellation even without metadata
+                    )  # We'll continue with blockchain cancellation even without metadata
             except json.JSONDecodeError as e:
                 # If we can't parse the metadata JSON, record the error but continue
                 print(f"Error parsing metadata JSON: {e}")
@@ -1969,6 +1976,7 @@ class IPFSClient:
         pin_node: str = "https://store.hippius.network",
         substrate_url: str = "wss://rpc.hippius.network",
         publish: bool = True,
+        file_name: str = None,
     ) -> Union[S3PublishResult, S3PublishPin]:
         """
         Publish a file to IPFS and the Hippius marketplace in one operation.
@@ -1993,6 +2001,7 @@ class IPFSClient:
             pin_node: IPFS node URL for backup pinning (default: remote service)
             substrate_url: the substrate url to connect to for the storage request
             publish: Whether to publish to blockchain (True) or just upload to IPFS (False)
+            file_name: The original file name.
 
         Returns:
             S3PublishResult: Object containing CID, file info, and transaction hash when publish=True
@@ -2089,7 +2098,10 @@ class IPFSClient:
         # Step 1: Upload to store_node (local) for immediate availability
         try:
             store_client = AsyncIPFSClient(api_url=store_node)
-            result = await store_client.add_file(file_path)
+            result = await store_client.add_file(
+                file_path,
+                file_name=file_name,
+            )
             cid = result["Hash"]
             logger.info(f"File uploaded to store node {store_node} with CID: {cid}")
         except Exception as e:
@@ -2112,7 +2124,8 @@ class IPFSClient:
             try:
                 # Pass the seed phrase directly to avoid password prompts for encrypted config
                 substrate_client = SubstrateClient(
-                    seed_phrase=seed_phrase, url=substrate_url
+                    seed_phrase=seed_phrase,
+                    url=substrate_url,
                 )
                 logger.info(
                     f"Submitting storage request to substrate for file: {filename}, CID: {cid}"
@@ -2203,7 +2216,7 @@ class IPFSClient:
         """
         start_time = time.time()
 
-        # Download the file directly from the specified download_node
+        # Download the file directly into memory from the specified download_node
         try:
             # Create parent directories if they don't exist
             os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True)
@@ -2211,41 +2224,31 @@ class IPFSClient:
             download_client = AsyncIPFSClient(api_url=download_node)
 
             download_url = f"{download_node.rstrip('/')}/api/v0/cat?arg={cid}"
+
+            # Download file into memory
+            file_data = bytearray()
             async with download_client.client.stream("POST", download_url) as response:
                 response.raise_for_status()
+                async for chunk in response.aiter_bytes(chunk_size=8192):
+                    file_data.extend(chunk)
 
-                with open(output_path, "wb") as f:
-                    async for chunk in response.aiter_bytes(chunk_size=8192):
-                        f.write(chunk)
-
-            logger.info(f"File downloaded from {download_node} with CID: {cid}")
+            # Convert to bytes for consistency
+            file_data = bytes(file_data)
+            logger.info(
+                f"File downloaded from {download_node} with CID: {cid} ({len(file_data)} bytes)"
+            )
 
         except Exception as e:
             raise HippiusIPFSError(
                 f"Failed to download file from {download_node}: {str(e)}"
             )
 
-        # Get file info after download
-        size_bytes = os.path.getsize(output_path)
-        elapsed_time = time.time() - start_time
-
         # Attempt automatic decryption if requested
         decrypted = False
         encryption_key_used = None
+        final_data = file_data  # This will hold either encrypted or decrypted data
 
         if auto_decrypt:
-            # Check if key storage is enabled and available
-            try:
-                key_storage_available = is_key_storage_enabled()
-                logger.debug(f"Key storage enabled: {key_storage_available}")
-            except ImportError:
-                logger.debug("Key storage module not available")
-                key_storage_available = False
-
-            # Read the downloaded file content
-            with open(output_path, "rb") as f:
-                file_data = f.read()
-
             # Check if file is empty - this indicates a problem
             if len(file_data) == 0:
                 logger.error(f"Downloaded file is empty (0 bytes) for CID: {cid}")
@@ -2263,6 +2266,14 @@ class IPFSClient:
                 decrypted = False
                 encryption_key_used = None
             else:
+                # Check if key storage is enabled and available
+                try:
+                    key_storage_available = is_key_storage_enabled()
+                    logger.debug(f"Key storage enabled: {key_storage_available}")
+                except ImportError:
+                    logger.debug("Key storage module not available")
+                    key_storage_available = False
+
                 # File has content, attempt decryption if requested
                 decryption_attempted = False
                 decryption_successful = False
@@ -2292,17 +2303,10 @@ class IPFSClient:
                                     existing_key_b64
                                 )
                                 box = nacl.secret.SecretBox(encryption_key_bytes)
-                                decrypted_data = box.decrypt(file_data)
-
-                                # Write the decrypted data back to the file
-                                with open(output_path, "wb") as f:
-                                    f.write(decrypted_data)
+                                final_data = box.decrypt(file_data)
 
                                 decryption_successful = True
                                 decrypted = True
-                                size_bytes = len(
-                                    decrypted_data
-                                )  # Update size to decrypted size
                                 logger.info(
                                     "Successfully decrypted file using stored key"
                                 )
@@ -2310,8 +2314,7 @@ class IPFSClient:
                             except Exception as decrypt_error:
                                 logger.debug(
                                     f"Decryption failed with stored key: {decrypt_error}"
-                                )
-                                # Continue to try fallback decryption
+                                )  # Continue to try fallback decryption
                         else:
                             logger.debug(
                                 "No encryption key found for account+bucket combination"
@@ -2326,17 +2329,10 @@ class IPFSClient:
                     decryption_attempted = True
 
                     try:
-                        decrypted_data = self.decrypt_data(file_data)
-
-                        # Write the decrypted data back to the file
-                        with open(output_path, "wb") as f:
-                            f.write(decrypted_data)
+                        final_data = self.decrypt_data(file_data)
 
                         decryption_successful = True
                         decrypted = True
-                        size_bytes = len(
-                            decrypted_data
-                        )  # Update size to decrypted size
 
                         # Store the encryption key for the result
                         encryption_key_used = (
@@ -2361,6 +2357,14 @@ class IPFSClient:
                 elif not decryption_attempted:
                     logger.debug("No decryption attempted - no keys available")
 
+        # Write the final data (encrypted or decrypted) to disk once
+        with open(output_path, "wb") as f:
+            f.write(final_data)
+
+        # Get final file info
+        size_bytes = len(final_data)
+        elapsed_time = time.time() - start_time
+
         return S3DownloadResult(
             cid=cid,
             output_path=output_path,

{hippius-0.2.38 → hippius-0.2.40}/hippius_sdk/ipfs_core.py

@@ -48,11 +48,16 @@ class AsyncIPFSClient:
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         await self.close()
 
-    async def add_file(self, file_path: str) -> Dict[str, Any]:
+    async def add_file(
+        self,
+        file_path: str,
+        file_name: str = None,
+    ) -> Dict[str, Any]:
         """
         Add a file to IPFS.
 
         Args:
+            file_name: Name of the file
             file_path: Path to the file to add
 
         Returns:
@@ -60,9 +65,9 @@ class AsyncIPFSClient:
         """
         with open(file_path, "rb") as f:
             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")}
+            file_name = file_name if file_name else os.path.basename(file_path)
+            files = {"file": (file_name, 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&cid-version=1",

{hippius-0.2.38 → hippius-0.2.40}/pyproject.toml

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