simpledht 0.1.2__tar.gz → 0.1.4__tar.gz

simpledht-0.1.4/PKG-INFO

@@ -0,0 +1,239 @@
+Metadata-Version: 2.4
+Name: simpledht
+Version: 0.1.4
+Summary: A simple distributed hash table implementation
+Home-page: https://github.com/dhruvldrp9/simpledht
+Author: Dhruvkumar Patel
+Author-email: dhruv.ldrp9@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.1
+Requires-Dist: click>=8.0.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Distributed Hash Table (DHT) Implementation
+
+A Python-based Distributed Hash Table implementation that allows nodes to connect across different networks using IP addresses. This implementation supports key-value storage and retrieval across multiple nodes.
+
+## Features
+
+- Cross-network node communication
+- Key-value storage and retrieval
+- Automatic node discovery
+- Data replication between nodes
+- Data synchronization when joining the network
+- Reliable bootstrapping with retry mechanism
+- Simple CLI interface
+- Public IP detection
+- Local network support
+- Python library interface for programmatic use
+
+## Installation
+
+### From PyPI (Recommended)
+
+```bash
+pip install simpledht
+```
+
+### From Source
+
+1. Clone the repository:
+```bash
+git clone https://github.com/dhruvldrp9/SimpleDHT
+cd SimpleDHT
+```
+
+2. Create and activate a virtual environment:
+```bash
+python -m venv env
+source env/bin/activate  # On Windows: env\Scripts\activate
+```
+
+3. Install the package in development mode:
+```bash
+pip install -e .
+```
+
+## Usage
+
+### As a Python Library
+
+The package can be used programmatically in your Python code:
+
+```python
+from simpledht import DHTNode
+
+# Create and start a node
+node = DHTNode(host='0.0.0.0', port=5000)
+node.start()
+
+# Store data
+node.put('mykey', 'myvalue')
+
+# Retrieve data
+value = node.get('mykey')
+
+# Connect to another node
+node.bootstrap('other_node_ip:5000')
+
+# Stop the node when done
+node.stop()
+```
+
+See the `examples/` directory for more detailed usage examples:
+- `basic_usage.py`: Simple example of creating and connecting nodes
+- `distributed_storage.py`: Advanced example showing distributed storage with multiple nodes
+
+### Command Line Interface
+
+#### Starting a Node
+
+To start a new DHT node:
+
+```bash
+python -m simpledht.cli start --host 0.0.0.0 --port 5000
+```
+
+To start a node and connect to existing nodes:
+
+```bash
+python -m simpledht.cli start --host 0.0.0.0 --port 5001 --bootstrap "PUBLIC_IP:5000"
+```
+
+#### Storing Data
+
+To store a key-value pair:
+
+```bash
+python -m simpledht.cli put --host PUBLIC_IP --port 5000 mykey "my value"
+```
+
+#### Retrieving Data
+
+```bash
+python -m simpledht.cli get --host PUBLIC_IP --port 5000 mykey
+```
+
+### Cross-Network Example
+
+1. Start Node 1 (First network):
+```bash
+python -m simpledht.cli start --host 0.0.0.0 --port 5000
+```
+
+2. Start Node 2 (Second network):
+```bash
+python -m simpledht.cli start --host 0.0.0.0 --port 5000 --bootstrap "NODE1_PUBLIC_IP:5000"
+```
+
+3. Store and retrieve data:
+```bash
+# Store on Node 1
+python -m simpledht.cli put --host NODE1_PUBLIC_IP --port 5000 test_key "test_value"
+
+# Retrieve from Node 2
+python -m simpledht.cli get --host NODE2_PUBLIC_IP --port 5000 test_key
+```
+
+## Network Configuration
+
+### Firewall Setup
+
+Ensure the UDP port (default: 5000) is open in your firewall:
+
+```bash
+# For UFW (Ubuntu)
+sudo ufw allow 5000/udp
+
+# For iptables
+sudo iptables -A INPUT -p udp --dport 5000 -j ACCEPT
+```
+
+### Port Forwarding
+
+If your node is behind a NAT router:
+1. Access your router's admin interface
+2. Set up port forwarding for UDP port 5000
+3. Forward to your node's local IP address
+
+## New Features in Version 0.1.3
+
+- **Improved Bootstrap Mechanism**: Added retry logic for more reliable connections across networks
+- **Data Synchronization**: Nodes automatically sync data when joining the network
+- **Enhanced Error Handling**: Better handling of network timeouts and connection issues
+- **Full Data Replication**: All nodes maintain a complete copy of the data for redundancy
+- **Alternative Command Method**: Added support for running via `python -m simpledht.cli`
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Connection Timeout**
+   - Check if the target node is running
+   - Verify firewall settings
+   - Ensure port forwarding is configured correctly
+   - Try increasing the timeout: `--timeout 10`
+
+2. **Address Already in Use**
+   - The port is already being used by another process
+   - Try a different port number
+   - Check running processes: `netstat -tuln | grep 5000`
+
+3. **No Response from Node**
+   - Verify the node is running
+   - Check network connectivity: `ping NODE_IP`
+   - Test port connectivity: `nc -vzu NODE_IP 5000`
+
+### Error Messages
+
+- `Failed to bootstrap with IP:PORT`: Invalid bootstrap node format
+- `No response received`: Node is not responding
+- `Address already in use`: Port conflict
+- `Failed to get public IP`: Network connectivity issue
+- `Connection attempt X/3 timed out, retrying...`: Network latency or connectivity issues
+- `simpledht: command not found`: The command-line tool is not in your PATH. Use the Python module directly: `python -m simpledht.cli`
+
+## Architecture
+
+The DHT implementation uses:
+- UDP sockets for communication
+- SHA-256 for node ID generation
+- Automatic public IP detection
+- Data replication between nodes
+- Bootstrap nodes for network discovery
+- Retry mechanism for reliable connections
+
+## Security Considerations
+
+- This is a basic implementation and should not be used in production without additional security measures
+- Consider adding:
+  - Encryption for data in transit
+  - Authentication for node joining
+  - Rate limiting to prevent abuse
+  - Input validation
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Commit your changes
+4. Push to the branch
+5. Create a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

{simpledht-0.1.2 → simpledht-0.1.4}/README.md

@@ -27,7 +27,7 @@ pip install simpledht
 
 1. Clone the repository:
 ```bash
-git clone <repository-url>
+git clone https://github.com/dhruvldrp9/SimpleDHT
 cd SimpleDHT
 ```
 
@@ -77,48 +77,50 @@ See the `examples/` directory for more detailed usage examples:
 #### Starting a Node
 
 To start a new DHT node:
+
 ```bash
-simpledht start --host 0.0.0.0 --port 5000
+python -m simpledht.cli start --host 0.0.0.0 --port 5000
 ```
 
 To start a node and connect to existing nodes:
+
 ```bash
-simpledht start --host 0.0.0.0 --port 5001 --bootstrap "PUBLIC_IP:5000"
+python -m simpledht.cli start --host 0.0.0.0 --port 5001 --bootstrap "PUBLIC_IP:5000"
 ```
 
 #### Storing Data
 
 To store a key-value pair:
+
 ```bash
-simpledht put --host PUBLIC_IP --port 5000 mykey "my value"
+python -m simpledht.cli put --host PUBLIC_IP --port 5000 mykey "my value"
 ```
 
 #### Retrieving Data
 
-To retrieve a value:
 ```bash
-simpledht get --host PUBLIC_IP --port 5000 mykey
+python -m simpledht.cli get --host PUBLIC_IP --port 5000 mykey
 ```
 
 ### Cross-Network Example
 
 1. Start Node 1 (First network):
 ```bash
-simpledht start --host 0.0.0.0 --port 5000
+python -m simpledht.cli start --host 0.0.0.0 --port 5000
 ```
 
 2. Start Node 2 (Second network):
 ```bash
-simpledht start --host 0.0.0.0 --port 5000 --bootstrap "NODE1_PUBLIC_IP:5000"
+python -m simpledht.cli start --host 0.0.0.0 --port 5000 --bootstrap "NODE1_PUBLIC_IP:5000"
 ```
 
 3. Store and retrieve data:
 ```bash
 # Store on Node 1
-simpledht put --host NODE1_PUBLIC_IP --port 5000 test_key "test_value"
+python -m simpledht.cli put --host NODE1_PUBLIC_IP --port 5000 test_key "test_value"
 
 # Retrieve from Node 2
-simpledht get --host NODE2_PUBLIC_IP --port 5000 test_key
+python -m simpledht.cli get --host NODE2_PUBLIC_IP --port 5000 test_key
 ```
 
 ## Network Configuration
@@ -142,12 +144,13 @@ If your node is behind a NAT router:
 2. Set up port forwarding for UDP port 5000
 3. Forward to your node's local IP address
 
-## New Features in Version 0.1.2
+## New Features in Version 0.1.3
 
 - **Improved Bootstrap Mechanism**: Added retry logic for more reliable connections across networks
 - **Data Synchronization**: Nodes automatically sync data when joining the network
 - **Enhanced Error Handling**: Better handling of network timeouts and connection issues
 - **Full Data Replication**: All nodes maintain a complete copy of the data for redundancy
+- **Alternative Command Method**: Added support for running via `python -m simpledht.cli`
 
 ## Troubleshooting
 
@@ -176,6 +179,7 @@ If your node is behind a NAT router:
 - `Address already in use`: Port conflict
 - `Failed to get public IP`: Network connectivity issue
 - `Connection attempt X/3 timed out, retrying...`: Network latency or connectivity issues
+- `simpledht: command not found`: The command-line tool is not in your PATH. Use the Python module directly: `python -m simpledht.cli`
 
 ## Architecture
 

{simpledht-0.1.2 → simpledht-0.1.4}/setup.py

@@ -5,11 +5,11 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="simpledht",
-    version="0.1.2",
+    version="0.1.4",
     author="Dhruvkumar Patel",
     author_email="dhruv.ldrp9@gmail.com",
     description="A simple distributed hash table implementation",
-    long_description="A simple distributed hash table implementation",
+    long_description=long_description,
     long_description_content_type="text/markdown",
     url="https://github.com/dhruvldrp9/simpledht",
     packages=find_packages(),

{simpledht-0.1.2 → simpledht-0.1.4}/simpledht/__init__.py

@@ -20,7 +20,7 @@ Example usage:
     node.bootstrap('other_node_ip:5000')
 """
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"
 
 from .dht_node import DHTNode
 from .cli import main as cli_main

simpledht-0.1.4/simpledht.egg-info/PKG-INFO

@@ -0,0 +1,239 @@
+Metadata-Version: 2.4
+Name: simpledht
+Version: 0.1.4
+Summary: A simple distributed hash table implementation
+Home-page: https://github.com/dhruvldrp9/simpledht
+Author: Dhruvkumar Patel
+Author-email: dhruv.ldrp9@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.1
+Requires-Dist: click>=8.0.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Distributed Hash Table (DHT) Implementation
+
+A Python-based Distributed Hash Table implementation that allows nodes to connect across different networks using IP addresses. This implementation supports key-value storage and retrieval across multiple nodes.
+
+## Features
+
+- Cross-network node communication
+- Key-value storage and retrieval
+- Automatic node discovery
+- Data replication between nodes
+- Data synchronization when joining the network
+- Reliable bootstrapping with retry mechanism
+- Simple CLI interface
+- Public IP detection
+- Local network support
+- Python library interface for programmatic use
+
+## Installation
+
+### From PyPI (Recommended)
+
+```bash
+pip install simpledht
+```
+
+### From Source
+
+1. Clone the repository:
+```bash
+git clone https://github.com/dhruvldrp9/SimpleDHT
+cd SimpleDHT
+```
+
+2. Create and activate a virtual environment:
+```bash
+python -m venv env
+source env/bin/activate  # On Windows: env\Scripts\activate
+```
+
+3. Install the package in development mode:
+```bash
+pip install -e .
+```
+
+## Usage
+
+### As a Python Library
+
+The package can be used programmatically in your Python code:
+
+```python
+from simpledht import DHTNode
+
+# Create and start a node
+node = DHTNode(host='0.0.0.0', port=5000)
+node.start()
+
+# Store data
+node.put('mykey', 'myvalue')
+
+# Retrieve data
+value = node.get('mykey')
+
+# Connect to another node
+node.bootstrap('other_node_ip:5000')
+
+# Stop the node when done
+node.stop()
+```
+
+See the `examples/` directory for more detailed usage examples:
+- `basic_usage.py`: Simple example of creating and connecting nodes
+- `distributed_storage.py`: Advanced example showing distributed storage with multiple nodes
+
+### Command Line Interface
+
+#### Starting a Node
+
+To start a new DHT node:
+
+```bash
+python -m simpledht.cli start --host 0.0.0.0 --port 5000
+```
+
+To start a node and connect to existing nodes:
+
+```bash
+python -m simpledht.cli start --host 0.0.0.0 --port 5001 --bootstrap "PUBLIC_IP:5000"
+```
+
+#### Storing Data
+
+To store a key-value pair:
+
+```bash
+python -m simpledht.cli put --host PUBLIC_IP --port 5000 mykey "my value"
+```
+
+#### Retrieving Data
+
+```bash
+python -m simpledht.cli get --host PUBLIC_IP --port 5000 mykey
+```
+
+### Cross-Network Example
+
+1. Start Node 1 (First network):
+```bash
+python -m simpledht.cli start --host 0.0.0.0 --port 5000
+```
+
+2. Start Node 2 (Second network):
+```bash
+python -m simpledht.cli start --host 0.0.0.0 --port 5000 --bootstrap "NODE1_PUBLIC_IP:5000"
+```
+
+3. Store and retrieve data:
+```bash
+# Store on Node 1
+python -m simpledht.cli put --host NODE1_PUBLIC_IP --port 5000 test_key "test_value"
+
+# Retrieve from Node 2
+python -m simpledht.cli get --host NODE2_PUBLIC_IP --port 5000 test_key
+```
+
+## Network Configuration
+
+### Firewall Setup
+
+Ensure the UDP port (default: 5000) is open in your firewall:
+
+```bash
+# For UFW (Ubuntu)
+sudo ufw allow 5000/udp
+
+# For iptables
+sudo iptables -A INPUT -p udp --dport 5000 -j ACCEPT
+```
+
+### Port Forwarding
+
+If your node is behind a NAT router:
+1. Access your router's admin interface
+2. Set up port forwarding for UDP port 5000
+3. Forward to your node's local IP address
+
+## New Features in Version 0.1.3
+
+- **Improved Bootstrap Mechanism**: Added retry logic for more reliable connections across networks
+- **Data Synchronization**: Nodes automatically sync data when joining the network
+- **Enhanced Error Handling**: Better handling of network timeouts and connection issues
+- **Full Data Replication**: All nodes maintain a complete copy of the data for redundancy
+- **Alternative Command Method**: Added support for running via `python -m simpledht.cli`
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Connection Timeout**
+   - Check if the target node is running
+   - Verify firewall settings
+   - Ensure port forwarding is configured correctly
+   - Try increasing the timeout: `--timeout 10`
+
+2. **Address Already in Use**
+   - The port is already being used by another process
+   - Try a different port number
+   - Check running processes: `netstat -tuln | grep 5000`
+
+3. **No Response from Node**
+   - Verify the node is running
+   - Check network connectivity: `ping NODE_IP`
+   - Test port connectivity: `nc -vzu NODE_IP 5000`
+
+### Error Messages
+
+- `Failed to bootstrap with IP:PORT`: Invalid bootstrap node format
+- `No response received`: Node is not responding
+- `Address already in use`: Port conflict
+- `Failed to get public IP`: Network connectivity issue
+- `Connection attempt X/3 timed out, retrying...`: Network latency or connectivity issues
+- `simpledht: command not found`: The command-line tool is not in your PATH. Use the Python module directly: `python -m simpledht.cli`
+
+## Architecture
+
+The DHT implementation uses:
+- UDP sockets for communication
+- SHA-256 for node ID generation
+- Automatic public IP detection
+- Data replication between nodes
+- Bootstrap nodes for network discovery
+- Retry mechanism for reliable connections
+
+## Security Considerations
+
+- This is a basic implementation and should not be used in production without additional security measures
+- Consider adding:
+  - Encryption for data in transit
+  - Authentication for node joining
+  - Rate limiting to prevent abuse
+  - Input validation
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Commit your changes
+4. Push to the branch
+5. Create a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

simpledht-0.1.2/PKG-INFO

@@ -1,27 +0,0 @@
-Metadata-Version: 2.4
-Name: simpledht
-Version: 0.1.2
-Summary: A simple distributed hash table implementation
-Home-page: https://github.com/dhruvldrp9/simpledht
-Author: Dhruvkumar Patel
-Author-email: dhruv.ldrp9@gmail.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: requests>=2.25.1
-Requires-Dist: click>=8.0.1
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-A simple distributed hash table implementation

simpledht-0.1.2/simpledht.egg-info/PKG-INFO

@@ -1,27 +0,0 @@
-Metadata-Version: 2.4
-Name: simpledht
-Version: 0.1.2
-Summary: A simple distributed hash table implementation
-Home-page: https://github.com/dhruvldrp9/simpledht
-Author: Dhruvkumar Patel
-Author-email: dhruv.ldrp9@gmail.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: requests>=2.25.1
-Requires-Dist: click>=8.0.1
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-A simple distributed hash table implementation