Deploy backend to Hugging Face

.env

@@ -0,0 +1,16 @@
+
+DATABASE_URL=https://mrlyvrpxsumashqzcmhd.supabase.co
+SUPABASE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im1ybHl2cnB4c3VtYXNocXpjbWhkIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjE1NzQ5ODAsImV4cCI6MjA3NzE1MDk4MH0.HoD5V3nXSGnLFSbjcqveBn7LUZZPS4KUTEuM3eoQ2uQ
+
+JWT_SECRET_KEY=Hello_buddy
+SECRET_KEY=hello_buddy
+CLIENT=http://localhost:3000
+Qdrant_api_key=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhY2Nlc3MiOiJtIn0.9ZKSLbgV0_jyesC_fqhyuMHS2XRacAKa-jYeo01vCng
+Qdrant_url=https://db450db1-2425-4e2e-b839-b1c585defee3.europe-west3-0.gcp.cloud.qdrant.io
+Qdrant_Collection=FINDR
+
+CLOUDINARY_API_SECRET=oaBBFHmbY7i6GNs8q_auVcwd5OM
+CLOUDINARY_API_KEY=456896227428735
+CLOUDINARY_CLIENT_NAME=dc728fl24
+CLOUDINARY_URL=cloudinary://456896227428735:oaBBFHmbY7i6GNs8q_auVcwd5OM@dc728fl24
+scheduler=https://findr-ai-scheduler.onrender.com

.gitignore

@@ -0,0 +1,168 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+/get-pip.py
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+Server/.env
+Client/.env
+.venv
+env/
+venv/
+new_env/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+/datasets
+/.dockerignore
+/start.sh
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

App/app.py

@@ -0,0 +1,447 @@
+import os
+from flask import Flask,request,jsonify,make_response
+from flask_bcrypt import Bcrypt
+from functools import wraps
+from supabase import create_client
+from flask_jwt_extended import JWTManager, create_access_token,unset_jwt_cookies, jwt_required, get_jwt_identity,decode_token
+from App.models import  User,LostItem,FoundItem,Match
+from dotenv import load_dotenv
+from flask_cors import CORS
+from src.training import encode_img_and_text
+from qdrant_client import QdrantClient
+from qdrant_client.http import models
+import cloudinary
+from cloudinary import uploader 
+import warnings
+import base64
+from io import BytesIO
+import threading
+from datetime import timedelta
+warnings.filterwarnings("ignore", message=".*QuickGELU mismatch.*")
+
+
+load_dotenv()
+
+app = Flask(__name__)
+app.config["SQLALCHEMY_DATABASE_URI"] = os.getenv("DATABASE_URL")
+app.config["SECRET_KEY"] = os.getenv("SECRET_KEY")
+app.config["JWT_SECRET_KEY"] = os.getenv("JWT_SECRET_KEY")
+app.config["JWT_TOKEN_LOCATION"] = ["cookies"]
+app.config["JWT_ACCESS_COOKIE_NAME"] = "Token"
+app.config["JWT_COOKIE_SAMESITE"] = "None"
+app.config["JWT_COOKIE_SECURE"] = False
+app.config["JWT_COOKIE_DOMAIN"] = ".localhost"
+app.config["JWT_ACCESS_TOKEN_EXPIRES"] = timedelta(days=3)
+
+
+qdrant=QdrantClient(
+    url=os.getenv("Qdrant_url"),
+    api_key=os.getenv("Qdrant_api_key"),
+)
+
+cloudinary.config(
+    cloud_name=os.getenv("CLOUDINARY_CLIENT_NAME"),
+    api_key=os.getenv("CLOUDINARY_API_KEY"),
+    api_secret=os.getenv("CLOUDINARY_API_SECRET"),
+)
+
+
+db = create_client(os.getenv("DATABASE_URL"),os.getenv("SUPABASE_KEY"))
+bcrypt=Bcrypt(app)
+jwt=JWTManager(app)
+CORS(app, supports_credentials=True, origins=[os.getenv("CLIENT")])
+
+
+print('Qdrant connected')
+print("Posgres Connected")
+
+
+
+def decode_jwt(fn):
+    @wraps(fn)
+    def wrapper(*args, **kwargs):
+        token=request.cookies.get("Token")
+        if not token:
+            print('no token found')
+            return jsonify({
+                "message":"No Token Found"
+            })
+        else:
+            id=decode_token(token)["sub"]
+            print(id)
+            return fn(user_id=id, *args, **kwargs)
+    return wrapper
+
+class DotDict(dict):
+    def __getattr__(self, key):
+        try:
+            return self[key]
+        except KeyError:
+            raise AttributeError(f"No such attribute: {key}")
+
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+
+
+
+    
+
+def upload_img(img):
+    return uploader.upload(img, resource_type="image")["secure_url"]    
+
+@app.route('/register',methods=["POST"])
+def register():
+    try:
+        print("received")
+        data=request.get_json()
+        first_name=data['firstName']
+        last_name=data['lastName']
+        email=data['email']
+        phone=data['phone']
+        password=data['password']
+        if db.table("users").select("*").eq("email",email).limit(1).execute().data:
+
+            return jsonify({
+                "success":False,
+                "error":"User Already Exist"
+            })
+        hashing=bcrypt.generate_password_hash(password).decode("utf-8")
+        new_user=db.table("users").insert({"first_name":first_name,"last_name":last_name,"email":email,"phone":phone,"password":hashing}).execute().data[0]
+        
+        token=create_access_token(identity=str(new_user.get("id")), expires_delta=timedelta(days=3))
+        res=make_response({
+            "success":True,
+            "message":"User Registered Successfully",
+
+        })
+        res.set_cookie("Token",token,httponly=True,secure=True,samesite="None",max_age=259200,domain=".localhost")
+        return res,200
+    except Exception as e:
+        print(e)
+        return jsonify({
+                "sucsess":False,
+                "message":"Internal Server Error"
+            }),400
+
+@app.route("/login",methods=["POST"])
+def login():
+    try:
+        data=request.get_json()
+        print(data)
+        email=data['email']
+        password=data['password']
+        user= db.table("users").select("*").eq("email",email).limit(1).execute().data[0]
+        if not user or not bcrypt.check_password_hash(user.get("password"),password):
+            return jsonify({
+                "sucsess":False,
+                "message":"No User Found"
+            }),200
+        token=create_access_token(identity=str(user.get("id")), expires_delta=timedelta(days=3))
+        res=make_response({
+            "success":True,
+            "message":"User Login Successfully",
+
+            })
+        res.set_cookie("Token",token,httponly=True,secure=True,samesite="None",max_age=259200,domain=".localhost")
+        return res,200
+    except Exception as e:
+        print(e)
+        return jsonify({
+                "sucsess":False,
+                "message":"Internal Server Error"
+            }),400
+
+
+@app.route('/logout',methods=["GET"])
+def logout():
+    res=make_response({
+        "success":True,
+        "message":"Logout Successfully"
+    })
+    unset_jwt_cookies(res)
+    return res,200
+
+@app.route('/get_user',methods=['GET'])
+@decode_jwt
+def get_user(user_id):
+    user=user= db.table("users").select("*").eq("id",user_id).limit(1).execute().data[0]
+    return jsonify({
+        "success":True,
+        "user":{"first_name": user.first_name,
+                "last_name": user.last_name,
+                "email": user.email,
+                "phone_number": user.phone}
+            }), 200
+
+
+@app.route('/lostItem',methods=['POST'])
+@decode_jwt
+def lostItem(user_id):
+    print('search start')
+    try:
+        imgs_data=request.files.getlist('item')
+        img_urls=[upload_img(img) for img in imgs_data]    
+        description=request.form.get('description')
+        print(imgs_data, description)
+        vector=encode_img_and_text(imgs_data,description)
+        lastSeenLocation=request.form.get('lastSeenLocation')
+        dateTimeLost=request.form.get('dateTimeLost')
+        name=request.form.get('name')
+        email=request.form.get('email')
+        phone=request.form.get('phone')
+        reward=request.form.get('reward')
+        additionalNotes=request.form.get('additionalNotes')
+        item=db.table("lostItem").insert({"user_id":user_id,"name":name,"email":email,"phone":phone,"description":description,"lastSeenLocation":lastSeenLocation,"dateTimeLost":dateTimeLost,"reward":reward,"additionalNotes":additionalNotes,"image_url": img_urls}).execute().data[0]
+        print('db save', len(vector))
+
+        collections = qdrant.get_collections().collections
+        existing_names = [c.name for c in collections]
+    
+        if "lost_items" not in existing_names:
+            qdrant.create_collection(
+            collection_name="lost_items",
+            vectors_config=models.VectorParams(
+                size=512,
+                distance=models.Distance.COSINE
+            )
+        )
+
+        qdrant.upsert(
+            collection_name="lost_items",
+            points=[
+                models.PointStruct(id=item.get("id"), vector=vector, payload={"description":description,"place_lost":lastSeenLocation,"status" : "active"})
+            ],
+        )
+        print('vector save')
+        return jsonify({
+            "success":True
+        }),200
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({
+            "success":False
+        }),400
+
+
+@app.route('/foundItem',methods=['POST'])
+@decode_jwt
+def foundItem(user_id):
+    print('search start')
+    try:
+        imgs_data=request.files.getlist('item')
+        img_urls=[upload_img(img) for img in imgs_data]    
+        description=request.form.get('description')
+        print(imgs_data, description)
+        vector=encode_img_and_text(imgs_data,description)
+        found_near=request.form.get('found_near')
+        name=request.form.get('name')
+        email=request.form.get('email')
+        phone=request.form.get('phone')
+        item=db.table("foundItem").insert({"user_id":user_id,"name":name,"email":email,"phone":phone,"description":description,"found_near":found_near,"image_url": img_urls}).execute().data[0]
+
+        print('db save', len(vector))
+
+        collections = qdrant.get_collections().collections
+        existing_names = [c.name for c in collections]
+    
+        if "found_items" not in existing_names:
+            qdrant.create_collection(
+            collection_name="found_items",
+            vectors_config=models.VectorParams(
+                size=512,
+                distance=models.Distance.COSINE
+            )
+        )
+
+        qdrant.upsert(
+            collection_name="found_items",
+            points=[
+                models.PointStruct(id=item.get("id"), vector=vector, payload={"description":description,"place_found":found_near,"status" : "active"})
+            ],
+        )
+        print('vector save')
+        return jsonify({
+            "success":True
+        }),200
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({
+            "success":False
+        }),200
+
+@app.route('/allLostItems',methods=['GET'])
+@decode_jwt
+def allLostItems(user_id):
+    
+        rows = db.table("lostItem").select("*").eq("user_id",user_id).execute().data
+        items = [DotDict(r) for r in rows]
+        output = []
+        for item in items[0]:
+            output.append({
+            "id": item.id,
+            "name": item.name,
+            "email": item.email,
+            "phone": item.phone,
+            "description": item.description,
+            "lastSeenLocation": item.lastSeenLocation,
+            "dateTimeLost": item.dateTimeLost,
+            "reward": item.reward,
+            "additionalNotes": item.additionalNotes,
+            "image_url": item.image_url,
+            "status": item.status,
+            "created_at": item.created_at
+        })
+        return jsonify({
+            "success":True,
+            "lostItems":output
+        }),200
+
+@app.route('/matchLost/<lost_id>',methods=['GET'])
+def matchLost(lost_id):
+    items = db.table("lostItem").select("*").eq("id",lost_id).limit(1).execute().data[0]
+    found_items=[]
+    if not items.get("found_items"):
+        return jsonify({
+            "success":False,
+            "message":"No Lost Item Found"
+        }),400
+    for ids in items.get("found_items"):
+        found_item=db.table("foundItem").select("*").eq("id",int(ids)).limit(1).execute().data[0]
+        if found_item:
+            found_items.append({
+                "id": found_item.get("id"),
+                "name": found_item.get("name"),
+                "email": found_item.get("email"),
+                "phone": found_item.get("phone"),
+                "description": found_item.get("description"),
+                "found_near": found_item.get("found_near"),
+                "image_url": found_item.get("image_url"),
+                "status": found_item.get("status"),
+                "created_at": found_item.get("created_at")
+            })   
+    
+    return jsonify({
+            "success":True,
+            "foundItems": found_items
+        }),200
+
+
+
+@app.route('/matchFound/<lost_id>',methods=['GET'])
+def matchFound(lost_id):
+    items = db.table("foundItem").select("*").eq("id",lost_id).limit(1).execute().data[0]
+
+    found_items=[]
+    if not items.get("lost_items"):
+        return jsonify({
+            "success":False,
+            "message":"No Found Item Found"
+        }),200
+    for ids in items.get("lost_items"):
+        found_item=db.table("lostItem").select("*").eq("id",int(ids)).limit(1).execute().data[0]
+        if found_item:
+            found_items.append({
+                "id": found_item.get("id"),
+                "name": found_item.get("name"),
+                "email": found_item.get("email"),
+                "phone": found_item.get("phone"),
+                "description": found_item.get("description"),
+                "found_near": found_item.get("lastSeenLocation"),
+                "image_url": found_item.get("image_url"),
+                "status": found_item.get("status"),
+                "created_at": found_item.get("created_at")
+            })
+    
+    return jsonify({
+            "success":True,
+            "foundItems": found_items
+        }),200
+
+
+@app.route('/lostMatchDetail/<lost_id>',methods=['GET'])
+def lostMatchDetail(lost_id):
+    found_item = db.table("lostItem").select("*").eq("id",lost_id).limit(1).execute().data[0]
+    found_items=[]
+    if not found_item:
+        return jsonify({
+            "success":False,
+            "message":"No Found Item Found"
+        }),400
+    
+    found_items.append({
+                "id": found_item.get("id"),
+                "name": found_item.get("name"),
+                "email": found_item.get("email"),
+                "phone": found_item.get("phone"),
+                "description": found_item.get("description"),
+                "found_near": found_item.get("lastSeenLocation"),
+                "image_url": found_item.get("image_url"),
+                "status": found_item.get("status"),
+                "date_lost":found_item.get("dateTimeLost"),
+                "reward":found_item.get("reward"),
+                "additional_notes":found_item.get("additionalNotes"),
+                "created_at": found_item.get("created_at")
+    })
+
+    
+    return jsonify({
+            "success":True,
+            "foundItems": found_items
+        }),200
+
+
+@app.route('/allFoundItems',methods=['GET'])
+@decode_jwt
+def allFoundItems(user_id):
+    items = db.table("foundItem").select("*").eq("user_id",user_id).execute().data[0]
+    output = []
+    for item in items:
+            output.append({
+            "id": item.get("id"),
+            "name": item.get("name"),
+            "email": item.get("email"),
+            "phone": item.get("phone"),
+            "description": item.get("description"),
+            "found_near": item.get("found_near"),
+            "image_url": item.get("image_url"),
+            "status": item.get("status"),
+            "created_at": item.get("created_at")
+        })
+    return jsonify({
+            "success":True,
+            "foundItems":output
+        }),200
+
+@app.route('/foundMatchDetail/<lost_id>',methods=['GET'])
+def foundMatchDetail(lost_id):
+    found_item = db.table("foundItem").select("*").eq("id",lost_id).limit(1).execute().data[0]
+    print(lost_id)
+    found_items=[]
+    if not found_item:
+        return jsonify({
+            "success":False,
+            "message":"No Found Item Found"
+        }),400
+    
+    found_items.append({
+                "id": found_item.get("id"),
+                "name": found_item.get("name"),
+                "email": found_item.get("email"),
+                "phone": found_item.get("phone"),
+                "description": found_item.get("description"),
+                "found_near": found_item.get("found_near"),
+                "image_url": found_item.get("image_url"),
+                "status": found_item.get("status"),
+                "created_at": found_item.get("created_at")
+    })
+    
+    
+    return jsonify({
+            "success":True,
+            "foundItems": found_items
+        }),200
+    
+if __name__ == "__main__":
+    app.run(debug=True,port=8000)

App/models.py

@@ -0,0 +1,56 @@
+from flask_sqlalchemy import SQLAlchemy
+import uuid
+from sqlalchemy.dialects.postgresql import JSON,ARRAY
+from sqlalchemy.ext.mutable import MutableList
+
+db = SQLAlchemy()
+
+class User(db.Model):
+    __tablename__ = "users"
+
+    id = db.Column(db.Integer, primary_key=True)
+    first_name = db.Column(db.String(50), nullable=False)
+    last_name = db.Column(db.String(50), nullable=False)
+    email = db.Column(db.String(100), unique=True, nullable=False)
+    phone=db.Column(db.String(15), nullable=False)
+    password = db.Column(db.String(200), nullable=False)
+
+
+class LostItem(db.Model):
+    __tablename__="lostItem"
+    id = db.Column(db.Integer, primary_key=True, index=True)
+    user_id = db.Column(db.Integer, db.ForeignKey("users.id"),nullable=False)
+    name=db.Column(db.String,nullable=False)
+    email=db.Column(db.String,nullable=False)
+    phone=db.Column(db.String,nullable=False)
+    description = db.Column(db.Text, nullable=False)
+    lastSeenLocation = db.Column(db.Text, nullable=False)
+    dateTimeLost = db.Column(db.Text, nullable=False)
+    reward = db.Column(db.Text)
+    additionalNotes  = db.Column(db.Text)
+    image_url = db.Column(JSON, nullable=False)
+    status=db.Column(db.String,nullable=False,default='active')
+    found_items=db.Column(MutableList.as_mutable(ARRAY(db.String)),nullable=False)
+    created_at = db.Column(db.TIMESTAMP, server_default=db.func.now(),nullable=False)
+
+class FoundItem(db.Model):
+    __tablename__="foundItem"
+    id = db.Column(db.Integer, primary_key=True, index=True)
+    user_id = db.Column(db.Integer, db.ForeignKey("users.id"),nullable=False)
+    name=db.Column(db.String,nullable=False)
+    email=db.Column(db.String,nullable=False)
+    phone=db.Column(db.String,nullable=False)
+    description = db.Column(db.Text, nullable=False)
+    found_near= db.Column(db.Text, nullable=False)
+    image_url = db.Column(JSON, nullable=False)
+    status=db.Column(db.String,nullable=False,default='active')
+    lost_items=db.Column(MutableList.as_mutable(ARRAY(db.String)),nullable=False)
+    created_at = db.Column(db.TIMESTAMP, server_default=db.func.now(),nullable=False)
+
+class Match(db.Model):
+    __tablename__="matches"
+    id = db.Column(db.Integer, primary_key=True, index=True)
+    lost_item_id = db.Column(db.Integer, db.ForeignKey("lostItem.id"),nullable=False)
+    found_item_id = db.Column(db.Integer, db.ForeignKey("foundItem.id"),nullable=False)
+    confidence_score=db.Column(db.Float,nullable=False)
+    created_at = db.Column(db.TIMESTAMP, server_default=db.func.now(),nullable=False)    

App/scheduler.py

@@ -0,0 +1,195 @@
+import os
+from flask import Flask,request,jsonify,make_response
+from flask_bcrypt import Bcrypt
+from functools import wraps
+from flask_jwt_extended import JWTManager, create_access_token,unset_jwt_cookies, jwt_required, get_jwt_identity,decode_token
+from dotenv import load_dotenv
+from flask_cors import CORS
+from qdrant_client import QdrantClient
+from qdrant_client.http import models
+from datetime import datetime, timedelta
+from qdrant_client.models import PayloadSchemaType
+from supabase import create_client
+
+load_dotenv()
+
+app = Flask(__name__)
+app.config["SQLALCHEMY_DATABASE_URI"] = os.getenv("DATABASE_URL")
+
+db = create_client(os.getenv("DATABASE_URL"),os.getenv("SUPABASE_KEY"))
+
+
+qdrant=QdrantClient(
+    url=os.getenv("Qdrant_url"),
+    api_key=os.getenv("Qdrant_api_key"),
+)
+qdrant.create_payload_index(
+    collection_name="found_items",
+    field_name="status",
+    field_schema=PayloadSchemaType.KEYWORD
+)
+
+DEFAULT_MIN_AGE_MINUTES = 60
+DEFAULT_CONFIDENCE = 0.78
+DEFAULT_TOP_K = 5
+
+CORS(app, supports_credentials=True, origins=[os.getenv("CLIENT")])
+
+print('Qdrant connected')
+print("Posgres Connected")
+
+
+def iso_now_minus(minutes):
+    return (datetime.utcnow() - timedelta(minutes=minutes)).isoformat()
+
+
+@app.route("/admin/match-active-lost", methods=["POST"])
+def match_active_lost():
+    body = request.get_json(silent=True) or {}
+    min_age_minutes = int(body.get("min_age_minutes", DEFAULT_MIN_AGE_MINUTES))
+    confidence_threshold = float(body.get("confidence_threshold", DEFAULT_CONFIDENCE))
+    top_k = int(body.get("top_k", DEFAULT_TOP_K))
+
+    cutoff = iso_now_minus(min_age_minutes)
+    
+    lost_rows = (db.table("lostItem").select("*").eq("status","active").execute())
+    lost_items = [
+    {
+        "id": r.get("id"),
+        "user_id": r.get("user_id"),
+        "created_at": r.get("created_at")
+    }
+
+    
+    for r in lost_rows.data
+    ]
+    if not lost_items:
+        return jsonify({"message": "No eligible lost items found", "checked": 0}), 200
+    
+    created_matches = []
+    errors = []
+
+    for lost in lost_items:
+        lost_id=int(lost["id"])
+        lost_user_id=str(lost["user_id"])
+        try:
+            point=qdrant.retrieve(collection_name="lost_items", ids=[lost_id], with_vectors=True)
+            if not point:
+                errors.append({"lost_id": lost_id, "error": "No vector found in Qdrant for this lost item"})
+                continue
+            lost_vector = point[0].vector
+        except Exception as e:
+            errors.append({"lost_id": lost_id, "error": f"Qdrant get_point failed: {str(e)}"})
+            continue
+
+        qfilter = models.Filter(
+            must=[models.FieldCondition(key="status", match=models.MatchValue(value="active"))]
+        )    
+
+        try:
+            results = qdrant.search(
+                collection_name="found_items",
+                query_vector=lost_vector,
+                limit=top_k,
+                query_filter=qfilter
+            )
+        except Exception as e:
+            errors.append({"lost_id": lost_id, "error": f"Qdrant search failed: {str(e)}"})
+            continue
+
+        for r in results:
+            score = float(r.score) if r.score is not None else None
+            if score is None:
+                continue
+            if score < confidence_threshold:
+                continue
+
+            found_point_payload = r.payload or {}
+            found_supabase_id = found_point_payload.get("id") or r.id
+            
+            if lost_user_id == str(found_point_payload.get("user_id")):
+                continue
+
+            try:
+                existing_match=db.table("matches").select("lost_item_id","found_item_id").eq("found_item_id", found_supabase_id).eq("lost_item_id", lost_id).limit(1).execute()
+                if existing_match:
+                    continue
+            except Exception as e:
+                errors.append({"lost_id": lost_id, "error": f"Database query failed: {str(e)}"})
+                continue
+            
+            
+            try:
+                match_record = db.table("matches").insert({
+                                 "lost_item_id": lost_id,
+                                 "found_item_id": found_supabase_id,
+                                 "confidence_score": score
+                                    }).execute()
+                created_matches.append({"lost_id": lost_id, "found_id": found_supabase_id, "similarity": score})
+            except Exception as e:
+                errors.append({"lost_id": lost_id, "found_id": found_supabase_id, "error": f"Supabase insert failed: {str(e)}"})
+    
+    matches=(db.table("matches").select("id","lost_item_id","found_item_id","confidence_score").execute()) 
+
+    match_items = [
+    {
+        "id": r.get("id"),
+        "lost_id": int(r.get("lost_item_id")),
+        "found_id": int(r.get("found_item_id")),
+        "confidence_score": r.get("confidence_score")
+    }     
+    for r in matches.data
+    ]
+
+    for match in match_items:
+        already_exist_found=(db.table("lostItem").select("*").eq("user_id", match["lost_id"]).contains("found_items", [str(match["found_id"])]).limit(1).execute()
+)
+        if already_exist_found:
+            continue
+        else:
+            res=(db.table("lostItem").select("*").eq("id", match["lost_id"]).limit(1).execute()
+)
+            if not res.data:
+                found_item = None
+            else:
+                found_item = res.data[0]
+
+            current_lost_items = found_item.get("found_items") or []
+
+            if match["found_id"] not in current_lost_items:
+                current_lost_items.append(match["found_id"])
+
+            db.table("lostItem").update({"found_items": current_lost_items }).eq("id", match["lost_id"]).execute()  
+        
+        already_exist_found=( db.table("foundItem").select("*").eq("user_id", match["found_id"]).contains("lost_items", [str(match["lost_id"])]).limit(1).execute()
+)
+        if already_exist_found:
+            continue    
+        
+        else:
+            res=(db.table("foundItem").select("lost_items").eq("id", match["found_id"]).limit(1).execute()
+)
+            if not res.data:
+                found_item = None
+            else:
+                found_item = res.data[0]
+
+            current_lost_items = found_item.get("lost_items") or []
+
+            if match["lost_id"] not in current_lost_items:
+                current_lost_items.append(match["lost_id"])
+
+            db.table("foundItem").update({"lost_items": current_lost_items }).eq("id", match["found_id"]).execute()    
+
+
+    return jsonify({
+        "checked_lost_count": len(lost_rows.data),
+        "created_matches_count": len(created_matches),
+        "created_matches": created_matches,
+        "errors": errors
+    }), 200
+
+
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0",port=5000)

Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.10-slim
+
+WORKDIR /Server
+
+# 🔴 REQUIRED system libraries for pyarrow / datasets
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    gcc \
+    g++ \
+    cmake \
+    curl \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+
+# 🔴 Upgrade tooling and install deps
+RUN python -m pip install --upgrade pip setuptools wheel \
+    && python -m pip install -r requirements.txt --no-cache-dir
+
+COPY . .
+
+CMD ["python", "-m", "App.app"]
+

requirements.txt

@@ -0,0 +1,19 @@
+torch
+torchvision
+numpy
+pillow
+tqdm
+transformers
+huggingface_hub
+flask
+flask-cors
+flask-sqlalchemy
+flask-bcrypt
+flask-jwt-extended
+psycopg2-binary
+python-dotenv
+cloudinary
+qdrant-client
+datasets
+open-clip-torch
+supabase

requirements_scheduler.txt

@@ -0,0 +1,13 @@
+flask
+flask-cors
+flask-sqlalchemy
+flask-bcrypt
+flask-jwt-extended
+psycopg2-binary
+python-dotenv
+cloudinary
+qdrant-client
+numpy
+pillow
+tqdm
+supabase

setup.py

@@ -0,0 +1,25 @@
+from setuptools import setup,find_packages
+from typing import List
+
+HYPHEN_E_DOT='-e .'
+
+def get_requiremnets(filename : str)->List[str]:
+    requirements = []
+    with open(filename,'r') as f:
+        requirements=f.readlines()
+        requirements = [req.replace('\n','') for req in requirements]
+
+        if HYPHEN_E_DOT in requirements:
+            requirements.remove(HYPHEN_E_DOT)
+
+    return requirements        
+
+setup (
+    name = "FINDR",
+    version = "0.0.1",
+    packages = find_packages(),
+    author = "Prashant",
+    author_email = "prashant.goyal2002@gmail.com",
+    description = "a simple project to predict performance of student",
+    install_requires = get_requiremnets('requirements.txt')
+)

src/evaluation.py

@@ -0,0 +1,59 @@
+import os,json
+from training import clip_dataset
+import torch
+from torch.utils.data import DataLoader
+import open_clip
+from datasets import load_dataset
+from tqdm import tqdm
+import numpy as np
+
+import warnings
+warnings.filterwarnings("ignore", message=".*QuickGELU mismatch.*")
+
+def collate(batch):
+    img,text=zip(*batch)
+    return torch.stack(img,0),torch.stack(text,0)
+
+@torch.no_grad
+def encode_img(model,processor,tokenizer,split,device):
+    ds=clip_dataset(split=split,processor=processor,tokenizer=tokenizer)
+    print('dataset Loaded')
+    dl=DataLoader(ds,batch_size=4,shuffle=False,num_workers=4,collate_fn=collate)
+    all_img,all_text=[],[]
+    for img,text in tqdm(dl,desc=f"Encode {split}"):
+        img=img.to(device)
+        text=text.to(device)
+        img_f=model.encode_image(img)
+        text_f=model.encode_text(text)
+        img_f=img_f/img_f.norm(keepdim=True,dim=-1)
+        text_f=text_f/text_f.norm(keepdim=True,dim=-1)
+        all_img.append(img_f.cpu())
+        all_text.append(text_f.cpu())
+    return torch.cat(all_img),torch.cat(all_text)
+
+
+def gold_k(sims,k):
+    ranks = (-sims).argsort(axis=1)
+    hits = (ranks[:, :k] == np.arange(sims.shape[0])[:,None]).any(axis=1)
+    return hits.mean()
+
+
+def main(path='./model/clip/best.pt',arch='ViT-B-32', pretrained='openai'):
+    device="cuda" if torch.cuda.is_available() else "cpu"
+    torch.cuda.empty_cache()
+    model, _, preprocess =open_clip.create_model_and_transforms(arch,pretrained=pretrained,device=device,quick_gelu=True )
+    tokenizer=open_clip.get_tokenizer(arch)
+    state=torch.load(path,map_location='cuda')['model']
+    model.load_state_dict(state, strict=False)
+    model.eval()
+    print('model loaded')
+    img_f,text_f=encode_img(model,processor=preprocess,tokenizer=tokenizer,split='test',device=device)
+    sim=(img_f@text_f.T).numpy()
+    g1=gold_k(sim,1)
+    g5=gold_k(sim,5)
+    g10=gold_k(sim,10)
+    print(f"Image->Text  R@1={g1:.3f}  R@5={g5:.3f}  R@10={g10:.3f}")
+
+if __name__=="__main__":
+    main()    
+

src/preprocessing.py

@@ -0,0 +1,29 @@
+from datasets import load_dataset
+import datasets
+from huggingface_hub import hf_hub_download
+from PIL import Image
+import torch
+import requests
+import os
+
+class Preprocessing():
+    def __init__(self):
+        pass
+
+    def load_dataset(self,split):
+        os.environ["HF_HUB_DOWNLOAD_TIMEOUT"] = "10500"
+        dataset = load_dataset("lmms-lab/COCO-Caption", split=split, cache_dir="D:/Java Projects/Findr/Server/datasets")
+        ds = dataset.filter(lambda x: x['image'] is not None and x['question_id'] is not None and len(x['answer']) > 0)
+        return ds
+
+    def image_caption_pairs(self,ds):
+        import random
+        for data in ds:
+            img:Image.Image=data['image'].convert('RGB')
+            cap=random.choice(data['answer']).strip()
+            print(img,cap)
+            yield img,cap    
+
+if __name__=="__main__":
+    obj=Preprocessing()
+    obj.load_dataset('val')

src/training.py

@@ -0,0 +1,206 @@
+import os,random,math
+import torch
+import torch.nn as nn
+from torchvision import transforms
+from tqdm import tqdm
+import open_clip
+from datasets import load_dataset
+from PIL import Image
+from src.preprocessing import Preprocessing
+from torch.utils.data import DataLoader,Dataset
+import warnings
+import base64
+from io import BytesIO
+warnings.filterwarnings("ignore", message=".*QuickGELU mismatch.*")
+
+device='cuda' if torch.cuda.is_available() else 'cpu'
+torch.cuda.empty_cache()
+model, _, preprocess =open_clip.create_model_and_transforms('ViT-B-32',pretrained='openai',device=device )
+SAVE_DIR='model/clip/best.pt'
+tokenizer=open_clip.get_tokenizer('ViT-B-32')
+
+def seed_everything(seed=42):
+    random.seed(seed); torch.manual_seed(seed); torch.cuda.manual_seed_all(seed)
+
+class clip_dataset(torch.utils.data.Dataset):
+
+    def __init__(self,split='val',processor=None,tokenizer=None):
+        preprocessor=Preprocessing()
+        self.ds=preprocessor.load_dataset(split=split)
+        self.tokenizer=tokenizer
+        self.processor=processor
+
+    def __len__(self):
+        return len(self.ds)    
+    
+    def __getitem__(self,index):
+        data=self.ds[index]
+        img:Image.Image=data['image'].convert('RGB')
+        text=random.choice(data['answer']).strip()
+        image=self.processor(img) if self.processor else img
+        token_text=self.tokenizer([text])[0]
+        return image,token_text
+    
+def clip_loss(image_features, text_features, temperature):
+    image_features = image_features / image_features.norm(dim=-1, keepdim=True)
+    text_features  = text_features  / text_features.norm(dim=-1, keepdim=True)
+    logits_per_image = (image_features @ text_features.t()) * torch.exp(temperature)
+    logits_per_text  = logits_per_image.t()
+    targets = torch.arange(image_features.size(0), device=image_features.device)
+    loss_i = nn.CrossEntropyLoss()(logits_per_image, targets)
+    loss_t = nn.CrossEntropyLoss()(logits_per_text, targets)
+    return (loss_i + loss_t) / 2    
+
+def collate(batch):
+        imgs, toks = zip(*batch)
+        imgs = torch.stack(imgs, 0)
+        toks = torch.stack(toks, 0)
+        return imgs, toks            
+
+def train(arch='ViT-B-32',pretrained='openai',batchSize=2,epochs=5,lr=5e-5,warmup_steps=200,grad_accum=1,output_dir='model/clip'):
+    seed_everything(42)
+    torch.cuda.empty_cache()
+    os.makedirs(output_dir,exist_ok=True)
+    
+    tokenizer=open_clip.get_tokenizer(arch)
+
+    train_ds=clip_dataset(split='val',processor=preprocess,tokenizer=tokenizer)
+    val_ds=clip_dataset(split='test',processor=preprocess,tokenizer=tokenizer)
+
+    train_dl = DataLoader(train_ds, batch_size=batchSize, shuffle=True, num_workers=4, collate_fn=collate, pin_memory=True)
+    val_dl   = DataLoader(val_ds,   batch_size=batchSize, shuffle=False, num_workers=4, collate_fn=collate, pin_memory=True)
+
+    total_steps = epochs * math.ceil(len(train_dl) / grad_accum)
+    def lr_lambda(step):
+        if step < warmup_steps:
+            return (step + 1) / max(1, warmup_steps)
+        progress = (step - warmup_steps) / max(1, total_steps - warmup_steps)
+        return 0.5 * (1 + math.cos(math.pi * progress))
+    
+
+    optimizer = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=0.01)
+    scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)
+
+    scaler = torch.cuda.amp.GradScaler(enabled=(device.startswith("cuda")))
+    best_val = float("inf")
+
+    for epoch in range(1,epochs+1):
+        model.train()
+        running = 0.0
+        step = 0
+        pbar = tqdm(train_dl, desc=f"Epoch {epoch}/{epochs}")
+        optimizer.zero_grad(set_to_none=True)
+        for images, tokens in pbar:
+            images = images.to(device, non_blocking=True)
+            tokens = tokens.to(device, non_blocking=True)
+
+            with torch.cuda.amp.autocast(enabled=(device.startswith("cuda"))):
+                image_features = model.encode_image(images)
+                text_features  = model.encode_text(tokens)
+                loss = clip_loss(image_features, text_features, model.logit_scale)
+
+            scaler.scale(loss / grad_accum).backward()
+            step += 1
+            running += loss.item()
+            if step % grad_accum == 0:
+                scaler.step(optimizer); scaler.update()
+                optimizer.zero_grad(set_to_none=True)
+                scheduler.step()
+
+            pbar.set_postfix(loss=running / step, lr=optimizer.param_groups[0]["lr"])
+
+
+    model.eval()
+    with torch.no_grad():
+            val_losses = []
+            for images, tokens in tqdm(val_dl, leave=False, desc="Val"):
+                images = images.to(device); tokens = tokens.to(device)
+                with torch.cuda.amp.autocast(enabled=(device.startswith("cuda"))):
+                    image_features = model.encode_image(images)
+                    text_features  = model.encode_text(tokens)
+                    val_loss = clip_loss(image_features, text_features, model.logit_scale)
+                val_losses.append(val_loss.item())
+            val_mean = sum(val_losses)/len(val_losses)
+
+    ckpt_path = os.path.join(output_dir, f"epoch{epoch}_val{val_mean:.4f}.pt")
+    torch.save({"model": model.state_dict()}, ckpt_path)
+    if val_mean < best_val:
+        best_val = val_mean
+        torch.save({"model": model.state_dict()}, os.path.join(output_dir, "best.pt"))
+
+    print(f"Epoch {epoch} done. TrainLoss ~{running/step:.4f}  ValLoss {val_mean:.4f}")        
+
+class FeedbackDataset(Dataset):
+    def __init__(self, examples, processor=None):
+        self.examples = examples
+        self.processor = processor
+
+    def __len__(self):
+        return len(self.examples)
+
+    def __getitem__(self, idx):
+        ex = self.examples[idx]
+        image = ex["image"]
+        if not isinstance(image, Image.Image):
+            image = Image.open(image).convert("RGB")
+        return image, ex["text"], ex["label"]
+    
+def feedback(model,processor,device,data,epochs=5,batch_size=4,lr=1e-6):
+    dataset=FeedbackDataset(data,processor=processor)
+    dataLoader=DataLoader(dataset,batch_size=batch_size,shuffle=True)
+    optimizer = torch.optim.AdamW(model.parameters(), lr=lr)
+    loss_fn = nn.CosineEmbeddingLoss()
+    model.load_state_dict(torch.load(SAVE_DIR, map_location=device))
+    model.train()
+    for epoch in range(epochs):
+        total_loss = 0
+        for images, texts, labels in dataLoader:
+            inputs = processor(text=texts, images=images,
+                               return_tensors="pt", padding=True).to(device)
+            text_embeds = model.get_text_features(inputs["input_ids"], inputs["attention_mask"])
+            image_embeds = model.get_image_features(inputs["pixel_values"])
+            text_embeds = text_embeds / text_embeds.norm(dim=-1, keepdim=True)
+            image_embeds = image_embeds / image_embeds.norm(dim=-1, keepdim=True)
+
+            labels = torch.tensor(labels, dtype=torch.float, device=device)
+            loss = loss_fn(image_embeds, text_embeds, labels)
+
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+
+            total_loss += loss.item()
+        
+        print(f"{epoch+1}/{epochs} , Loss :{total_loss/len(dataLoader):.4f}")
+
+
+
+def encode_img_and_text(imgs,text):
+    image_feat=[]
+    model, _, preprocess =open_clip.create_model_and_transforms('ViT-B-32',pretrained='openai',device=device,quick_gelu=True )
+    checkpoint = torch.load(SAVE_DIR, map_location=device)
+    model.to(device)
+    for img in imgs:
+        if hasattr(img, 'read'):
+            image = Image.open(img.stream).convert("RGB")
+        else:
+            if isinstance(img, dict) and 'preview' in img:
+                img_data = img['preview'].split(",")[1]
+                image = Image.open(BytesIO(base64.b64decode(img_data))).convert("RGB")
+            else:
+                raise ValueError("Unsupported image input")
+        image_input = preprocess(image).unsqueeze(0).to(device)
+        with torch.no_grad():
+            image_features = model.encode_image(image_input)
+            image_features = image_features / image_features.norm(dim=-1, keepdim=True)
+            image_feat.append(image_features)
+    image_embedding=torch.stack(image_feat).mean(dim=0)
+    text_tokens=tokenizer([text]).to(device)
+    with torch.no_grad():
+        text_features = model.encode_text(text_tokens)
+        text_features = text_features / text_features.norm(dim=-1, keepdim=True) 
+    alpha=0.7
+    combined=alpha*image_embedding+(1-alpha)*text_features
+    combined=combined/combined.norm(dim=-1,keepdim=True)
+    return combined.squeeze(0).cpu().tolist()    
+