check linting

src/api/routers/embedding.py

@@ -25,16 +25,18 @@ from src.core.exceptions import (
     ValidationError,
 )
 from src.api.dependencies import get_model_manager
-from src.utils.validators import extract_embedding_kwargs, validate_texts, count_tokens_batch
+from src.utils.validators import (
+    extract_embedding_kwargs,
+    validate_texts,
+    count_tokens_batch,
+)
 from src.config.settings import get_settings
 
 
 router = APIRouter(tags=["embeddings"])
 
 
-def _ensure_model_type(
-    config, expected_type: str, model_id: str
-) -> None:
+def _ensure_model_type(config, expected_type: str, model_id: str) -> None:
     """
     Validate that the model configuration matches the expected type.
 
@@ -206,4 +208,3 @@ async def create_sparse_embedding(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail=f"Failed to create query embedding: {str(e)}",
         )
-    

src/api/routers/rerank.py

@@ -6,7 +6,6 @@ It accepts a list of documents and returns a ranked list based on relevance to t
 """
 
 import time
-from typing import List
 from fastapi import APIRouter, Depends, HTTPException, status
 from loguru import logger
 
@@ -21,7 +20,7 @@ from src.core.exceptions import (
 from src.api.dependencies import get_model_manager
 from src.utils.validators import extract_embedding_kwargs
 
-router = APIRouter(prefix="/rerank",tags=["rerank"])
+router = APIRouter(prefix="/rerank", tags=["rerank"])
 
 
 @router.post(
@@ -91,20 +90,16 @@ async def rerank_documents(
         processing_time = time.time() - start
 
         results = []
-        
+
         for rank_result in ranking_results:
-            doc_idx = rank_result.get('corpus_id', 0)  
+            doc_idx = rank_result.get("corpus_id", 0)
             if doc_idx < len(valid_docs):
                 original_idx = valid_docs[doc_idx][0]  # Original index
                 doc_text = documents_list[doc_idx]
-                score = rank_result['score']
-                
+                score = rank_result["score"]
+
                 results.append(
-                    RerankResult(
-                        text=doc_text,
-                        score=score,
-                        index=original_idx
-                    )
+                    RerankResult(text=doc_text, score=score, index=original_idx)
                 )
 
         logger.info(
@@ -130,4 +125,4 @@ async def rerank_documents(
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail=f"Failed to rerank documents: {str(e)}",
-        )
+        )

src/core/base.py

@@ -6,7 +6,7 @@ must follow, ensuring consistency across dense and sparse embeddings.
 """
 
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Union
 
 
 class BaseEmbeddingModel(ABC):

src/models/embeddings/dense.py

@@ -112,7 +112,7 @@ class DenseEmbeddingModel(BaseEmbeddingModel):
 
         try:
             embeddings = self.model.encode(input, **kwargs)
-            
+
             return [
                 emb.tolist() if hasattr(emb, "tolist") else list(emb)
                 for emb in embeddings

src/models/embeddings/rank.py

@@ -113,22 +113,17 @@ class RerankModel:
         """
         if not self._loaded or self.model is None:
             self.load()
-        
+
         try:
-            ranking_results = self.model.rank(
-                query, 
-                documents, 
-                top_k=top_k, 
-                **kwargs
-            )
-            
+            ranking_results = self.model.rank(query, documents, top_k=top_k, **kwargs)
+
             # Normalize scores to 0-1 range for consistency
             normalized_results = self._normalize_rerank_scores(ranking_results)
-            
+
             logger.debug(
                 f"Reranked {len(documents)} docs, returned top {len(normalized_results)}"
             )
-            
+
             return normalized_results
 
         except Exception as e:
@@ -137,9 +132,7 @@ class RerankModel:
             raise RerankingDocumentError(self.model_id, error_msg)
 
     def _normalize_rerank_scores(
-        self, 
-        rankings: List[Dict], 
-        target_range: tuple = (0, 1)
+        self, rankings: List[Dict], target_range: tuple = (0, 1)
     ) -> List[Dict]:
         """
         Normalize reranking scores using min-max normalization.
@@ -154,35 +147,30 @@ class RerankModel:
         """
         if not rankings:
             return []
-        
+
         raw_scores = [ranking["score"] for ranking in rankings]
-        
+
         min_score = min(raw_scores)
         max_score = max(raw_scores)
-        
+
         if max_score == min_score:
             return [
-                {
-                    "corpus_id": r["corpus_id"],
-                    "score": target_range[1]
-                }
+                {"corpus_id": r["corpus_id"], "score": target_range[1]}
                 for r in rankings
             ]
-        
+
         target_min, target_max = target_range
         normalized_rankings = []
-        
+
         for ranking in rankings:
             score = ranking["score"]
-            normalized_score = (
-                target_min + 
-                (score - min_score) * (target_max - target_min) / (max_score - min_score)
+            normalized_score = target_min + (score - min_score) * (
+                target_max - target_min
+            ) / (max_score - min_score)
+            normalized_rankings.append(
+                {"corpus_id": ranking["corpus_id"], "score": float(normalized_score)}
             )
-            normalized_rankings.append({
-                "corpus_id": ranking["corpus_id"],
-                "score": float(normalized_score)
-            })
-        
+
         return normalized_rankings
 
     @property
@@ -222,4 +210,4 @@ class RerankModel:
             f"id={self.model_id}, "
             f"type={self.model_type}, "
             f"loaded={self.is_loaded})"
-        )
+        )

src/models/schemas/requests.py

@@ -13,7 +13,7 @@ from .common import EmbeddingOptions
 class BaseEmbedRequest(BaseModel):
     """
     OpenAI-compatible embedding request.
-    
+
     Matches the format of OpenAI's embeddings API:
     https://platform.openai.com/docs/api-reference/embeddings
     """
@@ -25,16 +25,11 @@ class BaseEmbedRequest(BaseModel):
     )
 
     encoding_format: Optional[Literal["float", "base64"]] = Field(
-        default="float", 
-        description="Encoding format"
+        default="float", description="Encoding format"
     )
-    dimensions: Optional[int] = Field(
-        None, 
-        description="Output dimensions")
+    dimensions: Optional[int] = Field(None, description="Output dimensions")
 
-    user: Optional[str] = Field(
-        None,
-        description="User identifier")
+    user: Optional[str] = Field(None, description="User identifier")
 
     options: Optional[EmbeddingOptions] = Field(
         None, description="Optional embedding generation parameters"

src/models/schemas/responses.py

@@ -23,6 +23,7 @@ class BaseEmbedResponse(BaseModel):
 
 class EmbeddingObject(BaseModel):
     """Single embedding object."""
+
     object: Literal["embedding"] = "embedding"
     embedding: List[float] = Field(..., description="Embedding vector")
     index: int = Field(..., description="Index of the embedding")
@@ -30,6 +31,7 @@ class EmbeddingObject(BaseModel):
 
 class TokenUsage(BaseModel):
     """Usage statistics."""
+
     prompt_tokens: int
     total_tokens: int
 
@@ -44,14 +46,15 @@ class DenseEmbedResponse(BaseEmbedResponse):
         data: List of generated dense embeddings
         model: Identifier of the model used
         usage: Usage statistics
-        
+
     """
+
     object: Literal["list"] = "list"
     data: List[EmbeddingObject]
     model: str = Field(..., description="Model identifier used")
     usage: TokenUsage = Field(..., description="Usage statistics")
 
-    class Config:        
+    class Config:
         json_schema_extra = {
             "example": {
                 "object": "list",