Upload postprocess_jsonl_latest.py

postprocess_jsonl_latest.py

@@ -26,144 +26,47 @@ from sentence_transformers import SentenceTransformer
 import torch
 
 # --- IPFS CID Generation Code (from provided ipfs_multiformats.py) ---
+# https://github.com/endomorphosis/ipfs_accelerate_py/blob/5f88e36551b626e99b05bd4bd8a3e043c5c0e8c9/ipfs_accelerate_py/ipfs_multiformats.py#L25
 import hashlib
 from multiformats import CID, multihash
 import tempfile
+import os
 import sys
-
 class ipfs_multiformats_py:
-    def __init__(self, resources=None, metadata=None):
+    def __init__(self, resources, metadata):
         self.multihash = multihash
-        # Added error handling for multihash version/import
-        if not hasattr(self.multihash, 'wrap') or not hasattr(self.multihash, 'decode'):
-             logging.warning("Multihash library structure might have changed. CID generation may fail.")
         return None
 
+    # Step 1: Hash the file content with SHA-256
     def get_file_sha256(self, file_path):
         hasher = hashlib.sha256()
-        try:
-            with open(file_path, 'rb') as f:
-                while chunk := f.read(8192):
-                    hasher.update(chunk)
-            return hasher.digest()
-        except Exception as e:
-            logging.error(f"Error hashing file {file_path}: {e}")
-            return None
-
-    # Takes bytes input directly
-    def get_bytes_sha256(self, data_bytes: bytes):
-        hasher = hashlib.sha256()
-        hasher.update(data_bytes)
+        with open(file_path, 'rb') as f:
+            while chunk := f.read(8192):
+                hasher.update(chunk)
         return hasher.digest()
 
-    def get_multihash_sha256(self, content_hash):
-        if content_hash is None:
-            return None
-        try:
-            # Try using multihash.digest instead of wrap
-            mh = self.multihash.digest(content_hash, 'sha2-256')
-            return mh
-        except Exception as e:
-            logging.error(f"Error creating multihash: {e}")
-            return None
-
-    def get_multihash_sha256_old(self, content_hash):
-        if content_hash is None:
-            return None
-        try:
-            # Use 'sha2-256' which corresponds to code 0x12
-            #mh = self.multihash.wrap(code='sha2-256', digest=content_hash)
-            mh = self.multihash.wrap('sha2-256', content_hash)
-            return mh
-        except Exception as e:
-            logging.error(f"Error wrapping hash in multihash: {e}")
-            return None
-
-    def get_cid_old(self, data):
-        """Generates CID v1 base32 for bytes data or file path."""
-        mh = None
-        try:
-            if isinstance(data, (str, Path)) and os.path.isfile(data):
-                # logging.debug(f"Calculating CID for file: {data}")
-                file_content_hash = self.get_file_sha256(data)
+    # Step 2: Wrap the hash in Multihash format
+    def get_multihash_sha256(self, file_content_hash):
+        mh = self.multihash.wrap(file_content_hash, 'sha2-256')
+        return mh
+
+    # Step 3: Generate CID from Multihash (CIDv1)
+    def get_cid(self, file_data):
+        if os.path.isfile(file_data) == True:
+            absolute_path = os.path.abspath(file_data)
+            file_content_hash = self.get_file_sha256(file_data)
+            mh = self.get_multihash_sha256(file_content_hash)
+            cid = CID('base32', 'raw', mh)
+        else:
+            with tempfile.NamedTemporaryFile(mode='w', delete=False) as f:
+                filename = f.name
+                with open(filename, 'w') as f_new:
+                    f_new.write(file_data)
+                file_content_hash = self.get_file_sha256(filename)
                 mh = self.get_multihash_sha256(file_content_hash)
-            elif isinstance(data, bytes):
-                # logging.debug(f"Calculating CID for bytes (length: {len(data)})")
-                bytes_hash = self.get_bytes_sha256(data)
-                mh = self.get_multihash_sha256(bytes_hash)
-            elif isinstance(data, str):
-                # logging.debug(f"Calculating CID for string (length: {len(data)})")
-                # Treat string as UTF-8 bytes
-                bytes_hash = self.get_bytes_sha256(data.encode('utf-8'))
-                mh = self.get_multihash_sha256(bytes_hash)
-            else:
-                logging.warning(f"Unsupported data type for CID generation: {type(data)}. Skipping CID.")
-                return None
-
-            if mh:
-                # CIDv1, base32, raw codec (0x55)
-                cid = CID(base='base32', version=1, codec='raw', multihash=mh)
-                return str(cid)
-            else:
-                return None
-        except Exception as e:
-            logging.error(f"Error generating CID: {e}", exc_info=False)
-            return None
-
-    def get_cid(self, data):
-        """Generates CID v1 base32 for bytes data or file path."""
-        try:
-            # Get the hash first
-            content_hash = None
-            if isinstance(data, (str, Path)) and os.path.isfile(data):
-                content_hash = self.get_file_sha256(data)
-            elif isinstance(data, bytes):
-                content_hash = self.get_bytes_sha256(data)
-            elif isinstance(data, str):
-                content_hash = self.get_bytes_sha256(data.encode('utf-8'))
-            else:
-                logging.warning(f"Unsupported data type for CID generation: {type(data)}. Skipping CID.")
-                return None
-
-            if not content_hash:
-                return None
-
-            # Try the new CID API format
-            try:
-                # Version 1 of multiformats may use from_digest or other method instead of passing multihash directly
-                from multiformats import multihash
-                digest = multihash.digest(content_hash, 'sha2-256')
-                cid = CID.from_digest(digest, 'raw')  # Try this format first
-                return str(cid)
-            except (AttributeError, TypeError):
-                try:
-                    # Try alternate creation method
-                    mh = self.get_multihash_sha256(content_hash)
-                    cid = CID(version=1, codec='raw', hash=mh)  # Try with hash parameter
-                    return str(cid)
-                except:
-                    # Fallback to simple base64 encoding if CID creation fails
-                    import base64
-                    b64_hash = base64.b64encode(content_hash).decode('ascii')
-                    return f"sha256:{b64_hash}"
-
-        except Exception as e:
-            logging.error(f"Error generating CID: {e}", exc_info=False)
-            # Fallback to a simple hash representation
-            try:
-                if isinstance(data, (str, Path)) and os.path.isfile(data):
-                    content_hash = self.get_file_sha256(data)
-                elif isinstance(data, bytes):
-                    content_hash = self.get_bytes_sha256(data)
-                elif isinstance(data, str):
-                    content_hash = self.get_bytes_sha256(data.encode('utf-8'))
-                else:
-                    return None
-
-                import base64
-                return f"sha256:{base64.b64encode(content_hash).decode('ascii')}"
-            except:
-                return None
+                cid = CID('base32', 1, 'raw', mh)
+                os.remove(filename)
+        return str(cid)
 # --- End IPFS CID Code ---
 
 
@@ -1049,7 +952,7 @@ def create_embedding_dataset(
             logging.info(f"Using CPU (no GPU acceleration available)")
 
         model = SentenceTransformer(embedding_model_name, device=device)
-        cid_generator = ipfs_multiformats_py() # Initialize CID generator
+        cid_generator = ipfs_multiformats_py(resources=None, metadata=None) # Initialize CID generator
         logging.info("Embedding model & CID generator loaded.")
     except Exception as e:
         logging.error(f"Failed to load embedding model or init CID generator: {e}", exc_info=True)