ratio1 3.4.102__py3-none-any.whl → 3.4.104__py3-none-any.whl

ratio1/_ver.py

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

ratio1/const/evm_net.py

@@ -616,8 +616,8 @@ EVM_NET_CONSTANTS = {
       "0xai_A61eKDV1otIH6uWy3zDlbJNJUWayp1jAsirOuYxztf82",  # tr1s-02
     ],
     EvmNetConstants.EE_ORACLE_SYNC_USE_R1FS_KEY: False,  # Do not use R1FS for oracle sync in testnet.
-    EvmNetConstants.ORACLE_SYNC_BLOCKCHAIN_PRESENCE_MIN_THRESHOLD_KEY: 0.3,
-    EvmNetConstants.ORACLE_SYNC_ONLINE_PRESENCE_MIN_THRESHOLD_KEY: 0.4,
+    EvmNetConstants.ORACLE_SYNC_BLOCKCHAIN_PRESENCE_MIN_THRESHOLD_KEY: 0.15,
+    EvmNetConstants.ORACLE_SYNC_ONLINE_PRESENCE_MIN_THRESHOLD_KEY: 0.2,
   },
   EvmNetData.DEVNET: {
     EvmNetConstants.EE_NET_MON_01_SUPERVISOR_LOG_TIME_KEY: 60,  # Log every minute.

ratio1/ipfs/r1fs.py

@@ -922,9 +922,9 @@ class R1FSEngine:
       if not os.path.isfile(file_path):
         raise FileNotFoundError(f"File not found: {file_path}")
 
-      # Check file size and throw an error if larger than 2 GB.
+      # Check file size and throw an error if larger than 5 GB.
       file_size = os.path.getsize(file_path)
-      if file_size > 2 * 1024 * 1024 * 1024:
+      if file_size > 5 * 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)  # mandatory passphrase
@@ -1522,6 +1522,589 @@ class R1FSEngine:
         result = False
       return result
 
+
+    ########## START DELETE METHODS ##########
+    if True:
+      def is_pinned(self, cid: str, show_logs: bool = False) -> bool:
+        """
+        Check if a CID is pinned locally.
+
+        Parameters
+        ----------
+        cid : str
+            The CID to check.
+
+        show_logs : bool, optional
+            Whether to show logs. Default is False.
+
+        Returns
+        -------
+        bool
+            True if the CID is pinned, False otherwise.
+
+        Examples
+        --------
+        >>> if engine.is_pinned("QmHash123..."):
+        >>>   print("File is pinned")
+        """
+        try:
+          output = self.__run_command(
+            ["ipfs", "pin", "ls", "--type=recursive", cid],
+            raise_on_error=False,
+            show_logs=False
+          )
+          is_pinned = cid in output
+          if show_logs:
+            self.Pd(f"CID {cid} pinned: {is_pinned}")
+          return is_pinned
+        except Exception as e:
+          if show_logs:
+            self.Pd(f"Error checking if CID {cid} is pinned: {e}")
+          return False
+
+      def unpin_file(
+        self,
+        cid: str,
+        unpin_remote: bool = True,
+        show_logs: bool = True,
+        raise_on_error: bool = False
+      ) -> bool:
+        """
+        Unpin a file from R1FS locally and optionally on the relay.
+        This marks the file for garbage collection but does not immediately delete it.
+
+        Parameters
+        ----------
+        cid : str
+            The CID to unpin.
+
+        unpin_remote : bool, optional
+            Whether to also unpin from the relay. Default is True.
+
+        show_logs : bool, optional
+            Whether to show logs. Default is True.
+
+        raise_on_error : bool, optional
+            If True, raise an Exception on errors. Otherwise logs them. Default is False.
+
+        Returns
+        -------
+        bool
+            True if unpinning was successful, False otherwise.
+
+        Examples
+        --------
+        >>> # Unpin locally and on relay
+        >>> engine.unpin_file("QmHash123...")
+
+        >>> # Unpin only locally
+        >>> engine.unpin_file("QmHash123...", unpin_remote=False)
+        """
+        if cid in [None, ""]:
+          msg = "CID parameter cannot be None or empty"
+          if raise_on_error:
+            raise ValueError(msg)
+          else:
+            if show_logs:
+              self.P(msg, color='r')
+            return False
+
+        success = True
+
+        try:
+          # First, unpin locally
+          result = self.__run_command(
+            ["ipfs", "pin", "rm", cid],
+            raise_on_error=raise_on_error,
+            show_logs=False
+          )
+
+          if show_logs:
+            self.Pd(f"Unpinned CID locally: {cid}")
+
+        except Exception as e:
+          msg = f"Error unpinning CID {cid} locally: {e}"
+          success = False
+          if raise_on_error:
+            raise RuntimeError(msg)
+          else:
+            if show_logs:
+              self.P(msg, color='r')
+            return False
+
+        # Then, notify the relay to unpin (mirrors add_file behavior)
+        if unpin_remote and self.__ipfs_relay_api is not None:
+          try:
+            request_url = f"{self.__ipfs_relay_api}/api/v0/pin/rm?arg={cid}"
+            response = requests.post(
+              request_url,
+              auth=HTTPBasicAuth(self.__ipfs_api_key_username, self.__ipfs_api_key_password),
+              verify=self.__ipfs_certificate_path
+            )
+
+            if response.status_code == 200:
+              if show_logs:
+                self.Pd(f"Relay successfully notified to unpin CID={cid}")
+            else:
+              msg = f"Failed to notify relay to unpin CID {cid}: {response.text}"
+              if raise_on_error:
+                raise RuntimeError(msg)
+              else:
+                if show_logs:
+                  self.P(msg, color='r')
+                success = False
+            #end if response status code
+          except requests.RequestException as e:
+            msg = f"Error notifying relay to unpin CID {cid}: {e}"
+            if raise_on_error:
+              raise RuntimeError(msg)
+            else:
+              if show_logs:
+                self.P(msg, color='r')
+              success = False
+          #end try
+        #end if relay API exists
+
+        # Remove from tracking dicts if present
+        if success:
+          self.__uploaded_files.pop(cid, None)
+          self.__downloaded_files.pop(cid, None)
+
+        return success
+
+      def delete_file(
+        self,
+        cid: str,
+        unpin_remote: bool = True,
+        run_gc: bool = False,
+        cleanup_local_files: bool = False,
+        show_logs: bool = True,
+        raise_on_error: bool = False
+      ) -> bool:
+        """
+        Delete a file from R1FS by unpinning it locally and optionally on the relay,
+        then optionally running garbage collection.
+
+        Note: Unpinning removes the file from your local node and (optionally) the relay.
+        However, if other nodes have pinned this content, it may remain accessible on the network.
+
+        Parameters
+        ----------
+        cid : str
+            The CID to delete.
+
+        unpin_remote : bool, optional
+            Whether to also unpin from the relay. Default is True.
+            Set to False if you only want to free local storage.
+
+        run_gc : bool, optional
+            Whether to run garbage collection immediately after unpinning.
+            Default is False (GC runs automatically with --enable-gc flag on daemon).
+            Set to True for immediate disk space reclamation.
+
+        cleanup_local_files : bool, optional
+            Whether to also remove local downloaded files from the downloads directory.
+            Default is False.
+
+        show_logs : bool, optional
+            Whether to show logs. Default is True.
+
+        raise_on_error : bool, optional
+            If True, raise an Exception on errors. Otherwise logs them. Default is False.
+
+        Returns
+        -------
+        bool
+            True if deletion was successful, False otherwise.
+
+        Examples
+        --------
+        >>> # Simple delete (unpin locally and on relay)
+        >>> engine.delete_file("QmHash123...")
+
+        >>> # Delete with immediate garbage collection
+        >>> engine.delete_file("QmHash123...", run_gc=True)
+
+        >>> # Delete only locally, keep on relay
+        >>> engine.delete_file("QmHash123...", unpin_remote=False)
+
+        >>> # Full cleanup: unpin everywhere, GC, and remove local files
+        >>> engine.delete_file("QmHash123...", run_gc=True, cleanup_local_files=True)
+        """
+        if cid in [None, ""]:
+          msg = "CID parameter cannot be None or empty"
+          if raise_on_error:
+            raise ValueError(msg)
+          else:
+            if show_logs:
+              self.P(msg, color='r')
+            return False
+
+        try:
+          # Unpin the file (locally and optionally on relay)
+          success = self.unpin_file(
+            cid=cid,
+            unpin_remote=unpin_remote,
+            show_logs=show_logs,
+            raise_on_error=raise_on_error
+          )
+
+          if not success:
+            return False
+
+          # Optional: clean up local downloaded files
+          if cleanup_local_files:
+            local_folder = os.path.join(self.__downloads_dir, cid)
+            if os.path.exists(local_folder):
+              try:
+                if os.path.isdir(local_folder):
+                  shutil.rmtree(local_folder)
+                else:
+                  os.remove(local_folder)
+                if show_logs:
+                  self.Pd(f"Removed local files for CID {cid}")
+              except Exception as e:
+                msg = f"Error removing local files for CID {cid}: {e}"
+                if show_logs:
+                  self.P(msg, color='r')
+                # Don't fail the whole operation if local cleanup fails
+
+          # Optional: run garbage collection immediately
+          if run_gc:
+            if show_logs:
+              self.Pd("Running garbage collection...")
+            try:
+              gc_result = self.__run_command(
+                ["ipfs", "repo", "gc"],
+                raise_on_error=False,
+                show_logs=False  # GC output can be very verbose
+              )
+              if show_logs:
+                self.P(f"Deleted file {cid} and ran garbage collection", color='g')
+            except Exception as e:
+              msg = f"Error running garbage collection: {e}"
+              if show_logs:
+                self.P(msg, color='r')
+              # Don't fail if GC fails - the unpin was successful
+          else:
+            if show_logs:
+              location = "local + relay" if unpin_remote else "local only"
+              self.P(f"Unpinned file {cid} ({location})", color='g')
+
+          return True
+
+        except Exception as e:
+          msg = f"Error deleting file {cid}: {e}"
+          if raise_on_error:
+            raise RuntimeError(msg)
+          else:
+            if show_logs:
+              self.P(msg, color='r')
+            return False
+
+      def delete_files(
+        self,
+        cids: list,
+        unpin_remote: bool = True,
+        run_gc_after_all: bool = True,
+        cleanup_local_files: bool = False,
+        show_logs: bool = True,
+        raise_on_error: bool = False,
+        continue_on_error: bool = True
+      ) -> dict:
+        """
+        Delete multiple files from R1FS in bulk.
+        More efficient than calling delete_file repeatedly as it can run GC once at the end.
+
+        Parameters
+        ----------
+        cids : list
+            List of CIDs to delete.
+
+        unpin_remote : bool, optional
+            Whether to also unpin from the relay. Default is True.
+
+        run_gc_after_all : bool, optional
+            Whether to run garbage collection once after all deletions.
+            Default is True. More efficient than running GC for each file.
+
+        cleanup_local_files : bool, optional
+            Whether to also remove local downloaded files. Default is False.
+
+        show_logs : bool, optional
+            Whether to show logs. Default is True.
+
+        raise_on_error : bool, optional
+            If True, raise an Exception on first error. Default is False.
+
+        continue_on_error : bool, optional
+            Whether to continue deleting remaining files if one fails.
+            Only used if raise_on_error is False. Default is True.
+
+        Returns
+        -------
+        dict
+            Dictionary with keys:
+            - 'success': list of successfully deleted CIDs
+            - 'failed': list of CIDs that failed to delete
+            - 'total': total number of CIDs processed
+            - 'success_count': number of successful deletions
+            - 'failed_count': number of failed deletions
+
+        Examples
+        --------
+        >>> # Delete multiple files efficiently
+        >>> cids = ["QmHash1...", "QmHash2...", "QmHash3..."]
+        >>> result = engine.delete_files(cids)
+        >>> print(f"Deleted {result['success_count']} of {result['total']} files")
+
+        >>> # Delete locally only, no GC
+        >>> result = engine.delete_files(cids, unpin_remote=False, run_gc_after_all=False)
+
+        >>> # Full cleanup
+        >>> result = engine.delete_files(
+        >>>   cids,
+        >>>   cleanup_local_files=True,
+        >>>   run_gc_after_all=True
+        >>> )
+        """
+        if not isinstance(cids, list):
+          msg = "cids parameter must be a list"
+          if raise_on_error:
+            raise ValueError(msg)
+          else:
+            if show_logs:
+              self.P(msg, color='r')
+            return {
+              'success': [],
+              'failed': cids if isinstance(cids, list) else [cids],
+              'total': 0,
+              'success_count': 0,
+              'failed_count': 0
+            }
+
+        if len(cids) == 0:
+          if show_logs:
+            self.Pd("No CIDs provided for deletion")
+          return {
+            'success': [],
+            'failed': [],
+            'total': 0,
+            'success_count': 0,
+            'failed_count': 0
+          }
+
+        if show_logs:
+          self.P(f"Deleting {len(cids)} files from R1FS...", color='m')
+
+        success_list = []
+        failed_list = []
+
+        for i, cid in enumerate(cids):
+          if show_logs:
+            self.Pd(f"Processing {i+1}/{len(cids)}: {cid}")
+
+          try:
+            # Delete without running GC for each file (we'll do it once at the end)
+            result = self.delete_file(
+              cid=cid,
+              unpin_remote=unpin_remote,
+              run_gc=False,  # Don't GC per file
+              cleanup_local_files=cleanup_local_files,
+              show_logs=False,  # Reduce log spam
+              raise_on_error=raise_on_error
+            )
+
+            if result:
+              success_list.append(cid)
+            else:
+              failed_list.append(cid)
+              if not continue_on_error:
+                break
+          except Exception as e:
+            failed_list.append(cid)
+            if show_logs:
+              self.P(f"Error deleting CID {cid}: {e}", color='r')
+            if raise_on_error:
+              raise
+            if not continue_on_error:
+              break
+
+        # Run garbage collection once at the end (more efficient)
+        if run_gc_after_all and len(success_list) > 0:
+          if show_logs:
+            self.P("Running garbage collection for all deleted files...", color='m')
+          try:
+            gc_result = self.__run_command(
+              ["ipfs", "repo", "gc"],
+              raise_on_error=False,
+              show_logs=False
+            )
+            if show_logs:
+              self.Pd("Garbage collection completed")
+          except Exception as e:
+            if show_logs:
+              self.P(f"Warning: Garbage collection failed: {e}", color='r')
+            # Don't fail the whole operation if GC fails
+
+        result = {
+          'success': success_list,
+          'failed': failed_list,
+          'total': len(cids),
+          'success_count': len(success_list),
+          'failed_count': len(failed_list)
+        }
+
+        if show_logs:
+          location = "local + relay" if unpin_remote else "local only"
+          self.P(
+            f"Bulk delete completed: {result['success_count']}/{result['total']} succeeded ({location})",
+            color='g' if result['failed_count'] == 0 else 'y'
+          )
+          if result['failed_count'] > 0:
+            self.P(f"Failed to delete {result['failed_count']} files", color='r')
+
+        return result
+
+      def garbage_collect(self, show_logs: bool = True, raise_on_error: bool = False) -> bool:
+        """
+        Manually run IPFS garbage collection to reclaim disk space from unpinned files.
+
+        Note: The IPFS daemon runs with --enable-gc flag, so GC happens automatically.
+        This method is useful for immediate disk space reclamation.
+
+        Parameters
+        ----------
+        show_logs : bool, optional
+            Whether to show logs. Default is True.
+
+        raise_on_error : bool, optional
+            If True, raise an Exception on errors. Default is False.
+
+        Returns
+        -------
+        bool
+            True if garbage collection succeeded, False otherwise.
+
+        Examples
+        --------
+        >>> # Run garbage collection manually
+        >>> engine.garbage_collect()
+        """
+        try:
+          if show_logs:
+            self.P("Running IPFS garbage collection...", color='m')
+
+          result = self.__run_command(
+            ["ipfs", "repo", "gc"],
+            raise_on_error=raise_on_error,
+            show_logs=False  # GC output can be very verbose
+          )
+
+          if show_logs:
+            # Count lines in output to show how many blocks were freed
+            lines = result.strip().split('\n') if result else []
+            blocks_removed = len([l for l in lines if l.strip()])
+            self.P(f"Garbage collection completed (~{blocks_removed} blocks processed)", color='g')
+
+          return True
+
+        except Exception as e:
+          msg = f"Error running garbage collection: {e}"
+          if raise_on_error:
+            raise RuntimeError(msg)
+          else:
+            if show_logs:
+              self.P(msg, color='r')
+            return False
+
+      def cleanup_downloads(
+        self,
+        cid: str = None,
+        show_logs: bool = True
+      ) -> int:
+        """
+        Clean up downloaded files from the local downloads directory.
+        This does NOT unpin files from IPFS, only removes local file copies.
+
+        Parameters
+        ----------
+        cid : str, optional
+            Specific CID to clean up. If None, cleans all downloads.
+
+        show_logs : bool, optional
+            Whether to show logs. Default is True.
+
+        Returns
+        -------
+        int
+            Number of items cleaned up.
+
+        Examples
+        --------
+        >>> # Clean up all downloaded files
+        >>> count = engine.cleanup_downloads()
+        >>> print(f"Cleaned up {count} files")
+
+        >>> # Clean up specific CID's downloads
+        >>> engine.cleanup_downloads(cid="QmHash123...")
+        """
+        count = 0
+
+        try:
+          if not os.path.exists(self.__downloads_dir):
+            if show_logs:
+              self.Pd(f"Downloads directory does not exist: {self.__downloads_dir}")
+            return 0
+
+          if cid is not None:
+            # Clean up specific CID
+            target_path = os.path.join(self.__downloads_dir, cid)
+            if os.path.exists(target_path):
+              try:
+                if os.path.isdir(target_path):
+                  shutil.rmtree(target_path)
+                else:
+                  os.remove(target_path)
+                count = 1
+                if show_logs:
+                  self.P(f"Cleaned up local files for CID: {cid}", color='g')
+                # Remove from tracking dict
+                self.__downloaded_files.pop(cid, None)
+              except Exception as e:
+                if show_logs:
+                  self.P(f"Error cleaning up CID {cid}: {e}", color='r')
+            else:
+              if show_logs:
+                self.Pd(f"No local files found for CID: {cid}")
+          else:
+            # Clean up all downloads
+            for item in os.listdir(self.__downloads_dir):
+              item_path = os.path.join(self.__downloads_dir, item)
+              try:
+                if os.path.isdir(item_path):
+                  shutil.rmtree(item_path)
+                else:
+                  os.remove(item_path)
+                count += 1
+              except Exception as e:
+                if show_logs:
+                  self.P(f"Error removing {item_path}: {e}", color='r')
+
+            if show_logs:
+              self.P(f"Cleaned up {count} items from downloads directory", color='g')
+
+            # Clear all tracking
+            self.__downloaded_files.clear()
+
+        except Exception as e:
+          if show_logs:
+            self.P(f"Error during cleanup: {e}", color='r')
+
+        return count
+
+    ######## END DELETE METHODS #########
+
     def calculate_file_cid(
       self,
       file_path: str,

ratio1/logging/logger_mixins/pickle_serialization_mixin.py

@@ -1,6 +1,7 @@
 import os
 import bz2
 import pickle
+import tempfile
 from time import time
 
 class _PickleSerializationMixin(object):
@@ -55,12 +56,41 @@ class _PickleSerializationMixin(object):
     return myobj
 
 
-  def save_pickle(self, data, fn, folder=None,
-                  use_prefix=False, verbose=True,
-                  compressed=False,
-                  subfolder_path=None,
-                  locking=True,
-                  ):
+  def _fsync_dir(self, dirpath: str):
+    """Best-effort directory fsync for durable rename; silently ignore if unsupported."""
+    try:
+      # Linux: O_DIRECTORY available; on other OSes this may fail -> we ignore.
+      dir_fd = os.open(dirpath, getattr(os, "O_DIRECTORY", 0))
+      try:
+        os.fsync(dir_fd)
+      finally:
+        os.close(dir_fd)
+    except Exception:
+      # Not all platforms/filesystems support directory fsync; ignore if it fails.
+      pass
+  # enddef
+
+  def _fsync_file(self, filepath: str):
+    """Best-effort file fsync for durability; silently ignore if unsupported."""
+    # Ensure file contents hit disk even if helper didn't fsync
+    try:
+      rd_fd = os.open(filepath, os.O_RDONLY)
+      try:
+        os.fsync(rd_fd)
+      finally:
+        os.close(rd_fd)
+    except Exception:
+      # Best effort; continue to replace
+      pass
+  # enddef
+
+  def save_pickle(
+      self, data, fn, folder=None,
+      use_prefix=False, verbose=True,
+      compressed=False,
+      subfolder_path=None,
+      locking=True,
+  ):
     """
     compressed: True if compression is required OR you can just add '.pklz' to `fn`
     """
@@ -69,7 +99,6 @@ class _PickleSerializationMixin(object):
       if verbose:
         self.P(s)
       return
-
     # enddef
 
     lfld = self.get_target_folder(target=folder)
@@ -87,36 +116,62 @@ class _PickleSerializationMixin(object):
       datafile = os.path.join(datafolder, fn)
 
     os.makedirs(os.path.split(datafile)[0], exist_ok=True)
+    target_dir = os.path.dirname(datafile)
 
     tm_start = time()
     tm_elapsed = None
     err_msg = None
-    if compressed or '.pklz' in fn:
-      if not compressed:
-        P("Saving pickle with compression=True forced due to extension")
-      else:
-        P("Saving pickle with compression...")
-      if self._save_compressed_pickle(datafile, myobj=data, locking=locking):
-        tm_elapsed = time() - tm_start
-        P("  Compressed pickle {} saved in {} folder in {:.1f}s".format(fn, folder, tm_elapsed))
-      else:
-        P("  FAILED compressed pickle save!")
-    else:
-      P("Saving uncompressed pikle (lock:{}) : {} ".format(locking, datafile))
-      with self.managed_lock_resource(datafile, condition=locking):
-        try:
-          with open(datafile, 'wb') as fhandle:
-            pickle.dump(data, fhandle, protocol=pickle.HIGHEST_PROTOCOL)
+
+    # Create a temp file in the SAME directory so os.replace is atomic
+    tmp_fd, tmp_path = tempfile.mkstemp(prefix=os.path.basename(fn) + ".", suffix=".tmp", dir=target_dir)
+    os.close(tmp_fd)  # we'll reopen with Python I/O or let helper write to it
+
+    try:
+      if compressed or '.pklz' in fn:
+        if not compressed:
+          P("Saving pickle with compression=True forced due to extension")
+        else:
+          P("Saving pickle with compression...")
+
+        ok = self._save_compressed_pickle(tmp_path, myobj=data, locking=locking)
+        if ok:
+          # Ensure data is flushed to disk before rename
+          self._fsync_file(tmp_path)
+          os.replace(tmp_path, datafile)  # atomic move
+          self._fsync_dir(target_dir)
           tm_elapsed = time() - tm_start
-        except Exception as e:
-          err_msg = e
-      if tm_elapsed is not None:
-        if verbose:
-          P("  Saved pickle '{}' in '{}' folder in {:.1f}s".format(fn, folder, tm_elapsed))
+          P("  Compressed pickle {} saved in {} folder in {:.1f}s".format(fn, folder, tm_elapsed))
+        else:
+          P("  FAILED compressed pickle save!")
       else:
-        # maybe show this only if verbose?
-        P(f"  FAILED pickle save! Error: {err_msg}")
-    # endif compressed or not
+        P("Saving uncompressed pikle (lock:{}) : {} ".format(locking, datafile))
+        with self.managed_lock_resource(datafile, condition=locking):
+          try:
+            with open(tmp_path, 'wb') as fhandle:
+              pickle.dump(data, fhandle, protocol=pickle.HIGHEST_PROTOCOL)
+              fhandle.flush()
+              os.fsync(fhandle.fileno())  # ensure data is written to disk
+            # Atomic replace + dir fsync
+            os.replace(tmp_path, datafile)
+            self._fsync_dir(target_dir)
+            tm_elapsed = time() - tm_start
+          except Exception as e:
+            err_msg = e
+        if tm_elapsed is not None:
+          if verbose:
+            P("  Saved pickle '{}' in '{}' folder in {:.1f}s".format(fn, folder, tm_elapsed))
+        else:
+          # maybe show this only if verbose?
+          P(f"  FAILED pickle save! Error: {err_msg}")
+      # endif compressed or not
+    except Exception as e:
+      err_msg = e
+      try:
+        if os.path.exists(datafile):
+          os.remove(tmp_path)
+      except:
+        pass
+      P(f"  FAILED pickle save! Error: {err_msg}")
     return datafile
 
 

{ratio1-3.4.102.dist-info → ratio1-3.4.104.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ratio1
-Version: 3.4.102
+Version: 3.4.104
 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.102.dist-info → ratio1-3.4.104.dist-info}/RECORD

@@ -1,5 +1,5 @@
 ratio1/__init__.py,sha256=YimqgDbjLuywsf8zCWE0EaUXH4MBUrqLxt0TDV558hQ,632
-ratio1/_ver.py,sha256=TamRKB7DITOfuI5npELhadEeQY9YCIaHOrMR9S5NWP0,332
+ratio1/_ver.py,sha256=ifnFzHWR-j5DQzRyIzuoGsp1XnbfkaWHwmvpvAU80Pk,332
 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/apps.py,sha256=MD4SRTNId663D3SX78_GJa40BI_H1mdcNbL2gy_Hio0,827
 ratio1/const/base.py,sha256=QIeRH6X-u8DbezQCGipI3isL1LGComBQC5hLedO1jrQ,6042
 ratio1/const/comms.py,sha256=qEYX4ciYg8SYWSDZZTUYxzpR1--2a7UusrWzAq0hxo8,2259
 ratio1/const/environment.py,sha256=632L5GrcNqF3-JhvrC6kXzXwLMcihRgMlOkLurnOwGY,1031
-ratio1/const/evm_net.py,sha256=lyklHZS9DsbWfhansFTXpCULjtZMA9m_KVP_4z9Lp3M,20020
+ratio1/const/evm_net.py,sha256=mCFvb2GXke0EaAWNKMVKWxXmDcqWxgqNnK5xK-5Qxg8,20021
 ratio1/const/formatter.py,sha256=AW3bWlqf39uaqV4BBUuW95qKYfF2OkkU4f9hy3kSVhM,200
 ratio1/const/heartbeat.py,sha256=eVWuGIP5sAIYzQjOJUehmKlYHetoquSw-sTJwSKrHk8,3223
 ratio1/const/misc.py,sha256=VDCwwpf5bl9ltx9rzT2WPVP8B3mZFRufU1tSS5MO240,413
@@ -74,7 +74,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=5Uo_adugcGTg8kVsev9kmyUSSzh9FdM803jPdu8QEWw,72273
+ratio1/ipfs/r1fs.py,sha256=SBl1_UEhVd0rb4mgk9_zsdjBtp4XQKZ5_Fj4JMWzwls,91441
 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
@@ -93,7 +93,7 @@ ratio1/logging/logger_mixins/download_mixin.py,sha256=ZZ1QuQ7kDcUkxhu65odD2pvBRl
 ratio1/logging/logger_mixins/general_serialization_mixin.py,sha256=bNM-6AsYhKD56v79hvJDgO8un5rHH4IKv1XJ3yksseQ,7424
 ratio1/logging/logger_mixins/json_serialization_mixin.py,sha256=JnfVOdQQTlx10sTLjQv8d7DO-1lNKuK4E8vMSE_t--Q,15198
 ratio1/logging/logger_mixins/machine_mixin.py,sha256=VoGijSjj0CwfbSo_jjp3uvs_aovWwQHNDEqu5jzmWJE,3640
-ratio1/logging/logger_mixins/pickle_serialization_mixin.py,sha256=T2NubHBoXPkIjSEM-9NgIiYfVbOk3qHI2VQ2BkHp_MY,9553
+ratio1/logging/logger_mixins/pickle_serialization_mixin.py,sha256=tmdmoRz38iJGfK4J37oEghbRizN4BdZs7F2kObZ2ldQ,11391
 ratio1/logging/logger_mixins/process_mixin.py,sha256=eI0izBAhStPOant2SZv2ZuTDH10s2ON_CkuGQEEFew4,1888
 ratio1/logging/logger_mixins/resource_size_mixin.py,sha256=nH0R9RmhJxatX_qSQu_CtkLD6sH2stMOylpp_Ym6mHI,2281
 ratio1/logging/logger_mixins/timers_mixin.py,sha256=jXQvGxpemTrKZRI5ydrTUYrqAnXzZnvwzpqN4agJlGo,17299
@@ -109,8 +109,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.102.dist-info/METADATA,sha256=L8VoZiI6WcTmCO61RTu4lvo8SmypVauPtaMi6pCgoC0,12256
-ratio1-3.4.102.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ratio1-3.4.102.dist-info/entry_points.txt,sha256=DR_olREzU1egwmgek3s4GfQslBi-KR7lXsd4ap0TFxE,46
-ratio1-3.4.102.dist-info/licenses/LICENSE,sha256=cvOsJVslde4oIaTCadabXnPqZmzcBO2f2zwXZRmJEbE,11311
-ratio1-3.4.102.dist-info/RECORD,,
+ratio1-3.4.104.dist-info/METADATA,sha256=sxYnwiLr81mwsgXs3QKZfm4DzSdEl9uymyhl0-GMNYY,12256
+ratio1-3.4.104.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ratio1-3.4.104.dist-info/entry_points.txt,sha256=DR_olREzU1egwmgek3s4GfQslBi-KR7lXsd4ap0TFxE,46
+ratio1-3.4.104.dist-info/licenses/LICENSE,sha256=cvOsJVslde4oIaTCadabXnPqZmzcBO2f2zwXZRmJEbE,11311
+ratio1-3.4.104.dist-info/RECORD,,