ipfs-node 0.1.6__tar.gz

ipfs_node-0.1.6/INSTALL.md

@@ -0,0 +1,63 @@
+# Installation Instructions
+
+## Prerequisites
+
+Before installing the Kubo Python library, ensure you have the following prerequisites:
+
+1. **Go**: Version 1.19 is required to compile the Go IPFS bindings.
+   - Install from [golang.org](https://golang.org/doc/install)
+   - Verify with `go version`
+
+2. **Python**: Version 3.7 or later.
+   - Verify with `python --version` or `python3 --version`
+
+3. **C Compiler**: Required for building the shared library.
+   - Linux: GCC (`sudo apt install build-essential`)
+   - macOS: Xcode Command Line Tools (`xcode-select --install`)
+   - Windows: MinGW or Visual C++ Build Tools
+
+## Installation
+
+### Option 1: Install from PyPI (Not available yet)
+
+```bash
+pip install ipfs_node
+```
+
+### Option 2: Install from Source
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/emendir/py_ipfs_node.git
+   cd ipfs_node
+   ```
+
+2. Install the package:
+   ```bash
+   pip install -e .
+   ```
+
+   This will:
+   - Download the Kubo Go dependencies
+   - Compile the shared library
+   - Install the Python package in development mode
+
+3. If installation fails because of Go compilation errors, you can manually build the Go library:
+   ```bash
+   rm -f src/ipfs_node/lib/libkubo* # OPTIONAL: Remove the compiled library
+   
+   ./src/libkubo/compile_linux.sh  # Linux
+   ./src/libkubo/compile_android.sh  # Android
+   pip install -e .
+   ```
+
+
+
+## Verifying Installation
+
+Run the example script to verify your installation:
+
+```bash
+python examples/basic_usage.py
+```
+

ipfs_node-0.1.6/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ipfs_node-0.1.6/MANIFEST.in

@@ -0,0 +1,8 @@
+include README.md
+include LICENSE
+include INSTALL.md
+include libkubo/go.mod
+include libkubo/kubo_wrapper.go
+recursive-include ipfs_node/lib *
+recursive-include examples *.py
+recursive-include tests *.py

ipfs_node-0.1.6/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.1
+Name: ipfs_node
+Version: 0.1.6
+Summary: Run an IPFS node inside of python using kubo as a library.
+Home-page: https://github.com/emendir/py_ipfs_node
+Author: Emendir
+Author-email: 
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cffi>=1.15.0
+
+# Kubo Python Library
+
+A Python wrapper for the Kubo (Go-IPFS) library.
+
+## Overview
+
+This library provides Python bindings for [Kubo](https://github.com/ipfs/kubo), the Go implementation of IPFS, allowing you to:
+
+- Spawn an in-process IPFS node
+- Add and retrieve files/directories from IPFS
+- Connect to the IPFS network
+- Manage IPFS repositories
+- Publish and subscribe to IPFS PubSub topics
+- Mount and connect to remote TCP services via libp2p
+
+## Project Status
+
+This library is very early in its development, and is published as a proof-of-concept that it is feasible to write a python wrapper around kubo (Go-IPFS) to run IPFS nodes from within python.
+Much of the code is LLM-generated, and code coverage is poor.
+
+The API structure of this library WILL CHANGE in the near future!
+
+So far this library has been tested on Linux x86 64-bit and Android ARM 64-bit (in Termux & in Kivy).
+Assuming that it proves to be a reliable way of working in python, this library will be developed to maturity and maintained.
+
+## Installation
+
+```bash
+pip install ipfs_node
+```
+
+## Dev Requirements
+
+- Go 1.19
+- Python 3.7+
+- IPFS Kubo dependencies
+
+## Basic Usage
+
+### Working with Files
+
+```python
+from ipfs_node import IpfsNode
+
+# Create a new node with a temporary repository
+with IpfsNode.ephemeral() as node:
+    # Add a file to IPFS
+    cid = node.files.publish("README.md")
+    print(f"Added file with CID: {cid}")
+    
+    # Retrieve a file from IPFS
+    node.files.download(cid, "download.md")
+```
+
+### Using PubSub
+
+```python
+from ipfs_node import IpfsNode
+
+with IpfsNode.ephemeral() as node:
+    # Subscribe to a topic
+    with node.pubsub.subscribe("my-topic") as subscription:
+        # Publish a message
+        node.pubsub.publish("my-topic", "Hello, IPFS world!")
+        
+        # Receive messages
+        message = subscription.next_message(timeout=2.0)
+        if message:
+            print(f"Received: {message.data.decode('utf-8')}")
+        
+        # Or use a callback
+        def on_message(msg):
+            print(f"Received via callback: {msg.data.decode('utf-8')}")
+        
+        subscription.subscribe(on_message)
+```
+
+### Using TCP Tunnels (LibP2P Stream Mounting)
+
+```python
+from ipfs_node import IpfsNode
+
+# Create an IPFS node
+with IpfsNode.ephemeral() as node:
+    
+    # Example 1: Listen for connections on a protocol and forward them to a local service
+    node.tunnels.open_listener("my-service", 8888)
+    
+    # Example 2: Forward local connections to a remote peer
+    node.tunnels.open_sender("their-service", 8889, node.peer_id)
+    
+    # List active listeners and streams
+    tunnels = node.tunnels.get_tunnels()
+    print(tunnels.listeners)
+    print(tunnels.senders)
+    
+    # Close specific connections when done
+    node.tunnels.close_listener("my-service")
+    node.tunnels.close_sender("their-service")
+```
+
+## Documentation
+
+- [Installation Instructions](INSTALL.md)
+- [PubSub Documentation](docs/pubsub.md)
+- [P2P Stream Mounting](docs/p2p.md)
+
+## Examples
+
+- [Basic Usage](examples/basic_usage.py)
+- [File Sharing](examples/file_sharing.py)
+- [PubSub Example](examples/pubsub_example.py)
+- [Chat Application](examples/chat_app.py)
+- [P2P Stream Mounting](examples/p2p_example.py)
+- [P2P Socket Communication](examples/p2p_socket_example.py)
+
+## License
+
+MIT License

ipfs_node-0.1.6/README.md

@@ -0,0 +1,119 @@
+# Kubo Python Library
+
+A Python wrapper for the Kubo (Go-IPFS) library.
+
+## Overview
+
+This library provides Python bindings for [Kubo](https://github.com/ipfs/kubo), the Go implementation of IPFS, allowing you to:
+
+- Spawn an in-process IPFS node
+- Add and retrieve files/directories from IPFS
+- Connect to the IPFS network
+- Manage IPFS repositories
+- Publish and subscribe to IPFS PubSub topics
+- Mount and connect to remote TCP services via libp2p
+
+## Project Status
+
+This library is very early in its development, and is published as a proof-of-concept that it is feasible to write a python wrapper around kubo (Go-IPFS) to run IPFS nodes from within python.
+Much of the code is LLM-generated, and code coverage is poor.
+
+The API structure of this library WILL CHANGE in the near future!
+
+So far this library has been tested on Linux x86 64-bit and Android ARM 64-bit (in Termux & in Kivy).
+Assuming that it proves to be a reliable way of working in python, this library will be developed to maturity and maintained.
+
+## Installation
+
+```bash
+pip install ipfs_node
+```
+
+## Dev Requirements
+
+- Go 1.19
+- Python 3.7+
+- IPFS Kubo dependencies
+
+## Basic Usage
+
+### Working with Files
+
+```python
+from ipfs_node import IpfsNode
+
+# Create a new node with a temporary repository
+with IpfsNode.ephemeral() as node:
+    # Add a file to IPFS
+    cid = node.files.publish("README.md")
+    print(f"Added file with CID: {cid}")
+    
+    # Retrieve a file from IPFS
+    node.files.download(cid, "download.md")
+```
+
+### Using PubSub
+
+```python
+from ipfs_node import IpfsNode
+
+with IpfsNode.ephemeral() as node:
+    # Subscribe to a topic
+    with node.pubsub.subscribe("my-topic") as subscription:
+        # Publish a message
+        node.pubsub.publish("my-topic", "Hello, IPFS world!")
+        
+        # Receive messages
+        message = subscription.next_message(timeout=2.0)
+        if message:
+            print(f"Received: {message.data.decode('utf-8')}")
+        
+        # Or use a callback
+        def on_message(msg):
+            print(f"Received via callback: {msg.data.decode('utf-8')}")
+        
+        subscription.subscribe(on_message)
+```
+
+### Using TCP Tunnels (LibP2P Stream Mounting)
+
+```python
+from ipfs_node import IpfsNode
+
+# Create an IPFS node
+with IpfsNode.ephemeral() as node:
+    
+    # Example 1: Listen for connections on a protocol and forward them to a local service
+    node.tunnels.open_listener("my-service", 8888)
+    
+    # Example 2: Forward local connections to a remote peer
+    node.tunnels.open_sender("their-service", 8889, node.peer_id)
+    
+    # List active listeners and streams
+    tunnels = node.tunnels.get_tunnels()
+    print(tunnels.listeners)
+    print(tunnels.senders)
+    
+    # Close specific connections when done
+    node.tunnels.close_listener("my-service")
+    node.tunnels.close_sender("their-service")
+```
+
+## Documentation
+
+- [Installation Instructions](INSTALL.md)
+- [PubSub Documentation](docs/pubsub.md)
+- [P2P Stream Mounting](docs/p2p.md)
+
+## Examples
+
+- [Basic Usage](examples/basic_usage.py)
+- [File Sharing](examples/file_sharing.py)
+- [PubSub Example](examples/pubsub_example.py)
+- [Chat Application](examples/chat_app.py)
+- [P2P Stream Mounting](examples/p2p_example.py)
+- [P2P Socket Communication](examples/p2p_socket_example.py)
+
+## License
+
+MIT License

ipfs_node-0.1.6/examples/basic_usage.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""
+Basic usage example for the Kubo Python library.
+
+This example demonstrates how to:
+1. Create an ephemeral IPFS node
+2. Add a file to IPFS
+3. Add a string to IPFS
+4. Retrieve data from IPFS
+"""
+
+import os
+import sys
+import tempfile
+
+# Add the parent directory to the Python path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from ipfs_node import IpfsNode
+
+def main():
+    # Create a temporary file for the example
+    with tempfile.NamedTemporaryFile(mode='w', delete=False) as temp_file:
+        temp_file.write("Hello, IPFS!")
+        temp_file_path = temp_file.name
+    
+    try:
+        # Create an ephemeral IPFS node
+        print("Creating ephemeral IPFS node...")
+        with IpfsNode.ephemeral() as node:
+            print("Created IPFS node with ID:", node.peer_id)
+            print("Created IPFS node with Multiaddress:", node.get_addrs())
+            
+            # Add a file to IPFS
+            print(f"Adding file: {temp_file_path}")
+            file_cid = node.files.publish(temp_file_path)
+            print(f"File added with CID: {file_cid}")
+            
+            # Add a string to IPFS
+            content = "Hello, IPFS from Python!"
+            
+            # Retrieve the file content
+            retrieved_content = node.files.read(file_cid)
+            print(f"Retrieved content from file: {retrieved_content}")
+            
+            
+            # Try to connect to a public IPFS node
+            try:
+                print("Connecting to public IPFS node...")
+                # ipfs.io multiaddress
+                peer_addr = "/dnsaddr/bootstrap.libp2p.io/p2p/QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN"
+                success = node.peers.connect(peer_addr)
+                print(f"Connection {'successful' if success else 'failed'}")
+            except Exception as e:
+                print(f"Error connecting to peer: {e}")
+            
+            print("IPFS node operations completed successfully!")
+    
+    finally:
+        # Clean up the temporary file
+        os.unlink(temp_file_path)
+
+if __name__ == "__main__":
+    main()