From 65cb6680eb3a481d644d81294262dac7b0ade1b4 Mon Sep 17 00:00:00 2001
From: ahmedmujtaba-gif <ahmed.mujtaba@utopiabrands.com>
Date: Fri, 8 May 2026 20:26:24 +0500
Subject: [PATCH] Remove tracked pycache files

---
 .../__pycache__/db_setup.cpython-313.pyc      | Bin 2327 -> 0 bytes
 dev_backend/__pycache__/main.cpython-313.pyc  | Bin 1183 -> 0 bytes
 .../__pycache__/views.cpython-313.pyc         | Bin 1234 -> 0 bytes
 dev_backend/vector_db_router/models.py        | 208 +++++-----
 dev_backend/vector_db_router/serializers.py   |  44 +--
 dev_backend/vector_db_router/views.py         | 364 +++++++++---------
 6 files changed, 308 insertions(+), 308 deletions(-)
 delete mode 100644 dev_backend/__pycache__/db_setup.cpython-313.pyc
 delete mode 100644 dev_backend/__pycache__/main.cpython-313.pyc
 delete mode 100644 dev_backend/mysql_process/__pycache__/views.cpython-313.pyc
 mode change 100644 => 100755 dev_backend/vector_db_router/models.py
 mode change 100644 => 100755 dev_backend/vector_db_router/serializers.py
 mode change 100644 => 100755 dev_backend/vector_db_router/views.py

diff --git a/dev_backend/__pycache__/db_setup.cpython-313.pyc b/dev_backend/__pycache__/db_setup.cpython-313.pyc
deleted file mode 100644
index cdc274ac3fe2e87e92347ad41e5ee15458c4f2af..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2327
zcma)7&2Jk;6rcU@di}As<Jjp(K5*O6;C{r2P^v_s$R$mw-KMQKQCm{9Y`l}ibiM1&
zZbB1rh$;@H5u_6I#t~7tAjAbBaUlOe(;S)(wOWZvsJEbS=%EMRtg}gjM8ils`+INR
zn|ZUp_uj54N*KX7bmw{HmjFV4Fu@<*3PRl4R~$mOk&0BVhzcCxG7R%Yp78J%ib6po
zqNfv!fr3ON4+o0Df=px&OT|zjOu~f-iFk4l?4l&<VY#RjVkB0GlXxLP5}qzpY$_y4
z(!*iE&7|4Gkz%TlCh0;8Y4PM}aYtb%+3Dep^DfJK(UJ8#WYFcEr8oQwZNB#+Rk_TU
z-rUsq2v%Z8;J$49r$u~Qi^R4TP1{-|eG9d@S0b%yi<;VvJ`zcrn%<2_`vjle@sx#`
z<!D5=EZf!HifuVVAUEsIj8!h%mW!{sRo&7jFadQe&(tTeg^BLkOcOC}-Ovo%#nyC|
zr%j&0d4uSd`>t8RmP@6oZD7*@+fcr72sW|;Z7vh6yIAuM(y%pAu`rE#?kaX12!tjZ
zYfeL~>Q}rN5(X}tI-Fmb#@d+fVAwgj#fGQBLEUll=T6b!0Ip%nV5bWsrPH%Yb;h}B
z9`rV@&d~6gOX~U4+K76hL}LwnF0ZN=&XxxJwfD}d!#+NDwlwV94djRO$MfomtVF{G
zfmn#8S22~R93Rzm$NAVM1{Ei5$E9M;CN7l?-PKvtW%lL$0hNOU9xCN)0Q*n|s%3ON
zhY(ba%Bw;zZ=nt}f{u#Q=r)%DR1$pm&9|Sor=Y?nVSSprEer*su;T=h(NJK||M3%j
zKN&I4arCzE3L58*3gcW>9GXo}x^As6mox3MZnCTOz17px^RyqLfD90(h)IKPrHbt-
zH_MYCsA-^V+8$9-*-HwCT`oiWa#hRC8M)IH$E{csT1hu_k~169Vd6;!o(7i7SAfNw
zF{U}#ovL-$W@ys{cD1WsqG^pyNhfUD3Xj7=d5Y%H6Q$$szP{g%FDWPI23L78(7qB&
z%|}-y6i+XhpPBR4eYtH}ZhLlPd_%k^w>@{dVT0?De3bhl(2c%q2JkI+NW3Ef_#u@K
z35z_J56Fvx#BfLe^%goMaQEnZ0^r|tj`E=N1|ycyI?Cwx#t0f^zTQv;RqPckZiL%x
zM;1RC^4EQ;EdkPk-$)C-6!9%K-@ffj(qenRm!(BuXc$UN#N|nQ5Q<wIt5^mFvY`Yt
zn!wj;6@oR}(#m$VT5+=yVgCji^@~V@+9Xj>5f(gA*t7?xtVpHx)}U-@1~j-{@l-qx
z#pFP2C<BA+13)7zH`WbE4m6$cI2T}IS@BTGeAD*hz>?BCH~28M|GU9o`|rN5Eu}u3
zJM$pcI&aUNd>Cn6j<nAWtnxyjV<ncJS02aG3)Ro6^Y(qYeOYdQc4J~gyeGFmcY0v&
z>$&{v+)sgg68+o^Xfe#?6XIe-VmO(~9~Kt(bNQ^i*d;N1SO7iLi$ox!i8b5hwZ4tk
zI_ilpHqt|xA=|<qWIJeB)5fR332Pc*J%IAIL&NLM+N_Kb_BE*F&eWi&2um(1H99n5
z*+rGDWy30z$ZTS{MO&aj>SlQoS7*AR`FDHYy<&TeHRxeP(bx-SHmNo^i?Nm9I5b}!
z7>~0(6HJwU!MMR^H?#@T#MY$7kAO-*8vI1a0p`UB^O*Y{tpP+0UgduHmrR-X7<mVD
ztcN(C!?Y@J99Ktse@CG@I#5S@>Zs!p>Zzl)N9f`bx>!dC>!|Bb)LBQb!qNj2`BZrv
zPcF>foLz}`tSIq?OE)jw`ea$@T*r5JbS*2dt%M>AyKe5f)xR9dY{3nOhS6V2Fu~77
R|4s$D_O+zUb&z8a(LcT~FSq~z

diff --git a/dev_backend/__pycache__/main.cpython-313.pyc b/dev_backend/__pycache__/main.cpython-313.pyc
deleted file mode 100644
index a33d8a7309aa7f4b9d8fa18b169696504c5522fb..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1183
zcmbtT&rj4q6rQ$A+udci%MT%341svqgIhJh1cN4+h|)!aTaKGF-R*#l-L}lkF0fuC
zG2sdagBKGxp*J|e(LVvjL>xlUcre~DoK2kB?gAP-IfuUQd-J{5d0%EuQmF)BtN!Je
z`&|U!8z-$5Z-SFo0st?82}~gmP!t6u6hR@@lAgtaa)w)|C|sy)^>4{o{BLFQT(c%D
z%0uk@eElo-^O?lFVyH+p;wawWQa)iMQPOBf?F}Bwr;Id8H*i~CGcqV+bfAs~m-C%Q
z7wT@}OAPn)gJOCB3`IW%jHv^_R7};34~wX`*ju>X+&UME-Dbi}>VnxmEU}7<H9cm^
zOt&;MLRS01J3PvYR2j1|8J!%bGA1^uVwUQ>Yh(CeYHISK>o^{qvk|1d1vp!Um=qum
z10TbCz7qznPqG3{dV%d&PC%evW7QoqkXW-0vVCHeJs0|fCV2`&jNQOz1qnM0EfiD<
zMD;e^3Cg&x=m>Ja>Qx@CD)MN&k>ju~>y-sO>(NvrSRo3^tQ}L!A%fHHJdF{12G^5%
zIq*DKChSKvUSl9YmQ%|1Q3)?#Dh8OwLYq9HGCKnF9jZ7k^6d(wie18u9o4d?T@P9o
zRi>FUcIYCBS%vtmrF|@cJV*%4RZhLhm6%<qjf-S1k|Qe+zte1*5}TY<L!@#6zrD2U
zk0Ek37tUeCUleVRb|P<R&*=b7w<0Oc{GF!~J0?xLe%Y%!uql2EPFPDoZ|W7F=#D<&
zV&eKUR>5{`q<ay&iW<y;HLGNopE67IitYNjaDl2LmB6Wb@D94d+VIDKU$f7#BnZL*
zNF0Fpu?&RRlDeoaX^YyjxT>rutJ;dTCT=L}%7(VCZHn8<ma?sFY46m%YvX(U#$G1>
z5lnmsgGb=;A-H@5ZXAMJhhX$GNWMsYl~env?)`M{&o)UBpG(IH*8daed=EO8N7m*y
hgWaLAT~6=s11ZYyb`8F{z4L6R!tx)$1R7)~{0*voErS36

diff --git a/dev_backend/mysql_process/__pycache__/views.cpython-313.pyc b/dev_backend/mysql_process/__pycache__/views.cpython-313.pyc
deleted file mode 100644
index 86d7527857f0b94e8ee961703e5b6273c05f1d94..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1234
zcmY*Y&u<%55Pompde>fO?YNXQv>}+13YkJo!Bv&kw2InPVU5y~Evk?$S)1MGu(00U
z%x*$maVS3|4oJ`o2X1gnB@RV!;LmWB3#=L?65`OCkvSmI1M@bHMMv8A=9`)K=FK;=
zLtWPhN^Sdzdms_=hX6;C8!5vBRK6u9F=>Ms6lhuKQbRHrFhd5}$Uw$WKuPTkV^mO$
zEM!wGH*$ssnvsWmiZhJ~LkB(8l}5oRLNV3V#-ve#Qkk@r)8zapH5_XlTYY&1{<oRg
z^Yjp!xfX5dEq0o;v?E(h%AnKK&{Ir3`KLWK+036LAIjq_$JZw+`eSing(kU0-w$Fd
z=1xUU)N4HCz7r+NGPfKKiN1X6*3G3mHV<Pr@G<!2+pEE5%%LJB@;h!6C)pdR%kt2Y
zU*~Z<;!z}GO9E^-VEJ*|_FV4Am~CP)>iM>L7=pNz;&;=itK%TUys@&%qcHFzem7SQ
zA#gVBI7-x`yK`IIjss{rYc{rVEGlZB<2Uqhd5M&<jkBaVq7Esdrt~^B*#ey-FOuf?
zq)M!5LVT$ycud8Vo8qoi-jj~#G&2hlrzS=&N*&rEZ?P9hhhAVET2WRKwTo3*>-=th
znR{MPz8!$)V2P?7_%T-R{*4b2Bt^*fX4JL=hbM}|W6Sj_G88abk{eSEioh(2p~9eu
zI!p=!<q^ZZTrMX|)vg~`ovP@9>#w(0EyseYcZgnt6ghmWy=K`TVNa{wUbNx0kxLuj
zS>1B^$I*P)OD08|EHCw>EW=4mFo9om5tqm09vNsXQ-4%E_5J$~_5R%Do#K^#_R2qx
z^2djSqN8wXoBeY2SNikyox-Jl_R_xthUO>H3?BcC*60^nk$jE&H`+P&-7~MUA2a9J
zPpn2)D$gcL+zavXAc{)Vj)mNWF35;LG$UmJL@OXG7V(cJS!WH0EZz)3{LGLSwkfR5
z^6U?Iw>Qu4#PgOIGdBQHN1{J9g`f*tX_RXoMspS&c0jYjunp;mCk&}c*?2&Pc!t1p
z;$*ho#c}lbWjKRS3|F*)3l>f39+}xE^<7fmC*^(e#-F6RN6zk%SAN&0zG~jn1`3fT
zzMTDZ_I`es&I}}#)_>Ed?tk*b?d|67nT7s|g&qCkfT8)IaH2n5d2pfs=C$3kOa1Ak
Vox=5D1|362r04$<Ct(h={s%JMJM91f

diff --git a/dev_backend/vector_db_router/models.py b/dev_backend/vector_db_router/models.py
old mode 100644
new mode 100755
index 16cac52..c011d98
--- a/dev_backend/vector_db_router/models.py
+++ b/dev_backend/vector_db_router/models.py
@@ -1,104 +1,104 @@
-from qdrant_client import AsyncQdrantClient, models
-from qdrant_client.models import PointStruct
-from typing import Dict, Any
-
-class CollectionHandler:
-    def __init__(self, collection_name: str, vector: Any, vector_size: int, payload: Dict,
-    id: int=None,
-    link: str=None,
-    asin: str=None,
-    category: str=None,
-    brand: str=None,
-    client: AsyncQdrantClient=None
-    ):
-        self.collection_name = collection_name
-        self.vector = vector
-        self.id = id
-        self.vector_size = vector_size
-        self.payload = payload
-        self.link = link
-        self.asin = asin
-        self.category = category
-        self.brand = brand
-        self.client = client if client else AsyncQdrantClient("localhost", port=6333)
-
-    async def create_collection(self):
-        try:
-            if await self.client.collection_exists(self.collection_name):
-                return {"message": "Collection already exists"}
-            
-            await self.client.create_collection(
-                collection_name=self.collection_name,
-                vectors_config=models.VectorParams(size=self.vector_size, distance=models.Distance.EUCLID),
-                optimizers_config=models.OptimizersConfigDiff(indexing_threshold=20000)
-            )
-            
-            # Creating payload indexes as per project logic
-
-            await self.client.create_payload_index(
-                collection_name=self.collection_name,
-                field_name="link",
-                field_schema=models.PayloadSchemaType.KEYWORD
-            )
-            await self.client.create_payload_index(
-                collection_name=self.collection_name,
-                field_name="title",
-                field_schema=models.PayloadSchemaType.KEYWORD
-            )
-
-            await self.client.create_payload_index(
-                collection_name=self.collection_name,
-                field_name="brand",
-                field_schema=models.PayloadSchemaType.KEYWORD
-            )
-            await self.client.create_payload_index(
-                collection_name=self.collection_name,
-                field_name="asin",
-                field_schema=models.PayloadSchemaType.KEYWORD
-            )
-
-            
-            return {"message": f"Collection {self.collection_name} created successfully"}
-        except Exception as e:
-            return {"message": str(e)}
-
-    async def insertion(self):
-        try:
-            await self.client.upsert(
-                collection_name=self.collection_name,
-                points=[
-                    PointStruct(id=self.id, vector=self.vector, payload=self.payload)
-                ]
-            )
-            return True
-        except Exception as e:
-            # Note: In a real app we'd use a logger here
-            print(f"Insertion failed for ID {self.id}: {e}")
-            return False
-    
-    async def upsert_point(self):
-        return await self.insertion()
-
-    async def search(self, query_vector):
-        try:
-            result = await self.client.search(
-                collection_name=self.collection_name,
-                query_vector=query_vector,
-                limit=10
-            )
-            return result
-        except Exception as e:
-            print("Search failed: ", e)
-            return None
-
-    async def update_collection(self):
-        """Update is implemented as an upsert of the point data."""
-        return await self.upsert_point()
-
-    async def delete_collection(self):
-        try:
-            await self.client.delete_collection(collection_name=self.collection_name)
-            return {"message": f"Collection {self.collection_name} deleted successfully"}
-        except Exception as e:
-            return {"message": str(e)}
-    
+from qdrant_client import AsyncQdrantClient, models
+from qdrant_client.models import PointStruct
+from typing import Dict, Any
+
+class CollectionHandler:
+    def __init__(self, collection_name: str, vector: Any, vector_size: int, payload: Dict,
+    id: int=None,
+    link: str=None,
+    asin: str=None,
+    category: str=None,
+    brand: str=None,
+    client: AsyncQdrantClient=None
+    ):
+        self.collection_name = collection_name
+        self.vector = vector
+        self.id = id
+        self.vector_size = vector_size
+        self.payload = payload
+        self.link = link
+        self.asin = asin
+        self.category = category
+        self.brand = brand
+        self.client = client if client else AsyncQdrantClient("localhost", port=6333)
+
+    async def create_collection(self):
+        try:
+            if await self.client.collection_exists(self.collection_name):
+                return {"message": "Collection already exists"}
+            
+            await self.client.create_collection(
+                collection_name=self.collection_name,
+                vectors_config=models.VectorParams(size=self.vector_size, distance=models.Distance.EUCLID),
+                optimizers_config=models.OptimizersConfigDiff(indexing_threshold=20000)
+            )
+            
+            # Creating payload indexes as per project logic
+
+            await self.client.create_payload_index(
+                collection_name=self.collection_name,
+                field_name="link",
+                field_schema=models.PayloadSchemaType.KEYWORD
+            )
+            await self.client.create_payload_index(
+                collection_name=self.collection_name,
+                field_name="title",
+                field_schema=models.PayloadSchemaType.KEYWORD
+            )
+
+            await self.client.create_payload_index(
+                collection_name=self.collection_name,
+                field_name="brand",
+                field_schema=models.PayloadSchemaType.KEYWORD
+            )
+            await self.client.create_payload_index(
+                collection_name=self.collection_name,
+                field_name="asin",
+                field_schema=models.PayloadSchemaType.KEYWORD
+            )
+
+            
+            return {"message": f"Collection {self.collection_name} created successfully"}
+        except Exception as e:
+            return {"message": str(e)}
+
+    async def insertion(self):
+        try:
+            await self.client.upsert(
+                collection_name=self.collection_name,
+                points=[
+                    PointStruct(id=self.id, vector=self.vector, payload=self.payload)
+                ]
+            )
+            return True
+        except Exception as e:
+            # Note: In a real app we'd use a logger here
+            print(f"Insertion failed for ID {self.id}: {e}")
+            return False
+    
+    async def upsert_point(self):
+        return await self.insertion()
+
+    async def search(self, query_vector):
+        try:
+            result = await self.client.search(
+                collection_name=self.collection_name,
+                query_vector=query_vector,
+                limit=10
+            )
+            return result
+        except Exception as e:
+            print("Search failed: ", e)
+            return None
+
+    async def update_collection(self):
+        """Update is implemented as an upsert of the point data."""
+        return await self.upsert_point()
+
+    async def delete_collection(self):
+        try:
+            await self.client.delete_collection(collection_name=self.collection_name)
+            return {"message": f"Collection {self.collection_name} deleted successfully"}
+        except Exception as e:
+            return {"message": str(e)}
+    
diff --git a/dev_backend/vector_db_router/serializers.py b/dev_backend/vector_db_router/serializers.py
old mode 100644
new mode 100755
index dd43e20..fa3bbb1
--- a/dev_backend/vector_db_router/serializers.py
+++ b/dev_backend/vector_db_router/serializers.py
@@ -1,22 +1,22 @@
-from pydantic import BaseModel
-from typing import Dict, List, Any
-
-class CreateCollectionSerializer(BaseModel):
-    collection_name: str
-    vector: List[float]
-    vector_size: int
-    payload: Dict[str, Any]
-    id: int
-
-class QueryCollectionSerializer(BaseModel):
-    collection_name: str
-    query_vector: List[float]
-
-class UpdateCollectionSerializer(BaseModel):
-    collection_name: str
-    vector: List[float]
-    payload: Dict[str, Any]
-    id: int
-
-class DeleteCollectionSerializer(BaseModel):
-    collection_name: str
+from pydantic import BaseModel
+from typing import Dict, List, Any
+
+class CreateCollectionSerializer(BaseModel):
+    collection_name: str
+    vector: List[float]
+    vector_size: int
+    payload: Dict[str, Any]
+    id: int
+
+class QueryCollectionSerializer(BaseModel):
+    collection_name: str
+    query_vector: List[float]
+
+class UpdateCollectionSerializer(BaseModel):
+    collection_name: str
+    vector: List[float]
+    payload: Dict[str, Any]
+    id: int
+
+class DeleteCollectionSerializer(BaseModel):
+    collection_name: str
diff --git a/dev_backend/vector_db_router/views.py b/dev_backend/vector_db_router/views.py
old mode 100644
new mode 100755
index b87275e..c88a5c5
--- a/dev_backend/vector_db_router/views.py
+++ b/dev_backend/vector_db_router/views.py
@@ -1,183 +1,183 @@
-from db_setup import get_qdrant_client
-from typing import Annotated
-from fastapi import Depends, HTTPException, APIRouter
-from qdrant_client import AsyncQdrantClient
-from fastapi.responses import JSONResponse
-from .serializers import (
-    CreateCollectionSerializer, 
-    QueryCollectionSerializer, 
-    UpdateCollectionSerializer, 
-    DeleteCollectionSerializer
-)
-from model_export.dino_image_matching import get_vectors
-from .models import CollectionHandler
-import os
-app_router = APIRouter()
-import logging
-logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
-log = logging.getLogger(__name__)
-
-import pandas as pd
-
-@app_router.get("/get_vectors")
-async def get_vectors_endpoint(
-    q: Annotated[AsyncQdrantClient, Depends(get_qdrant_client)],
-    image_path:str=os.getenv("DATASET")
-):
-    try:
-        # Construct path relative to this file
-        base_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-        excel_path = os.path.join(base_root, "model_export", "listing_data.xlsx")
-        df = pd.read_excel(excel_path)
-        asin_list = df['ASIN'].dropna().astype(str).tolist()
-        log.info(f"Generating vectors and ingesting {len(asin_list)} ASINs into Qdrant from {excel_path}")
-        
-        # 1. Initialize/Create collection "Product"
-        # DINOv2 vitb14 vector size is 768
-        init_handler = CollectionHandler(
-            collection_name="Product",
-            vector=[],
-            vector_size=768,
-            payload={},
-            client=q
-        )
-        await init_handler.create_collection()
-        
-        result_lst = []
-        for index, row in df.iterrows():
-            asin = str(row['ASIN'])
-            if pd.isna(row['ASIN']):
-                continue
-                
-            title = str(row['Title'])
-            brand = str(row['Brand'])
-            link = str(row['Image'])
-            
-            # Call get_vectors
-            vector = get_vectors(image_input=image_path, item=asin)
-            
-            if vector is None:
-                log.warning(f"Skipping {asin} due to missing image/vector")
-                continue
-            
-            payload = {
-                "asin": asin,
-                "title": title,
-                "brand": brand,
-                "link": link
-            }
-            
-            # 2. Ingest into Qdrant using CollectionHandler
-            # Use the injected client 'q' and convert index to int
-            handler = CollectionHandler(
-                collection_name="Product",
-                vector=vector,
-                vector_size=768,
-                payload=payload,
-                id=int(index),
-                link=link,
-                asin=asin,
-                brand=brand,
-                client=q
-            )
-            success = await handler.upsert_point()
-            
-            if success:
-                result_lst.append({
-                    "item": asin, 
-                    "status": "ingested",
-                    "payload": payload
-                })
-                log.info(f"Vector ingested for {asin} (ID: {index})")
-            else:
-                log.error(f"Failed to ingest vector for {asin}")
-        
-        return JSONResponse({"status": "success", "message": f"Ingested {len(result_lst)} items into Product collection", "result": result_lst})
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app_router.post("/create")
-async def create_collection_endpoint(
-    q: Annotated[AsyncQdrantClient, Depends(get_qdrant_client)],
-    body: CreateCollectionSerializer = None
-):
-    try:
-        if body is None:
-            raise HTTPException(status_code=400, detail="Collection name is required")
-        
-        print("collection_name: ", body.collection_name)
-        
-        handler = CollectionHandler(
-            collection_name=body.collection_name,
-            vector=body.vector,
-            vector_size=body.vector_size,
-            payload=body.payload,
-            id=body.id
-        )
-        
-        # 1. Create collection
-        result = await handler.create_collection()
-        
-        # 2. Automatically call upsert_point
-        await handler.upsert_point()
-
-        return JSONResponse(result)
-
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app_router.get("/query")
-async def query_collection_endpoint(
-    q: Annotated[AsyncQdrantClient, Depends(get_qdrant_client)],
-    body: QueryCollectionSerializer
-):
-    try:
-        handler = CollectionHandler(
-            collection_name=body.collection_name,
-            vector=body.query_vector,
-            vector_size=len(body.query_vector),
-            payload={},
-            id=0
-        )
-        result = await handler.search(body.query_vector)
-        return JSONResponse({"results": str(result)})
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app_router.put("/update")
-async def update_collection_endpoint(
-    q: Annotated[AsyncQdrantClient, Depends(get_qdrant_client)],
-    body: UpdateCollectionSerializer
-):
-    try:
-        handler = CollectionHandler(
-            collection_name=body.collection_name,
-            vector=body.vector,
-            vector_size=len(body.vector),
-            payload=body.payload,
-            id=body.id
-        )
-        result = await handler.update_collection()
-        return JSONResponse({"status": "success", "result": result})
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app_router.delete("/delete")
-async def delete_collection_endpoint(
-    q: Annotated[AsyncQdrantClient, Depends(get_qdrant_client)],
-    body: DeleteCollectionSerializer
-):
-    try:
-        handler = CollectionHandler(
-            collection_name=body.collection_name,
-            vector=[],
-            vector_size=0,
-            payload={},
-            id=0
-        )
-        result = await handler.delete_collection()
-        return JSONResponse(result)
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-        
+from db_setup import get_qdrant_client
+from typing import Annotated
+from fastapi import Depends, HTTPException, APIRouter
+from qdrant_client import AsyncQdrantClient
+from fastapi.responses import JSONResponse
+from .serializers import (
+    CreateCollectionSerializer, 
+    QueryCollectionSerializer, 
+    UpdateCollectionSerializer, 
+    DeleteCollectionSerializer
+)
+from model_export.dino_image_matching import get_vectors
+from .models import CollectionHandler
+import os
+app_router = APIRouter()
+import logging
+logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
+log = logging.getLogger(__name__)
+
+import pandas as pd
+
+@app_router.get("/get_vectors")
+async def get_vectors_endpoint(
+    q: Annotated[AsyncQdrantClient, Depends(get_qdrant_client)],
+    image_path:str=os.getenv("DATASET")
+):
+    try:
+        # Construct path relative to this file
+        base_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+        excel_path = os.path.join(base_root, "model_export", "listing_data.xlsx")
+        df = pd.read_excel(excel_path)
+        asin_list = df['ASIN'].dropna().astype(str).tolist()
+        log.info(f"Generating vectors and ingesting {len(asin_list)} ASINs into Qdrant from {excel_path}")
+        
+        # 1. Initialize/Create collection "Product"
+        # DINOv2 vitb14 vector size is 768
+        init_handler = CollectionHandler(
+            collection_name="Product",
+            vector=[],
+            vector_size=768,
+            payload={},
+            client=q
+        )
+        await init_handler.create_collection()
+        
+        result_lst = []
+        for index, row in df.iterrows():
+            asin = str(row['ASIN'])
+            if pd.isna(row['ASIN']):
+                continue
+                
+            title = str(row['Title'])
+            brand = str(row['Brand'])
+            link = str(row['Image'])
+            
+            # Call get_vectors
+            vector = get_vectors(image_input=image_path, item=asin)
+            
+            if vector is None:
+                log.warning(f"Skipping {asin} due to missing image/vector")
+                continue
+            
+            payload = {
+                "asin": asin,
+                "title": title,
+                "brand": brand,
+                "link": link
+            }
+            
+            # 2. Ingest into Qdrant using CollectionHandler
+            # Use the injected client 'q' and convert index to int
+            handler = CollectionHandler(
+                collection_name="Product",
+                vector=vector,
+                vector_size=768,
+                payload=payload,
+                id=int(index),
+                link=link,
+                asin=asin,
+                brand=brand,
+                client=q
+            )
+            success = await handler.upsert_point()
+            
+            if success:
+                result_lst.append({
+                    "item": asin, 
+                    "status": "ingested",
+                    "payload": payload
+                })
+                log.info(f"Vector ingested for {asin} (ID: {index})")
+            else:
+                log.error(f"Failed to ingest vector for {asin}")
+        
+        return JSONResponse({"status": "success", "message": f"Ingested {len(result_lst)} items into Product collection", "result": result_lst})
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app_router.post("/create")
+async def create_collection_endpoint(
+    q: Annotated[AsyncQdrantClient, Depends(get_qdrant_client)],
+    body: CreateCollectionSerializer = None
+):
+    try:
+        if body is None:
+            raise HTTPException(status_code=400, detail="Collection name is required")
+        
+        print("collection_name: ", body.collection_name)
+        
+        handler = CollectionHandler(
+            collection_name=body.collection_name,
+            vector=body.vector,
+            vector_size=body.vector_size,
+            payload=body.payload,
+            id=body.id
+        )
+        
+        # 1. Create collection
+        result = await handler.create_collection()
+        
+        # 2. Automatically call upsert_point
+        await handler.upsert_point()
+
+        return JSONResponse(result)
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app_router.get("/query")
+async def query_collection_endpoint(
+    q: Annotated[AsyncQdrantClient, Depends(get_qdrant_client)],
+    body: QueryCollectionSerializer
+):
+    try:
+        handler = CollectionHandler(
+            collection_name=body.collection_name,
+            vector=body.query_vector,
+            vector_size=len(body.query_vector),
+            payload={},
+            id=0
+        )
+        result = await handler.search(body.query_vector)
+        return JSONResponse({"results": str(result)})
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app_router.put("/update")
+async def update_collection_endpoint(
+    q: Annotated[AsyncQdrantClient, Depends(get_qdrant_client)],
+    body: UpdateCollectionSerializer
+):
+    try:
+        handler = CollectionHandler(
+            collection_name=body.collection_name,
+            vector=body.vector,
+            vector_size=len(body.vector),
+            payload=body.payload,
+            id=body.id
+        )
+        result = await handler.update_collection()
+        return JSONResponse({"status": "success", "result": result})
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app_router.delete("/delete")
+async def delete_collection_endpoint(
+    q: Annotated[AsyncQdrantClient, Depends(get_qdrant_client)],
+    body: DeleteCollectionSerializer
+):
+    try:
+        handler = CollectionHandler(
+            collection_name=body.collection_name,
+            vector=[],
+            vector_size=0,
+            payload={},
+            id=0
+        )
+        result = await handler.delete_collection()
+        return JSONResponse(result)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+        
     
\ No newline at end of file