ratio1 3.4.88__py3-none-any.whl → 3.4.90__py3-none-any.whl

ratio1/_ver.py

@@ -1,4 +1,4 @@
-__VER__ = "3.4.88"
+__VER__ = "3.4.90"
 
 if __name__ == "__main__":
   with open("pyproject.toml", "rt") as fd:

ratio1/const/payload.py

@@ -208,7 +208,7 @@ class PAYLOAD_DATA:
   NETMON_LAST_SEEN = 'last_seen_sec'
   NETMON_IS_SUPERVISOR = 'is_supervisor'
   NETMON_WHITELIST = 'whitelist'
-  NETMON_WHITELIST_MAP = 'whitelist_map'
+  NETMON_WHITELIST_MAP = 'WHITELIST_MAP'
   NETMON_NODE_SECURED = 'secured'
   NETMON_NODE_VERSION = 'version'
   NETMON_NODE_R1FS_ID = 'r1fs_id'

ratio1/ipfs/r1fs.py

@@ -72,6 +72,7 @@ import random
 from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
 
 DEFAULT_SECRET = "ratio1"
+DEFAULT_FILENAME_JSON = "data.json"
 
 from threading import Lock
 
@@ -626,16 +627,49 @@ class R1FSEngine:
       data, 
       fn=None, 
       secret: str = None,
-      tempfile=False, 
+      nonce: int = None,
+      use_tempfile=False,
       show_logs=True,
       raise_on_error=False,
-    ) -> bool:
+    ) -> str:
       """
       Add a JSON object to IPFS.
+      
+      Parameters
+      ----------
+      data : any
+          JSON-serializable data to add to IPFS.
+          
+      fn : str, optional
+          Filename to use for the JSON data. If None, uses DEFAULT_FILENAME_JSON
+          in a unique temporary directory.
+          
+      secret : str, optional
+          Passphrase for AES-GCM encryption. Defaults to 'ratio1'.
+          
+      nonce : int, optional
+          Nonce for encryption. If None, a random nonce will be generated.
+          
+      use_tempfile : bool, optional
+          If True, use a system temporary file with random name. If False, use specified filename in unique directory.
+          
+      show_logs : bool, optional
+          Whether to show logs via self.P / self.Pd. Default is True.
+          
+      raise_on_error : bool, optional
+          If True, raise an Exception on command errors. Otherwise, logs them. Default is False.
+          
+      Returns
+      -------
+      str
+          The CID of the added JSON file.
       """
+      unique_dir = None
       try:
-        json_data = json.dumps(data)
-        if tempfile:
+        json_data = json.dumps(data, sort_keys=True, separators=(',', ':'))
+        self.P(f"JSON data: {json_data}")
+        
+        if use_tempfile:
           if show_logs:
             self.Pd("Using tempfile for JSON")
           with tempfile.NamedTemporaryFile(
@@ -644,21 +678,55 @@ class R1FSEngine:
             f.write(json_data)
           fn = f.name
         else:
-          fn = self._get_unique_or_complete_upload_name(fn=fn, suffix=".json")
+          # Use default filename if none specified
+          if fn is None:
+            fn = DEFAULT_FILENAME_JSON
+            
+          # Create unique temporary directory for the file
+          unique_dir = os.path.join(tempfile.gettempdir(), uuid.uuid4().hex)
+          os.makedirs(unique_dir, exist_ok=True)
+          fn = os.path.join(unique_dir, fn)
+          
           if show_logs:
-            self.Pd(f"Using unique name for JSON: {fn}")
+            self.Pd(f"Using unique directory for JSON: {fn}")
           with open(fn, "w") as f:
             f.write(json_data)
         #end if tempfile
+        
+        if show_logs:
+          self.Pd(f"About to call add_file with: file_path={fn}, nonce={nonce}, secret={secret[:10] if secret else 'None'}...")
+        
         cid = self.add_file(
-          file_path=fn, secret=secret, show_logs=show_logs,
+          file_path=fn,
+          secret=secret,
+          nonce=nonce,
+          show_logs=show_logs,
           raise_on_error=raise_on_error
         )
+        
+        if show_logs:
+          self.Pd(f"add_file returned CID: {cid}")
+        
         return cid
+        
       except Exception as e:
         if show_logs:
           self.P(f"Error adding JSON to IPFS: {e}", color='r')
+        if raise_on_error:
+          raise
         return None
+        
+      finally:
+        # Clean up temporary files and directories
+        if fn and os.path.exists(fn):
+          os.remove(fn)
+          if show_logs:
+            self.Pd(f"Cleaned up temporary JSON file: {fn}")
+            
+        if unique_dir and os.path.exists(unique_dir):
+          os.rmdir(unique_dir)
+          if show_logs:
+            self.Pd(f"Cleaned up temporary directory: {unique_dir}")
       
       
     def add_yaml(
@@ -666,7 +734,8 @@ class R1FSEngine:
       data, 
       fn=None, 
       secret: str = None,
-      tempfile=False, 
+      nonce: int = None,
+      tempfile=False,
       show_logs=True,
       raise_on_error=False,
     ) -> str:
@@ -689,7 +758,10 @@ class R1FSEngine:
           with open(fn, "w") as f:
             f.write(yaml_data)
         cid = self.add_file(
-          file_path=fn, secret=secret, show_logs=show_logs,
+          file_path=fn,
+          secret=secret,
+          nonce=nonce,
+          show_logs=show_logs,
           raise_on_error=raise_on_error
         )
         return cid
@@ -704,36 +776,93 @@ class R1FSEngine:
       data, 
       fn=None, 
       secret: str = None,
-      tempfile=False, 
+      nonce: int = None,
+      use_tempfile=False,
       show_logs=True,
       raise_on_error=False,
-    ) -> bool:
+    ) -> str:
       """
       Add a Pickle object to IPFS.
+      
+      Parameters
+      ----------
+      data : any
+          Python object to pickle and add to IPFS.
+          
+      fn : str, optional
+          Filename to use for the pickle data. If None, generates a unique filename.
+          
+      secret : str, optional
+          Passphrase for AES-GCM encryption. Defaults to 'ratio1'.
+          
+      nonce : int, optional
+          Nonce for encryption. If None, a random nonce will be generated.
+          
+      use_tempfile : bool, optional
+          If True, use a system temporary file with random name. If False, use specified filename.
+          
+      show_logs : bool, optional
+          Whether to show logs via self.P / self.Pd. Default is True.
+          
+      raise_on_error : bool, optional
+          If True, raise an Exception on command errors. Otherwise, logs them. Default is False.
+          
+      Returns
+      -------
+      str
+          The CID of the added pickle file.
       """
       try:
         import pickle
-        if tempfile:
+        if show_logs:
+          self.Pd(f"Pickling data of type: {type(data)}")
+        
+        if use_tempfile:
           if show_logs:
             self.Pd("Using tempfile for Pickle")
           with tempfile.NamedTemporaryFile(mode='wb', suffix='.pkl', delete=False) as f:
             pickle.dump(data, f)
           fn = f.name
         else:
-          fn = self._get_unique_or_complete_upload_name(fn=fn, suffix=".pkl")
-          if show_logs:
-            self.Pd(f"Using unique name for pkl: {fn}")
+          if fn is None:
+            fn = self._get_unique_or_complete_upload_name(fn=fn, suffix=".pkl")
+            if show_logs:
+              self.Pd(f"Using unique name for pkl: {fn}")
+          else:
+            if show_logs:
+              self.Pd(f"Using provided filename: {fn}")
           with open(fn, "wb") as f:
             pickle.dump(data, f)
+        
+        if show_logs:
+          self.Pd(f"About to call add_file with: file_path={fn}, nonce={nonce}, secret={secret[:10] if secret else 'None'}...")
+        
         cid = self.add_file(
-          file_path=fn, secret=secret, show_logs=show_logs,
+          file_path=fn,
+          secret=secret,
+          nonce=nonce,
+          show_logs=show_logs,
           raise_on_error=raise_on_error
         )
+        
+        if show_logs:
+          self.Pd(f"add_file returned CID: {cid}")
+        
         return cid
+        
       except Exception as e:
         if show_logs:
           self.P(f"Error adding Pickle to IPFS: {e}", color='r')
+        if raise_on_error:
+          raise
         return None
+        
+      finally:
+        # Clean up temporary files
+        if 'fn' in locals() and fn and os.path.exists(fn):
+          os.remove(fn)
+          if show_logs:
+            self.Pd(f"Cleaned up temporary pickle file: {fn}")
 
 
     @require_ipfs_started
@@ -801,27 +930,35 @@ class R1FSEngine:
       key = self._hash_secret(secret)  # mandatory passphrase
 
       if nonce is None:
-        nonce = os.urandom(12)           # recommended for GCM
+        nonce_bytes = os.urandom(12)           # recommended for GCM
+        if show_logs:
+          self.Pd(f"Generated random nonce: {nonce_bytes.hex()}")
       else:
-        nonce = random.Random(nonce).randbytes(12)
+        original_nonce = nonce
+        nonce_bytes = random.Random(nonce).randbytes(12)
 
       original_basename = os.path.basename(file_path)
 
       # JSON metadata storing the original filename
       meta_dict = {"filename": original_basename}
       meta_bytes = json.dumps(meta_dict).encode("utf-8")
+      
+      if show_logs:
+        self.Pd(f"Original basename: {original_basename}")
+        self.Pd(f"Metadata: {meta_dict}")
+        self.Pd(f"Secret hash (first 16 bytes): {key[:16].hex()}")
 
       tmp_cipher_path = os.path.join(tempfile.gettempdir(), uuid.uuid4().hex + ".bin")
       
       folder_cid = None
       start_time = time.time()
       try:
-        encryptor = Cipher(algorithms.AES(key), modes.GCM(nonce)).encryptor()
+        encryptor = Cipher(algorithms.AES(key), modes.GCM(nonce_bytes)).encryptor()
 
         chunk_size = 1024 * 1024  # 1 MB chunks
         with open(file_path, "rb") as fin, open(tmp_cipher_path, "wb") as fout:
           # [nonce][4-byte-len][metadata][ciphertext][16-byte GCM tag]
-          fout.write(nonce)
+          fout.write(nonce_bytes)
           meta_len = len(meta_bytes)
           fout.write(meta_len.to_bytes(4, "big"))
           # encrypt the metadata and save
@@ -840,10 +977,12 @@ class R1FSEngine:
           tag = encryptor.tag
           fout.write(tag)
         #end with fin, fout
-        
+
         # Now we IPFS-add the ciphertext
         output = self.__run_command(["ipfs", "add", "-q", "-w", tmp_cipher_path], show_logs=show_logs)
         lines = output.strip().split("\n")
+        self.P("output lines: ", json.dumps(lines))
+
         if not lines:
           raise RuntimeError("No output from 'ipfs add -w -q' for ciphertext.")
         folder_cid = lines[-1].strip()
@@ -1002,11 +1141,19 @@ class R1FSEngine:
       
       # if the folder exists cleanup the content 
       if os.path.exists(local_folder):
-        if show_logs:
-          files = os.listdir(local_folder)
-          self.Pd(f"Cleaning up {local_folder} with {files}")
-        #end if show_logs
-        shutil.rmtree(local_folder)
+        if os.path.isdir(local_folder):
+          if show_logs:
+            files = os.listdir(local_folder)
+            self.Pd(f"Cleaning up {local_folder} with {files}")
+          #end if show_logs
+          shutil.rmtree(local_folder)
+        else:
+          # If it's a file, just remove it
+          if show_logs:
+            self.Pd(f"Removing existing file {local_folder}")
+          #end if show_logs
+          os.remove(local_folder)
+        #end if isdir
       #end if local_folder exists
 
       
@@ -1024,6 +1171,14 @@ class R1FSEngine:
       download_elapsed_time = time.time() - start_time
 
       # Expect exactly one file
+      if not os.path.isdir(local_folder):
+        msg = f"Expected {local_folder} to be a directory after IPFS download, but it's not"
+        if raise_on_error:
+          raise RuntimeError(msg)
+        else:
+          self.P(msg, color='r')
+          return
+
       contents = os.listdir(local_folder)
       if len(contents) != 1:
         msg = f"Expected 1 file in {local_folder}, found {contents}"
@@ -1106,6 +1261,224 @@ class R1FSEngine:
       #end if out_path is not None
       return out_path
 
+    @require_ipfs_started
+    def get_pickle(
+      self,
+      cid: str,
+      local_folder: str = None,
+      secret: str = None,
+      timeout: int = None,
+      pin: bool = True,
+      raise_on_error: bool = False,
+      show_logs: bool = True,
+    ):
+      """
+      Retrieve and deserialize a pickle file from R1FS by CID.
+      Uses get_file under the hood to download and decrypt the file, then loads it with pickle.
+
+      Parameters
+      ----------
+      cid : str
+        The folder CID (wrapped single file).
+
+      local_folder : str, optional
+        Destination folder. If None, we default to something like self.__downloads_dir/<CID>.
+
+      secret : str, optional
+        Passphrase for AES-GCM. Must not be empty. Defaults to 'ratio1'.
+
+      timeout : int, optional
+        Maximum seconds for the IPFS get. If None, use IPFSCt.TIMEOUT.
+
+      pin : bool, optional
+        If True, we optionally pin the folder. Default True.
+
+      raise_on_error : bool, optional
+        If True, raise an Exception on command errors/timeouts. Otherwise logs them. Default False.
+
+      show_logs : bool, optional
+        If True, logs steps via self.P / self.Pd. Default True.
+
+      Returns
+      -------
+      any
+        The deserialized Python object from the pickle file.
+
+      Raises
+      ------
+      ValueError
+        If the secret is empty.
+
+      RuntimeError
+        If multiple or zero files are found in the downloaded folder,
+        or if we fail to parse the JSON metadata.
+
+      Exception
+        If the GCM tag is invalid or the IPFS command times out
+        and raise_on_error=True.
+
+      Examples
+      --------
+      >>> # Simple usage with default passphrase
+      >>> data = engine.get_pickle("QmEncFolderXYZ")
+      >>> print(data)
+      {'key': 'value', 'list': [1, 2, 3]}
+      
+      """
+      import pickle
+      
+      # Use get_file to download and decrypt the file
+      file_path = self.get_file(
+        cid=cid,
+        local_folder=local_folder,
+        secret=secret,
+        timeout=timeout,
+        pin=pin,
+        raise_on_error=raise_on_error,
+        show_logs=show_logs,
+        return_absolute_path=True
+      )
+      
+      if file_path is None:
+        if raise_on_error:
+          raise RuntimeError(f"Failed to retrieve file for CID {cid}")
+        else:
+          if show_logs:
+            self.P(f"Failed to retrieve file for CID {cid}", color='r')
+          return None
+      
+      # Load the pickle file
+      try:
+        with open(file_path, "rb") as f:
+          data = pickle.load(f)
+        
+        if show_logs:
+          self.Pd(f"Successfully loaded pickle data from {file_path}")
+        
+        # Clean up the temporary file
+        os.remove(file_path)
+        if show_logs:
+          self.Pd(f"Cleaned up temporary pickle file: {file_path}")
+        
+        return data
+        
+      except Exception as e:
+        msg = f"Error loading pickle file {file_path}: {e}"
+        if raise_on_error:
+          raise RuntimeError(msg)
+        else:
+          if show_logs:
+            self.P(msg, color='r')
+          return None
+
+    @require_ipfs_started
+    def get_json(
+      self,
+      cid: str,
+      local_folder: str = None,
+      secret: str = None,
+      timeout: int = None,
+      pin: bool = True,
+      raise_on_error: bool = False,
+      show_logs: bool = True,
+    ):
+      """
+      Retrieve and deserialize a JSON file from R1FS by CID.
+      Uses get_file under the hood to download and decrypt the file, then loads it with json.
+
+      Parameters
+      ----------
+      cid : str
+        The folder CID (wrapped single file).
+
+      local_folder : str, optional
+        Destination folder. If None, we default to something like self.__downloads_dir/<CID>.
+
+      secret : str, optional
+        Passphrase for AES-GCM. Must not be empty. Defaults to 'ratio1'.
+
+      timeout : int, optional
+        Maximum seconds for the IPFS get. If None, use IPFSCt.TIMEOUT.
+
+      pin : bool, optional
+        If True, we optionally pin the folder. Default True.
+
+      raise_on_error : bool, optional
+        If True, raise an Exception on command errors/timeouts. Otherwise logs them. Default False.
+
+      show_logs : bool, optional
+        If True, logs steps via self.P / self.Pd. Default True.
+
+      Returns
+      -------
+      any
+        The deserialized JSON object from the file.
+
+      Raises
+      ------
+      ValueError
+        If the secret is empty.
+
+      RuntimeError
+        If multiple or zero files are found in the downloaded folder,
+        or if we fail to parse the JSON metadata.
+
+      Exception
+        If the GCM tag is invalid or the IPFS command times out
+        and raise_on_error=True.
+
+      Examples
+      --------
+      >>> # Simple usage with default passphrase
+      >>> data = engine.get_json("QmEncFolderXYZ")
+      >>> print(data)
+      {'key': 'value', 'list': [1, 2, 3]}
+      
+      """
+      # Use get_file to download and decrypt the file
+      file_path = self.get_file(
+        cid=cid,
+        local_folder=local_folder,
+        secret=secret,
+        timeout=timeout,
+        pin=pin,
+        raise_on_error=raise_on_error,
+        show_logs=show_logs,
+        return_absolute_path=True
+      )
+      
+      if file_path is None:
+        if raise_on_error:
+          raise RuntimeError(f"Failed to retrieve file for CID {cid}")
+        else:
+          if show_logs:
+            self.P(f"Failed to retrieve file for CID {cid}", color='r')
+          return None
+      
+      # Load the JSON file
+      try:
+        with open(file_path, "r", encoding="utf-8") as f:
+          data = json.load(f)
+        
+        if show_logs:
+          self.Pd(f"Successfully loaded JSON data from {file_path}")
+        
+        # Clean up the temporary file
+        os.remove(file_path)
+        if show_logs:
+          self.Pd(f"Cleaned up temporary JSON file: {file_path}")
+        
+        return data
+        
+      except Exception as e:
+        msg = f"Error loading JSON file {file_path}: {e}"
+        if raise_on_error:
+          raise RuntimeError(msg)
+        else:
+          if show_logs:
+            self.P(msg, color='r')
+          return None
+
 
     @require_ipfs_started
     def list_pins(self):
@@ -1148,6 +1521,346 @@ class R1FSEngine:
       except Exception as e:
         result = False
       return result
+
+    def calculate_file_cid(
+      self,
+      file_path: str,
+      nonce: int,
+      secret: str = None,
+      show_logs: bool = True
+    ) -> str:
+      """
+      Calculate the CID (Content Identifier) of a file without adding it to IPFS.
+      This method encrypts the file the same way as add_file and computes the CID
+      that would be generated if the encrypted file were added to IPFS.
+      
+      Parameters
+      ----------
+      file_path : str
+          Path to the local file to calculate CID for.
+          
+      nonce : int
+          Nonce for encryption. Required parameter for deterministic CID calculation.
+          
+      secret : str, optional
+          Passphrase for AES-GCM encryption. Defaults to 'ratio1'.
+          
+      show_logs : bool, optional
+          Whether to show logs via self.P / self.Pd. Default is True.
+          
+      Returns
+      -------
+      str
+          The CID of the encrypted file (e.g., "QmHash...")
+          
+      Raises
+      ------
+      FileNotFoundError
+          If file_path does not exist.
+          
+      ImportError
+          If IPFS is not available or not running.
+          
+      ValueError
+          If nonce is None or invalid.
+          
+      Examples
+      --------
+      >>> cid = engine.calculate_file_cid("/path/to/file.txt", nonce=12345)
+      >>> print(cid)
+      QmHash123ABC...
+      """
+      if not os.path.isfile(file_path):
+        raise FileNotFoundError(f"File not found: {file_path}")
+
+      if secret in ["", None]:
+        secret = self.__DEFAULT_SECRET
+        
+      # Validate nonce parameter
+      if nonce is None:
+        raise ValueError("nonce parameter is required for deterministic CID calculation")
+        
+      # Check file size and throw an error if larger than 2 GB.
+      file_size = os.path.getsize(file_path)
+      if file_size > 2 * 1024 * 1024 * 1024:
+        raise ValueError(f"File {file_path} is too large ({file_size} bytes). Maximum allowed size is 2 GB.")
+
+      key = self._hash_secret(secret)
+      nonce_bytes = random.Random(nonce).randbytes(12)
+
+      original_basename = os.path.basename(file_path)
+
+      # JSON metadata storing the original filename
+      meta_dict = {"filename": original_basename}
+      meta_bytes = json.dumps(meta_dict).encode("utf-8")
+
+      if show_logs:
+        self.Pd(f"Calculating CID for encrypted file: {file_path}")
+        self.Pd(f"Nonce input: {nonce}, Generated nonce bytes: {nonce_bytes.hex()}")
+        self.Pd(f"Original basename: {original_basename}")
+        self.Pd(f"Metadata: {meta_dict}")
+        self.Pd(f"Secret hash (first 16 bytes): {key[:16].hex()}")
+
+      # Create temporary encrypted file (same as in add_file)
+      tmp_cipher_path = os.path.join(tempfile.gettempdir(), uuid.uuid4().hex + ".bin")
+
+      try:
+        # Encrypt the file content (same as in add_file)
+        encryptor = Cipher(algorithms.AES(key), modes.GCM(nonce_bytes)).encryptor()
+
+        chunk_size = 1024 * 1024  # 1 MB chunks
+        with open(file_path, "rb") as fin, open(tmp_cipher_path, "wb") as fout:
+          # [nonce][4-byte-len][metadata][ciphertext][16-byte GCM tag]
+          fout.write(nonce_bytes)
+          meta_len = len(meta_bytes)
+          fout.write(meta_len.to_bytes(4, "big"))
+          # encrypt the metadata and save
+          enc_meta_data = encryptor.update(meta_bytes)
+          fout.write(enc_meta_data)
+
+          while True:
+            chunk = fin.read(chunk_size)
+            if not chunk:
+              break
+            fout.write(encryptor.update(chunk))
+          #end while there are still bytes to read
+          final_ct = encryptor.finalize()
+          fout.write(final_ct)
+          # Append 16-byte GCM tag
+          tag = encryptor.tag
+          fout.write(tag)
+        #end with fin, fout
+
+        # Use IPFS to calculate the hash without adding the file
+        output = self.__run_command(["ipfs", "add", "--only-hash", "-q", "-w", tmp_cipher_path], show_logs=show_logs)
+        lines = output.strip().split("\n")
+        self.P("output lines: ", json.dumps(lines))
+        if not lines:
+          raise RuntimeError("No output from 'ipfs add --only-hash -q -w' for ciphertext.")
+
+        # Get the CID from IPFS
+        file_cid = lines[0].strip()
+        if show_logs:
+          self.Pd(f"IPFS calculated CID: {file_cid}")
+        
+        return file_cid
+        
+      finally:
+        # Clean up temporary encrypted file
+        if os.path.exists(tmp_cipher_path):
+          os.remove(tmp_cipher_path)
+
+    def calculate_json_cid(
+      self,
+      data,
+      nonce: int,
+      fn: str = None,
+      secret: str = None,
+      show_logs: bool = True
+    ) -> str:
+      """
+      Calculate the CID (Content Identifier) of JSON data without adding it to IPFS.
+      This method saves the JSON data to a temporary file, then uses calculate_file_cid
+      to compute the CID that would be generated if the encrypted file were added to IPFS.
+      
+      Parameters
+      ----------
+      data : any
+          JSON-serializable data to calculate CID for.
+          
+      nonce : int
+          Nonce for encryption. Required parameter for deterministic CID calculation.
+          
+      fn : str, optional
+          Filename to use for the JSON data. If None, uses DEFAULT_FILENAME_JSON.
+          This affects the CID calculation as the filename is included in the metadata.
+          
+      secret : str, optional
+          Passphrase for AES-GCM encryption. Defaults to 'ratio1'.
+          
+      show_logs : bool, optional
+          Whether to show logs via self.P / self.Pd. Default is True.
+          
+      Returns
+      -------
+      str
+          The CID of the encrypted JSON file (e.g., "QmHash...")
+          
+      Raises
+      ------
+      ImportError
+          If IPFS is not available or not running.
+          
+      ValueError
+          If nonce is None or invalid, or if data cannot be JSON serialized.
+          
+      Examples
+      --------
+      >>> data = {"name": "test", "value": 123}
+      >>> cid = engine.calculate_json_cid(data, nonce=12345)
+      >>> print(cid)
+      QmHash123ABC...
+      
+      >>> # Use custom filename
+      >>> cid = engine.calculate_json_cid(data, nonce=12345, fn="config.json")
+      >>> print(cid)
+      QmHash456DEF...
+      """
+      # Serialize JSON data
+      try:
+        json_data = json.dumps(data, sort_keys=True, separators=(',', ':'))
+      except (TypeError, ValueError) as e:
+        raise ValueError(f"Data cannot be JSON serialized: {e}")
+      
+      self.P(f"JSON data: {json_data}")
+
+      # Use custom filename or default
+      if fn is None:
+        fn = DEFAULT_FILENAME_JSON
+
+      if show_logs:
+        self.Pd(f"Calculating CID for JSON data with {len(json_data)} characters, filename: {fn}")
+      
+      # Create temporary file for JSON data with the desired filename in a unique directory
+      unique_dir = os.path.join(tempfile.gettempdir(), uuid.uuid4().hex)
+      os.makedirs(unique_dir, exist_ok=True)
+      tmp_json_path = os.path.join(unique_dir, fn)
+      
+      file_cid = None
+      try:
+        # Write JSON data to temporary file
+        with open(tmp_json_path, "w") as f:
+          f.write(json_data)
+        
+        if show_logs:
+          self.Pd(f"About to call calculate_file_cid with: file_path={tmp_json_path}, nonce={nonce}, secret={secret[:10] if secret else 'None'}...")
+        
+        # Use calculate_file_cid to get the CID
+        file_cid = self.calculate_file_cid(
+          file_path=tmp_json_path,
+          nonce=nonce,
+          secret=secret,
+          show_logs=True  # Don't show logs from calculate_file_cid
+        )
+        
+        if show_logs:
+          self.Pd(f"calculate_file_cid returned CID: {file_cid}")
+        
+      finally:
+        # Clean up temporary JSON file and directory
+        if os.path.exists(tmp_json_path):
+          os.remove(tmp_json_path)
+        if os.path.exists(unique_dir):
+          os.rmdir(unique_dir)
+      
+      return file_cid
+
+    def calculate_pickle_cid(
+      self,
+      data,
+      nonce: int,
+      fn: str = None,
+      secret: str = None,
+      show_logs: bool = True
+    ) -> str:
+      """
+      Calculate the CID (Content Identifier) of pickle data without adding it to IPFS.
+      This method saves the pickle data to a temporary file, then uses calculate_file_cid
+      to compute the CID that would be generated if the encrypted file were added to IPFS.
+      
+      Parameters
+      ----------
+      data : any
+          Python object to pickle and calculate CID for.
+          
+      nonce : int
+          Nonce for encryption. Required parameter for deterministic CID calculation.
+          
+      fn : str, optional
+          Filename to use for the pickle data. If None, generates a unique filename.
+          This affects the CID calculation as the filename is included in the metadata.
+          
+      secret : str, optional
+          Passphrase for AES-GCM encryption. Defaults to 'ratio1'.
+          
+      show_logs : bool, optional
+          Whether to show logs via self.P / self.Pd. Default is True.
+          
+      Returns
+      -------
+      str
+          The CID of the encrypted pickle file (e.g., "QmHash...")
+          
+      Raises
+      ------
+      ImportError
+          If IPFS is not available or not running.
+          
+      ValueError
+          If nonce is None or invalid, or if data cannot be pickled.
+          
+      Examples
+      --------
+      >>> data = {"name": "test", "value": 123}
+      >>> cid = engine.calculate_pickle_cid(data, nonce=12345)
+      >>> print(cid)
+      QmHash123ABC...
+      
+      >>> # Use custom filename
+      >>> cid = engine.calculate_pickle_cid(data, nonce=12345, fn="model.pkl")
+      >>> print(cid)
+      QmHash456DEF...
+      """
+      # Serialize pickle data
+      try:
+        import pickle
+        pickle_data = pickle.dumps(data)
+      except (TypeError, ValueError, pickle.PicklingError) as e:
+        raise ValueError(f"Data cannot be pickled: {e}")
+      
+      if show_logs:
+        self.Pd(f"Pickled data of type: {type(data)}, size: {len(pickle_data)} bytes")
+
+      # Use custom filename or generate unique one
+      if fn is None:
+        fn = self._get_unique_or_complete_upload_name(fn=fn, suffix=".pkl")
+
+      if show_logs:
+        self.Pd(f"Calculating CID for pickle data with {len(pickle_data)} bytes, filename: {fn}")
+      
+      # Create temporary file for pickle data with the desired filename in a unique directory
+      unique_dir = os.path.join(tempfile.gettempdir(), uuid.uuid4().hex)
+      os.makedirs(unique_dir, exist_ok=True)
+      tmp_pickle_path = os.path.join(unique_dir, fn)
+      
+      file_cid = None
+      try:
+        # Write pickle data to temporary file
+        with open(tmp_pickle_path, "wb") as f:
+          f.write(pickle_data)
+        
+        if show_logs:
+          self.Pd(f"About to call calculate_file_cid with: file_path={tmp_pickle_path}, nonce={nonce}, secret={secret[:10] if secret else 'None'}...")
+        
+        # Use calculate_file_cid to get the CID
+        file_cid = self.calculate_file_cid(
+          file_path=tmp_pickle_path,
+          nonce=nonce,
+          secret=secret,
+          show_logs=True  # Don't show logs from calculate_file_cid
+        )
+        
+        if show_logs:
+          self.Pd(f"calculate_file_cid returned CID: {file_cid}")
+        
+      finally:
+        # Clean up temporary pickle file and directory
+        if os.path.exists(tmp_pickle_path):
+          os.remove(tmp_pickle_path)
+        if os.path.exists(unique_dir):
+          os.rmdir(unique_dir)
+      
+      return file_cid
       
 
   # Start/stop IPFS methods (R1FS API)

{ratio1-3.4.88.dist-info → ratio1-3.4.90.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ratio1
-Version: 3.4.88
+Version: 3.4.90
 Summary: `ratio1` or Ration1 SDK is the Python SDK required for client app development for the Ratio1 ecosystem
 Project-URL: Homepage, https://github.com/Ratio1/ratio1_sdk
 Project-URL: Bug Tracker, https://github.com/Ratio1/ratio1_sdk/issues

{ratio1-3.4.88.dist-info → ratio1-3.4.90.dist-info}/RECORD

@@ -1,5 +1,5 @@
 ratio1/__init__.py,sha256=YimqgDbjLuywsf8zCWE0EaUXH4MBUrqLxt0TDV558hQ,632
-ratio1/_ver.py,sha256=KBX4wRnlHrRWGTg3781atMEGfpsDqSshmos9h1nmjvU,331
+ratio1/_ver.py,sha256=nbr8aPsp3zz0PIc19Y-oBy7PiewAXGAgyk1132t5yQ0,331
 ratio1/base_decentra_object.py,sha256=iXvAAf6wPnGWzeeiRfwLojVoan-m1e_VsyPzjUQuENo,4492
 ratio1/plugins_manager_mixin.py,sha256=X1JdGLDz0gN1rPnTN_5mJXR8JmqoBFQISJXmPR9yvCo,11106
 ratio1/base/__init__.py,sha256=hACh83_cIv7-PwYMM3bQm2IBmNqiHw-3PAfDfAEKz9A,259
@@ -48,7 +48,7 @@ ratio1/const/evm_net.py,sha256=9is8Gx2_xtKlWRNAZTNAmmaA33c30xvpBT-zL4AtIuM,16774
 ratio1/const/formatter.py,sha256=AW3bWlqf39uaqV4BBUuW95qKYfF2OkkU4f9hy3kSVhM,200
 ratio1/const/heartbeat.py,sha256=Z_n87yI-L4vlBmlHZhkruysEJV5JVbXLQlGI26R42C4,3197
 ratio1/const/misc.py,sha256=VDCwwpf5bl9ltx9rzT2WPVP8B3mZFRufU1tSS5MO240,413
-ratio1/const/payload.py,sha256=HvKcN6a0r1ma1IMuBYZpYne9zTuLO8_8_18XflndAXY,7910
+ratio1/const/payload.py,sha256=lhHzkz6d3G7rVtMCitUHgjT85k4TE58K9Y5JteT_u7c,7910
 ratio1/const/plugins/deeploy_const.py,sha256=8QcIf7zo_gSC6SdHqQVecn4yOUKCPMXzHC9zgGW5-3E,13314
 ratio1/default/__init__.py,sha256=ozU6CMMuWl0LhG8Ae3LrZ65a6tLrptfscVYGf83zjxM,46
 ratio1/default/instance/__init__.py,sha256=JQiqTFm_U5__z4bTlvT033hUOSIDCtrQ-evMrhT6JdA,741
@@ -70,7 +70,7 @@ ratio1/io_formatter/default/aixp1.py,sha256=MX0TeUR4APA-qN3vUC6uzcz8Pssz5lgrQWo7
 ratio1/io_formatter/default/default.py,sha256=gEy78cP2D5s0y8vQh4aHuxqz7D10gGfuiKF311QhrpE,494
 ratio1/ipfs/__init__.py,sha256=vXEDLUNUO6lOTMGa8iQ9Zf7ajIQq9GZuvYraAHt3meE,38
 ratio1/ipfs/ifps_keygen,sha256=PcoYuo4c89_C9FWrKq9K_28ruhKqnxNn1s3nLHiF1tc,879
-ratio1/ipfs/r1fs.py,sha256=bslLpr0FTiqBsXPCoAqmH62MDki1lkvgW-oT7TvgFcQ,49458
+ratio1/ipfs/r1fs.py,sha256=5Uo_adugcGTg8kVsev9kmyUSSzh9FdM803jPdu8QEWw,72273
 ratio1/ipfs/ipfs_setup/ipfs.service,sha256=isTJQsktPy4i1yaDA9AC1OKdlTYvsCCRRAVX-EmGqAs,248
 ratio1/ipfs/ipfs_setup/launch_service.sh,sha256=GWhZyNqtohLxJg8Q_c8YnNZduu1ddXDU-IFRRMaEyiY,141
 ratio1/ipfs/ipfs_setup/restart.sh,sha256=9xHMgkUoAMI25jeaoDVFbCa_LjojYm3ubljW58RatKE,22
@@ -105,8 +105,8 @@ ratio1/utils/comm_utils.py,sha256=4cS9llRr_pK_3rNgDcRMCQwYPO0kcNU7AdWy_LtMyCY,10
 ratio1/utils/config.py,sha256=Elfkl7W4aDMvB5WZLiYlPXrecBncgTxb4hcKhQedMzI,10111
 ratio1/utils/dotenv.py,sha256=_AgSo35n7EnQv5yDyu7C7i0kHragLJoCGydHjvOkrYY,2008
 ratio1/utils/oracle_sync/oracle_tester.py,sha256=aJOPcZhtbw1XPqsFG4qYpfv2Taj5-qRXbwJzrPyeXDE,27465
-ratio1-3.4.88.dist-info/METADATA,sha256=leT_mX54IZnC---M00RkaKIzkw5ixmVa3sIUdi_q-Hk,12255
-ratio1-3.4.88.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ratio1-3.4.88.dist-info/entry_points.txt,sha256=DR_olREzU1egwmgek3s4GfQslBi-KR7lXsd4ap0TFxE,46
-ratio1-3.4.88.dist-info/licenses/LICENSE,sha256=cvOsJVslde4oIaTCadabXnPqZmzcBO2f2zwXZRmJEbE,11311
-ratio1-3.4.88.dist-info/RECORD,,
+ratio1-3.4.90.dist-info/METADATA,sha256=qoggjAXJC2ANieuj4wXCf7bpNYCFmJe4j2KQJIQwSa0,12255
+ratio1-3.4.90.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ratio1-3.4.90.dist-info/entry_points.txt,sha256=DR_olREzU1egwmgek3s4GfQslBi-KR7lXsd4ap0TFxE,46
+ratio1-3.4.90.dist-info/licenses/LICENSE,sha256=cvOsJVslde4oIaTCadabXnPqZmzcBO2f2zwXZRmJEbE,11311
+ratio1-3.4.90.dist-info/RECORD,,