PyPI - hippius - Versions diffs - 0.2.4__py3-none-any.whl → 0.2.5__py3-none-any.whl - Mend

hippius 0.2.4py3-none-any.whl → 0.2.5py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

{hippius-0.2.4.dist-info → hippius-0.2.5.dist-info}/METADATA +1 -1
hippius-0.2.5.dist-info/RECORD +17 -0
hippius_sdk/__init__.py +21 -10
hippius_sdk/cli.py +11 -0
hippius_sdk/cli_handlers.py +256 -48
hippius_sdk/cli_parser.py +20 -0
hippius_sdk/cli_rich.py +8 -2
hippius_sdk/client.py +5 -3
hippius_sdk/errors.py +77 -0
hippius_sdk/ipfs.py +237 -297
hippius_sdk/ipfs_core.py +209 -9
hippius_sdk/substrate.py +101 -14
hippius-0.2.4.dist-info/RECORD +0 -16
{hippius-0.2.4.dist-info → hippius-0.2.5.dist-info}/WHEEL +0 -0
{hippius-0.2.4.dist-info → hippius-0.2.5.dist-info}/entry_points.txt +0 -0

hippius_sdk/ipfs_core.py CHANGED Viewed

@@ -143,16 +143,65 @@ class AsyncIPFSClient:
     async def ls(self, cid: str) -> Dict[str, Any]:
         """
         List objects linked to the specified CID.
+        Detects if the CID is a directory and returns links to its contents.
         Args:
             cid: Content Identifier
         Returns:
-            Dict with links information
+            Dict with links information and a is_directory flag
         """
-        response = await self.client.post(f"{self.api_url}/api/v0/ls?arg={cid}")
-        response.raise_for_status()
-        return response.json()
+        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
+        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
     async def exists(self, cid: str) -> bool:
         """
@@ -173,19 +222,170 @@ class AsyncIPFSClient:
     async def download_file(self, cid: str, output_path: str) -> str:
         """
         Download content from IPFS to a file.
+        If the CID is a directory, it will create a directory and download all files.
         Args:
             cid: Content identifier
-            output_path: Path where to save the file
+            output_path: Path where to save the file/directory
+        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
+        # If we reached here, treat it as a regular file
+        try:
+            # Regular file download
+            content = await self.cat(cid)
+            # Ensure the parent directory exists
+            os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True)
+            with open(output_path, "wb") as f:
+                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
+    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 file
+            Path to the saved directory
         """
-        content = await self.cat(cid)
-        with open(output_path, "wb") as f:
-            f.write(content)
+        # 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.
+        Args:
+            cid: Content identifier of the directory
+            output_path: Path where to save the directory
+        Returns:
+            Path to the saved directory
+        """
+        # First, get the directory listing to find all contents
+        try:
+            ls_result = await self.ls(cid)
+            # Create target directory
+            os.makedirs(output_path, exist_ok=True)
+            # Extract all links from the directory listing
+            links = []
+            if "Objects" in ls_result and ls_result["Objects"]:
+                for obj in ls_result["Objects"]:
+                    if "Links" in obj:
+                        links.extend(obj["Links"])
+            # Download each item (file or directory)
+            for link in links:
+                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
+                # Build the target path
+                target_path = os.path.join(output_path, link_name)
+                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)
+                else:
+                    # It's a file - download it
+                    try:
+                        content = await self.cat(link_hash)
+                        os.makedirs(
+                            os.path.dirname(os.path.abspath(target_path)), exist_ok=True
+                        )
+                        with open(target_path, "wb") as f:
+                            f.write(content)
+                    except Exception as file_error:
+                        print(f"Failed to download file {link_name}: {str(file_error)}")
+            return output_path
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to download directory using 'get' command: {str(e)}"
+            )
     async def add_directory(
         self, dir_path: str, recursive: bool = True
     ) -> Dict[str, Any]:

hippius_sdk/substrate.py CHANGED Viewed

@@ -11,12 +11,27 @@ from dotenv import load_dotenv
 from mnemonic import Mnemonic
 from substrateinterface import Keypair, SubstrateInterface
-from hippius_sdk.config import (get_account_address, get_active_account,
-                                get_all_config, get_config_value,
-                                get_seed_phrase, set_active_account,
-                                set_seed_phrase)
-from hippius_sdk.utils import (format_size, hex_to_ipfs_cid,
-                               initialize_substrate_connection)
+from hippius_sdk.config import (
+    get_account_address,
+    get_active_account,
+    get_all_config,
+    get_config_value,
+    get_seed_phrase,
+    set_active_account,
+    set_seed_phrase,
+)
+from hippius_sdk.errors import (
+    HippiusAlreadyDeletedError,
+    HippiusFailedSubstrateDelete,
+    HippiusNotFoundError,
+    HippiusSubstrateAuthError,
+    HippiusSubstrateConnectionError,
+)
+from hippius_sdk.utils import (
+    format_size,
+    hex_to_ipfs_cid,
+    initialize_substrate_connection,
+)
 # Load environment variables
 load_dotenv()
@@ -1125,6 +1140,50 @@ class SubstrateClient:
         """
         return hex_to_ipfs_cid(hex_string)
+    async def check_storage_request_exists(self, cid: str) -> bool:
+        """
+        Check if a storage request exists for the given CID in the user's storage requests.
+        Args:
+            cid: Content Identifier (CID) to check
+        Returns:
+            bool: True if the CID exists in the user's storage requests, False otherwise
+        """
+        substrate, derived_address = initialize_substrate_connection(self)
+        if not derived_address:
+            # If we don't have a derived address, try to get the keypair
+            if not self._ensure_keypair():
+                raise ValueError("No account address available")
+            derived_address = self._keypair.ss58_address
+        # Get user storage requests to check if this CID is still stored
+        try:
+            # Get all user storage requests
+            user_files = await self.get_user_files(derived_address)
+            # Check if the CID is in the list
+            for file in user_files:
+                if file.get("cid") == cid or file.get("file_hash") == cid:
+                    return True
+            # If we didn't find it, try one more approach by querying pinning status
+            try:
+                pinning_status = self.get_pinning_status(derived_address)
+                for request in pinning_status:
+                    if request.get("cid") == cid:
+                        return True
+            except:
+                # If pinning status check fails, assume it doesn't exist
+                pass
+            # If we get here, the CID was not found
+            return False
+        except Exception:
+            # If we encounter an error checking, we'll assume it exists to be safe
+            return True
     async def cancel_storage_request(self, cid: str) -> str:
         """
         Cancel a storage request by CID from the Hippius blockchain.
@@ -1133,10 +1192,30 @@ class SubstrateClient:
             cid: Content Identifier (CID) of the file to cancel
         Returns:
-            str: Transaction hash
+            str: Transaction hash or status message
         """
+        # First check if this CID exists in the user's storage requests
+        try:
+            cid_exists = await self.check_storage_request_exists(cid)
+            if not cid_exists:
+                raise HippiusAlreadyDeletedError(
+                    f"CID {cid} is not found in storage requests - may already be deleted"
+                )
+        except Exception as e:
+            if not isinstance(e, HippiusAlreadyDeletedError):
+                # If there was an error checking, but not our custom exception, wrap it
+                raise HippiusSubstrateConnectionError(
+                    f"Error checking if CID exists: {str(e)}"
+                )
+            else:
+                # Re-raise our custom exception
+                raise
+        # Continue with cancellation if it exists
         if not self._ensure_keypair():
-            raise ValueError("Seed phrase must be set before making transactions")
+            raise HippiusSubstrateAuthError(
+                "Seed phrase must be set before making transactions"
+            )
         substrate, _ = initialize_substrate_connection(self)
@@ -1157,9 +1236,17 @@ class SubstrateClient:
         fee_tokens = fee / 10**12 if fee > 0 else 0
         print(f"Estimated transaction fee: {fee} ({fee_tokens:.10f} tokens)")
-        extrinsic = self._substrate.create_signed_extrinsic(
-            call=call, keypair=self._keypair
-        )
-        response = self._substrate.submit_extrinsic(extrinsic, wait_for_inclusion=True)
-        print(f"Transaction hash: {response.extrinsic_hash}")
-        return response.extrinsic_hash
+        try:
+            extrinsic = self._substrate.create_signed_extrinsic(
+                call=call, keypair=self._keypair
+            )
+            response = self._substrate.submit_extrinsic(
+                extrinsic, wait_for_inclusion=True
+            )
+            print(f"Transaction hash: {response.extrinsic_hash}")
+            return response.extrinsic_hash
+        except Exception as e:
+            # If the transaction failed, raise our custom exception
+            raise HippiusFailedSubstrateDelete(
+                f"Failed to cancel storage request: {str(e)}"
+            )

hippius-0.2.4.dist-info/RECORD DELETED Viewed

@@ -1,16 +0,0 @@
-hippius_sdk/__init__.py,sha256=WB2RYx8ds2QhT-f4WG6MJOzTNgwLySizDm2l44HCC-o,1572
-hippius_sdk/cli.py,sha256=9pEbs84-I7XTzTEdlJYwy48ziciomwj37SdJTg4fRVQ,17294
-hippius_sdk/cli_assets.py,sha256=V3MX63QTiex6mCp0VDXQJ7cagm5v1s4xtsu8c1O4G_k,371
-hippius_sdk/cli_handlers.py,sha256=UAQN-qHeIIa_x_wIfgQnfReijFstQTLLCyL7TpX-EMY,104306
-hippius_sdk/cli_parser.py,sha256=uh3JX6Jh9HiCHxyzNupjwYYayMwr6mzSKMabsAFTL_w,18892
-hippius_sdk/cli_rich.py,sha256=Z8bH3c9r7zWIWOKUoRUfz-d8rdgtIFP4s33sBwWCDYw,7324
-hippius_sdk/client.py,sha256=69g3OH280ulwHwdlaUGSlIVHkVWMgg_fPG5YPk1sN6k,16828
-hippius_sdk/config.py,sha256=sCWD2remLa-FodvxC2O45tiNSJD7gzv9idIStX9sF_k,21240
-hippius_sdk/ipfs.py,sha256=LOVXItshcH7QFnT3ijOWc3byuWgSFPTrtl9d-CzGINs,73734
-hippius_sdk/ipfs_core.py,sha256=AS5jjpJ9lbC5wbDP_asB3-pZBEpHsE9VjL8aQA5VUxM,7291
-hippius_sdk/substrate.py,sha256=XJ5ONcUOifyiYisKpaZhuapVn4tPBBtKa6aX3Twylig,44530
-hippius_sdk/utils.py,sha256=Ur7P_7iVnXXYvbg7a0aVrdN_8NkVxjhdngn8NzR_zpc,7066
-hippius-0.2.4.dist-info/METADATA,sha256=23L-M4rBxki07nCRwvwSvQiA_6knAGP8BDFniNJxTx8,29992
-hippius-0.2.4.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-hippius-0.2.4.dist-info/entry_points.txt,sha256=b1lo60zRXmv1ud-c5BC-cJcAfGE5FD4qM_nia6XeQtM,98
-hippius-0.2.4.dist-info/RECORD,,

{hippius-0.2.4.dist-info → hippius-0.2.5.dist-info}/WHEEL RENAMED Viewed

File without changes

{hippius-0.2.4.dist-info → hippius-0.2.5.dist-info}/entry_points.txt RENAMED Viewed

File without changes

hippius 0.2.4__py3-none-any.whl → 0.2.5__py3-none-any.whl

hippius 0.2.4py3-none-any.whl → 0.2.5py3-none-any.whl