lattica 1.0.1__cp311-abi3-manylinux_2_34_x86_64.whl

lattica/__init__.py

@@ -0,0 +1,16 @@
+from .client import Lattica
+from .connection_handler import (
+    ConnectionHandler
+)
+
+from lattica_python_core import rpc_method, rpc_stream, rpc_stream_iter
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Lattica",
+    "rpc_method",
+    "rpc_stream",
+    "rpc_stream_iter",
+    "ConnectionHandler",
+]

lattica/client.py

@@ -0,0 +1,249 @@
+from typing import Optional, Any, List, Union
+import pickle
+import time
+from dataclasses import dataclass
+from lattica_python_core import LatticaSDK, RpcClient, PeerInfo
+
+@dataclass
+class ValueWithExpiration:
+    value: Any
+    expiration_time: float
+
+    def __iter__(self):
+        return iter((self.value, self.expiration_time))
+
+    def __getitem__(self, item):
+        if item == 0:
+            return self.value
+        elif item == 1:
+            return self.expiration_time
+        else:
+            return getattr(self, item)
+
+    def __eq__(self, item):
+        if isinstance(item, ValueWithExpiration):
+            return self.value == item.value and self.expiration_time == item.expiration_time
+        elif isinstance(item, tuple):
+            return tuple.__eq__((self.value, self.expiration_time), item)
+        else:
+            return False
+
+def get_dht_time():
+    return time.time()
+
+
+class Lattica:
+    def __init__(self):
+        self.config = {}
+        self._lattica_instance = None
+        self._initialized = False
+
+    @classmethod
+    def builder(cls) -> 'Lattica':
+        return cls()
+
+    def with_bootstraps(self, bootstrap_nodes: List[str]) -> 'Lattica':
+        self.config['bootstrap_nodes'] = bootstrap_nodes
+        return self
+    def with_listen_addrs(self, listen_addrs: List[str]) -> 'Lattica':
+        self.config['listen_addrs'] = listen_addrs
+        return self
+
+    def with_idle_timeout(self, timeout_seconds: int) -> 'Lattica':
+        self.config['idle_timeout'] = timeout_seconds
+        return self
+
+    def with_mdns(self, with_mdns: bool) -> 'Lattica':
+        self.config['with_mdns'] = with_mdns
+        return self
+
+    def with_upnp(self, with_upnp: bool) -> 'Lattica':
+        self.config['with_upnp'] = with_upnp
+        return self
+
+    def with_relay_servers(self, relay_servers: List[str]) -> 'Lattica':
+        self.config['relay_servers'] = relay_servers
+        return self
+
+    def with_autonat(self, with_autonat: bool) -> 'Lattica':
+        self.config['with_autonat'] = with_autonat
+        return self
+
+    def with_dcutr(self, with_dcutr: bool) -> 'Lattica':
+        self.config['with_dcutr'] = with_dcutr
+        return self
+
+    def with_external_addrs(self, external_addrs: List[str]) -> 'Lattica':
+        self.config['external_addrs'] = external_addrs
+        return self
+
+    def with_storage_path(self, storage_path: str) -> 'Lattica':
+        self.config['storage_path'] = storage_path
+        return self
+
+    def with_dht_db_path(self, db_path: str) -> 'Lattica':
+        self.config['dht_db_path'] = db_path
+        return self
+
+    def with_key_path(self, key_path: str) -> 'Lattica':
+        self.config['key_path'] = key_path
+        return self
+
+    def with_protocol(self, protocol: str) -> 'Lattica':
+        self.config['protocol'] = protocol
+        return self
+
+    def build(self) -> 'Lattica':
+        self._initialize_client()
+        return self
+
+    def _initialize_client(self):
+        if self._initialized:
+            return
+
+        try:
+            self._initialize_lattica()
+            self._initialized = True
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize Lattica: {e}")
+
+    def _initialize_lattica(self):
+        try:
+            if self.config:
+                self._lattica_instance = LatticaSDK(self.config)
+            else:
+                self._lattica_instance = LatticaSDK()
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize the lattica1 instance: {e}")
+
+    def _ensure_initialized(self):
+        if not self._initialized:
+            self._initialize_client()
+
+    def store(self, key: str, value: Any, expiration_time: Optional[float] = None, subkey: Optional[str] = None) -> Union[bool, None]:
+        try:
+            # default expiration 10min
+            if expiration_time is None:
+                expiration_time = get_dht_time() + 600
+
+            serialized_value = pickle.dumps(value)
+            self._lattica_instance.store_with_subkey(key, serialized_value, expiration_time, subkey)
+            return True
+        except Exception as e:
+            print(f"Failed to store value: {e}")
+            return False
+
+    def get(self, key: str) -> Union[ValueWithExpiration, None]:
+        try:
+            result = self._lattica_instance.get_with_subkey(key)
+            if result is None:
+                return None
+
+            if isinstance(result, dict):
+                parsed_value = {}
+
+                for subkey, (serialized_value, expiration) in result.items():
+                    value = pickle.loads(serialized_value)
+                    parsed_value[subkey] = ValueWithExpiration(value=value, expiration_time=expiration)
+
+                first_expiration = next(iter(result.values()))[1]
+                return ValueWithExpiration(value=parsed_value, expiration_time=first_expiration)
+            else:
+                serialized_value, expiration = result
+                value = pickle.loads(serialized_value)
+                return ValueWithExpiration(value=value, expiration_time=expiration)
+                
+        except Exception as e:
+            print(f"Error getting value: {e}")
+            return None
+
+    def get_visible_maddrs(self) -> List[str]:
+        try:
+            return self._lattica_instance.get_visible_maddrs()
+        except Exception as e:
+            raise RuntimeError(f"Failed to get visible addresses: {e}")
+
+    def get_client(self, peer_id: str) -> RpcClient:
+        try:
+            return self._lattica_instance.get_client(peer_id)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get client: {e}")
+
+    def register_service(self, service_instance) -> None:
+        try:
+            self._lattica_instance.register_service(service_instance)
+        except Exception as e:
+            raise RuntimeError(f"Failed to register service: {e}")
+
+    def peer_id(self) -> str:
+        try:
+            return self._lattica_instance.peer_id()
+        except Exception as e:
+            raise RuntimeError(f"Failed to get peer ID: {e}")
+
+    def get_peer_info(self, peer_id: str) -> Optional[PeerInfo]:
+        try:
+            return self._lattica_instance.get_peer_info(peer_id)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get peer info: {e}")
+
+    def get_all_peers(self) -> List[str]:
+        try:
+            return self._lattica_instance.get_all_peers()
+        except Exception as e:
+            raise RuntimeError(f"Failed to get all peers: {e}")
+
+    def get_peer_addresses(self, peer_id: str) -> List[str]:
+        try:
+            return self._lattica_instance.get_peer_addresses(peer_id)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get peer addresses: {e}")
+
+    def get_peer_rtt(self, peer_id: str) -> float:
+        try:
+            return self._lattica_instance.get_peer_rtt(peer_id)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get peer RTT: {e}")
+
+    def put_block(self, data: bytes) -> str:
+        try:
+            return self._lattica_instance.put_block(data)
+        except Exception as e:
+            raise RuntimeError(f"Failed to put block: {e}")
+
+    def get_block(self, cid: str) -> bytes:
+        try:
+            return self._lattica_instance.get_block(cid)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get block: {e}")
+
+    def remove_block(self, cid: str):
+        try:
+            return self._lattica_instance.remove_block(cid)
+        except Exception as e:
+            raise RuntimeError(f"Failed to remove block: {e}")
+
+    def start_providing(self, key: str):
+        try:
+            return self._lattica_instance.start_providing(key)
+        except Exception as e:
+            raise RuntimeError(f"Failed to start providing: {e}")
+
+    def get_providers(self, key: str) -> List[str]:
+        try:
+            return self._lattica_instance.get_providers(key)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get providers: {e}")
+
+    def stop_providing(self, key: str):
+        try:
+            return self._lattica_instance.stop_providing(key)
+        except Exception as e:
+            raise RuntimeError(f"Failed to stop providing: {e}")
+
+    def __enter__(self):
+        self._ensure_initialized()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass

lattica/connection_handler.py

@@ -0,0 +1,406 @@
+import inspect
+from typing import List, get_type_hints
+from .client import Lattica
+
+def is_protobuf_message(obj):
+    return hasattr(obj, 'SerializeToString') and hasattr(obj, 'ParseFromString')
+
+def is_protobuf_class(cls):
+    # Check if it has protobuf key methods
+    has_serialize = hasattr(cls, 'SerializeToString')
+    has_parse = hasattr(cls, 'ParseFromString')
+
+    # Real protobuf classes or mock protobuf classes should have both methods
+    if has_serialize and has_parse:
+        return True
+
+    # Fallback check: module name contains _pb2 (real protobuf generated files)
+    if hasattr(cls, '__module__') and '_pb2' in cls.__module__:
+        return True
+
+    return False
+
+def smart_serialize(data):
+    if data is None:
+        return b''
+    elif is_protobuf_message(data):
+        return data.SerializeToString()
+    else:
+        import pickle
+        return pickle.dumps(data)
+
+def smart_deserialize(data, expected_type=None):
+    if not data:
+        return None
+
+    # If protobuf type is specified, try protobuf deserialization
+    if expected_type and is_protobuf_class(expected_type):
+        try:
+            proto_obj = expected_type()
+            proto_obj.ParseFromString(data)
+            return proto_obj
+        except Exception:
+            pass  # Try fallback methods
+
+    # Try auto-detection - check if it's pickle serialized dict with protobuf characteristics
+    try:
+        import pickle
+        result = pickle.loads(data)
+
+        # If result is dict, try to convert to matching protobuf type
+        if isinstance(result, dict) and expected_type and is_protobuf_class(expected_type):
+            # Try to create protobuf object and set attributes
+            try:
+                proto_obj = expected_type()
+                for key, value in result.items():
+                    if hasattr(proto_obj, key):
+                        setattr(proto_obj, key, value)
+                return proto_obj
+            except Exception:
+                pass
+
+        return result
+    except Exception as e:
+        raise RuntimeError(f"Failed to deserialize data: {e}")
+
+def get_method_type_hints(method):
+    try:
+        type_hints = get_type_hints(method)
+        sig = inspect.signature(method)
+
+        # Analyze parameter types
+        param_types = {}
+        for param_name, param in sig.parameters.items():
+            if param_name in type_hints and param_name != 'self':
+                annotation = type_hints[param_name]
+                if is_protobuf_class(annotation):
+                    param_types[param_name] = annotation
+                # Handle generics like Optional[ProtoType]
+                elif hasattr(annotation, '__origin__'):
+                    for arg in getattr(annotation, '__args__', []):
+                        if is_protobuf_class(arg):
+                            param_types[param_name] = arg
+                            break
+
+        # Analyze return type
+        return_type = None
+        if 'return' in type_hints:
+            annotation = type_hints['return']
+            if is_protobuf_class(annotation):
+                return_type = annotation
+            elif hasattr(annotation, '__origin__'):
+                for arg in getattr(annotation, '__args__', []):
+                    if is_protobuf_class(arg):
+                        return_type = arg
+                        break
+
+        return param_types, return_type
+    except Exception:
+        return {}, None
+
+class ConnectionHandlerMeta(type):
+    def __new__(mcs, name, bases, attrs):
+        # Collect RPC methods and stream methods
+        rpc_methods = set()
+        stream_methods = set()
+        stream_iter_methods = set()
+
+        # Inherit methods from base classes
+        for base in bases:
+            if hasattr(base, '_rpc_methods'):
+                rpc_methods.update(base._rpc_methods)
+            if hasattr(base, '_stream_methods'):
+                stream_methods.update(base._stream_methods)
+            if hasattr(base, '_stream_iter_methods'):
+                stream_iter_methods.update(base._stream_iter_methods)
+
+        # Scan current class methods
+        for attr_name, attr_value in attrs.items():
+            if hasattr(attr_value, '_is_rpc_method'):
+                if getattr(attr_value, '_is_stream_iter_method', False):
+                    stream_iter_methods.add(attr_name)
+                elif getattr(attr_value, '_is_stream_method', False):
+                    stream_methods.add(attr_name)
+                else:
+                    rpc_methods.add(attr_name)
+
+        attrs['_rpc_methods'] = list(rpc_methods)
+        attrs['_stream_methods'] = list(stream_methods)
+        attrs['_stream_iter_methods'] = list(stream_iter_methods)
+
+        # Create handlers for RPC methods
+        for method_name in rpc_methods:
+            if f'_handle_{method_name}' not in attrs:
+                attrs[f'_handle_{method_name}'] = mcs._create_rpc_handler(method_name)
+
+        # Create handlers for Stream methods
+        for method_name in stream_methods:
+            if f'_handle_stream_{method_name}' not in attrs:
+                attrs[f'_handle_stream_{method_name}'] = mcs._create_stream_handler(method_name)
+
+        for method_name in stream_iter_methods:
+            if f'_handle_stream_{method_name}' not in attrs:
+                attrs[f'_handle_stream_iter_{method_name}'] = mcs._create_stream_iter_handler(method_name)
+
+        # Save method type information for client use
+        attrs['_method_type_info'] = {}
+        for method_name in rpc_methods | stream_methods | stream_iter_methods:
+            if method_name in attrs:
+                method = attrs[method_name]
+                attrs['_method_type_info'][method_name] = get_method_type_hints(method)
+
+        return super().__new__(mcs, name, bases, attrs)
+
+    @staticmethod
+    def _create_rpc_handler(method_name: str):
+        def handler(self, data: bytes) -> bytes:
+            try:
+                # Get method and type information
+                method = getattr(self, method_name)
+                param_types, return_type = get_method_type_hints(method)
+
+                # Smart deserialization of request data
+                if data:
+                    # Check if there's a single protobuf parameter
+                    sig = inspect.signature(method)
+                    params = [p for name, p in sig.parameters.items() if name != 'self']
+
+                    if len(params) == 1 and params[0].name in param_types:
+                        # Single protobuf parameter
+                        proto_type = param_types[params[0].name]
+                        request_data = smart_deserialize(data, proto_type)
+                    else:
+                        # Other cases
+                        request_data = smart_deserialize(data)
+                else:
+                    request_data = None
+
+                # Call method
+                result = ConnectionHandlerMeta._call_method(method, request_data)
+
+                # Smart serialization of return data
+                return smart_serialize(result)
+
+            except Exception as e:
+                raise RuntimeError(f"RPC method {method_name} failed: {e}")
+        return handler
+
+    @staticmethod
+    def _create_stream_handler(method_name: str):
+        def handler(self, data: bytes) ->bytes:
+            try:
+                # Get method and type information
+                method = getattr(self, method_name)
+                param_types, return_type = get_method_type_hints(method)
+
+                # Smart deserialization of request data
+                if data:
+                    sig = inspect.signature(method)
+                    params = [p for name, p in sig.parameters.items() if name != 'self']
+
+                    if len(params) == 1 and params[0].name in param_types:
+                        # Single protobuf parameter
+                        proto_type = param_types[params[0].name]
+                        request_data = smart_deserialize(data, proto_type)
+                    else:
+                        # Other cases
+                        request_data = smart_deserialize(data)
+                else:
+                    request_data = None
+
+                # Call method
+                result = ConnectionHandlerMeta._call_method(method, request_data)
+                return smart_serialize(result)
+
+            except Exception as e:
+                raise RuntimeError(f"Stream method {method_name} failed: {e}")
+        return handler
+    @staticmethod
+    def _create_stream_iter_handler(method_name: str):
+        def handler(self, data: bytes) ->bytes:
+            try:
+                # Get method and type information
+                method = getattr(self, method_name)
+                param_types, _ = get_method_type_hints(method)
+
+                # Smart deserialization of request data
+                if data:
+                    sig = inspect.signature(method)
+                    params = [p for name, p in sig.parameters.items() if name != 'self']
+
+                    if len(params) == 1 and params[0].name in param_types:
+                        # Single protobuf parameter
+                        proto_type = param_types[params[0].name]
+                        request_data = smart_deserialize(data, proto_type)
+                    else:
+                        # Other cases
+                        request_data = smart_deserialize(data)
+                else:
+                    request_data = None
+
+                # Call method
+                return ConnectionHandlerMeta._call_method(method, request_data)
+            except Exception as e:
+                raise RuntimeError(f"Stream iter method {method_name} failed: {e}")
+        return handler
+    @staticmethod
+    def _call_method(method, request_data):
+        if request_data is not None:
+            sig = inspect.signature(method)
+            params = list(sig.parameters.values())
+            if params and params[0].name == 'self':
+                params = params[1:]
+
+            if len(params) == 0:
+                return method()
+            elif len(params) == 1:
+                return method(request_data)
+            else:
+                if isinstance(request_data, dict):
+                    return method(**request_data)
+                elif isinstance(request_data, (list, tuple)):
+                    return method(*request_data)
+                else:
+                    return method(request_data)
+        else:
+            return method()
+
+class MethodStub:
+    def __init__(self, stub: 'ServiceStub', method_name: str, is_stream: bool = False, is_stream_iter: bool = False):
+        self.stub = stub
+        self.method_name = method_name
+        self.is_stream = is_stream
+        self.is_stream_iter = is_stream_iter
+
+    def __call__(self, *args, **kwargs):
+        # Handle parameters - support protobuf auto-serialization
+        if len(args) == 0 and len(kwargs) == 0:
+            data = None
+        elif len(args) == 1 and len(kwargs) == 0:
+            data = args[0]
+        elif len(args) > 0 and len(kwargs) == 0:
+            data = list(args)
+        elif len(kwargs) > 0 and len(args) == 0:
+            data = kwargs
+        else:
+            data = kwargs
+            for i, arg in enumerate(args):
+                data[f'arg{i}'] = arg
+
+        full_method_name = f"{self.stub.service_name}.{self.method_name}"
+
+        # Smart serialization of data
+        serialized_data = smart_serialize(data)
+
+        # Get expected return type
+        expected_return_type = None
+        if hasattr(self.stub.connection_handler, '_method_type_info'):
+            method_info = self.stub.connection_handler._method_type_info.get(self.method_name)
+            if method_info:
+                param_types, return_type = method_info
+                expected_return_type = return_type
+
+        if self.is_stream_iter:
+            return self.stub.connection_handler._call_stream_iter_method(
+                self.stub.peer_id, full_method_name, serialized_data
+            )
+        elif self.is_stream:
+            # Stream call
+            future = self.stub.connection_handler._call_stream_method(
+                self.stub.peer_id, full_method_name, serialized_data
+            )
+
+            return FutureWrapper(future, expected_return_type, is_stream=True)
+        else:
+            # Regular RPC call
+            future = self.stub.connection_handler._call_method(
+                self.stub.peer_id, full_method_name, serialized_data
+            )
+            # Smart deserialization of response using expected return type
+            return FutureWrapper(future, expected_return_type, is_stream=False)
+
+class ServiceStub:
+    def __init__(self, connection_handler: 'ConnectionHandler', peer_id: str, service_name: str):
+        self.connection_handler = connection_handler
+        self.peer_id = peer_id
+        self.service_name = service_name
+        self._method_cache = {}
+
+    def __getattr__(self, name: str):
+        if name in self._method_cache:
+            return self._method_cache[name]
+
+        is_stream = name in getattr(self.connection_handler, '_stream_methods', [])
+        is_stream_iter = name in getattr(self.connection_handler, '_stream_iter_methods', [])
+
+        method_stub = MethodStub(self, name, is_stream, is_stream_iter)
+        self._method_cache[name] = method_stub
+        return method_stub
+
+class ConnectionHandler(metaclass=ConnectionHandlerMeta):
+    def __init__(self, lattica_instance: Lattica):
+        self.lattica_instance = lattica_instance
+        self._service_name = self.__class__.__name__
+        self._register_service()
+
+    def _register_service(self):
+        try:
+            self.lattica_instance.register_service(self)
+        except Exception as e:
+            raise
+
+    def get_service_name(self) -> str:
+        return self._service_name
+
+    def get_methods(self) -> List[str]:
+        return getattr(self, '_rpc_methods', [])
+
+    def get_stream_methods(self) -> List[str]:
+        return getattr(self, '_stream_methods', [])
+
+    def get_stub(self, peer_id: str) -> ServiceStub:
+        return ServiceStub(self, peer_id, self._service_name)
+
+    def _call_method(self, peer_id: str, method_name: str, data: bytes) -> bytes:
+        try:
+            client = self.lattica_instance.get_client(peer_id)
+            return client.call(method_name, data)
+        except Exception as e:
+            raise
+
+    def _call_stream_method(self, peer_id: str, method_name: str, data: bytes):
+        try:
+            client = self.lattica_instance.get_client(peer_id)
+            return client.call_stream(method_name, data)
+        except Exception as e:
+            raise e
+
+    def _call_stream_iter_method(self, peer_id: str, method_name: str, data: bytes):
+        try:
+            client = self.lattica_instance.get_client(peer_id)
+            return client.call_stream_iter(method_name, data)
+        except Exception as e:
+            raise
+
+class FutureWrapper:
+    def __init__(self, future, expected_return_type, is_stream=False):
+        self.future = future
+        self.expected_return_type = expected_return_type
+        self.is_stream = is_stream
+
+    def result(self, timeout=180):
+        raw_result = self.future.result(timeout=timeout)
+        return self._process_result(raw_result)
+
+    def __await__(self):
+        return self._async_result().__await__()
+
+    async def _async_result(self):
+        raw_result = await self.future
+        return self._process_result(raw_result)
+
+    def _process_result(self, raw_result):
+        if self.is_stream:
+            return smart_deserialize(raw_result, self.expected_return_type)
+        else:
+            return smart_deserialize(raw_result, self.expected_return_type)

lattica-1.0.1.dist-info/METADATA

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: lattica
+Version: 1.0.1
+Requires-Dist: asyncio ; python_full_version >= '3.11'
+Requires-Dist: typing-extensions ; python_full_version < '3.12'
+Requires-Dist: nest-asyncio ; python_full_version >= '3.11'
+Requires-Dist: pytest>=7.0.0 ; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0 ; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0 ; extra == 'dev'
+Requires-Dist: black>=23.0.0 ; extra == 'dev'
+Requires-Dist: isort>=5.12.0 ; extra == 'dev'
+Requires-Dist: flake8>=6.0.0 ; extra == 'dev'
+Requires-Dist: mypy>=1.0.0 ; extra == 'dev'
+Requires-Dist: psutil>=5.9.0 ; extra == 'dev'
+Requires-Dist: pytest>=7.0.0 ; extra == 'test'
+Requires-Dist: pytest-asyncio>=0.21.0 ; extra == 'test'
+Requires-Dist: pytest-cov>=4.0.0 ; extra == 'test'
+Requires-Dist: psutil>=5.9.0 ; extra == 'bench'
+Requires-Dist: matplotlib>=3.7.0 ; extra == 'bench'
+Requires-Dist: pandas>=2.0.0 ; extra == 'bench'
+Provides-Extra: dev
+Provides-Extra: test
+Provides-Extra: bench
+Summary: A unified Python SDK for P2P networking with integrated DHT and NAT capabilities
+Keywords: p2p,networking,dht,nat,libp2p,distributed
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# Lattica Python SDK
+
+A unified Python SDK for P2P networking with integrated DHT and NAT capabilities, built on top of libp2p.
+
+## Features
+
+- **Distributed Hash Table (DHT)**: Store and retrieve key-value pairs across the network
+- **Remote Procedure Call (RPC)**: Execute remote functions with support for complex data types
+- **Streaming RPC**: Handle large data transfers with streaming capabilities
+- **NAT Traversal**: Automatic NAT traversal with UPnP support
+- **Peer Discovery**: mDNS and rendezvous-based peer discovery
+- **High Performance**: Built with Rust for optimal performance
+
+## Installation
+You can install the released versions
+```bash
+pip install lattica
+```
+Or you can install from source using:
+```bash
+pip install git+https://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@github.com/OpenEdgeHQ/p2p-lattica.git#subdirectory=bindings/python
+```
+
+## Quick Start
+### Basic Usage
+
+```python
+from lattica import Lattica
+
+# Create a Lattica instance
+lattica = Lattica.builder().build()
+
+# Get your peer ID
+peer_id = lattica.peer_id()
+print(f"My peer ID: {peer_id}")
+```
+
+## Examples
+
+### 1. DHT Operations
+
+The DHT example demonstrates basic key-value storage and retrieval with subkey support.
+
+```python
+from lattica import Lattica
+
+# Create client1 as bootstrap node
+lattica = Lattica.builder()
+    .build()
+
+# Create client2 with bootstrap nodes
+lattica = Lattica.builder() \
+    .with_bootstraps(["/ip4/127.0.0.1/tcp/54282/p2p/QmServerPeerId"]) \
+    .build()
+
+# Store a simple key-value pair with default expiration 10 minute
+lattica.store("name", "alice")
+
+# get the value
+result = lattica.get("name")
+if result:
+    print(f"Value: {result.value}")
+    print(f"Expires: {result.expiration_time}")
+
+
+# Store values with subkeys (useful for voting, user data, etc.)
+key = "peer_list"
+peers = ["alice", "bob", "carol"]
+
+# Each peer stores their vote with a subkey
+lattica.store(key, "yes", expiration_time, subkey="alice")
+lattica.store(key, "no", expiration_time, subkey="bob")
+lattica.store(key, "maybe", expiration_time, subkey="carol")
+
+# get all votes
+votes_result = lattica.get(key)
+if votes_result:
+    for peer, vote_info in votes_result.value.items():
+        print(f"{peer}: {vote_info.value}")
+```
+
+### 2. RPC Operations
+
+The RPC example demonstrates remote procedure calls with support for complex data types and streaming.
+
+```python
+from lattica import Lattica, rpc_method, rpc_stream, rpc_stream_iter, ConnectionHandler
+
+
+
+class MyService(ConnectionHandler):
+    @rpc_method
+    def add(self, a: int, b: int) -> int:
+        """Simple addition"""
+        return a + b
+    
+    @rpc_stream
+    def process_data(self, data: list) -> list:
+        return data
+    
+    @rpc_stream_iter
+    def stream_rpc_iter(self):
+        while True:
+            text = "hello world"
+            yield text
+            
+# Create client1 as RPC server and bootstrap node
+lattica = Lattica.builder()
+    .build()
+service = MyService(lattica)
+
+# Create client2 with bootstrap nodes
+lattica = Lattica.builder() \
+    .with_bootstraps(["/ip4/127.0.0.1/tcp/54282/p2p/QmServerPeerId"]) \
+    .build()
+client_service = MyService(client_lattica)
+
+# Make RPC calls
+stub = client_service.get_stub(server_peer_id)
+result = stub.add(10, 20)  # Returns 30
+
+# Handle complex data types
+num_floats = int(2 * 1024 * 1024 * 1024) // 8 #2GB
+test_data = [random.random() for _ in range(num_floats)]
+result = stub.process_data(test_data)
+
+# stream iter call
+for text in stub.stream_rpc_iter():
+    print(f"recv: {text}")
+
+```
+
+## Configuration
+
+### Builder Pattern
+
+```python
+lattica = Lattica.builder() \
+    .with_bootstraps([
+        "/ip4/127.0.0.1/tcp/8080/p2p/QmBootstrap1",
+        "/ip4/127.0.0.1/tcp/8081/p2p/QmBootstrap2"
+    ]) \
+    .with_listen_addrs(["/ip4/0.0.0.0/tcp/0", "/ip4/0.0.0.0/udp/0/quic-v1"])
+    .with_external_addrs(["/ip4/0.0.0.0/tcp/0"])
+    .with_mdns(True) \
+    .with_upnp(True) \
+    .build()
+```
+
+### Configuration Options
+
+- `with_bootstraps(nodes)`: Set bootstrap nodes for network discovery
+- `with_listen_addrs(addrs)`: Set listening address
+- `with_mdns(enabled)`: Enable/disable mDNS peer discovery
+- `with_upnp(enabled)`: Enable/disable UPnP NAT traversal
+- `with_relay_servers(servers)`: Set relay servers for network relay
+- `with_autonat(enabled)`: Enable/disable AutoNAT detect[need relay servers]
+- `with_dcutr(enabled)`: Enable/disable TCP/QUIC NAT travelsal[need relay servers]
+- `with_external_addrs(addrs)`: Set external address
+- `with_storage_path`: Persistent storage path
+- `with_key_path`: Set Keypair path
+
+## Development
+
+### Building from Source
+
+```bash
+# Install maturin
+pip install maturin
+
+# Build the package
+cd bindings/python
+pip install .
+```

lattica-1.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+lattica-1.0.1.dist-info/METADATA,sha256=-utMtRx16rwZqRy41RWRyPssUVc0B2eePw6XDd8m1h8,5979
+lattica-1.0.1.dist-info/WHEEL,sha256=LWHqq2IM4QLepK4wz-qn725zui-nG-9ig3PtbmCZl-g,107
+lattica/__init__.py,sha256=8YITlLnp2HwFscCFPXoydAQlZfWQbWMIhESS26GovPI,295
+lattica/client.py,sha256=-wxEgMW-c_MA8Vc-I5PB34878xVvlP2aNYZIHrdRKy8,8437
+lattica/connection_handler.py,sha256=w8D4hG7KsXfbDdzSmZjn9cOfl8n-HCDEf91b6rElP_4,15749
+lattica_python_core/__init__.py,sha256=uXPn47KzWKWEomcCmXdktHbovVOR38Cbsv8Vu8IrTPQ,159
+lattica_python_core/lattica_python_core.abi3.so,sha256=YSitKEkmeRFHB1k4ti81Th1cVOy06EYhui-9oXZ1ybU,29424760
+lattica-1.0.1.dist-info/RECORD,,

lattica-1.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.9.6)
+Root-Is-Purelib: false
+Tag: cp311-abi3-manylinux_2_34_x86_64

lattica_python_core/__init__.py

@@ -0,0 +1,5 @@
+from .lattica_python_core import *
+
+__doc__ = lattica_python_core.__doc__
+if hasattr(lattica_python_core, "__all__"):
+    __all__ = lattica_python_core.__all__