Merge pull request #7 from Pushkar222-n/feature/ProdDeploy_Supabase_Qdrant

config.py

@@ -9,6 +9,8 @@ class Settings(BaseSettings):
     postgres_password: str
     postgres_db: str
     database_url: str
+    qdrant_url: str
+    qdrant_api_key: str
 
     class Config:
         env_file = '.env'

pyproject.toml

@@ -8,6 +8,8 @@ dependencies = [
     "chromadb>=1.5.2",
     "fastapi[all]>=0.122.0",
     "gradio>=6.2.0",
+    "grpcio>=1.78.0",
+    "grpcio-tools>=1.78.0",
     "langchain>=1.1.3",
     "langchain-groq>=1.1.1",
     "pandas>=2.3.3",

src/data_ingestion/create_embeddings.py

@@ -1,8 +1,10 @@
 from sentence_transformers import SentenceTransformer
-import chromadb
-from chromadb.config import Settings
+# import chromadb
+# from chromadb.config import Settings
+from qdrant_client import QdrantClient, models
 from sqlmodel import Session, select
 import logging
+from config import settings
 
 from src.database.session import engine
 from src.database.models import Animes
@@ -25,42 +27,74 @@ class EmbeddingPipeline:
         """
         logger.info(f"Loading embedding model: {model_name}")
         self.model = SentenceTransformer(model_name)
+        self.vector_size = self.model.get_sentence_embedding_dimension() or 0
 
-        self.chroma_client = chromadb.PersistentClient(
-            path="data/embeddings/chroma_db")
+        # self.chroma_client = chromadb.PersistentClient(
+        #     path="data/embeddings/chroma_db")
+        self.client = QdrantClient(url=settings.qdrant_url,
+                                   api_key=settings.qdrant_api_key,
+                                   cloud_inference=True)
 
         self.use_existing_embeddings = False
         print("ChromaDB initialized at data/embeddings/chroma_db")
 
     def create_or_get_collection(self, collection_name: str = "anime_collection"):
         """Create or get existing collection"""
-        try:
-            collection = self.chroma_client.get_collection(collection_name)
+        if self.client.collection_exists(collection_name=collection_name):
             logger.info(f"Found existing collection: {collection_name}")
-            logger.info(f"Current count: {collection.count()} documents")
+
+            collection = self.client.get_collection(collection_name)
+            logger.info(f"Found existing collection: {collection_name}")
+            logger.info(f"Current count: {collection.points_count} points")
 
             user_input = input("Reset collection? (y/n): ")
             if user_input.lower() == "y":
-                self.chroma_client.delete_collection(collection_name)
-                collection = self.chroma_client.create_collection(
-                    collection_name)
+                self.client.delete_collection(collection_name)
                 logger.info("Collection reset")
             else:
                 self.use_existing_embeddings = True
+                return collection_name
+
+        if not self.use_existing_embeddings:
+            is_collection_created = self.client.create_collection(collection_name=collection_name,
+                                                       vectors_config=models.VectorParams(
+                                                           size=self.vector_size,
+                                                           distance=models.Distance.COSINE
+                                                       ))
+            logger.info(f"Created new collection: {collection_name}: {is_collection_created}")
 
-        except:
-            collection = self.chroma_client.create_collection(collection_name)
-            logger.info(f"Created new collection: {collection_name}")
+        return collection_name
 
-        return collection
+    def fetch_data_from_postgres(self, batch_size: int = 2000):
+        """Fetch anime records from PostgreSQL in batches to avoid timeouts"""
+        logger.info("Fetching data from PostgreSQL in batches...")
+        all_results = []
 
-    def fetch_data_from_postgres(self):
-        """Fetch all anime records from PostgreSQL"""
-        logger.info("Fetching data from PostgreSQL...")
         with Session(engine) as session:
-            statement = select(Animes).where(Animes.searchable_text != None)
-            results = session.exec(statement).all()
-            return results
+            offset = 0
+            while True:
+                # order_by is strictly required when using offset/limit to guarantee no duplicates
+                statement = (
+                    select(Animes)
+                    .where(Animes.searchable_text != None)
+                    .order_by(Animes.id)
+                    .offset(offset)
+                    .limit(batch_size)
+                )
+
+                batch = session.exec(statement).all()
+
+                if not batch:
+                    break  # Break the loop when no more rows are returned
+
+                all_results.extend(batch)
+                offset += len(batch)
+                logger.info(
+                    f"Downloaded {offset} rows from Supabase so far...")
+
+        logger.info(
+            f"Successfully fetched a total of {len(all_results)} records.")
+        return all_results
 
     def embed_texts(self, texts: list[str], batch_size: int = 32) -> list[list[float]] | None:
         """
@@ -86,55 +120,56 @@ class EmbeddingPipeline:
         else:
             logger.info(f"Using existing stored embeddings.")
 
-    def store_in_chromadb(self, collection, db_records: list[Animes], embeddings: list[list[float]]):
+    def store_in_QdrantDB(self, client: QdrantClient, collection_name, db_records: list[Animes], final_texts: list[str], embeddings: list[list[float]]):
         """
-        Store embeddings and metadata in ChromaDB
+        Store embeddings and metadata in QdrantDB
 
         Args:
-            collection: ChromaDB collection,
+            client: QdrantDB Client
+            collection_name: QdrantDB collection name,
             db_records: List of Anime data retrieved from PostgreSQL database,
             embeddings: Pre_commputed embeddings
         """
 
-        logger.info("Storing in ChromaDB...")
-
-        ids = []
-        documents = []
-        metadatas = []
+        logger.info("Storing in QdrantDB...")
 
-        for row in db_records:
-            ids.append(str(row.mal_id))
-            documents.append(row.searchable_text)
+        points = []
 
-            # genres_str = ", ".join(row.genres) if isinstance(
-            #     row.genres, list) else str(row.genres or "")
+        for i, row in enumerate(db_records):
             genres_list = row.genres if isinstance(row.genres, list) else []
             if len(genres_list) == 0:
                 genres_list = ["Unknown"]
 
-            metadatas.append({
-                "title": row.title,
-                "genres": genres_list,
-                "score": float(row.score) if row.score else 0.0,
-                "type": row.type if row.type else "Unknown",
-                "scored_by": row.scored_by if row.scored_by else 0
-            })
-            print(f"Genre List saved: {", ".join(genres_list)}")
+            # Qdrant uses 'PointStruct' which holds the ID, Vector, and Payload (metadata + document)
+            point = models.PointStruct(
+                # Qdrant requires IDs to be integers or UUIDs
+                id=int(row.mal_id),
+                vector=embeddings[i],
+                payload={
+                    # Store the text here since Qdrant doesn't separate docs from metadata
+                    "document": final_texts[i],
+                    "title": row.title,
+                    "genres": genres_list,
+                    "score": float(row.score) if row.score else 0.0,
+                    "type": row.type if row.type else "Unknown",
+                    "scored_by": row.scored_by if row.scored_by else 0
+                }
+            )
+            points.append(point)
 
         chunk_size = 500
-        total_chunks = (len(ids) // chunk_size) + 1
-        logger.info(f"Inserting into ChromaDB in {total_chunks} batches...")
-
-        for i in range(0, len(ids), chunk_size):
-            collection.add(
-                ids=ids[i: i + chunk_size],
-                embeddings=embeddings[i: i + chunk_size],
-                documents=documents[i: i + chunk_size],
-                metadatas=metadatas[i: i + chunk_size]
+        total_chunks = (len(points) // chunk_size) + 1
+        logger.info(f"Inserting into Qdrant in {total_chunks} batches...")
+
+        for i in range(0, len(points), chunk_size):
+            batch = points[i: i + chunk_size]
+            self.client.upsert(
+                collection_name=collection_name,
+                points=batch
             )
             logger.info(f"Inserted batch {(i//chunk_size)+1}/{total_chunks}")
 
-        logger.info(f"✅ Successfully stored {len(ids)} animes in ChromaDB")
+        logger.info(f"Successfully stored {len(points)} animes in Qdrant")
 
     def run_pipeline(self):
         """Run complete embedding pipeline"""
@@ -143,34 +178,55 @@ class EmbeddingPipeline:
         db_records = self.fetch_data_from_postgres()
         logger.info(f"Loaded {len(db_records)} animes from Postgres")
 
-        collection = self.create_or_get_collection()
+        collection_name = self.create_or_get_collection()
 
         if not self.use_existing_embeddings:
-            texts_to_embed = [record.searchable_text for record in db_records]
+            texts_to_embed = []
+            for row in db_records:
+                text = row.searchable_text if row.searchable_text else ""
+                if hasattr(row, 'studios') and row.studios:
+                    text += f" Studio: {', '.join(row.studios)}"
+                texts_to_embed.append(text)
+
+            print(texts_to_embed[0])
             embeddings = self.embed_texts(texts_to_embed)
 
             if embeddings:
-                self.store_in_chromadb(collection, db_records, embeddings)
+                self.store_in_QdrantDB(
+                    self.client, collection_name, db_records, texts_to_embed, embeddings)
 
         logger.info("Embedding pipeline complete!")
-        return collection
+        return collection_name
 
 
 if __name__ == "__main__":
-    pipeline = EmbeddingPipeline()
-    collection = pipeline.run_pipeline()
-
-    print("\n--- Testing vector search ---")
-    query = "Anime similar to Attack Titan"
-
-    print(f"Query: {query}")
-
-    results = collection.query(query_texts=[query], n_results=15)
-
-    print("\n--- TOP 15 RESULTS ---")
-
-    for i, (title, distance) in enumerate(zip(
-        [m["title"] for m in results["metadatas"][0]],
-        results["distances"][0]
-    )):
-        print(f"{i+1}. {title} (distance: {distance:.3f})")
+    pass
+    # pipeline = EmbeddingPipeline()
+    # collection_name = pipeline.run_pipeline()
+
+    # client = QdrantClient(
+    #         url=settings.qdrant_url,
+    #         api_key=settings.qdrant_api_key,
+    #         cloud_inference=True
+    #     )
+
+    # print("\n--- Testing vector search ---")
+    # query = "Attack Titan"
+
+    # print(f"Query: {query}")
+
+    # search_results = client.search(
+    #         collection_name=collection_name,
+    #         query_vector=query_vector,
+    #         limit=limit,
+    #         # We want Qdrant to return the payload (metadata) so we can see the titles
+    #         with_payload=True
+    #     )
+
+    # print("\n--- TOP 15 RESULTS ---")
+
+    # for i, (title, distance) in enumerate(zip(
+    #     [m["title"] for m in results["metadatas"][0]],
+    #     results["distances"][0]
+    # )):
+    #     print(f"{i+1}. {title} (distance: {distance:.3f})")

src/database/session.py

@@ -2,4 +2,13 @@ from sqlmodel import create_engine
 import os
 from config import settings
 
-engine = create_engine(settings.database_url, echo=True)
+engine = create_engine(settings.database_url,
+                       echo=True,
+                       pool_size=10,         # Keep 10 connections permanently open and ready
+                       max_overflow=20,      # Allow up to 20 temporary extra connections during traffic spikes
+                       # How long to wait for an available connection before throwing an error
+                       pool_timeout=30,
+                       # Pings the DB slightly before executing a query to ensure the connection didn't drop
+                       pool_pre_ping=True,
+                       pool_recycle=1800     # Refresh connections every 30 minutes to prevent stale timeouts
+                       )

src/llm/anime_reranker.py

@@ -15,7 +15,7 @@ class AnimeReranker:
         # ----Postgres Global Truth
         self.C = 7.676           # The true weighted average score
         # 50th percentile of votes (Confidence threshold)
-        self.bayesian_m = 10875
+        self.bayesian_m = 44000
 
         # Hyperparameters for scoring
         self.passion_weight = 50     # Scaling factor for favorites/scored_by

src/retrieval/vector_search.py

@@ -1,9 +1,12 @@
-import chromadb
+# import chromadb
+import logging
+import grpc
+from config import settings
+from qdrant_client import QdrantClient, models
 from sentence_transformers import SentenceTransformer
 from src.database.session import engine
 from src.database.models import Animes
 from sqlmodel import Session, select
-import logging
 
 
 logger = logging.getLogger(__name__)
@@ -15,14 +18,20 @@ class AnimeRetriever:
     """Handles anime retrieval from ChromaDB"""
 
     def __init__(self,
-                 chroma_path: str = "data/embeddings/chroma_db",
-                 collection_name: str = "anime_collection",
-                 model: str = "all-MiniLM-L6-v2"):
-        self.client = chromadb.PersistentClient(chroma_path)
-        self.collection = self.client.get_collection(collection_name)
-        self.model = SentenceTransformer(model)
-
-        print(f"Loaded collection with {self.collection.count()} anime")
+                 collection_name: str = "anime_collection"):
+        self.client = QdrantClient(url=settings.qdrant_url,
+                                   api_key=settings.qdrant_api_key,
+                                   cloud_inference=True,
+                                   prefer_grpc=True,
+                                   timeout=10)
+        self.collection_name = collection_name
+        self.points_count = self.client.count(
+            collection_name=self.collection_name, exact=False).count
+        # self.model = SentenceTransformer(model)
+        self.model = "sentence-transformers/all-minilm-l6-v2"
+
+        print(
+            f"Loaded collection with {self.points_count} anime approximately")
 
     def fetch_anime_batch_from_postgres(self, mal_ids: list[int]) -> dict[int, Animes]:
         """Fetch multiple animes at once and return a dictionary mapped by mal_id"""
@@ -54,62 +63,78 @@ class AnimeRetriever:
         Returns:
             List of dicts with anime info
         """
-        # 1. Build chromadb WHERE clause for filtering
-        conditions = [{"scored_by": {"$gte": 9000}}]
+        must_conditions = [
+            # Base condition: scored_by >= 9000
+            models.FieldCondition(
+                key="scored_by",
+                range=models.Range(gte=20000)
+            )
+        ]
+
         if min_score:
             logger.info(f"SCORE: Filtered based on min_score: {min_score}")
-            conditions.append({"score": {"$gte": min_score}})
+            must_conditions.append(
+                models.FieldCondition(
+                    key="score",
+                    range=models.Range(gte=min_score)
+                )
+            )
 
         if anime_type:
             logger.info(
                 f"ANIME TYPE: Filtered based on anime_type: {anime_type}")
-            conditions.append({"type": {"$eq": anime_type}})
+            must_conditions.append(
+                models.FieldCondition(
+                    key="type",
+                    match=models.MatchValue(value=anime_type)
+                )
+            )
 
         if genre_filter:
             logger.info(
                 f"GENRE: Pre-filtering (OR) for genres: {', '.join(genre_filter)}")
-
-            genre_or_conditions = [
-                {"genres": {"$contains": genre}} for genre in genre_filter]
-
-            if len(genre_or_conditions) == 1:
-                conditions.append(genre_or_conditions[0])
-            else:
-                conditions.append({"$or": genre_or_conditions})
-
-        where_clause = None
-        if len(conditions) == 1:
-            where_clause = conditions[0]
-        elif len(conditions) > 1:
-            where_clause = {"$and": conditions}
-
-        # 2. Query ChromaDB
-        results = self.collection.query(
-            query_texts=[query],
-            n_results=n_results,
-            where=where_clause
-        )
-        if not results["ids"][0]:
+            # Qdrant's MatchAny automatically acts as an OR condition against list fields!
+            must_conditions.append(
+                models.FieldCondition(
+                    key="genres",
+                    match=models.MatchAny(any=genre_filter)
+                )
+            )
+
+        # Wrap all conditions in a Filter object
+        query_filter = models.Filter(
+            must=must_conditions) if must_conditions else None
+
+        search_results = self.client.query_points(
+            collection_name=self.collection_name,
+            query=models.Document(
+                text=query,
+                model=self.model
+            ),
+            query_filter=query_filter,
+            limit=n_results
+        ).points
+
+        if not search_results:
             return []
 
-        # 3. Batch fetch from PostgreSQL
-        retrieved_ids = [int(id_str) for id_str in results["ids"][0]]
+        retrieved_ids = [hit.id for hit in search_results]
         postgres_data_map = self.fetch_anime_batch_from_postgres(retrieved_ids)
 
         anime_list = []
-        for i, id_str in enumerate(results["ids"][0]):
-            mal_id = int(id_str)
-            distance = results["distances"][0][i]
+        for hit in search_results:
+            mal_id = hit.id
+            similarity_score = hit.score  # Qdrant returns cosine similarity here
 
             # Get the rich data from our Postgres map
             pg_anime = postgres_data_map.get(mal_id)
 
             if not pg_anime:
                 logger.warning(
-                    f"Anime ID {mal_id} found in Chroma but missing in Postgres!")
+                    f"Anime ID {mal_id} found in Qdrant but missing in Postgres!")
                 continue
 
-            # Merge Chroma math with Postgres truths
+            # Merge Vector Search results with Postgres truths
             anime_info = {
                 "mal_id": pg_anime.mal_id,
                 "mal_url": pg_anime.url,
@@ -119,7 +144,7 @@ class AnimeRetriever:
                 "scored_by": pg_anime.scored_by,
                 "type": pg_anime.type,
                 "year": pg_anime.year,
-                "genres": pg_anime.genres,  # Now an actual list again!
+                "genres": pg_anime.genres,
                 "studios": pg_anime.studios,
                 "themes": pg_anime.themes,
                 "demographics": pg_anime.demographics,
@@ -131,7 +156,7 @@ class AnimeRetriever:
                 "favorites": pg_anime.favorites,
                 "images": pg_anime.images,
                 "synopsis": pg_anime.synopsis,
-                "searchable_text": pg_anime.searchable_text
+                "searchable_text": pg_anime.searchable_text,
             }
             anime_list.append(anime_info)
 
@@ -147,12 +172,12 @@ class AnimeRetriever:
 if __name__ == "__main__":
     retriever = AnimeRetriever()
 
-    # # Test queries
-    # print("=== Test 1: Basic Search ===")
-    # results = retriever.search("dark psychological anime", n_results=15)
-    # for anime in results:
-    #     print(
-    #         f"- {anime['title']} (score: {anime['score']}, relevance: {anime['relevance_score']:.3f})")
+    # Test queries
+    print("=== Test 1: Basic Search ===")
+    results = retriever.search("dark psychological anime", n_results=15)
+    for anime in results:
+        print(
+            f"- {anime['title']} (score: {anime['score']})")
 
     # print("\n=== Test 2: Genre Filter ===")
     # results = retriever.search(

tests/add_index_to_qdrant.py

@@ -0,0 +1,46 @@
+from qdrant_client import QdrantClient, models
+from config import settings
+import logging
+
+logging.basicConfig(level=logging.INFO)
+
+# Connect to your Qdrant Cloud instance
+client = QdrantClient(
+    url=settings.qdrant_url,
+    api_key=settings.qdrant_api_key,
+)
+
+collection_name = "anime_collection"
+
+logging.info("Creating payload indices...")
+
+# 1. Index for scored_by (Integer)
+client.create_payload_index(
+    collection_name=collection_name,
+    field_name="scored_by",
+    field_schema=models.PayloadSchemaType.INTEGER,
+)
+
+# 2. Index for score (Float)
+client.create_payload_index(
+    collection_name=collection_name,
+    field_name="score",
+    field_schema=models.PayloadSchemaType.FLOAT,
+)
+
+# 3. Index for type (String/Keyword)
+client.create_payload_index(
+    collection_name=collection_name,
+    field_name="type",
+    field_schema=models.PayloadSchemaType.KEYWORD,
+)
+
+# 4. Index for genres (List of Strings -> Keyword)
+# Note: Qdrant automatically handles arrays of strings as Keyword indices!
+client.create_payload_index(
+    collection_name=collection_name,
+    field_name="genres",
+    field_schema=models.PayloadSchemaType.KEYWORD,
+)
+
+logging.info("✅ All payload indices created successfully!")

ui/gradio_app.py

@@ -16,8 +16,6 @@ GENRES = [
 ]
 
 SUGGESTIONS = [
-    {"label": "🌸 Similar to Naruto",
-        "query": "Action packed themed anime similar to Naruto"},
     {"label": "⚔️  Dark fantasy",
         "query": "Dark fantasy with an unreliable narrator"},
     {"label": "🤖 Cyberpunk action",
@@ -25,6 +23,8 @@ SUGGESTIONS = [
     {"label": "💀 Psychological",
         "query": "Psychological thriller that messes with your head"},
     {"label": "💘 Romance drama",      "query": "Bittersweet romance that makes you cry"},
+    {"label": "🌸 Similar to Naruto",
+        "query": "Action packed themed anime similar to Naruto"}
 ]
 
 # ─── HTML builders ────────────────────────────────────────────────────────────
@@ -41,6 +41,7 @@ def build_spotlight_card(anime: dict) -> str:
     title = anime.get("title", "Unknown")
     eng = anime.get("title_english") or ""
     score = anime.get("score") or "—"
+    scored_by = anime.get("scored_by") or "—"
     year = anime.get("year") or "—"
     kind = anime.get("type") or "—"
     eps = anime.get("episodes") or "—"
@@ -71,7 +72,7 @@ def build_spotlight_card(anime: dict) -> str:
         f"</div>"
         f"<div class='sc-body'>"
         f"<div class='sc-chips'>"
-        f"<span class='mc'>{kind}</span><span class='mc'>{year}</span><span class='mc'>{eps} ep</span>"
+        f"<span class='mc'>{kind}</span><span class='mc'>{year}</span><span class='mc'>{eps} ep</span><span class='mc'>Scored by:{scored_by}</span>"
         f"</div>"
         f"<h3 class='sc-title'>{title}</h3>"
         f"{eng_html}"
@@ -762,7 +763,7 @@ if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=True,
+        share=False,
         css=CSS,
         theme=theme,
     )

uv.lock

@@ -30,6 +30,8 @@ dependencies = [
     { name = "chromadb" },
     { name = "fastapi", extra = ["all"] },
     { name = "gradio" },
+    { name = "grpcio" },
+    { name = "grpcio-tools" },
     { name = "langchain" },
     { name = "langchain-groq" },
     { name = "pandas" },
@@ -58,6 +60,8 @@ requires-dist = [
     { name = "chromadb", specifier = ">=1.5.2" },
     { name = "fastapi", extras = ["all"], specifier = ">=0.122.0" },
     { name = "gradio", specifier = ">=6.2.0" },
+    { name = "grpcio", specifier = ">=1.78.0" },
+    { name = "grpcio-tools", specifier = ">=1.78.0" },
     { name = "langchain", specifier = ">=1.1.3" },
     { name = "langchain-groq", specifier = ">=1.1.1" },
     { name = "pandas", specifier = ">=2.3.3" },
@@ -1017,6 +1021,49 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/4d/27/d86b89e36de8a951501fb06a0f38df19853210f341d0b28f83f4aa0ffa08/grpcio-1.78.0-cp313-cp313-win_amd64.whl", hash = "sha256:f2d4e43ee362adfc05994ed479334d5a451ab7bc3f3fee1b796b8ca66895acb4", size = 4797393, upload-time = "2026-02-06T09:56:17.882Z" },
 ]
 
+[[package]]
+name = "grpcio-tools"
+version = "1.78.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "grpcio" },
+    { name = "protobuf" },
+    { name = "setuptools" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8b/d1/cbefe328653f746fd319c4377836a25ba64226e41c6a1d7d5cdbc87a459f/grpcio_tools-1.78.0.tar.gz", hash = "sha256:4b0dd86560274316e155d925158276f8564508193088bc43e20d3f5dff956b2b", size = 5393026, upload-time = "2026-02-06T09:59:59.53Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/75/78/280184d19242ed6762bf453c47a70b869b3c5c72a24dc5bf2bf43909faa3/grpcio_tools-1.78.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:6a8b8b7b49f319d29dbcf507f62984fa382d1d10437d75c3f26db5f09c4ac0af", size = 2545904, upload-time = "2026-02-06T09:57:52.769Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/51/3c46dea5113f68fe879961cae62d34bb7a3c308a774301b45d614952ee98/grpcio_tools-1.78.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:d62cf3b68372b0c6d722a6165db41b976869811abeabc19c8522182978d8db10", size = 5709078, upload-time = "2026-02-06T09:57:56.389Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/2c/dc1ae9ec53182c96d56dfcbf3bcd3e55a8952ad508b188c75bf5fc8993d4/grpcio_tools-1.78.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fa9056742efeaf89d5fe14198af71e5cbc4fbf155d547b89507e19d6025906c6", size = 2591744, upload-time = "2026-02-06T09:57:58.341Z" },
+    { url = "https://files.pythonhosted.org/packages/04/63/9b53fc9a9151dd24386785171a4191ee7cb5afb4d983b6a6a87408f41b28/grpcio_tools-1.78.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:e3191af125dcb705aa6bc3856ba81ba99b94121c1b6ebee152e66ea084672831", size = 2905113, upload-time = "2026-02-06T09:58:00.38Z" },
+    { url = "https://files.pythonhosted.org/packages/96/b2/0ad8d789f3a2a00893131c140865605fa91671a6e6fcf9da659e1fabba10/grpcio_tools-1.78.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:283239ddbb67ae83fac111c61b25d8527a1dbd355b377cbc8383b79f1329944d", size = 2656436, upload-time = "2026-02-06T09:58:03.038Z" },
+    { url = "https://files.pythonhosted.org/packages/09/4d/580f47ce2fc61b093ade747b378595f51b4f59972dd39949f7444b464a03/grpcio_tools-1.78.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ac977508c0db15301ef36d6c79769ec1a6cc4e3bc75735afca7fe7e360cead3a", size = 3106128, upload-time = "2026-02-06T09:58:05.064Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/29/d83b2d89f8d10e438bad36b1eb29356510fb97e81e6a608b22ae1890e8e6/grpcio_tools-1.78.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4ff605e25652a0bd13aa8a73a09bc48669c68170902f5d2bf1468a57d5e78771", size = 3654953, upload-time = "2026-02-06T09:58:07.15Z" },
+    { url = "https://files.pythonhosted.org/packages/08/71/917ce85633311e54fefd7e6eb1224fb780ef317a4d092766f5630c3fc419/grpcio_tools-1.78.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0197d7b561c79be78ab93d0fe2836c8def470683df594bae3ac89dd8e5c821b2", size = 3322630, upload-time = "2026-02-06T09:58:10.305Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/55/3fbf6b26ab46fc79e1e6f7f4e0993cf540263dad639290299fad374a0829/grpcio_tools-1.78.0-cp311-cp311-win32.whl", hash = "sha256:28f71f591f7f39555863ced84fcc209cbf4454e85ef957232f43271ee99af577", size = 993804, upload-time = "2026-02-06T09:58:13.698Z" },
+    { url = "https://files.pythonhosted.org/packages/73/86/4affe006d9e1e9e1c6653d6aafe2f8b9188acb2b563cd8ed3a2c7c0e8aec/grpcio_tools-1.78.0-cp311-cp311-win_amd64.whl", hash = "sha256:5a6de495dabf86a3b40b9a7492994e1232b077af9d63080811838b781abbe4e8", size = 1158566, upload-time = "2026-02-06T09:58:15.721Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ae/5b1fa5dd8d560a6925aa52de0de8731d319f121c276e35b9b2af7cc220a2/grpcio_tools-1.78.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:9eb122da57d4cad7d339fc75483116f0113af99e8d2c67f3ef9cae7501d806e4", size = 2546823, upload-time = "2026-02-06T09:58:17.944Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/ed/d33ccf7fa701512efea7e7e23333b748848a123e9d3bbafde4e126784546/grpcio_tools-1.78.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:d0c501b8249940b886420e6935045c44cb818fa6f265f4c2b97d5cff9cb5e796", size = 5706776, upload-time = "2026-02-06T09:58:20.944Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/69/4285583f40b37af28277fc6b867d636e3b10e1b6a7ebd29391a856e1279b/grpcio_tools-1.78.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:77e5aa2d2a7268d55b1b113f958264681ef1994c970f69d48db7d4683d040f57", size = 2593972, upload-time = "2026-02-06T09:58:23.29Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/eb/ecc1885bd6b3147f0a1b7dff5565cab72f01c8f8aa458f682a1c77a9fb08/grpcio_tools-1.78.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:8e3c0b0e6ba5275322ba29a97bf890565a55f129f99a21b121145e9e93a22525", size = 2905531, upload-time = "2026-02-06T09:58:25.406Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/a9/511d0040ced66960ca10ba0f082d6b2d2ee6dd61837b1709636fdd8e23b4/grpcio_tools-1.78.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:975d4cb48694e20ebd78e1643e5f1cd94cdb6a3d38e677a8e84ae43665aa4790", size = 2656909, upload-time = "2026-02-06T09:58:28.022Z" },
+    { url = "https://files.pythonhosted.org/packages/06/a3/3d2c707e7dee8df842c96fbb24feb2747e506e39f4a81b661def7fed107c/grpcio_tools-1.78.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:553ff18c5d52807dedecf25045ae70bad7a3dbba0b27a9a3cdd9bcf0a1b7baec", size = 3109778, upload-time = "2026-02-06T09:58:30.091Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/4b/646811ba241bf05da1f0dc6f25764f1c837f78f75b4485a4210c84b79eae/grpcio_tools-1.78.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:8c7f5e4af5a84d2e96c862b1a65e958a538237e268d5f8203a3a784340975b51", size = 3658763, upload-time = "2026-02-06T09:58:32.875Z" },
+    { url = "https://files.pythonhosted.org/packages/45/de/0a5ef3b3e79d1011375f5580dfee3a9c1ccb96c5f5d1c74c8cee777a2483/grpcio_tools-1.78.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:96183e2b44afc3f9a761e9d0f985c3b44e03e8bb98e626241a6cbfb3b6f7e88f", size = 3325116, upload-time = "2026-02-06T09:58:34.894Z" },
+    { url = "https://files.pythonhosted.org/packages/95/d2/6391b241ad571bc3e71d63f957c0b1860f0c47932d03c7f300028880f9b8/grpcio_tools-1.78.0-cp312-cp312-win32.whl", hash = "sha256:2250e8424c565a88573f7dc10659a0b92802e68c2a1d57e41872c9b88ccea7a6", size = 993493, upload-time = "2026-02-06T09:58:37.242Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/8f/7d0d3a39ecad76ccc136be28274daa660569b244fa7d7d0bbb24d68e5ece/grpcio_tools-1.78.0-cp312-cp312-win_amd64.whl", hash = "sha256:217d1fa29de14d9c567d616ead7cb0fef33cde36010edff5a9390b00d52e5094", size = 1158423, upload-time = "2026-02-06T09:58:40.072Z" },
+    { url = "https://files.pythonhosted.org/packages/53/ce/17311fb77530420e2f441e916b347515133e83d21cd6cc77be04ce093d5b/grpcio_tools-1.78.0-cp313-cp313-linux_armv7l.whl", hash = "sha256:2d6de1cc23bdc1baafc23e201b1e48c617b8c1418b4d8e34cebf72141676e5fb", size = 2546284, upload-time = "2026-02-06T09:58:43.073Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/d3/79e101483115f0e78223397daef71751b75eba7e92a32060c10aae11ca64/grpcio_tools-1.78.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:2afeaad88040894c76656202ff832cb151bceb05c0e6907e539d129188b1e456", size = 5705653, upload-time = "2026-02-06T09:58:45.533Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/a7/52fa3ccb39ceeee6adc010056eadfbca8198651c113e418dafebbdf2b306/grpcio_tools-1.78.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:33cc593735c93c03d63efe7a8ba25f3c66f16c52f0651910712490244facad72", size = 2592788, upload-time = "2026-02-06T09:58:48.918Z" },
+    { url = "https://files.pythonhosted.org/packages/68/08/682ff6bb548225513d73dc9403742d8975439d7469c673bc534b9bbc83a7/grpcio_tools-1.78.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:2921d7989c4d83b71f03130ab415fa4d66e6693b8b8a1fcbb7a1c67cff19b812", size = 2905157, upload-time = "2026-02-06T09:58:51.478Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/66/264f3836a96423b7018e5ada79d62576a6401f6da4e1f4975b18b2be1265/grpcio_tools-1.78.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e6a0df438e82c804c7b95e3f311c97c2f876dcc36376488d5b736b7bcf5a9b45", size = 2656166, upload-time = "2026-02-06T09:58:54.117Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/6b/f108276611522e03e98386b668cc7e575eff6952f2db9caa15b2a3b3e883/grpcio_tools-1.78.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e9c6070a9500798225191ef25d0055a15d2c01c9c8f2ee7b681fffa99c98c822", size = 3109110, upload-time = "2026-02-06T09:58:56.891Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/c7/cf048dbcd64b3396b3c860a2ffbcc67a8f8c87e736aaa74c2e505a7eee4c/grpcio_tools-1.78.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:394e8b57d85370a62e5b0a4d64c96fcf7568345c345d8590c821814d227ecf1d", size = 3657863, upload-time = "2026-02-06T09:58:59.176Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/37/e2736912c8fda57e2e57a66ea5e0bc8eb9a5fb7ded00e866ad22d50afb08/grpcio_tools-1.78.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a3ef700293ab375e111a2909d87434ed0a0b086adf0ce67a8d9cf12ea7765e63", size = 3324748, upload-time = "2026-02-06T09:59:01.242Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/5d/726abc75bb5bfc2841e88ea05896e42f51ca7c30cb56da5c5b63058b3867/grpcio_tools-1.78.0-cp313-cp313-win32.whl", hash = "sha256:6993b960fec43a8d840ee5dc20247ef206c1a19587ea49fe5e6cc3d2a09c1585", size = 993074, upload-time = "2026-02-06T09:59:03.085Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/68/91b400bb360faf9b177ffb5540ec1c4d06ca923691ddf0f79e2c9683f4da/grpcio_tools-1.78.0-cp313-cp313-win_amd64.whl", hash = "sha256:275ce3c2978842a8cf9dd88dce954e836e590cf7029649ad5d1145b779039ed5", size = 1158185, upload-time = "2026-02-06T09:59:05.036Z" },
+]
+
 [[package]]
 name = "h11"
 version = "0.16.0"