nexaroa 0.0.111__py3-none-any.whl

neuroshard/utils/autostart.py

@@ -0,0 +1,81 @@
+
+import sys
+import os
+import platform
+import shutil
+
+def enable_autostart():
+    app_name = "NeuroShardNode"
+    
+    if sys.platform == "win32":
+        import winreg
+        key_path = r"Software\Microsoft\Windows\CurrentVersion\Run"
+        try:
+            key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, key_path, 0, winreg.KEY_SET_VALUE)
+            winreg.SetValueEx(key, app_name, 0, winreg.REG_SZ, sys.executable)
+            winreg.CloseKey(key)
+            return True
+        except Exception as e:
+            print(f"Autostart failed: {e}")
+            return False
+            
+    elif sys.platform == "linux":
+        # Create ~/.config/autostart/neuroshard.desktop
+        desktop_file = f"""[Desktop Entry]
+Type=Application
+Name={app_name}
+Exec={sys.executable}
+Hidden=false
+NoDisplay=false
+X-GNOME-Autostart-enabled=true
+"""
+        path = os.path.expanduser(f"~/.config/autostart/{app_name.lower()}.desktop")
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "w") as f:
+            f.write(desktop_file)
+        return True
+        
+    elif sys.platform == "darwin": # macOS
+        # Use LaunchAgent
+        plist = f"""<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.neuroshard.node</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>{sys.executable}</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+</dict>
+</plist>
+"""
+        path = os.path.expanduser("~/Library/LaunchAgents/com.neuroshard.node.plist")
+        with open(path, "w") as f:
+            f.write(plist)
+        return True
+
+def disable_autostart():
+    app_name = "NeuroShardNode"
+    
+    if sys.platform == "win32":
+        import winreg
+        key_path = r"Software\Microsoft\Windows\CurrentVersion\Run"
+        try:
+            key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, key_path, 0, winreg.KEY_SET_VALUE)
+            winreg.DeleteValue(key, app_name)
+            winreg.CloseKey(key)
+        except: pass
+        
+    elif sys.platform == "linux":
+        path = os.path.expanduser(f"~/.config/autostart/{app_name.lower()}.desktop")
+        if os.path.exists(path):
+            os.remove(path)
+            
+    elif sys.platform == "darwin":
+        path = os.path.expanduser("~/Library/LaunchAgents/com.neuroshard.node.plist")
+        if os.path.exists(path):
+            os.remove(path)
+

neuroshard/utils/hardware.py

@@ -0,0 +1,121 @@
+
+import torch
+import psutil
+import platform
+import hashlib
+import uuid
+import os
+import socket
+
+
+def get_machine_id() -> str:
+    """
+    Get a unique identifier for this machine.
+    
+    Uses multiple sources to create a stable, unique ID:
+    1. Machine UUID (from DMI/SMBIOS on Linux, IOKit on macOS)
+    2. Hostname (fallback)
+    3. MAC address (fallback)
+    
+    This ID is stable across reboots but unique per machine.
+    """
+    machine_id_sources = []
+    
+    # Try to get machine-id (Linux)
+    for path in ['/etc/machine-id', '/var/lib/dbus/machine-id']:
+        try:
+            if os.path.exists(path):
+                with open(path, 'r') as f:
+                    machine_id_sources.append(f.read().strip())
+                break
+        except Exception:
+            pass
+    
+    # Try hostname
+    try:
+        machine_id_sources.append(socket.gethostname())
+    except Exception:
+        pass
+    
+    # Try MAC address (via uuid.getnode)
+    try:
+        mac = uuid.getnode()
+        if mac != uuid.getnode():  # Check it's not a random fallback
+            machine_id_sources.append(str(mac))
+    except Exception:
+        pass
+    
+    # Combine all sources
+    if machine_id_sources:
+        combined = ":".join(machine_id_sources)
+        return hashlib.sha256(combined.encode()).hexdigest()[:16]
+    
+    # Ultimate fallback: generate and cache a random ID
+    cache_dir = os.path.join(os.path.expanduser("~"), ".neuroshard")
+    os.makedirs(cache_dir, exist_ok=True)
+    machine_id_file = os.path.join(cache_dir, ".machine_id")
+    
+    if os.path.exists(machine_id_file):
+        with open(machine_id_file, 'r') as f:
+            return f.read().strip()
+    
+    random_id = uuid.uuid4().hex[:16]
+    with open(machine_id_file, 'w') as f:
+        f.write(random_id)
+    return random_id
+
+
+def get_instance_id(port: int) -> str:
+    """
+    Generate a unique instance ID for this node.
+    
+    Combines machine_id + port to create a stable, unique identifier.
+    This allows multiple nodes on the same machine (different ports)
+    or the same port on different machines to have unique identities.
+    
+    Args:
+        port: The port this node is running on
+        
+    Returns:
+        16-character hex string unique to this machine+port combination
+    """
+    machine_id = get_machine_id()
+    instance_string = f"{machine_id}:{port}"
+    return hashlib.sha256(instance_string.encode()).hexdigest()[:16]
+
+
+def get_hardware_info():
+    info = {
+        "system": platform.system(),
+        "cpu_cores": psutil.cpu_count(logical=False),
+        "ram_gb": round(psutil.virtual_memory().total / (1024**3), 2),
+        "gpu_available": torch.cuda.is_available(),
+        "gpu_name": "None",
+        "vram_gb": 0.0,
+        "device": "cpu"
+    }
+    
+    if info["gpu_available"]:
+        info["gpu_name"] = torch.cuda.get_device_name(0)
+        info["vram_gb"] = round(torch.cuda.get_device_properties(0).total_memory / (1024**3), 2)
+        info["device"] = "cuda"
+        
+    return info
+
+def suggest_config(info):
+    """Recommend layers based on hardware."""
+    # Heuristic: 124M params needs ~500MB RAM. 
+    # We can fit full model on almost any modern PC.
+    # But let's split it to demonstrate sharding.
+    
+    layers_per_node = 4 # Default shard size
+    
+    if info["vram_gb"] > 4 or (info["ram_gb"] > 8 and not info["gpu_available"]):
+        # Powerful node, can host more
+        layers_per_node = 6
+        
+    return {
+        "suggested_layers": f"0-{layers_per_node}",
+        "device": info["device"]
+    }
+

neuroshard/utils/serialization.py

@@ -0,0 +1,90 @@
+
+import io
+import base64
+import torch
+import zlib
+from safetensors.torch import save, load
+
+def serialize_tensor(tensor_or_dict, use_quantization: bool = True) -> str:
+    """
+    Serialize a PyTorch tensor (or dict of tensors) to a compressed, base64 encoded string
+    using SAFETENSORS for security (no pickle/RCE).
+    """
+    # If input is a single tensor, wrap it in a dict
+    if isinstance(tensor_or_dict, torch.Tensor):
+        data_dict = {"data": tensor_or_dict}
+    elif isinstance(tensor_or_dict, dict):
+        data_dict = tensor_or_dict
+    else:
+        raise ValueError("Input must be a Tensor or a Dict of Tensors")
+        
+    # Ensure all values are tensors (safetensors requirement)
+    # If we are doing quantization logic, we need to handle it before saving
+    
+    final_dict = {}
+    
+    # Quantization Logic
+    if isinstance(tensor_or_dict, torch.Tensor) and use_quantization and tensor_or_dict.dtype in [torch.float32, torch.float16]:
+        # Symmetric Quantization to INT8
+        max_val = tensor_or_dict.abs().max()
+        scale = max_val / 127.0 if max_val > 0 else torch.tensor(1.0, device=tensor_or_dict.device)
+        quantized = (tensor_or_dict / scale).round().to(torch.int8)
+        
+        # Safetensors only stores tensors, so we store scale as a 0-d tensor
+        final_dict["t"] = quantized
+        final_dict["s"] = scale.view(1) # 0-d to 1-d for safety sometimes
+        final_dict["q"] = torch.tensor([1], dtype=torch.int8) # Flag
+    elif isinstance(tensor_or_dict, torch.Tensor):
+         final_dict["data"] = tensor_or_dict
+    else:
+         # It's already a dict (e.g. state_dict)
+         final_dict = data_dict
+         
+    # Serialize with Safetensors
+    # Safetensors returns bytes directly
+    try:
+        safetensors_bytes = save(final_dict)
+    except Exception as e:
+        print(f"Safetensors save error: {e}")
+        # Fallback or re-raise. Safetensors might fail on some dtypes or non-contiguous.
+        # Ensure contiguous
+        final_dict = {k: v.contiguous() for k, v in final_dict.items()}
+        safetensors_bytes = save(final_dict)
+        
+    # Compress
+    compressed_data = zlib.compress(safetensors_bytes)
+    
+    return base64.b64encode(compressed_data).decode('utf-8')
+
+def deserialize_tensor(data: str) -> torch.Tensor:
+    """
+    Deserialize a base64 encoded string back to a PyTorch tensor using SAFETENSORS.
+    Secure against RCE.
+    """
+    try:
+        decoded_data = base64.b64decode(data)
+        try:
+            decompressed_data = zlib.decompress(decoded_data)
+        except zlib.error:
+            decompressed_data = decoded_data
+            
+        # Load from bytes
+        loaded_dict = load(decompressed_data)
+        
+        # Check if it was our quantized format
+        if "q" in loaded_dict and "t" in loaded_dict:
+            quantized = loaded_dict["t"]
+            scale = loaded_dict["s"]
+            # Dequantize
+            return quantized.to(torch.float32) * scale.item()
+            
+        # Check if it was a single tensor wrapper
+        if "data" in loaded_dict and len(loaded_dict) == 1:
+            return loaded_dict["data"]
+            
+        # Otherwise return the full dict (e.g. for weights)
+        return loaded_dict
+            
+    except Exception as e:
+        print(f"Error deserializing tensor (Security or Format): {e}")
+        raise e

neuroshard/version.py

@@ -0,0 +1 @@
+__version__ = "0.0.111"

nexaroa-0.0.111.dist-info/METADATA

@@ -0,0 +1,283 @@
+Metadata-Version: 2.4
+Name: nexaroa
+Version: 0.0.111
+Summary: Decentralized AI Network
+Author-email: NeuroShard Team <team@neuroshard.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://neuroshard.com
+Project-URL: Documentation, https://docs.neuroshard.com
+Project-URL: Repository, https://github.com/Nexaroa/neuroshard
+Project-URL: Issues, https://github.com/Nexaroa/neuroshard/issues
+Keywords: ai,machine-learning,distributed-computing,blockchain,llm,neural-network,decentralized,training
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: System :: Distributed Computing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: transformers>=4.30.0
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: uvicorn>=0.23.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: grpcio>=1.50.0
+Requires-Dist: protobuf>=4.21.0
+Requires-Dist: safetensors>=0.3.0
+Requires-Dist: cryptography>=41.0.0
+Requires-Dist: mnemonic>=0.20
+Requires-Dist: jinja2>=3.1.0
+Provides-Extra: gpu
+Requires-Dist: torch>=2.0.0; extra == "gpu"
+Provides-Extra: gui
+Requires-Dist: customtkinter>=5.2.0; extra == "gui"
+Requires-Dist: Pillow>=9.0.0; extra == "gui"
+Requires-Dist: pystray>=0.19.0; extra == "gui"
+Provides-Extra: full
+Requires-Dist: torch>=2.0.0; extra == "full"
+Requires-Dist: customtkinter>=5.2.0; extra == "full"
+Requires-Dist: Pillow>=9.0.0; extra == "full"
+Requires-Dist: pystray>=0.19.0; extra == "full"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: ruff>=0.0.280; extra == "dev"
+Requires-Dist: torch>=2.0.0; extra == "dev"
+Dynamic: license-file
+
+<p align="center">
+  <img src="assets/logo.png" alt="NeuroShard Logo" width="120" height="120">
+</p>
+
+<h1 align="center">NeuroShard</h1>
+
+<p align="center">
+  <strong>Decentralized LLM Training Network</strong>
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/neuroshard/"><img src="https://badge.fury.io/py/neuroshard.svg" alt="PyPI version"></a>
+  <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.9+-blue.svg" alt="Python 3.9+"></a>
+  <a href="https://github.com/Nexaroa/neuroshard/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" alt="License: Apache 2.0"></a>
+  <a href="https://discord.gg/4R49xpj7vn"><img src="https://img.shields.io/discord/1234567890?color=7289da&label=Discord&logo=discord&logoColor=white" alt="Discord"></a>
+</p>
+
+<p align="center">
+  <a href="https://neuroshard.com">Website</a> •
+  <a href="https://docs.neuroshard.com">Documentation</a> •
+  <a href="docs/whitepaper/neuroshard_whitepaper.pdf">Whitepaper</a> •
+  <a href="https://discord.gg/4R49xpj7vn">Discord</a> •
+  <a href="https://x.com/shardneuro">Twitter</a>
+</p>
+
+---
+
+## What is NeuroShard?
+
+NeuroShard is a **decentralized network** for training large language models. Anyone can contribute GPU/CPU power and earn **NEURO tokens** through Proof of Neural Work.
+
+Unlike centralized AI companies, NeuroShard distributes both the compute AND the rewards across all participants.
+
+### Key Features
+
+| Feature | Description |
+|---------|-------------|
+| **DiLoCo Training** | Distributed Low-Communication training - sync every 500 steps, not every step |
+| **Byzantine Tolerance** | Robust gradient aggregation (Krum, Trimmed Mean) handles malicious nodes |
+| **NEURO Rewards** | Earn tokens for contributing compute via Proof of Neural Work |
+| **Cryptographic Proofs** | ECDSA-signed proofs ensure trustless verification |
+| **Web Dashboard** | Real-time monitoring at `http://localhost:8000` |
+| **P2P Network** | Decentralized peer discovery and gossip protocol |
+
+---
+
+## Quick Start
+
+### Installation
+
+```bash
+pip install neuroshard
+```
+
+### Run a Node
+
+```bash
+# Get your token from neuroshard.com
+neuroshard --token YOUR_TOKEN
+```
+
+That's it! Your node will:
+1. Connect to the network
+2. Start training model layers
+3. Earn NEURO for your contribution
+
+### Web Dashboard
+
+Open `http://localhost:8000` to see:
+- Node status and role
+- Training progress (DiLoCo inner/outer steps)
+- NEURO balance
+- Network statistics
+
+---
+
+## System Requirements
+
+| Component | Minimum | Recommended |
+|-----------|---------|-------------|
+| **RAM** | 4 GB | 8+ GB |
+| **Python** | 3.9+ | 3.10+ |
+| **GPU** | Optional | NVIDIA 8GB+ VRAM |
+
+### GPU Support (Optional)
+
+For NVIDIA GPUs with CUDA:
+
+```bash
+pip install torch --index-url https://download.pytorch.org/whl/cu118
+```
+
+---
+
+## How It Works
+
+### DiLoCo Distributed Training
+
+NeuroShard uses [DiLoCo](https://arxiv.org/abs/2311.08105) (Distributed Low-Communication) for efficient distributed training:
+
+```
+┌─────────────────────────────────────────────────┐
+│  INNER LOOP (500 steps - no communication)      │
+│  • Each node trains independently               │
+│  • Local AdamW optimization                     │
+└─────────────────────────────────────────────────┘
+                      ↓
+┌─────────────────────────────────────────────────┐
+│  OUTER LOOP (sync with peers)                   │
+│  • Compute pseudo-gradient: Δθ = θ₀ - θ₅₀₀     │
+│  • Gossip to peers                              │
+│  • Byzantine-tolerant aggregation               │
+│  • Nesterov momentum update                     │
+└─────────────────────────────────────────────────┘
+                      ↓
+              (Repeat)
+```
+
+This reduces network communication by **500x** compared to synchronous training!
+
+### Proof of Neural Work
+
+Nodes earn NEURO by submitting cryptographically signed proofs of their work:
+
+- Training batches processed
+- Inference requests served
+- Uptime contribution
+- Data samples provided
+
+All proofs are verified using ECDSA signatures (secp256k1).
+
+---
+
+## Configuration
+
+### CLI Options
+
+```bash
+neuroshard --token YOUR_TOKEN \
+           --port 8000 \
+           --tracker https://tracker.neuroshard.com \
+           --training \
+           --diloco-steps 500
+```
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `--token` | Required | Your node authentication token |
+| `--port` | 8000 | HTTP server port |
+| `--tracker` | Auto | Tracker server URL |
+| `--training` | False | Enable training mode |
+| `--diloco-steps` | 500 | Inner steps before sync |
+
+See [full CLI reference](https://docs.neuroshard.com/guide/cli-reference) for all options.
+
+---
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                      NeuroShard Node                        │
+├─────────────────────────────────────────────────────────────┤
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐  │
+│  │  NeuroLLM   │  │   DiLoCo    │  │  Proof of Neural    │  │
+│  │  (Model)    │  │  Trainer    │  │  Work Ledger        │  │
+│  └─────────────┘  └─────────────┘  └─────────────────────┘  │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐  │
+│  │  P2P/DHT    │  │  Gradient   │  │  ECDSA Crypto       │  │
+│  │  Network    │  │  Aggregator │  │  (secp256k1)        │  │
+│  └─────────────┘  └─────────────┘  └─────────────────────┘  │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Documentation
+
+- **[Whitepaper](docs/whitepaper/neuroshard_whitepaper.pdf)** - Technical whitepaper (PDF)
+- **[Getting Started](https://docs.neuroshard.com/guide/quick-start)** - First steps
+- **[Running a Node](https://docs.neuroshard.com/guide/running-a-node)** - Detailed setup
+- **[Architecture](https://docs.neuroshard.com/architecture/overview)** - System design
+- **[Economics](https://docs.neuroshard.com/economics/overview)** - NEURO tokenomics
+- **[API Reference](https://docs.neuroshard.com/api/overview)** - SDK & endpoints
+
+---
+
+## Links
+
+| Resource | Link |
+|----------|------|
+| Website | [neuroshard.com](https://neuroshard.com) |
+| Documentation | [docs.neuroshard.com](https://docs.neuroshard.com) |
+| Whitepaper | [PDF](docs/whitepaper/neuroshard_whitepaper.pdf) |
+| Discord | [discord.gg/4R49xpj7vn](https://discord.gg/4R49xpj7vn) |
+| Twitter | [@shardneuro](https://x.com/shardneuro) |
+| PyPI | [pypi.org/project/neuroshard](https://pypi.org/project/neuroshard/) |
+
+---
+
+## Contributing
+
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
+
+```bash
+# Clone the repo
+git clone https://github.com/Nexaroa/neuroshard.git
+cd neuroshard
+
+# Install dev dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+```
+
+---
+
+## License
+
+Apache License 2.0 - see [LICENSE](LICENSE) for details.
+
+---
+
+<p align="center">
+  <strong>Train AI. Earn NEURO. Own the Network.</strong>
+</p>

nexaroa-0.0.111.dist-info/RECORD

@@ -0,0 +1,78 @@
+neuroshard/__init__.py,sha256=hs1z2vrdHRUffNx_HIIR8WBz0E6sfUzWhTyiwNl68WU,1816
+neuroshard/__main__.py,sha256=UERfOw_HxzNQjocDj11CqtPuc3Omu1Z7lzg0JrwKSrc,75
+neuroshard/cli.py,sha256=aM0kA_HdE1C2cac0SezBJunlqWnD9KF-KUTvU4pXKz4,15305
+neuroshard/governance_cli.py,sha256=nfndsuTTHKtPVOrMdJ5lAqwfphyPrdXm7aDi-2ZQX5w,23748
+neuroshard/grpc_server.py,sha256=CMgqI0rsGmnFuC0TWoplAIE-d_kWNLsM_SwAcIU1j2A,38039
+neuroshard/runner.py,sha256=b04QnVbuEdzwGez2EtiVyRebfor60ldTJtQ7sjR11PY,127617
+neuroshard/version.py,sha256=BtvlzlO7UNG5nD9ftqoP0J2wHDhVCXpzuMsjYBw0Wfg,24
+neuroshard/core/__init__.py,sha256=ceGh-I4x0xpq7N_3agYX2Yml3BAOQ5e6ihAMVqpjMcs,3685
+neuroshard/core/consensus/verifier.py,sha256=amxkvY42lEHUBOGsGPIT7XXup8_jQ1j2M2TxD7SdKZo,10216
+neuroshard/core/crypto/__init__.py,sha256=V3i6sTOPwtpD5DOCWBzqErzZ-c3aSgwUV_u-p5ROi6A,574
+neuroshard/core/crypto/ecdsa.py,sha256=ra8VNiFxNbigs4Zi4zec3_-Jvafe4tgw7OXpPMRk4EA,12037
+neuroshard/core/economics/__init__.py,sha256=aUgA4H8_NKF06enGOTGJu5L8OKlj5jsgfjDjWoxWfq0,1902
+neuroshard/core/economics/constants.py,sha256=KkyzFhXNNwDPVRgRi88LvnfDzzJc9FlMBF6gHKijTHw,19415
+neuroshard/core/economics/ledger.py,sha256=KBfrYpxpvg7Q6PcUokoV0u34iaISll6egDPk7F-FQXk,87395
+neuroshard/core/economics/market.py,sha256=Ia9cFAavqRk1AlljYtvkpRp-AvHlvZHBWEl6Z9RaL1c,39261
+neuroshard/core/economics/wallet.py,sha256=MrUFUsCHbXt9ejWm03oeddvvC8fzKrvQKbIQ_J0Rlfk,5125
+neuroshard/core/governance/__init__.py,sha256=TaVWlJEcFNb7hJyZGy74xjw-vpHCLn6FuTzOeeVJ_Gk,1813
+neuroshard/core/governance/proposal.py,sha256=mLM3B1ZpnV6EiPRtYnVIv_asYWH82S9_RFK7ArWStYY,19550
+neuroshard/core/governance/registry.py,sha256=_eVmgmEjShB6xSiQW9xsCYDies3K2CFhfxQp6Ged9Oo,20474
+neuroshard/core/governance/versioning.py,sha256=KuanpynrE8unp7XlfqnZSq_JiuRLITCxLNuHXWKOPcI,11062
+neuroshard/core/governance/voting.py,sha256=kscWe3P7bxyX0mkk58ALzMqBiXSbwwwInXx7eMwAlv4,14499
+neuroshard/core/model/__init__.py,sha256=ZEtJQGvLlX-89BVdtBshmwivmB78D3WmrxRNk_20KEg,758
+neuroshard/core/model/dynamic.py,sha256=Wa9G-sF-lOWMzMFgj0iilKDrvlPkhxz10jMSpDhwM8Y,193625
+neuroshard/core/model/llm.py,sha256=QBj6mPgO3QOY1OCWEirE6GybalhL0XHO5isOaTO9DTY,31815
+neuroshard/core/model/registry.py,sha256=i7cns9m97IqlCKEAHzas31eLltV1uQzxFHAU-gywneY,5351
+neuroshard/core/model/scaler.py,sha256=JTWa4BiWqIiL9TJ19MLI8yLby-6WCuPWSKLHS4AyrbQ,15561
+neuroshard/core/model/tokenizer.py,sha256=8P_qiDPRwCi2BNDpXWqSpYaLop6cd-dnWFk5wIRhbV8,20786
+neuroshard/core/network/__init__.py,sha256=almT0nYxro7tnsV_VEzpyFCvn5nVHPxFVJ6H_naNI4g,1926
+neuroshard/core/network/connection_pool.py,sha256=Bn1ZB_Cr6B2J481-zUikifqhGQR4PWw6Y5Iyg_DpoVc,2866
+neuroshard/core/network/dht.py,sha256=ubRZPOX7GbTtGQEAFsPxZzKml7eiZAkuJBIjE0vNUlQ,4262
+neuroshard/core/network/dht_plan.py,sha256=ra7KQ2oJnCFmFng6DA1SXKxcZz695iaGvYOPdKzyDd0,1670
+neuroshard/core/network/dht_proof_store.py,sha256=iHC1CCd3IonkPUCQkMhvE_9NgMHxjRUF1MEqzot9o88,23039
+neuroshard/core/network/dht_protocol.py,sha256=IM3mILEK9YD4bkJPpHsuj5XFdWPMycWGKQDwSnHlxvM,10325
+neuroshard/core/network/dht_service.py,sha256=qYn03Xf_dhQIVCssDhzdUHvBF6r-tBy1zCOT0ffG0j4,22353
+neuroshard/core/network/encrypted_channel.py,sha256=E_o34WSdE4HICVMomDnw-fAaexvKCjFcGUNwo3cNiEM,4560
+neuroshard/core/network/nat.py,sha256=Xv9d4pLVQGX_PtRk4qtopfr5rYH_ktY5MYVL3nZFxe0,8736
+neuroshard/core/network/nat_traversal.py,sha256=zHyVFfUaEpm7cOsCLDwQMP3qUbsXNmrW4enGVUGWXQw,23083
+neuroshard/core/network/p2p.py,sha256=CTXCEWZVhLDqSc3WQpHFCFtvlEoGj3zFDOK55dsIUUA,43473
+neuroshard/core/network/p2p_data.py,sha256=Tg1tYWxjhMe30zwPlaDlwUozFPOvieHUUphsfuQLXWQ,5794
+neuroshard/core/swarm/__init__.py,sha256=k-rS0ssUhNmzDnD-JWwh4EeIKcF-u9WxLf0d9cHQ5d8,3597
+neuroshard/core/swarm/aggregation.py,sha256=60SI-Vuiqv03AcNlVUOvVDJThcaYN46rOYBlrU4PxQ8,24614
+neuroshard/core/swarm/buffers.py,sha256=RT10848Q8EyUpIXRZXQHtAfNgIkq6IkyLqd41B-iOX0,21884
+neuroshard/core/swarm/checkpoint.py,sha256=veOgX3TmxXKt3NronSZ8dUG6S1FAxFcPzQkMQelMBCk,24494
+neuroshard/core/swarm/compute.py,sha256=FeDRTcwhS_hMM6cMjhp1Ev8zkZqLYzBqKSKiB3WaPQ4,22104
+neuroshard/core/swarm/diloco.py,sha256=Oav4ZUWresvbkJsZoAC7vsLkH5Qe3JFk5nFYbf1AhTA,29307
+neuroshard/core/swarm/factory.py,sha256=4knlYSThC-1SdJuHQP_rlzVQzcHVARljAtQGOCtaMng,52909
+neuroshard/core/swarm/heartbeat.py,sha256=VBn7HpwmxumJF7Sf-Z5D5kFrFJe_dYkLjpoHDctrBus,24190
+neuroshard/core/swarm/logger.py,sha256=Qkllfl0BtpBMRL9K72W3fkg8ylgHPmqMTfjHRXWRnug,15903
+neuroshard/core/swarm/router.py,sha256=X6hHzDVyMbkLN_Cm6TyXSRZQt13YwYC72fo-8anTVxQ,23794
+neuroshard/core/swarm/service.py,sha256=x9q5C1G8lPljds0ZlB-twX8IzwqwfTjW-jJJBrwbd6U,22625
+neuroshard/core/training/__init__.py,sha256=h5SdG90k2smX4SiFw63UlcKIHCYXJLqJizEfzQM3bms,1186
+neuroshard/core/training/checkpoint.py,sha256=wywkLTY1qktoxlI9P-B85l9CbYWTUIq52CEQIgf8vqw,20800
+neuroshard/core/training/distributed.py,sha256=Oqq4jrJxRffjY3Xm8wHu3S6DMfXVKL8YtcYWkIVuUec,65683
+neuroshard/core/training/global_tracker.py,sha256=BnCY9J_c6XReSysndgjncDhgnqaFuMbQNE2MyAAo3Kg,23341
+neuroshard/core/training/production.py,sha256=pZoWHccZznRkvD5ZChubjqd3QviOHz8qAKdFobo9NM4,9441
+neuroshard/sdk/__init__.py,sha256=qEd55d_DO4WuhgQQHuxEIB6bTlRwS-cA9lZmxRJs9GE,1844
+neuroshard/sdk/client.py,sha256=VnYfSeyMFAyHVAAyAru43CUty5KKx7_sp3sAoa55wPk,34307
+neuroshard/sdk/errors.py,sha256=kvHbo7Dtpb-PRRkUCCUxUr2EBLLDpOwEAhW1VGEbgyU,3309
+neuroshard/sdk/types.py,sha256=A5Wq-sbyTqyFamcDnagm8itgZfyURBUu-yFSIgC6DcI,6593
+neuroshard/tracker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+neuroshard/tracker/server.py,sha256=3X2Eo_FGk34OuePodTeK22Wkf3_Pu9um-xmWodGQWlE,33031
+neuroshard/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+neuroshard/ui/app.py,sha256=2yq3Z3aL0lXCD75Wh_oAdoCptZPHK9jBbSNkktfGMiI,2898
+neuroshard/ui/templates/index.html,sha256=hdCLGA3FDaALoa2M8WKWWeCSv5UH3Avlx6e17KrFkXc,54423
+neuroshard/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+neuroshard/utils/autostart.py,sha256=dy_eGvHODhZDzgz-7tWgDJmr7V-mIT9B9XO0zps6JfE,2509
+neuroshard/utils/hardware.py,sha256=VOMmk5Tc2LNx1lHWhsmcvcfC5BHnWX3z_ObK-50Y3Qw,3566
+neuroshard/utils/serialization.py,sha256=rVFqLzn2EErNzXDqbOUAdd7yRFR9VIeuG1Aox3-OwKA,3389
+nexaroa-0.0.111.dist-info/licenses/LICENSE,sha256=ELu7jtPExUAz8HqkYx5qleJDjBAVSC3TxEEob18Lecw,10756
+protos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+protos/neuroshard.proto,sha256=cIjQHEC8u4Ma7TIan5ZSWPd9R2jZhHgugMxXhUHZt_Y,19586
+protos/neuroshard_pb2.py,sha256=pNBe4e8x35xAtXQiJ7O04Vtm2PS9cYiv0mqdIRu01NM,25741
+protos/neuroshard_pb2_grpc.py,sha256=oxa3Cg3338Hyo4QJp4KONxVBM3vdxtklPQD3jcPq5G8,51472
+nexaroa-0.0.111.dist-info/METADATA,sha256=be2WDFl3aKF51XuA94aVYV1sNg9ZvTMvenkDMRIKsR8,10558
+nexaroa-0.0.111.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nexaroa-0.0.111.dist-info/entry_points.txt,sha256=UpgqEOj8YhHtIaXtvoGUvH_QQNsaFtFl51yEDjhTjQ0,144
+nexaroa-0.0.111.dist-info/top_level.txt,sha256=-iOU8F_mFPWif-RCEC3U2E8A_t0k0zDZxgV96W6RElo,18
+nexaroa-0.0.111.dist-info/RECORD,,

nexaroa-0.0.111.dist-info/WHEEL

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

nexaroa-0.0.111.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+neuroshard = neuroshard.cli:main
+neuroshard-governance = neuroshard.governance_cli:main
+neuroshard-node = neuroshard.cli:main