hippius 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

hippius_sdk/config.py

@@ -740,5 +740,76 @@ def reset_config() -> bool:
     return save_config(DEFAULT_CONFIG.copy())
 
 
+def get_keypair(
+    ss58_address: Optional[str] = None, account_name: Optional[str] = None
+) -> "Keypair":
+    """
+    Get a Keypair object for a given SS58 address or account name.
+
+    This function will attempt to find the specified account and generate
+    a Keypair object using the stored seed phrase.
+
+    Args:
+        ss58_address: SS58 address of the account
+        account_name: Name of the account (used if ss58_address is None)
+
+    Returns:
+        Keypair: A substrate Keypair object
+
+    Raises:
+        ValueError: If the account cannot be found or if the seed phrase is not available
+        ImportError: If the required dependencies are not installed
+    """
+    # Import here to avoid circular imports
+    try:
+        from substrateinterface import Keypair
+    except ImportError:
+        raise ImportError(
+            "Substrate interface is required to get a keypair. "
+            "Install with: pip install substrate-interface"
+        )
+
+    # If ss58_address is provided, look for a matching account
+    if ss58_address:
+        accounts = list_accounts()
+        found_account = None
+
+        for name, data in accounts.items():
+            if data.get("ss58_address") == ss58_address:
+                found_account = name
+                break
+
+        if found_account:
+            account_name = found_account
+        else:
+            raise ValueError(f"No account found with SS58 address: {ss58_address}")
+
+    # If no account_name by this point, use the active account
+    if not account_name:
+        account_name = get_active_account()
+        if not account_name:
+            raise ValueError(
+                "No account specified and no active account. "
+                "Set an active account with: hippius account switch <account_name>"
+            )
+
+    # Get the seed phrase for the account
+    seed_phrase = get_seed_phrase(account_name=account_name)
+    if not seed_phrase:
+        if get_config_value("substrate", "seed_phrase_encoded"):
+            raise ValueError(
+                f"The seed phrase for account '{account_name}' is encrypted. "
+                f"Please decrypt it first with: hippius seed decode --account {account_name}"
+            )
+        else:
+            raise ValueError(
+                f"No seed phrase found for account '{account_name}'. "
+                f'Set one with: hippius seed set "your seed phrase" --account {account_name}'
+            )
+
+    # Create and return the keypair
+    return Keypair.create_from_mnemonic(seed_phrase)
+
+
 # Initialize configuration on module import
 ensure_config_dir()

hippius_sdk/substrate.py

@@ -599,6 +599,29 @@ class SubstrateClient:
             ConnectionError: If connection to Substrate fails
             ValueError: If query fails
         """
+        # For backward compatibility, this method now calls get_user_files_from_profile
+        # with appropriate conversions
+        return self.get_user_files_from_profile(account_address)
+
+    def get_user_files_from_profile(
+        self,
+        account_address: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        Get user files by fetching the user profile CID from ipfsPallet and then retrieving
+        the profile JSON from IPFS.
+
+        Args:
+            account_address: Substrate account address (uses keypair address if not specified)
+                             Format: 5H1QBRF7T7dgKwzVGCgS4wioudvMRf9K4NEDzfuKLnuyBNzH
+
+        Returns:
+            List[Dict[str, Any]]: List of file objects from the user profile
+
+        Raises:
+            ConnectionError: If connection to Substrate fails
+            ValueError: If query fails or profile cannot be retrieved
+        """
         try:
             # Initialize Substrate connection if not already connected
             if not hasattr(self, "_substrate") or self._substrate is None:
@@ -622,159 +645,204 @@ class SubstrateClient:
                     account_address = self._keypair.ss58_address
                     print(f"Using keypair address: {account_address}")
 
-            # Prepare the JSON-RPC request
-            request = {
-                "jsonrpc": "2.0",
-                "method": "get_user_files",
-                "params": [account_address],
-                "id": 1,
-            }
+            # Query the blockchain for the user profile CID
+            print(f"Querying user profile for account: {account_address}")
+            result = self._substrate.query(
+                module="IpfsPallet",
+                storage_function="UserProfile",
+                params=[account_address],
+            )
 
-            print(f"Querying detailed file information for account: {account_address}")
+            # Check if a profile was found
+            if not result.value:
+                print(f"No profile found for account: {account_address}")
+                return []
 
-            # Make the JSON-RPC call
-            response = self._substrate.rpc_request(
-                method="get_user_files", params=[account_address]
-            )
+            # The result is a hex-encoded IPFS CID
+            # Handle both cases: bytes (needs .hex()) and string (already hex)
+            if isinstance(result.value, bytes):
+                hex_cid = result.value.hex()
+            else:
+                # If it's already a string, use it directly
+                hex_cid = result.value
 
-            # Check for errors in the response
-            if "error" in response:
-                error_msg = (
-                    f"RPC error: {response['error'].get('message', 'Unknown error')}"
-                )
-                print(error_msg)
-                raise ValueError(error_msg)
-
-            # Extract the result
-            files = response.get("result", [])
-            print(f"Found {len(files)} files stored by this account")
-
-            # Helper function to convert ASCII code arrays to strings
-            def ascii_to_string(value):
-                if isinstance(value, list) and all(isinstance(x, int) for x in value):
-                    return "".join(chr(code) for code in value)
-                return str(value)
-
-            # Helper function to properly format CIDs
-            def format_cid(cid_str):
-                # If it already looks like a proper CID, return it as is
-                if cid_str.startswith(("Qm", "bafy", "bafk", "bafyb", "bafzb", "b")):
-                    return cid_str
-
-                # Check if it's a hex string
-                if all(c in "0123456789abcdefABCDEF" for c in cid_str):
-                    # First try the special case where the hex string is actually ASCII encoded
+                # Remove '0x' prefix if present
+                if hex_cid.startswith("0x"):
+                    hex_cid = hex_cid[2:]
+
+            print(f"Found user profile CID (hex): {hex_cid}")
+
+            # Convert the hex CID to a readable IPFS CID
+            profile_cid = self._hex_to_ipfs_cid(hex_cid)
+            print(f"Decoded IPFS CID: {profile_cid}")
+
+            # Fetch the profile JSON from IPFS
+            from hippius_sdk.ipfs import IPFSClient
+
+            ipfs_client = IPFSClient()
+
+            print(f"Fetching user profile from IPFS: {profile_cid}")
+            profile_data = ipfs_client.cat(profile_cid)
+
+            # Parse the JSON content
+            if not profile_data.get("is_text", False):
+                raise ValueError("User profile is not in text format")
+
+            profile_json = json.loads(profile_data.get("content", "{}"))
+            print(f"Successfully retrieved user profile")
+
+            # Extract the file list from the profile
+            # The profile might be either a dictionary with a 'files' key or a direct list of files
+            files = []
+            if isinstance(profile_json, dict):
+                files = profile_json.get("files", [])
+            elif isinstance(profile_json, list):
+                # The profile itself might be a list of files
+                files = profile_json
+            else:
+                print(f"Warning: Unexpected profile structure: {type(profile_json)}")
+
+            print(f"Found {len(files)} files in user profile")
+
+            # Process the files to match the expected format
+            processed_files = []
+            for file in files:
+                # Make sure file is a dictionary
+                if not isinstance(file, dict):
+                    # Skip non-dictionary entries silently
+                    continue
+
+                # Convert numeric arrays to strings if needed
+                # Handle file_hash: could be an array of ASCII/UTF-8 code points
+                file_hash = None
+                raw_file_hash = file.get("file_hash")
+                if isinstance(raw_file_hash, list) and all(
+                    isinstance(n, int) for n in raw_file_hash
+                ):
                     try:
-                        # Try to decode the hex as ASCII characters
-                        # (This is the case with some substrate responses where the CID is hex-encoded ASCII)
-                        hex_bytes = bytes.fromhex(cid_str)
-                        ascii_str = hex_bytes.decode("ascii")
-
-                        # If the decoded string starts with a valid CID prefix, return it
-                        if ascii_str.startswith(
-                            ("Qm", "bafy", "bafk", "bafyb", "bafzb", "b")
-                        ):
-                            return ascii_str
+                        # Convert array of numbers to bytes, then to a string
+                        file_hash = bytes(raw_file_hash).decode("utf-8")
                     except Exception:
                         pass
+                else:
+                    # Try different field names for the CID that might be in the profile
+                    file_hash = (
+                        file.get("cid")
+                        or file.get("hash")
+                        or file.get("fileHash")
+                        or raw_file_hash
+                    )
 
-                    # If the above doesn't work, try the standard CID decoding
+                # Handle file_name: could be an array of ASCII/UTF-8 code points
+                file_name = None
+                raw_file_name = file.get("file_name")
+                if isinstance(raw_file_name, list) and all(
+                    isinstance(n, int) for n in raw_file_name
+                ):
                     try:
-                        import base58
-                        import binascii
-
-                        # Try to decode hex to binary then to base58 for CIDv0
-                        try:
-                            binary_data = binascii.unhexlify(cid_str)
-                            if (
-                                len(binary_data) > 2
-                                and binary_data[0] == 0x12
-                                and binary_data[1] == 0x20
-                            ):
-                                # This looks like a CIDv0 (Qm...)
-                                decoded_cid = base58.b58encode(binary_data).decode(
-                                    "utf-8"
-                                )
-                                return decoded_cid
-                        except Exception:
-                            pass
-
-                        # If not successful, just return hex with 0x prefix as fallback
-                        return f"0x{cid_str}"
-                    except ImportError:
-                        # If base58 is not available, return hex with prefix
-                        return f"0x{cid_str}"
-
-                # Default case - return as is
-                return cid_str
-
-            # Helper function to format file sizes
-            def format_file_size(size_bytes):
-                if size_bytes >= 1024 * 1024:
-                    return f"{size_bytes / (1024 * 1024):.2f} MB"
+                        # Convert array of numbers to bytes, then to a string
+                        file_name = bytes(raw_file_name).decode("utf-8")
+                    except Exception:
+                        pass
                 else:
-                    return f"{size_bytes / 1024:.2f} KB"
-
-            # Helper function to format miner IDs for display
-            def format_miner_id(miner_id):
-                if (
-                    truncate_miners
-                    and isinstance(miner_id, str)
-                    and miner_id.startswith("1")
-                    and len(miner_id) > 40
-                ):
-                    # Truncate long peer IDs
-                    return f"{miner_id[:12]}...{miner_id[-4:]}"
-                return miner_id
-
-            # Process the response
-            processed_files = []
-            for file in files:
-                processed_file = {"file_size": file.get("file_size", 0)}
+                    # Try different field names for the filename
+                    file_name = (
+                        file.get("filename")
+                        or file.get("name")
+                        or file.get("fileName")
+                        or raw_file_name
+                    )
 
-                # Add formatted file size
-                processed_file["size_formatted"] = format_file_size(
-                    processed_file["file_size"]
+                # Try different field names for the size
+                file_size = (
+                    file.get("size")
+                    or file.get("fileSize")
+                    or file.get("file_size")
+                    or 0
                 )
 
-                # Convert file_hash from byte array to string
-                if "file_hash" in file:
-                    cid_str = ascii_to_string(file["file_hash"])
-                    processed_file["file_hash"] = format_cid(cid_str)
-
-                # Convert file_name from byte array to string
-                if "file_name" in file:
-                    processed_file["file_name"] = ascii_to_string(file["file_name"])
-
-                # Convert miner_ids from byte arrays to strings
-                if "miner_ids" in file and isinstance(file["miner_ids"], list):
-                    all_miners = [
-                        ascii_to_string(miner_id) for miner_id in file["miner_ids"]
-                    ]
-                    processed_file["miner_ids_full"] = all_miners
-                    processed_file["miner_count"] = len(all_miners)
-
-                    # Truncate miner list if requested
-                    if max_miners > 0 and len(all_miners) > max_miners:
-                        displayed_miners = all_miners[:max_miners]
-                    else:
-                        displayed_miners = all_miners
+                processed_file = {
+                    "file_hash": file_hash,
+                    "file_name": file_name,
+                    # Add any other fields available in the profile
+                    "miner_ids": file.get(
+                        "miner_ids", []
+                    ),  # Try to get miners if available
+                    "miner_count": len(file.get("miner_ids", [])),  # Count the miners
+                    "file_size": file_size,
+                }
 
-                    # Format and store the displayed miners
-                    processed_file["miner_ids"] = [
-                        {"id": miner_id, "formatted": format_miner_id(miner_id)}
-                        for miner_id in displayed_miners
-                    ]
+                # Add formatted file size if available
+                if file_size:
+                    size_bytes = file_size
+                    if size_bytes >= 1024 * 1024:
+                        processed_file[
+                            "size_formatted"
+                        ] = f"{size_bytes / (1024 * 1024):.2f} MB"
+                    else:
+                        processed_file["size_formatted"] = f"{size_bytes / 1024:.2f} KB"
                 else:
-                    processed_file["miner_ids"] = []
-                    processed_file["miner_ids_full"] = []
-                    processed_file["miner_count"] = 0
+                    processed_file["size_formatted"] = "Unknown"
 
                 processed_files.append(processed_file)
 
             return processed_files
 
         except Exception as e:
-            error_msg = f"Error querying user files: {str(e)}"
+            error_msg = f"Error retrieving user files from profile: {str(e)}"
             print(error_msg)
             raise ValueError(error_msg)
+
+    def _hex_to_ipfs_cid(self, hex_string: str) -> str:
+        """
+        Convert a hex-encoded IPFS CID to a regular IPFS CID.
+
+        Args:
+            hex_string: Hex string representation of an IPFS CID
+
+        Returns:
+            str: Regular IPFS CID
+        """
+        # First, try to decode as ASCII if it's a hex representation of ASCII characters
+        try:
+            if hex_string.startswith("0x"):
+                hex_string = hex_string[2:]
+
+            bytes_data = bytes.fromhex(hex_string)
+            ascii_str = bytes_data.decode("ascii")
+
+            # If the decoded string starts with a valid CID prefix, return it
+            if ascii_str.startswith(("Qm", "bafy", "bafk", "bafyb", "bafzb", "b")):
+                return ascii_str
+        except Exception:
+            # If ASCII decoding fails, continue with other methods
+            pass
+
+        # Try to decode as a binary CID
+        try:
+            import base58
+
+            if hex_string.startswith("0x"):
+                hex_string = hex_string[2:]
+
+            binary_data = bytes.fromhex(hex_string)
+
+            # Check if it matches CIDv0 pattern (starts with 0x12, 0x20)
+            if (
+                len(binary_data) > 2
+                and binary_data[0] == 0x12
+                and binary_data[1] == 0x20
+            ):
+                # CIDv0 (Qm...)
+                return base58.b58encode(binary_data).decode("utf-8")
+
+            # If it doesn't match CIDv0, for CIDv1 just return the hex without 0x prefix
+            # since adding 0x breaks IPFS gateway URLs
+            return hex_string
+        except ImportError:
+            # If base58 is not available
+            print("Warning: base58 module not available for proper CID conversion")
+            return hex_string
+        except Exception as e:
+            print(f"Error converting hex to CID: {e}")
+            return hex_string

hippius_sdk/utils.py

@@ -0,0 +1,87 @@
+"""
+Utility functions for the Hippius SDK.
+"""
+
+import os
+import math
+from typing import Dict, Any, Union, List, Optional
+
+
+def ensure_directory_exists(directory_path: str) -> None:
+    """
+    Create a directory if it doesn't exist.
+
+    Args:
+        directory_path: Path to the directory to ensure exists
+    """
+    if not os.path.exists(directory_path):
+        os.makedirs(directory_path, exist_ok=True)
+
+
+def format_size(size_bytes: int) -> str:
+    """
+    Format a size in bytes to a human-readable string.
+
+    Args:
+        size_bytes: Size in bytes
+
+    Returns:
+        str: Human-readable size (e.g., "1.23 MB")
+    """
+    if size_bytes == 0:
+        return "0 B"
+
+    size_names = ("B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
+    i = int(math.floor(math.log(size_bytes, 1024)))
+    if i >= len(size_names):
+        i = len(size_names) - 1
+    p = math.pow(1024, i)
+    s = round(size_bytes / p, 2)
+    return f"{s} {size_names[i]}"
+
+
+def deep_merge(target: Dict[str, Any], source: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Deep merge two dictionaries, with source taking precedence over target.
+
+    Args:
+        target: Target dictionary to merge into
+        source: Source dictionary to merge from
+
+    Returns:
+        Dict[str, Any]: Merged dictionary
+    """
+    for key, value in source.items():
+        if key in target and isinstance(target[key], dict) and isinstance(value, dict):
+            target[key] = deep_merge(target[key], value)
+        else:
+            target[key] = value
+    return target
+
+
+def parse_comma_separated(value: Optional[str]) -> List[str]:
+    """
+    Parse a comma-separated string into a list.
+
+    Args:
+        value: Comma-separated string or None
+
+    Returns:
+        List[str]: List of stripped values, or empty list if value is None
+    """
+    if not value:
+        return []
+    return [item.strip() for item in value.split(",") if item.strip()]
+
+
+def is_valid_url(url: str) -> bool:
+    """
+    Basic check if a string is a valid URL.
+
+    Args:
+        url: URL to check
+
+    Returns:
+        bool: True if valid URL, False otherwise
+    """
+    return url.startswith(("http://", "https://", "ws://", "wss://"))

hippius-0.1.9.dist-info/RECORD

@@ -1,10 +0,0 @@
-hippius_sdk/__init__.py,sha256=fs2pZ_wIl3eaUz6qFprcRsZhYakqv6-qm468NZh-8h4,1260
-hippius_sdk/cli.py,sha256=0IQZh2by6kN8Sol3eDFfZzgj5otBeIOKC4lq2wIejOc,76317
-hippius_sdk/client.py,sha256=54tsg4k29sqt3F77LQJ_vhzzTR73QuZ_edqI_BvZM1E,14905
-hippius_sdk/config.py,sha256=gTr8EXeZ3jJNchcG9WyjbQdpPRHTxL5IWZgyIAm_X-c,22869
-hippius_sdk/ipfs.py,sha256=9fds5MJwVb7t8IqROM70x9fWgyk9_Ot5psat_hMnRN8,63969
-hippius_sdk/substrate.py,sha256=fa8K8vVdYGVtB3VNJ-_Vdw8bOxDUajFmj6se-rHZveQ,30853
-hippius-0.1.9.dist-info/METADATA,sha256=SPXMFKAJ_at35FEPB9uDMi3iBP7EXMLxskPvLxHmCQE,28000
-hippius-0.1.9.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-hippius-0.1.9.dist-info/entry_points.txt,sha256=b1lo60zRXmv1ud-c5BC-cJcAfGE5FD4qM_nia6XeQtM,98
-hippius-0.1.9.dist-info/RECORD,,