semantic-router 0.1.0.dev6__tar.gz → 0.1.0.dev8__tar.gz

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: semantic-router
-Version: 0.1.0.dev6
+Version: 0.1.0.dev8
 Summary: Super fast semantic router for AI decision making
 License: MIT
 Author: Aurelio AI

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "semantic-router"
-version = "0.1.0.dev6"
+version = "0.1.0.dev8"
 description = "Super fast semantic router for AI decision making"
 authors = ["Aurelio AI <hello@aurelio.ai>"]
 readme = "README.md"

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/__init__.py

@@ -1,6 +1,6 @@
-from semantic_router.routers import RouterConfig, SemanticRouter, HybridRouter
 from semantic_router.route import Route
+from semantic_router.routers import HybridRouter, RouterConfig, SemanticRouter
 
 __all__ = ["SemanticRouter", "HybridRouter", "Route", "RouterConfig"]
 
-__version__ = "0.1.0.dev6"
+__version__ = "0.1.0.dev8"

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/encoders/__init__.py

@@ -8,8 +8,7 @@ from semantic_router.encoders.clip import CLIPEncoder
 from semantic_router.encoders.cohere import CohereEncoder
 from semantic_router.encoders.fastembed import FastEmbedEncoder
 from semantic_router.encoders.google import GoogleEncoder
-from semantic_router.encoders.huggingface import HuggingFaceEncoder
-from semantic_router.encoders.huggingface import HFEndpointEncoder
+from semantic_router.encoders.huggingface import HFEndpointEncoder, HuggingFaceEncoder
 from semantic_router.encoders.mistral import MistralEncoder
 from semantic_router.encoders.openai import OpenAIEncoder
 from semantic_router.encoders.tfidf import TfidfEncoder

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/encoders/aurelio.py

@@ -1,8 +1,8 @@
 import os
 from typing import Any, List, Optional
-from pydantic import Field
 
-from aurelio_sdk import AurelioClient, AsyncAurelioClient, EmbeddingResponse
+from aurelio_sdk import AsyncAurelioClient, AurelioClient, EmbeddingResponse
+from pydantic import Field
 
 from semantic_router.encoders.base import SparseEncoder
 from semantic_router.schema import SparseEmbedding

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/encoders/bedrock.py

@@ -17,10 +17,12 @@ Classes:
 """
 
 import json
-from typing import Dict, List, Optional, Any, Union
 import os
 from time import sleep
+from typing import Any, Dict, List, Optional, Union
+
 import tiktoken
+
 from semantic_router.encoders import DenseEncoder
 from semantic_router.utils.defaults import EncoderDefault
 from semantic_router.utils.logger import logger

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/encoders/clip.py

@@ -1,8 +1,8 @@
-from typing import Any, List, Optional
+from typing import Any, Dict, List, Optional
 
 import numpy as np
 from pydantic import PrivateAttr
-from typing import Dict
+
 from semantic_router.encoders import DenseEncoder
 
 

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/encoders/huggingface.py

@@ -20,11 +20,11 @@ Classes:
     HFEndpointEncoder: A class for generating embeddings using a Huggingface endpoint.
 """
 
-import requests
-import time
 import os
-from typing import Any, List, Optional, Dict
+import time
+from typing import Any, Dict, List, Optional
 
+import requests
 from pydantic import PrivateAttr
 
 from semantic_router.encoders import DenseEncoder

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/encoders/openai.py

@@ -1,21 +1,20 @@
-from asyncio import sleep as asleep
 import os
+from asyncio import sleep as asleep
 from time import sleep
 from typing import Any, List, Optional, Union
-from pydantic import PrivateAttr
 
 import openai
+import tiktoken
 from openai import OpenAIError
 from openai._types import NotGiven
 from openai.types import CreateEmbeddingResponse
-import tiktoken
+from pydantic import PrivateAttr
 
 from semantic_router.encoders import DenseEncoder
 from semantic_router.schema import EncoderInfo
 from semantic_router.utils.defaults import EncoderDefault
 from semantic_router.utils.logger import logger
 
-
 model_configs = {
     "text-embedding-ada-002": EncoderInfo(
         name="text-embedding-ada-002",

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/index/base.py

@@ -1,17 +1,16 @@
 import asyncio
-from datetime import datetime
-import time
-from typing import Any, List, Optional, Tuple, Union, Dict
 import json
+import time
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 import numpy as np
 from pydantic import BaseModel
 
-from semantic_router.schema import ConfigParameter, SparseEmbedding, Utterance
 from semantic_router.route import Route
+from semantic_router.schema import ConfigParameter, SparseEmbedding, Utterance
 from semantic_router.utils.logger import logger
 
-
 RETRY_WAIT_TIME = 2.5
 
 

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/index/hybrid_local.py

@@ -1,12 +1,11 @@
-from typing import List, Optional, Tuple, Dict
+from typing import Any, Dict, List, Optional, Tuple
 
 import numpy as np
 from numpy.linalg import norm
 
-from semantic_router.schema import ConfigParameter, SparseEmbedding, Utterance
 from semantic_router.index.local import LocalIndex
+from semantic_router.schema import ConfigParameter, SparseEmbedding, Utterance
 from semantic_router.utils.logger import logger
-from typing import Any
 
 
 class HybridLocalIndex(LocalIndex):

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/index/local.py

@@ -1,12 +1,11 @@
-from typing import List, Optional, Tuple, Dict
+from typing import Any, Dict, List, Optional, Tuple
 
 import numpy as np
 
-from semantic_router.schema import ConfigParameter, SparseEmbedding, Utterance
 from semantic_router.index.base import BaseIndex, IndexConfig
 from semantic_router.linear import similarity_matrix, top_scores
+from semantic_router.schema import ConfigParameter, SparseEmbedding, Utterance
 from semantic_router.utils.logger import logger
-from typing import Any
 
 
 class LocalIndex(BaseIndex):

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/index/pinecone.py

@@ -1,12 +1,11 @@
-import aiohttp
 import asyncio
 import hashlib
+import json
 import os
 import time
-import json
-
-from typing import Any, Dict, List, Optional, Union, Tuple
+from typing import Any, Dict, List, Optional, Tuple, Union
 
+import aiohttp
 import numpy as np
 from pydantic import BaseModel, Field
 
@@ -112,11 +111,11 @@ class PineconeIndex(BaseIndex):
     region: str = "us-east-1"
     host: str = ""
     client: Any = Field(default=None, exclude=True)
-    async_client: Any = Field(default=None, exclude=True)
     index: Optional[Any] = Field(default=None, exclude=True)
     ServerlessSpec: Any = Field(default=None, exclude=True)
     namespace: Optional[str] = ""
     base_url: Optional[str] = "https://api.pinecone.io"
+    headers: dict[str, str] = {}
 
     def __init__(
         self,
@@ -132,6 +131,15 @@ class PineconeIndex(BaseIndex):
         init_async_index: bool = False,
     ):
         super().__init__()
+        self.api_key = api_key or os.getenv("PINECONE_API_KEY")
+        if not self.api_key:
+            raise ValueError("Pinecone API key is required.")
+        self.headers = {
+            "Api-Key": self.api_key,
+            "Content-Type": "application/json",
+            "X-Pinecone-API-Version": "2024-07",
+            "User-Agent": "source_tag=semanticrouter",
+        }
         self.index_name = index_name
         self.dimensions = dimensions
         self.metric = metric
@@ -153,10 +161,7 @@ class PineconeIndex(BaseIndex):
             raise ValueError("Pinecone API key is required.")
 
         self.client = self._initialize_client(api_key=self.api_key)
-        if init_async_index:
-            self.async_client = self._initialize_async_client(api_key=self.api_key)
-        else:
-            self.async_client = None
+
         # try initializing index
         self.index = self._init_index()
 
@@ -181,20 +186,6 @@ class PineconeIndex(BaseIndex):
 
         return Pinecone(**pinecone_args)
 
-    def _initialize_async_client(self, api_key: Optional[str] = None):
-        api_key = api_key or self.api_key
-        if api_key is None:
-            raise ValueError("Pinecone API key is required.")
-        async_client = aiohttp.ClientSession(
-            headers={
-                "Api-Key": api_key,
-                "Content-Type": "application/json",
-                "X-Pinecone-API-Version": "2024-07",
-                "User-Agent": "source_tag=semanticrouter",
-            }
-        )
-        return async_client
-
     def _init_index(self, force_create: bool = False) -> Union[Any, None]:
         """Initializing the index can be done after the object has been created
         to allow for the user to set the dimensions and other parameters.
@@ -659,8 +650,8 @@ class PineconeIndex(BaseIndex):
         :rtype: Tuple[np.ndarray, List[str]]
         :raises ValueError: If the index is not populated.
         """
-        if self.async_client is None or self.host == "":
-            raise ValueError("Async client or host are not initialized.")
+        if self.host == "":
+            raise ValueError("Host is not initialized.")
         query_vector_list = vector.tolist()
         if route_filter is not None:
             filter_query = {"sr_route": {"$in": route_filter}}
@@ -693,8 +684,8 @@ class PineconeIndex(BaseIndex):
         :return: A list of (route_name, utterance) objects.
         :rtype: List[Tuple]
         """
-        if self.async_client is None or self.host == "":
-            raise ValueError("Async client or host are not initialized.")
+        if self.host == "":
+            raise ValueError("Host is not initialized.")
 
         return await self._async_get_routes()
 
@@ -722,15 +713,21 @@ class PineconeIndex(BaseIndex):
         }
         if self.host == "":
             raise ValueError("self.host is not initialized.")
-        async with self.async_client.post(
-            f"https://{self.host}/query",
-            json=params,
-        ) as response:
-            return await response.json(content_type=None)
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"https://{self.host}/query",
+                json=params,
+                headers=self.headers,
+            ) as response:
+                return await response.json(content_type=None)
 
     async def _async_list_indexes(self):
-        async with self.async_client.get(f"{self.base_url}/indexes") as response:
-            return await response.json(content_type=None)
+        async with aiohttp.ClientSession() as session:
+            async with session.get(
+                f"{self.base_url}/indexes",
+                headers=self.headers,
+            ) as response:
+                return await response.json(content_type=None)
 
     async def _async_upsert(
         self,
@@ -741,12 +738,14 @@ class PineconeIndex(BaseIndex):
             "vectors": vectors,
             "namespace": namespace,
         }
-        async with self.async_client.post(
-            f"https://{self.host}/vectors/upsert",
-            json=params,
-        ) as response:
-            res = await response.json(content_type=None)
-            return res
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"https://{self.host}/vectors/upsert",
+                json=params,
+                headers=self.headers,
+            ) as response:
+                res = await response.json(content_type=None)
+                return res
 
     async def _async_create_index(
         self,
@@ -762,26 +761,34 @@ class PineconeIndex(BaseIndex):
             "metric": metric,
             "spec": {"serverless": {"cloud": cloud, "region": region}},
         }
-        async with self.async_client.post(
-            f"{self.base_url}/indexes",
-            json=params,
-        ) as response:
-            return await response.json(content_type=None)
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{self.base_url}/indexes",
+                json=params,
+                headers=self.headers,
+            ) as response:
+                return await response.json(content_type=None)
 
     async def _async_delete(self, ids: list[str], namespace: str = ""):
         params = {
             "ids": ids,
             "namespace": namespace,
         }
-        async with self.async_client.post(
-            f"https://{self.host}/vectors/delete",
-            json=params,
-        ) as response:
-            return await response.json(content_type=None)
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"https://{self.host}/vectors/delete",
+                json=params,
+                headers=self.headers,
+            ) as response:
+                return await response.json(content_type=None)
 
     async def _async_describe_index(self, name: str):
-        async with self.async_client.get(f"{self.base_url}/indexes/{name}") as response:
-            return await response.json(content_type=None)
+        async with aiohttp.ClientSession() as session:
+            async with session.get(
+                f"{self.base_url}/indexes/{name}",
+                headers=self.headers,
+            ) as response:
+                return await response.json(content_type=None)
 
     async def _async_get_all(
         self, prefix: Optional[str] = None, include_metadata: bool = False
@@ -815,33 +822,38 @@ class PineconeIndex(BaseIndex):
             params["namespace"] = self.namespace
         metadata = []
 
-        while True:
-            if next_page_token:
-                params["paginationToken"] = next_page_token
-
-            async with self.async_client.get(
-                list_url, params=params, headers={"Api-Key": self.api_key}
-            ) as response:
-                if response.status != 200:
-                    error_text = await response.text()
-                    logger.error(f"Error fetching vectors: {error_text}")
+        async with aiohttp.ClientSession() as session:
+            while True:
+                if next_page_token:
+                    params["paginationToken"] = next_page_token
+
+                async with session.get(
+                    list_url,
+                    params=params,
+                    headers=self.headers,
+                ) as response:
+                    if response.status != 200:
+                        error_text = await response.text()
+                        logger.error(f"Error fetching vectors: {error_text}")
+                        break
+
+                    response_data = await response.json(content_type=None)
+
+                vector_ids = [vec["id"] for vec in response_data.get("vectors", [])]
+                if not vector_ids:
                     break
+                all_vector_ids.extend(vector_ids)
 
-                response_data = await response.json(content_type=None)
+                if include_metadata:
+                    metadata_tasks = [
+                        self._async_fetch_metadata(id) for id in vector_ids
+                    ]
+                    metadata_results = await asyncio.gather(*metadata_tasks)
+                    metadata.extend(metadata_results)
 
-            vector_ids = [vec["id"] for vec in response_data.get("vectors", [])]
-            if not vector_ids:
-                break
-            all_vector_ids.extend(vector_ids)
-
-            if include_metadata:
-                metadata_tasks = [self._async_fetch_metadata(id) for id in vector_ids]
-                metadata_results = await asyncio.gather(*metadata_tasks)
-                metadata.extend(metadata_results)
-
-            next_page_token = response_data.get("pagination", {}).get("next")
-            if not next_page_token:
-                break
+                next_page_token = response_data.get("pagination", {}).get("next")
+                if not next_page_token:
+                    break
 
         return all_vector_ids, metadata
 
@@ -851,7 +863,7 @@ class PineconeIndex(BaseIndex):
         namespace: str | None = None,
     ) -> dict:
         """Fetch metadata for a single vector ID asynchronously using the
-        async_client.
+        ClientSession.
 
         :param vector_id: The ID of the vector to fetch metadata for.
         :type vector_id: str
@@ -873,27 +885,26 @@ class PineconeIndex(BaseIndex):
         elif self.namespace:
             params["namespace"] = [self.namespace]
 
-        headers = {
-            "Api-Key": self.api_key,
-        }
-
-        async with self.async_client.get(
-            url, params=params, headers=headers
-        ) as response:
-            if response.status != 200:
-                error_text = await response.text()
-                logger.error(f"Error fetching metadata: {error_text}")
-                return {}
-
-            try:
-                response_data = await response.json(content_type=None)
-            except Exception as e:
-                logger.warning(f"No metadata found for vector {vector_id}: {e}")
-                return {}
-
-            return (
-                response_data.get("vectors", {}).get(vector_id, {}).get("metadata", {})
-            )
+        async with aiohttp.ClientSession() as session:
+            async with session.get(
+                url, params=params, headers=self.headers
+            ) as response:
+                if response.status != 200:
+                    error_text = await response.text()
+                    logger.error(f"Error fetching metadata: {error_text}")
+                    return {}
+
+                try:
+                    response_data = await response.json(content_type=None)
+                except Exception as e:
+                    logger.warning(f"No metadata found for vector {vector_id}: {e}")
+                    return {}
+
+                return (
+                    response_data.get("vectors", {})
+                    .get(vector_id, {})
+                    .get("metadata", {})
+                )
 
     def __len__(self):
         namespace_stats = self.index.describe_index_stats()["namespaces"].get(

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/index/postgres.py

@@ -1,7 +1,7 @@
 import os
 import uuid
 from enum import Enum
-from typing import Any, Dict, List, Optional, Tuple, TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
 
 import numpy as np
 from pydantic import BaseModel, Field

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/llms/base.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, List, Optional, Dict
+from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel
 

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/llms/llamacpp.py

@@ -1,6 +1,6 @@
 from contextlib import contextmanager
 from pathlib import Path
-from typing import Any, Optional, List, Dict
+from typing import Any, Dict, List, Optional
 
 from pydantic import PrivateAttr
 

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/llms/openai.py

@@ -1,24 +1,24 @@
+import inspect
+import json
 import os
-from typing import List, Optional, Any, Callable, Dict, Union
-from pydantic import PrivateAttr
+import re
+from typing import Any, Callable, Dict, List, Optional, Union
 
 import openai
-from openai._types import NotGiven, NOT_GIVEN
+from openai._types import NOT_GIVEN, NotGiven
+from openai.types.chat.chat_completion_message_tool_call import (
+    ChatCompletionMessageToolCall,
+)
+from pydantic import PrivateAttr
 
 from semantic_router.llms import BaseLLM
 from semantic_router.schema import Message
 from semantic_router.utils.defaults import EncoderDefault
-from semantic_router.utils.logger import logger
-import json
 from semantic_router.utils.function_call import (
-    get_schema,
     convert_python_type_to_json_type,
+    get_schema,
 )
-import inspect
-import re
-from openai.types.chat.chat_completion_message_tool_call import (
-    ChatCompletionMessageToolCall,
-)
+from semantic_router.utils.logger import logger
 
 
 class OpenAILLM(BaseLLM):

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/llms/openrouter.py

@@ -1,9 +1,8 @@
 import os
 from typing import List, Optional
 
-from pydantic import PrivateAttr
-
 import openai
+from pydantic import PrivateAttr
 
 from semantic_router.llms import BaseLLM
 from semantic_router.schema import Message

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/routers/base.py

@@ -1,15 +1,15 @@
+import hashlib
 import importlib
 import json
 import os
 import random
-import hashlib
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
-from typing_extensions import deprecated
-from pydantic import BaseModel, Field
 
 import numpy as np
 import yaml  # type: ignore
+from pydantic import BaseModel, Field
 from tqdm.auto import tqdm
+from typing_extensions import deprecated
 
 from semantic_router.encoders import (
     AutoEncoder,
@@ -1343,11 +1343,15 @@ class BaseRouter(BaseModel):
             # Switch to a local index for fitting
             from semantic_router.index.local import LocalIndex
 
-            remote_routes = self.index.get_utterances(include_metadata=True)
+            remote_utterances = self.index.get_utterances(include_metadata=True)
             # TODO Enhance by retrieving directly the vectors instead of embedding all utterances again
-            routes, utterances, function_schemas, metadata = map(
-                list, zip(*remote_routes)
-            )
+            routes = []
+            utterances = []
+            metadata = []
+            for utterance in remote_utterances:
+                routes.append(utterance.route)
+                utterances.append(utterance.utterance)
+                metadata.append(utterance.metadata)
             embeddings = self.encoder(utterances)
             self.index = LocalIndex()
             self.index.add(

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/routers/hybrid.py

@@ -1,22 +1,22 @@
-from typing import Any, Dict, List, Optional, Union
-from tqdm.auto import tqdm
 import asyncio
-from pydantic import Field
+from typing import Any, Dict, List, Optional, Union
 
 import numpy as np
+from pydantic import Field
+from tqdm.auto import tqdm
 
 from semantic_router.encoders import (
+    BM25Encoder,
     DenseEncoder,
     SparseEncoder,
-    BM25Encoder,
     TfidfEncoder,
 )
-from semantic_router.route import Route
 from semantic_router.index import BaseIndex, HybridLocalIndex
+from semantic_router.llms import BaseLLM
+from semantic_router.route import Route
+from semantic_router.routers.base import BaseRouter, threshold_random_search, xq_reshape
 from semantic_router.schema import RouteChoice, SparseEmbedding, Utterance
 from semantic_router.utils.logger import logger
-from semantic_router.routers.base import BaseRouter, xq_reshape, threshold_random_search
-from semantic_router.llms import BaseLLM
 
 
 class HybridRouter(BaseRouter):
@@ -286,11 +286,15 @@ class HybridRouter(BaseRouter):
             # Switch to a local index for fitting
             from semantic_router.index.hybrid_local import HybridLocalIndex
 
-            remote_routes = self.index.get_utterances(include_metadata=True)
+            remote_utterances = self.index.get_utterances(include_metadata=True)
             # TODO Enhance by retrieving directly the vectors instead of embedding all utterances again
-            routes, utterances, function_schemas, metadata = map(
-                list, zip(*remote_routes)
-            )
+            routes = []
+            utterances = []
+            metadata = []
+            for utterance in remote_utterances:
+                routes.append(utterance.route)
+                utterances.append(utterance.utterance)
+                metadata.append(utterance.metadata)
             embeddings = self.encoder(utterances)
             sparse_embeddings = self.sparse_encoder(utterances)
             self.index = HybridLocalIndex()

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/schema.py

@@ -1,12 +1,14 @@
+import json
 from datetime import datetime, timezone
 from difflib import Differ
 from enum import Enum
-import json
+from typing import Any, Dict, List, Optional, Tuple, Union
+
 import numpy as np
-from typing import List, Optional, Union, Any, Dict, Tuple
+from aurelio_sdk.schema import BM25Embedding
 from pydantic import BaseModel, Field
+
 from semantic_router.utils.logger import logger
-from aurelio_sdk.schema import BM25Embedding
 
 
 class EncoderType(Enum):

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/utils/function_call.py

@@ -1,12 +1,11 @@
 import inspect
 from typing import Any, Callable, Dict, List, Optional, Union
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from semantic_router.llms import BaseLLM
 from semantic_router.schema import Message, RouteChoice
 from semantic_router.utils.logger import logger
-from pydantic import Field
 
 
 class Parameter(BaseModel):

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/encoders/base.py

@@ -1,7 +1,7 @@
 from typing import Any, Coroutine, List, Optional
 
-from pydantic import BaseModel, Field, field_validator
 import numpy as np
+from pydantic import BaseModel, Field, field_validator
 
 from semantic_router.schema import SparseEmbedding
 

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/encoders/bm25.py

@@ -1,9 +1,9 @@
 from typing import Any, Dict, List, Optional
 
 from semantic_router.encoders.tfidf import TfidfEncoder
-from semantic_router.utils.logger import logger
-from semantic_router.schema import SparseEmbedding
 from semantic_router.route import Route
+from semantic_router.schema import SparseEmbedding
+from semantic_router.utils.logger import logger
 
 
 class BM25Encoder(TfidfEncoder):

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/encoders/zure.py

@@ -1,11 +1,11 @@
-from asyncio import sleep as asleep
 import os
+from asyncio import sleep as asleep
 from time import sleep
 from typing import List, Optional, Union
 
 import openai
-from openai._types import NotGiven
 from openai import OpenAIError
+from openai._types import NotGiven
 from openai.types import CreateEmbeddingResponse
 
 from semantic_router.encoders import DenseEncoder

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/llms/zure.py

@@ -1,8 +1,8 @@
 import os
 from typing import List, Optional
-from pydantic import PrivateAttr
 
 import openai
+from pydantic import PrivateAttr
 
 from semantic_router.llms import BaseLLM
 from semantic_router.schema import Message

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/routers/__init__.py

@@ -1,6 +1,6 @@
 from semantic_router.routers.base import BaseRouter, RouterConfig
-from semantic_router.routers.semantic import SemanticRouter
 from semantic_router.routers.hybrid import HybridRouter
+from semantic_router.routers.semantic import SemanticRouter
 
 __all__ = [
     "BaseRouter",

{semantic_router-0.1.0.dev6 → semantic_router-0.1.0.dev8}/semantic_router/routers/semantic.py

@@ -5,9 +5,9 @@ import numpy as np
 from semantic_router.encoders import DenseEncoder
 from semantic_router.index.base import BaseIndex
 from semantic_router.llms import BaseLLM
-from semantic_router.utils.logger import logger
 from semantic_router.route import Route
 from semantic_router.routers.base import BaseRouter
+from semantic_router.utils.logger import logger
 
 
 class SemanticRouter(BaseRouter):