hippius 0.2.5__tar.gz → 0.2.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hippius
-Version: 0.2.5
+Version: 0.2.7
 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.7}/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.7"
 __all__ = [
     "HippiusClient",
     "IPFSClient",

{hippius-0.2.5 → hippius-0.2.7}/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":
@@ -235,6 +236,15 @@ def main():
                 force=args.force if hasattr(args, "force") else False,
             )
 
+        elif args.command == "pin":
+            return run_async_handler(
+                cli_handlers.handle_pin,
+                client,
+                args.cid,
+                publish=not args.no_publish if hasattr(args, "no_publish") else True,
+                miner_ids=miner_ids,
+            )
+
         elif args.command == "ec-delete":
             return run_async_handler(
                 cli_handlers.handle_ec_delete,

{hippius-0.2.5 → hippius-0.2.7}/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]"
@@ -1565,6 +1713,117 @@ async def handle_delete(client: HippiusClient, cid: str, force: bool = False) ->
     return 0
 
 
+async def handle_pin(
+    client: HippiusClient, cid: str, publish: bool = True, miner_ids=None
+) -> int:
+    """Handle the pin command to pin a CID to IPFS and optionally publish to blockchain"""
+    from rich.panel import Panel
+
+    # First check if this CID exists
+    try:
+        exists_result = await client.exists(cid)
+        if not exists_result["exists"]:
+            error(f"CID [bold cyan]{cid}[/bold cyan] not found on IPFS")
+            return 1
+    except Exception as e:
+        warning(f"Error checking if CID exists: {e}")
+        return 1
+
+    # Create operation title based on publish flag
+    if publish:
+        info(
+            f"Preparing to pin and publish content with CID: [bold cyan]{cid}[/bold cyan]"
+        )
+        operation_title = "Pin & Publish Operation"
+    else:
+        info(f"Preparing to pin content with CID: [bold cyan]{cid}[/bold cyan]")
+        operation_title = "Pin Operation"
+
+    # Display operation details
+    operation_details = [
+        f"CID: [bold cyan]{cid}[/bold cyan]",
+        f"Publishing to blockchain: {'Enabled' if publish else 'Disabled'}",
+    ]
+    print_panel("\n".join(operation_details), title=operation_title)
+
+    # Need to authenticate if publishing to blockchain
+    if publish:
+        try:
+            # Ensure we have a keypair for substrate operations
+            _ = client.substrate_client._ensure_keypair()
+        except Exception as e:
+            warning(f"Failed to initialize blockchain client: {str(e)}")
+            warning("Will continue with pinning but blockchain publishing may fail")
+
+    # Show spinner during pinning
+    with console.status(
+        "[cyan]Pinning content to IPFS...[/cyan]", spinner="dots"
+    ) as status:
+        try:
+            # Pin the content to IPFS
+            pin_result = await client.ipfs_client.pin(cid)
+
+            if not pin_result.get("success", False):
+                error(
+                    f"Failed to pin content: {pin_result.get('message', 'Unknown error')}"
+                )
+                return 1
+
+            # If publishing to blockchain, do that now
+            if publish:
+                status.update("[cyan]Publishing content to blockchain...[/cyan]")
+
+                # Create a FileInput object for the substrate client
+                from hippius_sdk.substrate import FileInput
+
+                file_input = FileInput(file_hash=cid, file_name=f"pinned_{cid}")
+
+                # Submit the storage request
+                tx_hash = await client.substrate_client.storage_request(
+                    files=[file_input], miner_ids=miner_ids
+                )
+
+                # Create result panel with blockchain details
+                gateway_url = f"{client.ipfs_client.gateway}/ipfs/{cid}"
+                panel_details = [
+                    f"Successfully pinned and published: [bold cyan]{cid}[/bold cyan]",
+                    f"Gateway URL: [bold cyan]{gateway_url}[/bold cyan]",
+                    f"Transaction hash: [bold green]{tx_hash}[/bold green]",
+                    "\nThis content is now:",
+                    "1. Pinned to your IPFS node",
+                    "2. Published to the IPFS network",
+                    "3. Stored on the Hippius blockchain",
+                ]
+                console.print(
+                    Panel(
+                        "\n".join(panel_details),
+                        title="Operation Complete",
+                        border_style="green",
+                    )
+                )
+            else:
+                # Just pinning, no blockchain publishing
+                gateway_url = f"{client.ipfs_client.gateway}/ipfs/{cid}"
+                panel_details = [
+                    f"Successfully pinned: [bold cyan]{cid}[/bold cyan]",
+                    f"Gateway URL: [bold cyan]{gateway_url}[/bold cyan]",
+                    "\nThis content is now pinned to your IPFS node.",
+                    "It will remain available as long as your node is running.",
+                ]
+                console.print(
+                    Panel(
+                        "\n".join(panel_details),
+                        title="Pinning Complete",
+                        border_style="green",
+                    )
+                )
+
+            return 0
+        except Exception as e:
+            error(f"Error during operation: {e}")
+            return 1
+
+
 async def handle_ec_delete(
     client: HippiusClient, metadata_cid: str, force: bool = False
 ) -> int:

{hippius-0.2.5 → hippius-0.2.7}/hippius_sdk/cli_parser.py

@@ -63,13 +63,19 @@ examples:
   
   # Erasure code without publishing to global IPFS network
   hippius erasure-code large_file.avi --no-publish
-  
+
   # Reconstruct an erasure-coded file
   hippius reconstruct QmMetadataHash reconstructed_file.mp4
-  
+
+  # Pin a CID to IPFS and publish to blockchain
+  hippius pin QmHash
+
+  # Pin a CID to IPFS without publishing to blockchain
+  hippius pin QmHash --no-publish
+
   # Delete a file from IPFS and marketplace
   hippius delete QmHash
-  
+
   # Delete an erasure-coded file and all its chunks
   hippius ec-delete QmMetadataHash
 """,
@@ -250,6 +256,23 @@ def add_storage_commands(subparsers):
         help="Delete without confirmation prompt",
     )
 
+    # Pin command
+    pin_parser = subparsers.add_parser(
+        "pin",
+        help="Pin a CID to IPFS and publish to blockchain",
+    )
+    pin_parser.add_argument("cid", help="CID to pin")
+    pin_parser.add_argument(
+        "--publish",
+        action="store_true",
+        help="Publish file to IPFS and store on the blockchain (default)",
+    )
+    pin_parser.add_argument(
+        "--no-publish",
+        action="store_true",
+        help="Don't publish file to blockchain (local pinning only)",
+    )
+
     # Keygen command
     keygen_parser = subparsers.add_parser(
         "keygen", help="Generate an encryption key for secure file storage"

{hippius-0.2.5 → hippius-0.2.7}/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.7}/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.7}/pyproject.toml

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