synaptoroute 0.1.0__py2.py3-none-any.whl

synaptoroute/__init__.py

@@ -0,0 +1,13 @@
+"""
+SynaptoRoute
+A high-throughput, local semantic routing engine.
+"""
+
+__version__ = "0.1.0"
+
+from synaptoroute.router import AdaptiveRouter
+from synaptoroute.encoder import Encoder
+from synaptoroute.storage import BaseStorage, SQLiteStorage
+from synaptoroute.models import Route
+
+__all__ = ["AdaptiveRouter", "Encoder", "BaseStorage", "SQLiteStorage", "Route", "__version__"]

synaptoroute/encoder.py

@@ -0,0 +1,25 @@
+import numpy as np
+import numpy.typing as npt
+from fastembed import TextEmbedding
+from typing import List
+
+class Encoder:
+    """
+    Handles local intent embeddings using fastembed ONNX models.
+    """
+    def __init__(self, model_name: str = "BAAI/bge-small-en-v1.5", providers: List[str] = None):
+        if providers is None:
+            providers = ["CPUExecutionProvider"]
+        self.model = TextEmbedding(model_name=model_name, providers=providers)
+    
+    def encode(self, text: str) -> npt.NDArray[np.float32]:
+        embeddings = list(self.model.embed([text]))
+        return embeddings[0]
+        
+    def encode_batch(self, texts: List[str]) -> npt.NDArray[np.float32]:
+        if not texts:
+            # Return empty array with correct shape for BGE models (384)
+            # If using another model, shape mismatches will be caught downstream
+            return np.empty((0, 384), dtype=np.float32)
+        embeddings = list(self.model.embed(texts))
+        return np.array(embeddings)

synaptoroute/exceptions.py

@@ -0,0 +1,15 @@
+class SynaptoRouteError(Exception):
+    """Base exception for SynaptoRoute."""
+    pass
+
+class RouteNotFoundError(SynaptoRouteError):
+    """Raised when a specified route cannot be found."""
+    pass
+
+class ModelLoadError(SynaptoRouteError):
+    """Raised when an embedding model fails to load."""
+    pass
+
+class RouterOverloadedError(SynaptoRouteError):
+    """Raised when the dynamic batching queue is full (DDoS protection)."""
+    pass

synaptoroute/models.py

@@ -0,0 +1,38 @@
+import json
+from typing import List, Optional, Dict, Any
+from pydantic import BaseModel, Field, field_validator, StringConstraints
+from typing_extensions import Annotated
+
+NonEmptyString = Annotated[str, StringConstraints(strip_whitespace=True, min_length=1)]
+
+class Route(BaseModel):
+    """
+    Represents a single semantic route or intent.
+    """
+    name: str = Field(..., min_length=1, pattern=r"^[a-zA-Z0-9_-]+$")
+    utterances: List[NonEmptyString] = Field(..., min_length=1)
+    threshold: float = Field(0.0, ge=-1.0, le=1.0)
+    metadata: Optional[Dict[str, Any]] = None
+
+    @field_validator('metadata')
+    @classmethod
+    def validate_metadata_serializable(cls, v: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+        if v is not None:
+            try:
+                json.dumps(v)
+            except (TypeError, ValueError) as e:
+                raise ValueError(f"Metadata must be JSON serializable: {e}")
+        return v
+
+    @field_validator('utterances')
+    @classmethod
+    def deduplicate_utterances(cls, v: List[str]) -> List[str]:
+        seen = set()
+        deduped = []
+        for utt in v:
+            if utt not in seen:
+                seen.add(utt)
+                deduped.append(utt)
+        if not deduped:
+            raise ValueError("Route must have at least one valid utterance.")
+        return deduped

synaptoroute/router.py

@@ -0,0 +1,271 @@
+import threading
+import numpy as np
+from sklearn.metrics.pairwise import cosine_similarity
+from sklearn.metrics import f1_score
+from typing import Optional
+import asyncio
+
+from synaptoroute.models import Route
+from synaptoroute.encoder import Encoder
+from synaptoroute.storage import BaseStorage
+from synaptoroute.exceptions import RouteNotFoundError, RouterOverloadedError
+
+class AdaptiveRouter:
+    def __init__(self, encoder: Encoder, storage: BaseStorage):
+        self.encoder = encoder
+        self.storage = storage
+        self.lock = threading.Lock()
+        
+        self._vectors = None
+        self._uncompiled_vectors = []
+        self._meta = []
+        self._route_map = {}
+        
+        self._batch_queue = None
+        self._worker_task = None
+        self.batch_size = 32
+        self.batch_timeout = 0.005
+        
+        self._load_routes()
+        
+    async def start(self):
+        self._batch_queue = asyncio.Queue(maxsize=10000)
+        self._worker_task = asyncio.create_task(self._batch_worker())
+
+    async def stop(self):
+        if self._worker_task:
+            self._worker_task.cancel()
+            try:
+                await self._worker_task
+            except asyncio.CancelledError:
+                pass
+
+    def _load_routes(self):
+        routes = self.storage.load_all_routes()
+        
+        for route in routes:
+            self._route_map[route.name] = route
+            if route.utterances:
+                embeddings = self.encoder.encode_batch(route.utterances)
+                self._uncompiled_vectors.append(embeddings)
+                self._meta.extend([route] * len(route.utterances))
+
+    def _rebuild_memory_locked(self):
+        self._vectors = None
+        self._uncompiled_vectors = []
+        self._meta = []
+        self._route_map = {}
+        self._load_routes()
+
+    def add_route(self, route: Route):
+        with self.lock:
+            is_overwrite = route.name in self._route_map
+            self.storage.save_route(route)
+            
+            if is_overwrite:
+                # O(1) Memory Replacement: Filter out the old route's vectors without full DB re-encoding
+                self._compile_vectors_locked()
+                if self._vectors is not None:
+                    mask = [r.name != route.name for r in self._meta]
+                    if len(mask) > 0:
+                        self._vectors = self._vectors[mask]
+                        self._meta = [r for r, keep in zip(self._meta, mask) if keep]
+            
+            self._route_map[route.name] = route
+            if route.utterances:
+                embeddings = self.encoder.encode_batch(route.utterances)
+                self._uncompiled_vectors.append(embeddings)
+                self._meta.extend([route] * len(route.utterances))
+
+    def add_utterance(self, route_name: str, utterance: str):
+        with self.lock:
+            if route_name not in self._route_map:
+                raise RouteNotFoundError(f"Route '{route_name}' not found.")
+                
+        # Reshape to 2D to ensure safe vstack compatibility
+        embedding = self.encoder.encode(utterance).reshape(1, -1)
+        
+        with self.lock:
+            self.storage.add_utterance(route_name, utterance)
+            self._uncompiled_vectors.append(embedding)
+            route = self._route_map[route_name]
+            route.utterances.append(utterance)
+            self._meta.append(route)
+
+    def _compile_vectors_locked(self):
+        if self._uncompiled_vectors:
+            if self._vectors is not None:
+                self._vectors = np.vstack([self._vectors] + self._uncompiled_vectors)
+            else:
+                self._vectors = np.vstack(self._uncompiled_vectors)
+            self._uncompiled_vectors = []
+
+    def __call__(self, query: str) -> Optional[Route]:
+        query_embedding = self.encoder.encode(query)
+        
+        with self.lock:
+            self._compile_vectors_locked()
+            
+            if self._vectors is None or len(self._vectors) == 0:
+                return None
+                
+            similarities = cosine_similarity([query_embedding], self._vectors)[0]
+            
+            best_route = None
+            best_score = -1.0
+            
+            for score, route in zip(similarities, self._meta):
+                if score >= route.threshold and score > best_score:
+                    best_score = score
+                    best_route = route
+                    
+            return best_route
+
+    async def aquery(self, query: str) -> Optional[Route]:
+        if self._batch_queue is None:
+            raise RuntimeError("Router must be started with `await router.start()` before calling aquery.")
+            
+        loop = asyncio.get_running_loop()
+        future = loop.create_future()
+        try:
+            self._batch_queue.put_nowait((query, future))
+        except asyncio.QueueFull:
+            raise RouterOverloadedError("Router queue is full (max 10000). Shedding load.")
+        return await future
+
+    async def _batch_worker(self):
+        try:
+            while True:
+                batch = []
+                try:
+                    item = await self._batch_queue.get()
+                    batch.append(item)
+                    
+                    while len(batch) < self.batch_size:
+                        try:
+                            item = await asyncio.wait_for(self._batch_queue.get(), timeout=self.batch_timeout)
+                            batch.append(item)
+                        except asyncio.TimeoutError:
+                            break
+                except asyncio.CancelledError:
+                    break
+                except Exception:
+                    continue
+
+                if not batch:
+                    continue
+
+                queries = [q for q, _ in batch]
+                futures = [f for _, f in batch]
+
+                try:
+                    def process_batch(qs):
+                        query_embeddings = self.encoder.encode_batch(qs)
+                        with self.lock:
+                            self._compile_vectors_locked()
+                            if self._vectors is None or len(self._vectors) == 0:
+                                return [None] * len(qs)
+                            similarities = cosine_similarity(query_embeddings, self._vectors)
+                            results = []
+                            for i in range(len(qs)):
+                                best_route = None
+                                best_score = -1.0
+                                for score, route in zip(similarities[i], self._meta):
+                                    if score >= route.threshold and score > best_score:
+                                        best_score = score
+                                        best_route = route
+                                results.append(best_route)
+                            return results
+
+                    results = await asyncio.to_thread(process_batch, queries)
+                    
+                    for future, result in zip(futures, results):
+                        if not future.done():
+                            future.set_result(result)
+                except asyncio.CancelledError:
+                    break
+                except Exception as e:
+                    for future in futures:
+                        if not future.done():
+                            future.set_exception(e)
+                finally:
+                    # Prevent async deadlocks by marking tasks done
+                    for _ in batch:
+                        self._batch_queue.task_done()
+        finally:
+            while not self._batch_queue.empty():
+                try:
+                    _, future = self._batch_queue.get_nowait()
+                    if not future.done():
+                        future.set_exception(asyncio.CancelledError("Router worker shutting down."))
+                except asyncio.QueueEmpty:
+                    break
+
+    def fit_thresholds(self, samples: list[str], labels: list[str]):
+        if not samples:
+            return
+        if len(samples) != len(labels):
+            raise ValueError("samples and labels lists must have the exact same length.")
+            
+        query_embeddings = self.encoder.encode_batch(samples)
+        
+        with self.lock:
+            self._compile_vectors_locked()
+            
+            if self._vectors is None or len(self._vectors) == 0:
+                return
+                
+            if not self._route_map:
+                return
+
+            vectors_snapshot = self._vectors
+            meta_snapshot = list(self._meta)
+            route_map_snapshot = dict(self._route_map)
+
+        similarities = cosine_similarity(query_embeddings, vectors_snapshot)
+        
+        best_routes = []
+        best_scores = []
+        
+        for i in range(len(samples)):
+            best_idx = np.argmax(similarities[i])
+            best_score = similarities[i][best_idx]
+            best_route = meta_snapshot[best_idx].name
+            best_routes.append(best_route)
+            best_scores.append(best_score)
+            
+        best_routes = np.array(best_routes)
+        best_scores = np.array(best_scores)
+        labels_arr = np.array(labels)
+        
+        # Test full cosine similarity range
+        thresholds_to_test = np.arange(-1.0, 1.05, 0.05)
+        new_thresholds = {}
+        
+        for route_name, route in route_map_snapshot.items():
+            best_f1 = -1.0
+            best_t = route.threshold
+            
+            y_true = (labels_arr == route_name).astype(int)
+            
+            for t in thresholds_to_test:
+                y_pred = ((best_routes == route_name) & (best_scores > t)).astype(int)
+                f1 = f1_score(y_true, y_pred, zero_division=0)
+                
+                if f1 >= best_f1:
+                    best_f1 = f1
+                    best_t = t
+            new_thresholds[route_name] = float(best_t)
+            
+        with self.lock:
+            for route_name, t in new_thresholds.items():
+                if route_name in self._route_map:
+                    route = self._route_map[route_name]
+                    old_t = route.threshold
+                    try:
+                        route.threshold = t
+                        self.storage.save_route(route)
+                    except Exception as e:
+                        route.threshold = old_t
+                        raise e
+

synaptoroute/storage.py

@@ -0,0 +1,139 @@
+import sqlite3
+import json
+import os
+from abc import ABC, abstractmethod
+from typing import List
+
+from synaptoroute.models import Route
+
+class BaseStorage(ABC):
+    @abstractmethod
+    def save_route(self, route: Route):
+        pass
+
+    @abstractmethod
+    def add_utterance(self, route_name: str, utterance: str):
+        pass
+
+    @abstractmethod
+    def load_all_routes(self) -> List[Route]:
+        pass
+
+class SQLiteStorage(BaseStorage):
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        dirname = os.path.dirname(self.db_path)
+        if dirname:
+            os.makedirs(dirname, exist_ok=True)
+        # timeout=10.0 handles 'database is locked' errors automatically with backoff
+        self.conn = sqlite3.connect(self.db_path, check_same_thread=False, timeout=10.0)
+        self.conn.execute('PRAGMA journal_mode=WAL;')
+        self.conn.execute('PRAGMA foreign_keys = ON')
+        self._init_db()
+
+    def close(self):
+        if self.conn:
+            self.conn.close()
+            self.conn = None
+
+    def __del__(self):
+        self.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def _get_connection(self):
+        return self.conn
+
+    def _init_db(self):
+        try:
+            with self._get_connection() as conn:
+                cursor = conn.cursor()
+                cursor.execute('''
+                    CREATE TABLE IF NOT EXISTS routes (
+                        name TEXT PRIMARY KEY,
+                        threshold REAL,
+                        metadata TEXT
+                    )
+                ''')
+                cursor.execute('''
+                    CREATE TABLE IF NOT EXISTS utterances (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        route_name TEXT,
+                        utterance TEXT,
+                        FOREIGN KEY(route_name) REFERENCES routes(name) ON DELETE CASCADE,
+                        UNIQUE(route_name, utterance)
+                    )
+                ''')
+                conn.commit()
+        except (sqlite3.OperationalError, sqlite3.IntegrityError, sqlite3.DatabaseError) as e:
+            raise RuntimeError(f"Failed to initialize database: {e}") from e
+
+    def save_route(self, route: Route):
+        try:
+            with self._get_connection() as conn:
+                cursor = conn.cursor()
+                metadata_str = json.dumps(route.metadata) if route.metadata is not None else None
+                
+                # Insert or replace route
+                cursor.execute('''
+                    INSERT OR REPLACE INTO routes (name, threshold, metadata)
+                    VALUES (?, ?, ?)
+                ''', (route.name, route.threshold, metadata_str))
+                
+                # Delete existing utterances for this route to avoid duplicates on replace
+                cursor.execute('''
+                    DELETE FROM utterances WHERE route_name = ?
+                ''', (route.name,))
+                
+                # Insert utterances
+                if route.utterances:
+                    cursor.executemany('''
+                        INSERT OR IGNORE INTO utterances (route_name, utterance)
+                        VALUES (?, ?)
+                    ''', [(route.name, u) for u in route.utterances])
+                    
+                conn.commit()
+        except (sqlite3.OperationalError, sqlite3.IntegrityError, sqlite3.DatabaseError) as e:
+            raise RuntimeError(f"Failed to save route: {e}") from e
+
+    def add_utterance(self, route_name: str, utterance: str):
+        try:
+            with self._get_connection() as conn:
+                cursor = conn.cursor()
+                cursor.execute('''
+                    INSERT OR IGNORE INTO utterances (route_name, utterance)
+                    VALUES (?, ?)
+                ''', (route_name, utterance))
+                conn.commit()
+        except (sqlite3.OperationalError, sqlite3.IntegrityError, sqlite3.DatabaseError) as e:
+            raise RuntimeError(f"Failed to add utterance: {e}") from e
+
+    def load_all_routes(self) -> List[Route]:
+        routes = []
+        try:
+            with self._get_connection() as conn:
+                cursor = conn.cursor()
+                cursor.execute('SELECT name, threshold, metadata FROM routes')
+                route_rows = cursor.fetchall()
+                
+                for row in route_rows:
+                    name, threshold, metadata_str = row
+                    metadata = json.loads(metadata_str) if metadata_str else None
+                    
+                    cursor.execute('SELECT utterance FROM utterances WHERE route_name = ?', (name,))
+                    utterance_rows = cursor.fetchall()
+                    utterances = [u[0] for u in utterance_rows]
+                    
+                    routes.append(Route(
+                        name=name,
+                        threshold=threshold,
+                        metadata=metadata,
+                        utterances=utterances
+                    ))
+        except (sqlite3.OperationalError, sqlite3.IntegrityError, sqlite3.DatabaseError) as e:
+            raise RuntimeError(f"Failed to load routes: {e}") from e
+        return routes

synaptoroute-0.1.0.dist-info/METADATA

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: synaptoroute
+Version: 0.1.0
+Summary: A dynamic zero-token semantic router
+Project-URL: Repository, https://github.com/sitanshukr08/SynaptoRoute
+Project-URL: Issues, https://github.com/sitanshukr08/SynaptoRoute/issues
+Author-email: Sitanshu <contact@example.com>
+License: MIT
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Dist: fastembed>=0.8.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: pydantic>=2.10.0
+Requires-Dist: scikit-learn>=1.3.0
+Provides-Extra: api
+Requires-Dist: fastapi>=0.100.0; extra == 'api'
+Requires-Dist: uvicorn>=0.22.0; extra == 'api'
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# SynaptoRoute
+
+[![PyPI version](https://badge.fury.io/py/synaptoroute.svg)](https://pypi.org/project/synaptoroute/)
+[![CI/CD Pipeline](https://github.com/sitanshukr08/SynaptoRoute/actions/workflows/ci.yml/badge.svg)](https://github.com/sitanshukr08/SynaptoRoute/actions)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![FastAPI](https://img.shields.io/badge/FastAPI-0.100+-green.svg)](https://fastapi.tiangolo.com)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/sitanshukr08/SynaptoRoute/blob/main/CONTRIBUTING.md)
+
+SynaptoRoute is a high-throughput, local semantic routing engine built for production Python microservices. Designed as a mathematically optimal alternative to Large Language Model (LLM) routing chains and slower local routers, it provides zero-token intent classification in under 3 milliseconds on standard cloud hardware.
+
+## Table of Contents
+- [Why SynaptoRoute?](#why-synaptoroute)
+- [Architecture & Optimizations](#architecture--optimizations)
+- [Performance Benchmarks](#performance-benchmarks)
+- [Installation & Deployment](#installation--deployment)
+- [Quick Start Guide](#quick-start-guide)
+- [System Limitations](#system-limitations)
+- [Community & Contributing](#community--contributing)
+
+---
+
+## Why SynaptoRoute?
+
+In modern agentic systems, relying on an external API (like OpenAI or Anthropic) to make simple routing decisions—such as determining if a user wants to reset their password or check their balance—introduces unacceptable latency (300ms+) and high token costs.
+
+SynaptoRoute solves this by executing intent classification entirely locally using INT8 quantized vector embeddings. 
+
+SynaptoRoute was engineered specifically to solve the $O(N)$ memory degradation problem during live hot-reloading and to maximize hardware utilization via asynchronous dynamic batching.
+
+## Architecture & Optimizations
+
+### 1. Lazy Memory Compilation
+Traditional routers suffer from severe performance degradation during live updates. When a new route is added, they execute an immediate `numpy.vstack`, copying the entire vector array in memory ($O(N)$ complexity). SynaptoRoute defers this reallocation, appending new vectors to a lightweight list ($O(1)$) and only executing the heavy compilation precisely when the next query arrives, preventing server freezes.
+
+### 2. Dynamic Asynchronous Batching
+Hardware accelerators (GPUs, AVX512 CPUs) are optimized for large matrix multiplications. Sending single queries sequentially incurs massive transfer overhead. SynaptoRoute utilizes a background `asyncio.Queue` worker that traps parallel HTTP requests, waits 5 milliseconds, groups them into a batch, and processes them in a single hardware cycle.
+
+### 3. INT8 Quantization
+By default, SynaptoRoute leverages the `BAAI/bge-small-en-v1.5` model quantized to 8-bit integers via the ONNX runtime, slashing memory bandwidth requirements by 4x and maximizing CPU cache utilization.
+
+---
+
+## Performance Benchmarks
+
+The following metrics were captured via automated GitHub Actions CI/CD running on a standard, unaccelerated `ubuntu-latest` 2-core cloud CPU.
+
+| Metric | Cloud CPU Latency | Context |
+| :--- | :--- | :--- |
+| **Inference P99** | 3.94 ms | Single sequential query latency. |
+| **Amortized P50** | 2.69 ms | Per-query latency when processing 1,000 concurrent requests via dynamic batching. |
+| **Hot-Reload** | 5.04 ms | Time required to dynamically inject a new utterance into memory without dropping active API requests. |
+
+> **📊 View Full Benchmarks:** For detailed analysis including Memory Leak Endurance, GPU Scaling, Classification F1-Scores, and Input Poisoning Survival Metrics, see our official [BENCHMARKS.md](BENCHMARKS.md).
+
+---
+
+## Installation & Deployment
+
+### Method 1: Docker REST API (Recommended)
+
+SynaptoRoute ships with a fully asynchronous FastAPI wrapper, designed for immediate drop-in deployment as a scalable microservice.
+
+```bash
+# Build the Docker image
+docker build -t synaptoroute .
+
+# Run the container
+docker run -p 8000:8000 synaptoroute
+```
+
+You can interface with the router immediately:
+```bash
+curl -X POST http://localhost:8000/route \
+     -H "Content-Type: application/json" \
+     -d '{"query": "I need help resetting my password"}'
+```
+
+### Method 2: Standard Python Package
+
+To embed SynaptoRoute natively into your existing Python pipelines, install directly from pip (or via git if testing the latest main branch):
+
+```bash
+pip install synaptoroute
+```
+
+---
+
+## Quick Start Guide
+
+```python
+import asyncio
+from synaptoroute.router import AdaptiveRouter
+from synaptoroute.encoder import Encoder
+from synaptoroute.storage import SQLiteStorage
+from synaptoroute.models import Route
+
+async def main():
+    # 1. Initialize Components
+    encoder = Encoder()
+    storage = SQLiteStorage("data/memory.sqlite")
+    router = AdaptiveRouter(encoder, storage)
+    
+    # 2. Define Routes
+    billing_route = Route(
+        name="billing", 
+        utterances=["I need a refund", "Where is my receipt?", "Cancel my subscription"]
+    )
+    router.add_route(billing_route)
+    
+    # 3. Start the Background Batching Worker
+    await router.start()
+    
+    # 4. Execute Async Queries
+    result = await router.aquery("How do I get my money back?")
+    print(f"Matched Intent: {result.name}") # Output: billing
+    
+    # 5. Graceful Shutdown
+    await router.stop()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+---
+
+## System Limitations
+
+**Horizontal Scaling (Kubernetes Split-Brain)**  
+SynaptoRoute relies on a highly optimized, local in-memory NumPy matrix to achieve its microsecond latency. As such, it is structurally bound to a single node. If deployed across multiple load-balanced Kubernetes pods, a hot-reload request hitting Pod A will update Pod A's local memory, but Pod B will remain unaware. Scaling horizontally requires implementing an external event bus (e.g., Redis Pub/Sub) to broadcast memory invalidation events across the cluster.
+
+---
+
+## Community & Contributing
+
+We welcome contributions of all sizes from the open-source community! 
+
+- **Contributing:** Please read our [Contributing Guidelines](CONTRIBUTING.md) to learn how to set up your development environment, run the test suite, and submit Pull Requests.
+- **Code of Conduct:** We are committed to fostering a welcoming environment. Please review our [Code of Conduct](CODE_OF_CONDUCT.md).
+- **Issues:** If you discover a bug or have a feature request, please [open an issue](https://github.com/sitanshukr08/SynaptoRoute/issues).

synaptoroute-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+synaptoroute/__init__.py,sha256=98YLN8Z0eUBeCUJdUKg86vgeKzy8SsC8qkK8ueaZYU0,378
+synaptoroute/encoder.py,sha256=vMce67SQTZOULezwNslNeCTn8yBvQqXSb9jJ3ohL4fs,1005
+synaptoroute/exceptions.py,sha256=YsJBgWxydamLpPwlejBx9PiVIDHwX2Hdfy1HPcTQmkE,441
+synaptoroute/models.py,sha256=MmnFKf4yL2MtBCWuDah0jZvlQ1YMcr7uZ8jvjtz-t9c,1355
+synaptoroute/router.py,sha256=hg69-8UBLv4Rn1SW1MDhQerB1sRvOV0cWJFh7HbICHY,10485
+synaptoroute/storage.py,sha256=R-0W2qEMokob67u1HJ7VokK6-hezZw6l9gHTfcZWStw,5289
+synaptoroute-0.1.0.dist-info/METADATA,sha256=dgoDsFi7ado1X4FFQJex0vDS5Xkvi6O15IeRugssAAo,7612
+synaptoroute-0.1.0.dist-info/WHEEL,sha256=e22IIVjxDyt0lABi4WpktFIGsmO_ebSDXLnPUbPK0E0,105
+synaptoroute-0.1.0.dist-info/licenses/LICENSE,sha256=d26nZSImxopcsPU80VczjSvLRycVXMT4JbaqbHB8TGo,1065
+synaptoroute-0.1.0.dist-info/RECORD,,

synaptoroute-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any

synaptoroute-0.1.0.dist-info/licenses/LICENSE

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