ipfs-node 0.1.6__py3-none-any.whl

ipfs_node/__init__.py

@@ -0,0 +1,4 @@
+from .ipfs_node import IpfsNode
+from .ipfs_pubsub import IPFSMessage, IPFSSubscription
+from .ipfs_tunnels import NodeTunnels
+__all__ = ["IpfsNode", "IPFSMessage", "IPFSSubscription", "NodeTunnels"]

ipfs_node/ipfs_files.py

@@ -0,0 +1,233 @@
+import os
+import tempfile
+import ctypes
+import shutil
+import platform
+import json
+import time
+import threading
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Union, List, Dict, Any, Callable, Tuple, Iterator, Set
+from libkubo import libkubo, c_str, c_bool, from_c_str, ffi
+
+from ipfs_tk_generics.files import BaseFiles
+
+
+class NodeFiles(BaseFiles):
+    def __init__(self, node):
+        self._node = node
+        self._repo_path = self._node._repo_path
+
+
+    def read(self, cid: str, *args, **kwargs) -> bytes:
+        """
+        Get bytes data from IPFS.
+
+        Args:
+            cid: The Content Identifier of the data to retrieve.
+                 Note: This method only works with file content, not directories.
+                 For directories, use the download() method instead.
+
+        Returns:
+            bytes: The retrieved data.
+        """
+        temp_file = None
+        temp_file_path = None
+        try:
+            # Create a temporary file to store the retrieved data
+            temp_file = tempfile.NamedTemporaryFile(delete=False)
+            temp_file_path = temp_file.name
+            temp_file.close()
+
+            # Get the file from IPFS
+            success = self.download(cid, temp_file_path)
+            if not success:
+                raise RuntimeError(f"Failed to retrieve data for CID: {cid}")
+
+            # Read the data from the temporary file
+            with open(temp_file_path, 'rb') as f:
+                return f.read()
+        except Exception as e:
+            raise RuntimeError(f"Error retrieving bytes from IPFS: {e}")
+        finally:
+            # Clean up the temporary file
+            if temp_file_path is not None and os.path.exists(temp_file_path):
+                try:
+                    os.unlink(temp_file_path)
+                except Exception:
+                    # Silently ignore cleanup errors
+                    pass
+
+    def publish(self, file_path: str, *args, **kwargs) -> str:
+        return self._add(file_path)
+    def _add(self, file_path: str, only_hash: bool = False, *args, **kwargs) -> str:
+        """
+        Add a file to IPFS.
+
+        Args:
+            file_path: Path to the file to add.
+
+        Returns:
+            str: The CID (Content Identifier) of the added file.
+        """
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        repo_path = c_str(self._repo_path.encode('utf-8'))
+        file_path_c = c_str(os.path.abspath(file_path).encode('utf-8'))
+
+        try:
+            cid_ptr = libkubo.AddFile(
+                repo_path, file_path_c, c_bool(only_hash))
+            if not cid_ptr:
+                raise RuntimeError("Failed to add file to IPFS")
+
+            # Copy the string content before freeing the pointer
+            cid = from_c_str(cid_ptr)
+
+            # Store the memory freeing operation in a separate try block
+            try:
+                # Free the memory allocated by C.CString in Go
+                libkubo.FreeString(cid_ptr)
+            except Exception as e:
+                print(f"Warning: Failed to free memory: {e}")
+
+            if not cid:
+                raise RuntimeError("Failed to add file to IPFS")
+
+            return cid
+        except Exception as e:
+            # Handle any exceptions during the process
+            raise RuntimeError(f"Error adding file to IPFS: {e}")
+
+    def download(self, cid: str, dest_path: str=".", **kwargs) -> bool:
+        """
+        Retrieve a file or directory from IPFS by its CID.
+
+        Args:
+            cid: The Content Identifier of the content to retrieve.
+            dest_path: Destination path where the file or directory will be saved.
+                       - For a file: The complete file path including filename.
+                       - For a directory: The path where the directory and its contents
+                         will be placed. All directory contents will be created inside 
+                         this path.
+
+        Returns:
+            bool: True if the content was successfully retrieved, False otherwise.
+        """
+        try:
+            dest_path = os.path.abspath(dest_path)
+            repo_path = c_str(self._repo_path.encode('utf-8'))
+            cid_c = c_str(cid.encode('utf-8'))
+            dest_path_c = c_str(os.path.abspath(dest_path).encode('utf-8'))
+
+            result = libkubo.Download(repo_path, cid_c, dest_path_c)
+
+            return result == 0
+        except Exception as e:
+            # Handle any exceptions during the process
+            raise RuntimeError(f"Error retrieving file from IPFS: {e}")
+
+    def pin(self, cid: str, recursive: bool = True) -> bool:
+        """
+        Pin a CID to the local IPFS node.
+
+        Args:
+            cid: The Content Identifier to pin.
+            recursive: Whether to recursively pin the object and its references.
+                      Currently, only recursive pinning is supported.
+
+        Returns:
+            bool: True if the CID was successfully pinned, False otherwise.
+        """
+        try:
+            repo_path = c_str(self._repo_path.encode('utf-8'))
+            cid_c = c_str(cid.encode('utf-8'))
+
+            result = libkubo.PinCID(repo_path, cid_c)
+
+            return result == 0
+        except Exception as e:
+            # Handle any exceptions during the process
+            raise RuntimeError(f"Error pinning CID: {e}")
+
+    def unpin(self, cid: str, recursive: bool = True) -> bool:
+        """
+        Unpin a CID from the local IPFS node.
+
+        Args:
+            cid: The Content Identifier to unpin.
+            recursive: Whether to recursively unpin the object and its references.
+                      Currently, this parameter is ignored as all unpinning is recursive.
+
+        Returns:
+            bool: True if the CID was successfully unpinned, False otherwise.
+        """
+        try:
+            repo_path = c_str(self._repo_path.encode('utf-8'))
+            cid_c = c_str(cid.encode('utf-8'))
+
+            result = libkubo.UnpinCID(repo_path, cid_c)
+
+            return result == 0
+        except Exception as e:
+            # Handle any exceptions during the process
+            raise RuntimeError(f"Error unpinning CID: {e}")
+
+    def list_pins(self, *args, **kwargs) -> list[str]:
+        """
+        List all pinned CIDs in the local IPFS node.
+
+        Returns:
+            list[str]: A list of pinned CIDs.
+        """
+        try:
+            repo_path = c_str(self._repo_path.encode('utf-8'))
+
+            pins_json_ptr = libkubo.ListPins(repo_path)
+            if not pins_json_ptr:
+                raise RuntimeError("Failed to list pins")
+
+            # Copy the string content before freeing the pointer
+            pins_json = from_c_str(pins_json_ptr)
+
+            # Store the memory freeing operation in a separate try block
+            try:
+                # Free the memory allocated by C.CString in Go
+                libkubo.FreeString(pins_json_ptr)
+            except Exception as e:
+                print(f"Warning: Failed to free memory: {e}")
+
+            if not pins_json:
+                return []
+
+            # Parse the JSON string into a Python list
+            pins = json.loads(pins_json)
+            return pins
+        except Exception as e:
+            # Handle any exceptions during the process
+            raise RuntimeError(f"Error listing pins: {e}")
+
+    def remove(self, cid: str) -> bool:
+        """
+        Remove a pinned object.
+
+        This is an alias for unpin that makes the API more intuitive.
+
+        Args:
+            cid: The Content Identifier to remove.
+
+        Returns:
+            bool: True if the CID was successfully removed, False otherwise.
+        """
+        return self.unpin(cid)
+
+    def predict_cid(self, filepath: str, *args, **kwargs):
+        return self._add(filepath, only_hash=True)
+
+
+    def terminate(self):
+        pass
+    def __del__(self):
+        self.terminate()

ipfs_node/ipfs_node.py

@@ -0,0 +1,230 @@
+import os
+import tempfile
+import ctypes
+import shutil
+import platform
+import json
+import time
+import threading
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Union, List, Dict, Any, Callable, Tuple, Iterator, Set
+from .ipfs_pubsub import IPFSMessage, IPFSSubscription, NodePubsub
+from libkubo import libkubo, c_str, from_c_str, ffi
+from .ipfs_tunnels import NodeTunnels
+from .ipfs_files import NodeFiles
+from .ipfs_peers import NodePeers
+
+from ipfs_tk_generics.client import IpfsClient
+class IpfsNode(IpfsClient):
+    """
+    Python wrapper for a Kubo IPFS node.
+
+    This class provides an interface to work with IPFS functionality
+    through the Kubo implementation.
+    """
+
+    def __init__(self, repo_path: Optional[str] = None, online: bool = True, enable_pubsub: bool = True):
+        """
+        Initialize an IPFS node with a specific repository path.
+
+        Args:
+            repo_path: Path to the IPFS repository. If None, a temporary
+                       repository will be created.
+            online: Whether the node should connect to the IPFS network.
+            enable_pubsub: Whether to enable pubsub functionality.
+        """
+        self._temp_dir = None
+        self._repo_path = repo_path
+        self._online = online
+        self._enable_pubsub = enable_pubsub
+        self._peer_id = None  # Will be set when connecting to the network
+        # If no repo path is provided, create a temporary directory
+        if self._repo_path is None:
+            self._temp_dir = tempfile.TemporaryDirectory()
+            self._repo_path = self._temp_dir.name
+            
+
+        # Initialize the repository if it doesn't exist
+        if not os.path.exists(os.path.join(self._repo_path, "config")):
+            self._init_repo()
+        else:
+            print("Loading existing IPFS repo")
+        libkubo.RunNode(c_str(self._repo_path.encode('utf-8')))
+
+        # Get the node ID if online
+        if self._online:
+            self._peer_id = self.get_node_id()
+        self._pubsub = NodePubsub(self)
+        self._tunnels = NodeTunnels(self)
+        self._files = NodeFiles(self)
+        self._peers = NodePeers(self)
+        
+        # Enable pubsub if requested
+        if self._enable_pubsub and self._online:
+            self.pubsub._enable_pubsub_config()
+    @property
+    def tunnels(self)->NodeTunnels:
+        return self._tunnels
+    @property
+    def pubsub(self)->NodePubsub:
+        return self._pubsub
+    @property
+    def files(self)->NodeFiles:
+        return self._files
+    @property
+    def peers (self)->NodePeers:
+        return self._peers
+    def _run(self):
+        pass
+
+    def _stop(self):
+        pass
+
+    def _init_repo(self):
+        """Initialize the IPFS repository."""
+        repo_path = c_str(self._repo_path.encode('utf-8'))
+        result = libkubo.CreateRepo(repo_path)
+
+        if result < 0:
+            raise RuntimeError(
+                f"Failed to initialize IPFS repository: {result}")
+        # print(f"Initalised repo at: {repo_path}")
+
+
+
+
+
+    def terminate(self):
+        """Close the IPFS node and clean up resources."""
+        self._pubsub.terminate()
+        self._tunnels.terminate()
+        self._files.terminate()
+        self._peers.terminate()
+        # Force cleanup of the node in Go
+        if self._repo_path:
+            try:
+                repo_path = c_str(self._repo_path.encode('utf-8'))
+                print("Cleaning up node...")
+                libkubo.CleanupNode(repo_path)
+                # print(f"Node for repo {self._repo_path} explicitly cleaned up")
+            except Exception as e:
+                print(f"Warning: Error cleaning up node: {e}")
+
+        # Clean up temporary directory if one was created
+        if self._temp_dir is not None:
+            self._temp_dir.cleanup()
+            self._temp_dir = None
+
+    def __enter__(self):
+        """Support for context manager protocol."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Clean up when exiting the context manager."""
+        self.terminate()
+
+
+    def _ipfs_host_ip(self,):
+        return "127.0.0.1"
+
+    def test_get_string(self) -> str:
+        """Test function to check basic string passing from Go to Python"""
+        try:
+            id_ptr = libkubo.TestGetString()
+            if not id_ptr:
+                print("TEST: No string returned from TestGetString")
+                return ""
+
+            test_str = from_c_str(id_ptr)
+            # print(f"TEST: String from Go: '{test_str}', length: {len(test_str)}")
+            return test_str
+        except Exception as e:
+            print(f"TEST ERROR: {e}")
+            return f"ERROR: {e}"
+
+    def get_node_id(self) -> str:
+        """
+        Get the peer ID of this IPFS node.
+
+        Returns:
+            str: The peer ID of the node, or empty string if not available.
+        """
+        if not self._online:
+            print("IPFS: not online")
+            return ""
+
+        # try to get the node ID
+        try:
+            repo_path = c_str(self._repo_path.encode('utf-8'))
+
+            id_ptr = libkubo.GetNodeID(repo_path)
+
+            if not id_ptr:
+                print("IPFS: NO ID_PTR")
+                return ""
+
+            # Copy the string content
+            peer_id = from_c_str(id_ptr)
+
+            # Don't free the memory - let Go's finalizer handle it
+            # The memory will be freed when Go's garbage collector runs
+
+            # Strip the prefix we added for debugging
+            if peer_id.startswith("ID:"):
+                peer_id = peer_id[3:]
+
+            return peer_id
+        except Exception as e:
+            print(f"IPFS ERROR in get_node_id: {e}")
+            return f"ERROR: {e}"
+
+    @property
+    def peer_id(self) -> str:
+        """Get the peer ID of this node."""
+        if not self._peer_id:
+            self._peer_id = self.get_node_id()
+        return self._peer_id
+
+    @classmethod
+    def ephemeral(cls, online: bool = True, enable_pubsub: bool = True):
+        """
+        Create an ephemeral IPFS node with a temporary repository.
+
+        Args:
+            online: Whether the node should connect to the IPFS network.
+            enable_pubsub: Whether to enable pubsub functionality.
+
+        Returns:
+            IpfsNode: A new IPFS node instance with a temporary repository.
+        """
+        return cls(None, online, enable_pubsub)
+    def get_addrs(self):
+        if not self._online:
+            print("IPFS: not online")
+            return ""
+
+        # try to get the node ID
+        try:
+            repo_path = c_str(self._repo_path.encode('utf-8'))
+
+            id_ptr = libkubo.GetNodeMultiAddrs(repo_path)
+
+            if not id_ptr:
+                print("IPFS: NO ID_PTR")
+                return ""
+
+            # Copy the string content
+            json_data = from_c_str(id_ptr)
+
+            # Don't free the memory - let Go's finalizer handle it
+            # The memory will be freed when Go's garbage collector runs
+
+            # Strip the prefix we added for debugging
+            return json.loads(json_data)
+        except Exception as e:
+            print(f"IPFS ERROR in get_node_id: {e}")
+            return f"ERROR: {e}"
+
+    def __del__(self):
+        self.terminate()

ipfs_node/ipfs_peers.py

@@ -0,0 +1,71 @@
+import os
+import tempfile
+import ctypes
+import shutil
+import platform
+import json
+import time
+import threading
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Union, List, Dict, Any, Callable, Tuple, Iterator, Set
+from libkubo import libkubo, c_str, from_c_str, ffi
+DEF_FIND_TIMEOUT=10
+from ipfs_tk_generics.peers import BasePeers
+class NodePeers(BasePeers):
+    def __init__(self, node):
+        self._node = node
+        self._repo_path = self._node._repo_path
+    def find(self, peer_id:str, timeout=DEF_FIND_TIMEOUT)->list[str]:
+        data = from_c_str(
+            libkubo.FindPeer(c_str(self._repo_path), c_str(peer_id), timeout), 
+        )
+        return json.loads(data)
+    def list_peers(self)->list[str]:
+        data = from_c_str(
+            libkubo.ListPeers(c_str(self._repo_path))
+        )
+    
+        return json.loads(data)
+    def list_ids(self)->list[str]:
+        data = from_c_str(
+            libkubo.ListPeersIDs(c_str(self._repo_path))
+        )
+    
+        return json.loads(data)
+    def connect(self, peer_addr: str) -> bool:
+        """
+        Connect to an IPFS peer.
+
+        Args:
+            peer_addr: Multiaddress of the peer to connect to.
+
+        Returns:
+            bool: True if successfully connected, False otherwise.
+        """
+        if not self._node._online:
+            raise RuntimeError("Cannot connect to peers in offline mode")
+
+        try:
+            repo_path = c_str(self._repo_path.encode('utf-8'))
+            peer_addr_c = c_str(peer_addr.encode('utf-8'))
+
+            result = libkubo.ConnectToPeer(repo_path, peer_addr_c)
+
+            return result == 0
+        except Exception as e:
+            # Handle any exceptions during the process
+            raise RuntimeError(f"Error connecting to peer: {e}")
+        def list_peers(self):
+            data = from_c_str(
+                libkubo.ListPeers(c_str(self._repo_path))
+            )
+            
+            return json.loads(data)
+    def is_connected(self, peer_id:str, *args, **kwargs):
+        #TODO: replace with ping
+        return peer_id in self.list_ids()
+    def terminate(self):
+        pass
+    def __del__(self):
+        self.terminate()