ipfs-node 0.1.12rc1__py3-none-win_amd64.whl

ipfs_node/ipfs_tunnels.py

@@ -0,0 +1,263 @@
+import ctypes
+import json
+from typing import List, Dict, Optional, Tuple, Any, Union
+from ipfs_tk_generics.tunnels import SenderTunnel, ListenerTunnel, TunnelsList, BaseTunnels
+from libkubo import libkubo, c_str, from_c_str, ffi, c_bool
+
+
+
+
+
+class NodeTunnels(BaseTunnels):
+    """
+    Provides P2P stream mounting functionality for IPFS nodes.
+
+    Stream mounting allows you to expose local TCP services to the libp2p network
+    and connect to remote TCP services exposed by other nodes.
+    """
+
+    def __init__(self, node):
+        self._node = node
+        self._repo_path = self._node._repo_path
+        BaseTunnels.__init__(self)
+
+
+    def _enable_p2p(self) -> bool:
+        """Enable p2p functionality in the IPFS configuration."""
+
+        repo_path = c_str(self._repo_path.encode('utf-8'))
+        result = libkubo.P2PEnable(repo_path)
+
+        if result <= 0:
+            print(f"Warning: Could not enable p2p functionality ({result})")
+            return False
+        return True
+
+    def open_sender(self, name: str, listen_addr: int | str, target_peer_id: str):
+        """
+        Forward local connections to a remote peer.
+
+        This creates a new listener that forwards connections to the specified
+        peer over the libp2p network.
+
+        Args:
+            name: The protocol name to use for the forwarding.
+            listen_addr: The local address to listen on (e.g. "127.0.0.1:8080").
+            target_peer_id: The peer ID to forward connections to.
+
+        Returns:
+            bool: True if the forwarding was set up successfully, False otherwise.
+        """
+        # if not target_peer_id.startswith("/p2p/"):
+        #     target_peer_id = f"/p2p/{target_peer_id}"
+        result = libkubo.P2PForward(
+            c_str(self._repo_path.encode('utf-8')),
+            c_str(name.encode('utf-8')),
+            c_str(self._port_to_addr(listen_addr).encode('utf-8')),
+            c_str(target_peer_id.encode('utf-8'))
+        )
+        if result > 0:
+            return
+        if result == -2:
+            print(f"Can't create sender {name} {listen_addr} {target_peer_id}")
+            raise Exception("IpfsNode.tunnels.open_sender: failed to open sender: bind: address already in use")
+            
+        
+        raise Exception("IpfsNode.tunnels.open_sender: failed to open sender")
+
+    def open_listener(self, name: str, target_addr: int | str):
+        """
+        Listen for libp2p connections and forward them to a local TCP service.
+
+        This exposes a local TCP service to the libp2p network.
+
+        Args:
+            name: The protocol name to use for the listener.
+            target_addr: The local address to forward connections to (e.g. "127.0.0.1:8080").
+
+        Returns:
+            bool: True if the listener was set up successfully, False otherwise.
+        """
+        result = libkubo.P2PListen(
+            c_str(self._repo_path.encode('utf-8')),
+            c_str(name.encode('utf-8')),
+            c_str(self._port_to_addr(target_addr)))
+        if result > 0:
+            return
+        if result == -2:
+            print(f"Can't open listener {name} {target_addr}")
+            raise Exception("IpfsNode.tunnels.open_sender: failed to open listener")
+            
+        
+        raise Exception("IpfsNode.tunnels.open_sender: failed to open listener")
+
+    def close_sender(self, name: str = None, port: int = None, peer_id: str = None) -> int:
+        """
+        Close a specific TCP forwarding connection, optionally filtered by protocol, port, or peer ID.
+
+        Args:
+            name: Optional protocol filter
+            port: Optional port filter
+            peer_id: Optional peer ID filter
+
+        Returns:
+            int: Number of forwarding connections closed
+        """
+        if peer_id and not peer_id.startswith("/p2p/"):
+            peer_id = f"/p2p/{peer_id}"
+        return self.close_tcp_connections(name, port, peer_id, senders=True, listeners=False)
+
+    def close_listener(self, name: str = None, port: int = None) -> int:
+        """
+        Close a specific TCP listening connection, optionally filtered by protocol name or port.
+
+        Args:
+            name: Optional protocol name filter
+            port: Optional port filter
+
+        Returns:
+            int: Number of listening connections closed
+        """
+        return self.close_tcp_connections(name, target_addr=port, listeners=True, senders=False)
+
+    def close_streams(self, name: str, port: int | None = None, target_peer_id: str = "") -> bool:
+        """
+        Close a P2P listener or stream.
+
+        Args:
+            name: The protocol name of the listener or stream to close.
+            listen_addr: For streams, the local address that the stream listens on.
+            target_peer_id: For streams, the peer ID that the stream connects to.
+
+        Returns:
+            bool: True if the listener or stream was closed successfully, False otherwise.
+        """
+        result = libkubo.P2PClose(
+            c_str(self._repo_path.encode('utf-8')),
+            c_str(name.encode('utf-8')),
+            c_str(self._port_to_addr(port)) if port else c_str(""),
+            c_str(target_peer_id.encode('utf-8'))
+        )
+        return result > 0
+
+    def close_tcp_connections(
+        self,
+        name: str = "", listen_addr: str | int | None = None, target_addr: str | int | None = None, all: bool = False,
+        listeners: bool = True, senders: bool = True
+    ) -> int:
+        """
+        Close specific TCP p2p connections, optionally filtered by protocol name, port, or peer ID.
+
+        Args:
+            name: Optional protocol name filter
+            port: Optional port filter
+            peer_id: Optional peer ID filter
+
+        Returns:
+            int: Number of connections closed
+        """
+
+        repo_path = c_str(self._repo_path.encode('utf-8'))
+
+        result = libkubo.P2PClose(
+            repo_path, c_str(name),
+            c_str(self._port_to_addr(listen_addr)),
+            c_str(self._port_to_addr(target_addr)),
+            c_bool(all), c_bool(listeners), c_bool(senders)
+        )
+        return result
+
+    def close_all_senders(self) -> int:
+        """
+        Close all TCP forwarding connections.
+
+        Returns:
+            int: Number of forwarding connections closed
+        """
+        return self.close_tcp_connections(all=True, listeners=False, senders=True)
+
+    def close_all_listeners(self) -> int:
+        """
+        Close all TCP listening connections.
+
+        Returns:
+            int: Number of listening connections closed
+        """
+        return self.close_tcp_connections(all=True, listeners=True, senders=False)
+    def close_all(self) -> int:
+        """
+        Close all TCP connections.
+
+        Returns:
+            int: Number of listening connections closed
+        """
+        return self.close_tcp_connections(all=True, listeners=True, senders=True)
+
+    def get_tunnels(self) ->TunnelsList:
+        """
+        List all active P2P tunnels.
+        """
+        result_ptr = libkubo.P2PListListeners(
+            c_str(self._repo_path.encode('utf-8'))
+        )
+
+        if not result_ptr:
+            return [], []
+
+        # Convert the C string to a Python string and release memory
+        result_str = from_c_str(result_ptr)
+        # libkubo.free(result_ptr)
+
+        if not result_str:
+            return [], []
+
+        # Parse the JSON
+        try:
+            result = json.loads(result_str)
+        except json.JSONDecodeError:
+            return [], []
+
+        # Add local listeners
+        listeners = []
+        for item in result.get('Listens', []):
+            listener = ListenerTunnel(
+                name=item.get('Protocol', ''),
+                # listen_address=item.get('ListenAddress', ''),
+                target_address=item.get('TargetAddress', '')
+            )
+            listeners.append(listener)
+
+        # Add remote listeners
+        forwarders = []
+        for item in result.get('Forwards', []):
+            listener = SenderTunnel(
+                name=item.get('Protocol', ''),
+                listen_address=item.get('ListenAddress', ''),
+                target_address=item.get('TargetAddress', '')
+            )
+            forwarders.append(listener)
+
+        # # Extract active streams
+        # streams = []
+        # for item in result.get('Streams', []):
+        #     stream = P2PStream(
+        #         name=item.get('Protocol', ''),
+        #         origin_address=item.get('LocalAddr', ''),
+        #         target_address=item.get('RemoteAddr', '')
+        #     )
+        #     streams.append(stream)
+
+        return TunnelsList(senders=forwarders, listeners=listeners)
+
+
+    def _port_to_addr(self, addr: int | str | None) -> str:
+        if not addr:
+            return ""
+        if isinstance(addr, int):
+            return f"/ip4/{self._node._ipfs_host_ip()}/tcp/{addr}"
+        else:
+            return addr
+    def terminate(self):
+        pass
+    def __del__(self):
+        self.terminate()

ipfs_node/utils/__init__.py

@@ -0,0 +1,3 @@
+"""Utility functions for the Kubo Python library."""
+
+__all__ = ["cid_utils", "peer_utils"]

ipfs_node/utils/cid_utils.py

@@ -0,0 +1,55 @@
+"""
+Utilities for working with IPFS Content Identifiers (CIDs).
+"""
+
+import re
+
+# Regular expression for matching CID v0 (Qm...)
+CID_V0_REGEX = re.compile(r"^Qm[1-9A-Za-z]{44}$")
+
+# Regular expression for matching CID v1
+CID_V1_REGEX = re.compile(r"^ba[a-zA-Z2-7]{57}$")
+
+def is_valid_cid(cid: str) -> bool:
+    """
+    Check if a string is a valid IPFS CID.
+    
+    Args:
+        cid: The Content Identifier to check.
+        
+    Returns:
+        bool: True if the CID is valid, False otherwise.
+    """
+    if not cid or not isinstance(cid, str):
+        return False
+    
+    # Check for CID v0 (starts with "Qm" and is 46 characters long)
+    if CID_V0_REGEX.match(cid):
+        return True
+    
+    # Check for CID v1 (starts with "ba" and is 59 characters long)
+    if CID_V1_REGEX.match(cid):
+        return True
+    
+    # Could add more sophisticated validation here
+    return False
+
+def format_cid_link(cid: str, gateway: str = "https://ipfs.io/ipfs/") -> str:
+    """
+    Format a CID as a link through an IPFS gateway.
+    
+    Args:
+        cid: The Content Identifier.
+        gateway: The IPFS gateway URL. Defaults to the public ipfs.io gateway.
+        
+    Returns:
+        str: The gateway URL for the CID.
+    """
+    if not is_valid_cid(cid):
+        raise ValueError(f"Invalid CID: {cid}")
+    
+    # Ensure the gateway URL ends with a slash
+    if not gateway.endswith("/"):
+        gateway += "/"
+    
+    return f"{gateway}{cid}"

ipfs_node/utils/peer_utils.py

@@ -0,0 +1,62 @@
+"""
+Utilities for working with IPFS peer addresses and connections.
+"""
+
+import re
+
+# Regular expression for matching multiaddress format
+MULTIADDR_REGEX = re.compile(r"^(/[^/]+)+$")
+
+# Regular expression for matching peer ID format (with multiaddress)
+PEER_ID_REGEX = re.compile(r"/p2p/([a-zA-Z0-9]+)$")
+
+def is_valid_multiaddr(addr: str) -> bool:
+    """
+    Check if a string is a valid IPFS multiaddress.
+    
+    Args:
+        addr: The multiaddress to check.
+        
+    Returns:
+        bool: True if the multiaddress is valid, False otherwise.
+    """
+    if not addr or not isinstance(addr, str):
+        return False
+    
+    # Basic check for multiaddress format
+    return bool(MULTIADDR_REGEX.match(addr))
+
+def extract_peer_id(multiaddr: str) -> str:
+    """
+    Extract the peer ID from a multiaddress.
+    
+    Args:
+        multiaddr: The multiaddress containing a peer ID.
+        
+    Returns:
+        str: The peer ID, or an empty string if not found.
+    """
+    if not is_valid_multiaddr(multiaddr):
+        return ""
+    
+    # Find the peer ID component
+    match = PEER_ID_REGEX.search(multiaddr)
+    if match:
+        return match.group(1)
+    
+    return ""
+
+def get_bootstrap_peers() -> list:
+    """
+    Get a list of default IPFS bootstrap peers.
+    
+    Returns:
+        list: A list of multiaddresses for the default bootstrap peers.
+    """
+    return [
+        "/dnsaddr/bootstrap.libp2p.io/p2p/QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN",
+        "/dnsaddr/bootstrap.libp2p.io/p2p/QmQCU2EcMqAqQPR2i9bChDtGNJchTbq5TbXJJ16u19uLTa",
+        "/dnsaddr/bootstrap.libp2p.io/p2p/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb",
+        "/dnsaddr/bootstrap.libp2p.io/p2p/QmcZf59bWwK5XFi76CZX8cbJ4BhTzzA3gU1ZjYZcYW3dwt",
+        "/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ",
+    ]

ipfs_node-0.1.12rc1.dist-info/METADATA

@@ -0,0 +1,194 @@
+Metadata-Version: 2.4
+Name: ipfs_node
+Version: 0.1.12rc1
+Summary: Run an IPFS node inside of python using kubo as a library.
+Author: Emendir
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/emendir/py_ipfs_node
+Project-URL: Repository, https://github.com/emendir/py_ipfs_node
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: LICENSE-CC0
+Requires-Dist: cffi>=1.15.0
+Requires-Dist: ipfs_tk
+Dynamic: license-file
+
+# 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 **EXPERIMENTAL**
+
+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 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.
+
+## Compatibility
+
+- linux x86-64 (tested on Ubuntu)
+- linux arm-64 (tested on Ubuntu on a raspberry pi 5)
+
+## Roadmap
+
+[py_ipfs_node](https://github.com/emendir/py_ipfs_node), will be incorporated into [ipfs_toolkit](https://github.com/emendir/IPFS-Toolkit-Python) [when py_ipfs_node's API has stabilised](https://github.com/emendir/py_ipfs_node/issues/1).
+
+[ipfs_toolkit](https://github.com/emendir/IPFS-Toolkit-Python) will become a multimodal IPFS library with a unified API for alternative modes of using IPFS:
+- running an embedded IPFS node
+- interacting with a separate IPFS node via its HTTP RPC
+
+You can check out a prototype version of the combination of these two libraries under the `kubo_python` branch of the IPFS-Toolkit repo:
+https://github.com/emendir/IPFS-Toolkit-Python/tree/kubo_python
+
+## 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)
+
+## Contributing
+
+### Get Involved
+
+- GitHub Discussions: if you want to share ideas
+- GitHub Issues: if you find bugs, other issues, or would like to submit feature requests
+- GitHub Merge Requests: if you think you know what you're doing, you're very welcome!
+
+### Donations
+
+To support me in my work on this and other projects, you can make donations with the following currencies:
+
+- **Bitcoin:** `BC1Q45QEE6YTNGRC5TSZ42ZL3MWV8798ZEF70H2DG0`
+- **Ethereum:** `0xA32C3bBC2106C986317f202B3aa8eBc3063323D4`
+- [**Fiat** (via Credit or Debit Card, Apple Pay, Google Pay, Revolut Pay)](https://checkout.revolut.com/pay/4e4d24de-26cf-4e7d-9e84-ede89ec67f32)
+
+Donations help me:
+- dedicate more time to developing and maintaining open-source projects
+- cover costs for IT infrastructure
+- finance projects requiring additional hardware & compute
+
+## About the Developer
+
+This project is developed by a human one-man team, publishing under the name _Emendir_.  
+I build open technologies trying to improve our world;
+learning, working and sharing under the principle:
+
+> _Freely I have received, freely I give._
+
+Feel welcome to join in with code contributions, discussions, ideas and more!
+
+## Open-Source in the Public Domain
+
+I dedicate this project to the public domain.
+It is open source and free to use, share, modify, and build upon without restrictions or conditions.
+
+I make no patent or trademark claims over this project.  
+
+Formally, you may use this project under either the: 
+- [MIT No Attribution (MIT-0)](https://choosealicense.com/licenses/mit-0/) or
+- [Creative Commons Zero (CC0)](https://choosealicense.com/licenses/cc0-1.0/)
+licence at your choice.  
+
+

ipfs_node-0.1.12rc1.dist-info/RECORD

@@ -0,0 +1,20 @@
+ipfs_node/__init__.py,sha256=hYyXSpnmMQLeaX2ssUVZl5ghbiVp-W2Ri_Dbdu9e1Jo,197
+ipfs_node/ipfs_files.py,sha256=uM2u74VBRWwGGlSJNq_3A4_bYb7RdfIHXP5YVDDL43I,7985
+ipfs_node/ipfs_node.py,sha256=E88bXvUjycwlPXAAa2pvRpQCANHGSFBWx9GQTIxRqsg,7287
+ipfs_node/ipfs_peers.py,sha256=yp56fI9OpyzGg8JHt9o89lT2nWI4YpzMrRvUfETlPZc,2216
+ipfs_node/ipfs_pubsub.py,sha256=g3mSV45BonYXZASgtWVGsi3VVSkZmOkBRldSRys6mlI,14439
+ipfs_node/ipfs_tunnels.py,sha256=__681B9UzHXi7r1CP32uVEeMYlV8-O4JPc6yUKZwQ4M,9018
+ipfs_node/utils/__init__.py,sha256=gskzZJEh_l3vsWbpgQII732lYNfqA835YXvMlxKiDkA,91
+ipfs_node/utils/cid_utils.py,sha256=K5g8VIueJDS0zsbkJV8ZccFa6rdOA9ShwsYJlyX-REU,1457
+ipfs_node/utils/peer_utils.py,sha256=ynZKbg2L26r0DfRUNYcVQQP_eguK6xENTFUhxHpHGmE,1848
+ipfs_node-0.1.12rc1.dist-info/licenses/LICENSE,sha256=i720OgyQLs68DSskm7ZLzaGKMnfskBIIHOuPWfwT2q4,907
+ipfs_node-0.1.12rc1.dist-info/licenses/LICENSE-CC0,sha256=kXBMw0w0VVXQAbLjqMKmis4OngrPaK4HY9ScH6MdtxM,7038
+libkubo/__init__.py,sha256=vg0PGjCRNyMadI3bRYtTjfxoaA6XMO7klgZuR2vQ2nU,67
+libkubo/libkubo_linux_x86_64.h,sha256=OVfQ74CEPn8M6nDWkDQluwDgSeRJOV0wOyBAvBMGJqM,5743
+libkubo/libkubo_loader.py,sha256=mkZkjZzqYw95jawRnc3DYyMRLZxBMOPzNrxfEP62aeg,2667
+libkubo/libkubo_windows_x86_64.dll,sha256=D50h0KoLL5A03WYncWIBMithzW94GFQQAGoFmaO9EDw,28926981
+libkubo/libkubo_windows_x86_64.h,sha256=sN7g_DZZHQavzjRqsIxepZaCrRJbLhGXOT9DQMZ18b0,6491
+ipfs_node-0.1.12rc1.dist-info/METADATA,sha256=cEPbGklEOvUpGRSvcEZX6_3xEhXP4B9kHeDqgOfSY4c,6350
+ipfs_node-0.1.12rc1.dist-info/WHEEL,sha256=ZjXRCNaQ9YSypEK2TE0LRB0sy2OVXSszb4Sx1XjM99k,97
+ipfs_node-0.1.12rc1.dist-info/top_level.txt,sha256=JqYMx6doRQgowycGRhKqc0zfikahqizuG9128CZcF3Y,18
+ipfs_node-0.1.12rc1.dist-info/RECORD,,

ipfs_node-0.1.12rc1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-win_amd64
+

ipfs_node-0.1.12rc1.dist-info/licenses/LICENSE

@@ -0,0 +1,18 @@
+MIT No Attribution
+
+Copyright [year] [fullname]
+
+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.
+
+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.