hippius 0.2.5__tar.gz → 0.2.6__tar.gz

{hippius-0.2.5 → hippius-0.2.6}/PKG-INFO

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

{hippius-0.2.5 → hippius-0.2.6}/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.5"
+__version__ = "0.2.6"
 __all__ = [
     "HippiusClient",
     "IPFSClient",

{hippius-0.2.5 → hippius-0.2.6}/hippius_sdk/cli.py

@@ -152,6 +152,7 @@ def main():
                 args.file_path,
                 miner_ids,
                 encrypt=encrypt,
+                publish=not args.no_publish if hasattr(args, "no_publish") else True,
             )
 
         elif args.command == "store-dir":

{hippius-0.2.5 → hippius-0.2.6}/hippius_sdk/cli_handlers.py

@@ -51,6 +51,7 @@ from hippius_sdk.errors import (
     HippiusFailedSubstrateDelete,
     HippiusMetadataError,
 )
+from hippius_sdk.substrate import FileInput
 
 try:
     import nacl.secret
@@ -246,6 +247,7 @@ async def handle_store(
     file_path: str,
     miner_ids: Optional[List[str]] = None,
     encrypt: Optional[bool] = None,
+    publish: bool = True,
 ) -> int:
     """Handle the store command (upload file to IPFS and store on Substrate)"""
     if not os.path.exists(file_path):
@@ -256,6 +258,16 @@ async def handle_store(
         error(f"[bold]{file_path}[/bold] is not a file")
         return 1
 
+    # If publishing is enabled, ensure we have a valid substrate client by accessing it
+    # This will trigger password prompts if needed right at the beginning
+    if publish and hasattr(client, "substrate_client") and client.substrate_client:
+        try:
+            # Force keypair initialization - this will prompt for password if needed
+            _ = client.substrate_client._ensure_keypair()
+        except Exception as e:
+            warning(f"Failed to initialize blockchain client: {str(e)}")
+            warning("Will continue with upload but blockchain publishing may fail")
+
     # Get file size for display
     file_size = os.path.getsize(file_path)
     file_name = os.path.basename(file_path)
@@ -282,6 +294,19 @@ async def handle_store(
             "[bold yellow]Encryption: Using default setting[/bold yellow]"
         )
 
+    # Add publishing status
+    if not publish:
+        upload_info.append(
+            "[bold yellow]Publishing: Disabled (local upload only)[/bold yellow]"
+        )
+        log(
+            "\nUpload will be local only - not publishing to blockchain or pinning to IPFS"
+        )
+    else:
+        upload_info.append(
+            "[bold green]Publishing: Enabled (publishing to blockchain)[/bold green]"
+        )
+
     # Parse miner IDs if provided
     miner_id_list = None
     if miner_ids:
@@ -318,13 +343,51 @@ async def handle_store(
         updater = asyncio.create_task(update_progress())
 
         try:
-            # Use the store_file method
+            # Use the upload_file method to get the CID
             result = await client.upload_file(
                 file_path=file_path,
                 encrypt=encrypt,
-                # miner_ids=miner_id_list
             )
 
+            # If publishing is enabled, store on blockchain
+            if publish and result.get("cid"):
+                try:
+                    # Pin and publish the file globally
+                    # First pin in IPFS (essential step for publishing)
+                    await client.ipfs_client.pin(result["cid"])
+
+                    # Then publish globally to make available across network
+                    publish_result = await client.ipfs_client.publish_global(
+                        result["cid"]
+                    )
+
+                    log(
+                        "\n[green]File has been pinned to IPFS and published to the network[/green]"
+                    )
+
+                    # Add gateway URL to the result for use in output
+                    if "cid" in result:
+                        result[
+                            "gateway_url"
+                        ] = f"{client.ipfs_client.gateway}/ipfs/{result['cid']}"
+
+                    # Store on blockchain if miners are provided
+                    if miner_ids:
+                        # Create a file input for blockchain storage
+                        file_input = FileInput(
+                            file_hash=result["cid"], file_name=file_name
+                        )
+
+                        # Submit storage request
+                        tx_hash = await client.substrate_client.storage_request(
+                            files=[file_input], miner_ids=miner_id_list
+                        )
+
+                        # Add transaction hash to result
+                        result["transaction_hash"] = tx_hash
+                except Exception as e:
+                    warning(f"Failed to publish file globally: {str(e)}")
+
             progress.update(task, completed=100)
             updater.cancel()
 
@@ -336,16 +399,24 @@ async def handle_store(
                 f"IPFS CID: [bold cyan]{result['cid']}[/bold cyan]",
             ]
 
-            if result.get("gateway_url"):
-                success_info.append(
-                    f"Gateway URL: [link]{result['gateway_url']}[/link]"
-                )
+            # Always add the gateway URL
+            gateway_url = result.get("gateway_url")
+            if not gateway_url and "cid" in result:
+                gateway_url = f"{client.ipfs_client.gateway}/ipfs/{result['cid']}"
+
+            if gateway_url:
+                success_info.append(f"Gateway URL: [link]{gateway_url}[/link]")
 
             if result.get("encrypted"):
                 success_info.append(
                     "[bold yellow]File was encrypted during upload[/bold yellow]"
                 )
 
+            if not publish:
+                success_info.append(
+                    "[bold yellow]File was uploaded locally only (not published to blockchain)[/bold yellow]"
+                )
+
             print_panel("\n".join(success_info), title="Upload Successful")
 
             # If we stored in the marketplace
@@ -382,6 +453,16 @@ async def handle_store_dir(
         error(f"[bold]{dir_path}[/bold] is not a directory")
         return 1
 
+    # If publishing is enabled, ensure we have a valid substrate client by accessing it
+    # This will trigger password prompts if needed right at the beginning
+    if publish and hasattr(client, "substrate_client") and client.substrate_client:
+        try:
+            # Force keypair initialization - this will prompt for password if needed
+            _ = client.substrate_client._ensure_keypair()
+        except Exception as e:
+            warning(f"Failed to initialize blockchain client: {str(e)}")
+            warning("Will continue with upload but blockchain publishing may fail")
+
     # Upload information panel
     upload_info = [f"Directory: [bold]{dir_path}[/bold]"]
 
@@ -460,14 +541,62 @@ async def handle_store_dir(
                     del result["transaction_hash"]
             else:
                 # If we want to publish, make sure files are pinned globally
-                for file_info in result.get("files", []):
-                    if "cid" in file_info:
-                        try:
-                            await client.ipfs_client.publish_global(file_info["cid"])
-                        except Exception as e:
-                            warning(
-                                f"Failed to publish file {file_info['name']} globally: {str(e)}"
-                            )
+                try:
+                    # Add gateway URL to the result for use in output
+                    if "cid" in result:
+                        result[
+                            "gateway_url"
+                        ] = f"{client.ipfs_client.gateway}/ipfs/{result['cid']}"
+
+                    # Pin and publish the directory root CID globally
+                    # First pin in IPFS (essential step for publishing)
+                    await client.ipfs_client.pin(result["cid"])
+
+                    # Then publish globally to make available across network
+                    await client.ipfs_client.publish_global(result["cid"])
+
+                    log(
+                        "\n[green]Directory has been pinned to IPFS and published to the network[/green]"
+                    )
+
+                    # Also pin and publish individual files if available
+                    for file_info in result.get("files", []):
+                        if "cid" in file_info:
+                            try:
+                                # Pin each file to ensure availability
+                                await client.ipfs_client.pin(file_info["cid"])
+
+                                # Then publish globally
+                                await client.ipfs_client.publish_global(
+                                    file_info["cid"]
+                                )
+                            except Exception as e:
+                                warning(
+                                    f"Failed to publish file {file_info['name']} globally: {str(e)}"
+                                )
+
+                    # Store on blockchain if miners are provided - this is what requires a password
+                    if (
+                        miner_ids
+                        and hasattr(client, "substrate_client")
+                        and client.substrate_client
+                    ):
+                        # Create a file input for blockchain storage
+                        file_input = FileInput(
+                            file_hash=result["cid"],
+                            file_name=os.path.basename(dir_path),
+                        )
+
+                        # This will prompt for a password if needed
+                        tx_hash = await client.substrate_client.storage_request(
+                            files=[file_input], miner_ids=miner_id_list
+                        )
+
+                        # Add transaction hash to result
+                        result["transaction_hash"] = tx_hash
+
+                except Exception as e:
+                    warning(f"Failed to publish directory globally: {str(e)}")
 
             # Complete the progress
             progress.update(task, completed=100)
@@ -482,9 +611,23 @@ async def handle_store_dir(
                 f"Directory CID: [bold cyan]{result['cid']}[/bold cyan]",
             ]
 
-            if result.get("gateway_url"):
+            # Always add the gateway URL
+            gateway_url = result.get("gateway_url")
+            if not gateway_url and "cid" in result:
+                gateway_url = f"{client.ipfs_client.gateway}/ipfs/{result['cid']}"
+
+            if gateway_url:
+                success_info.append(f"Gateway URL: [link]{gateway_url}[/link]")
+
+            # Add encryption and publish status to success info
+            if result.get("encrypted"):
+                success_info.append(
+                    "[bold yellow]Directory was encrypted during upload[/bold yellow]"
+                )
+
+            if not publish:
                 success_info.append(
-                    f"Gateway URL: [link]{result['gateway_url']}[/link]"
+                    "[bold yellow]Directory was uploaded locally only (not published to blockchain)[/bold yellow]"
                 )
 
             print_panel("\n".join(success_info), title="Directory Upload Successful")
@@ -508,10 +651,15 @@ async def handle_store_dir(
                 )
 
             # If publishing is enabled and we stored in the marketplace
-            if publish and "transaction_hash" in result:
-                log(
-                    f"\nStored in marketplace. Transaction hash: [bold]{result['transaction_hash']}[/bold]"
-                )
+            if publish:
+                # We only include transaction hash stuff if we actually created a blockchain transaction
+                if "transaction_hash" in result:
+                    log(
+                        f"\nStored in marketplace. Transaction hash: [bold]{result['transaction_hash']}[/bold]"
+                    )
+                else:
+                    # If publish is true but no transaction hash, just indicate files were published to IPFS
+                    log("\n[green]Directory was published to IPFS network.[/green]")
             elif not publish:
                 log(
                     "\n[yellow]Files were uploaded locally only. No blockchain publication or IPFS pinning.[/yellow]"

{hippius-0.2.5 → hippius-0.2.6}/hippius_sdk/ipfs.py

@@ -443,6 +443,7 @@ class IPFSClient:
         output_path: str,
         decrypt: Optional[bool] = None,
         max_retries: int = 3,
+        skip_directory_check: bool = False,
     ) -> Dict[str, Any]:
         """
         Download a file from IPFS with optional decryption.
@@ -453,6 +454,7 @@ class IPFSClient:
             output_path: Path where the downloaded file/directory will be saved
             decrypt: 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:
@@ -470,15 +472,17 @@ class IPFSClient:
         """
         start_time = time.time()
 
-        # Use the improved ls function to properly detect directories
+        # Skip directory check if requested (important for erasure code chunks)
         is_directory = False
-        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 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:
@@ -530,7 +534,10 @@ class IPFSClient:
             else:
                 download_path = output_path
 
-            await self.client.download_file(cid, download_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:
@@ -1225,8 +1232,12 @@ class IPFSClient:
                         async def download_chunk(cid, path, chunk_info):
                             async with encoded_chunks_semaphore:
                                 try:
+                                    # Always skip directory check for erasure code chunks
                                     await self.download_file(
-                                        cid, path, max_retries=max_retries
+                                        cid,
+                                        path,
+                                        max_retries=max_retries,
+                                        skip_directory_check=True,
                                     )
 
                                     # Read chunk data

{hippius-0.2.5 → hippius-0.2.6}/hippius_sdk/ipfs_core.py

@@ -219,7 +219,9 @@ class AsyncIPFSClient:
         except httpx.HTTPError:
             return False
 
-    async def download_file(self, cid: str, output_path: str) -> str:
+    async def download_file(
+        self, cid: str, output_path: str, skip_directory_check: bool = False
+    ) -> str:
         """
         Download content from IPFS to a file.
         If the CID is a directory, it will create a directory and download all files.
@@ -227,19 +229,22 @@ class AsyncIPFSClient:
         Args:
             cid: Content identifier
             output_path: Path where to save the file/directory
+            skip_directory_check: If True, skip directory check (useful for erasure code chunks)
 
         Returns:
             Path to the saved file/directory
         """
-        # First, check if this is a directory using the improved ls function
-        try:
-            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)
-        except Exception:
-            # If ls check fails, continue with regular file download
-            pass
+        # Skip directory check if requested (useful for erasure code chunks)
+        if not skip_directory_check:
+            # First, check if this is a directory using the improved ls function
+            try:
+                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)
+            except Exception:
+                # If ls check fails, continue with regular file download
+                pass
 
         # If we reached here, treat it as a regular file
         try:
@@ -251,13 +256,14 @@ class AsyncIPFSClient:
                 f.write(content)
             return output_path
         except Exception as e:
-            # As a last resort, try using the get command anyway
-            # This is helpful if the CID is a directory but we failed to detect it
-            try:
-                return await self.download_directory_with_get(cid, output_path)
-            except Exception:
-                # If all methods fail, re-raise the original error
-                raise e
+            # 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)
+                except Exception:
+                    pass
+            # Raise the original error
+            raise e
 
     async def download_directory(self, cid: str, output_path: str) -> str:
         """

{hippius-0.2.5 → hippius-0.2.6}/pyproject.toml

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