All files

.gitignore

@@ -0,0 +1,174 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+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
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.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
+.env
+.venv
+env/
+venv/
+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/
+
+# 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/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc

Dockerfile

@@ -0,0 +1,39 @@
+FROM python:3.12-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+# Install system dependencies
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends curl build-essential \
+    libglib2.0-0 \
+    libsm6 \
+    libxrender1 \
+    libxext6 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Poetry
+RUN curl -sSL https://install.python-poetry.org | python3 -
+
+# Add Poetry to PATH
+ENV PATH="/root/.local/bin:$PATH"
+ENV PYTHONPATH=/app
+
+# Set working directory
+WORKDIR /app/myapp
+
+# Copy only pyproject.toml and poetry.lock first (caching dependencies)
+COPY pyproject.toml poetry.lock* ./
+
+# Install dependencies
+RUN poetry install --no-root --only main
+
+# Copy the full project
+COPY . .
+
+# Expose port
+EXPOSE 8000
+
+# Command to run FastAPI
+CMD ["poetry", "run", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000", "--reload"]

Dockerfile.hugging-face

@@ -0,0 +1,43 @@
+FROM python:3.12-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+# Install system dependencies
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends curl build-essential \
+    libglib2.0-0 \
+    libsm6 \
+    libxrender1 \
+    libxext6 \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN curl -sSL https://install.python-poetry.org | python3 -
+
+# Add Poetry to PATH
+ENV PATH="/root/.local/bin:$PATH"
+ENV PYTHONPATH=/app
+
+WORKDIR /app/myapp
+
+COPY pyproject.toml poetry.lock* ./
+
+# Install dependencies
+RUN poetry install --no-root --only main
+
+# Copy the full project
+COPY . .
+
+EXPOSE 7860
+
+
+ENV SUPABASE_URL=""
+ENV SUPABASE_KEY=""
+ENV B2_KEY_ID=""
+ENV B2_APP_KEY=""
+ENV B2_BUCKET_NAME=""
+ENV PINECONE_API_KEY=""
+ENV PINECONE_REGION=""
+
+
+CMD ["poetry", "run", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860", "--reload"]

database/buckets/building_client.py

@@ -0,0 +1,30 @@
+from b2sdk.v2 import B2Api
+from fastapi import HTTPException, UploadFile
+from myapp.database.buckets.client import BucketClient
+from myapp.database.buckets.config import BUILDING_BUCKET_NAME, b2_api
+from myapp.logging.log import log_call
+
+class BuildingBucketClient(BucketClient):
+    def __init__(self, b2_api: B2Api):
+        super().__init__(b2_api, BUILDING_BUCKET_NAME)
+            
+    @log_call("Uploaded model file '{remote_file_name}' to building bucket")
+    async def upload_model(self, file_contents: bytes, remote_file_name: str):
+        try:
+            super().upload_model(file_contents, remote_file_name)
+        except Exception as e:  
+            raise HTTPException(status_code=500, detail=f"Failed to upload model file: {str(e)}")
+         
+    @log_call("Deleted file '{remote_file_name}' from building bucket")
+    async def delete_file(self, remote_file_name: str):
+        super().delete_file(remote_file_name)
+         
+    async def get_all_file_names(self, path: str = "") -> list[str]:
+        try:
+            file_names = [file_info.file_name for file_info, _ in self.bucket.ls(path, recursive=True)]
+            return file_names
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Failed to list files in bucket: {str(e)}")
+        
+
+building_bucket_client = BuildingBucketClient(b2_api)

database/buckets/client.py

@@ -0,0 +1,42 @@
+import io
+from b2sdk.v2 import B2Api
+from fastapi import HTTPException
+
+from myapp.utils.constants import ResultStatus
+
+class BucketClient:
+    def __init__(self, b2_api: B2Api, bucket_name: str):
+        self.bucket = b2_api.get_bucket_by_name(bucket_name)
+
+    def upload_model(self, file_bytes: bytes, remote_file_name: str):
+        try:
+            self.bucket.get_file_info_by_name(remote_file_name)
+            return  # File already exists, skip upload
+        except Exception:
+            pass
+        self.bucket.upload_bytes(file_bytes, remote_file_name)
+        
+    def get_file_by_url(self, image_url: str):
+        downloaded_file = io.BytesIO()
+        
+        self.bucket.download_file_by_name(image_url).save(downloaded_file)
+        downloaded_file.seek(0)
+        
+        return downloaded_file.read()
+
+    def delete_file(self, remote_file_name: str):
+        try:
+            file_version = self.bucket.get_file_info_by_name(remote_file_name)
+            if not file_version:
+                raise HTTPException(status_code=404, detail=f"File '{remote_file_name}' not found in bucket.")
+            self.bucket.delete_file_version(file_version.id_, remote_file_name)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Failed to delete file '{remote_file_name}': {str(e)}")
+        
+    async def delete_folder(self, folder_path: str):
+        try:
+            files_to_delete = [file_info for file_info, _ in self.bucket.ls(folder_path, recursive=True)]
+            for file_info in files_to_delete:
+                self.bucket.delete_file_version(file_info.id_, file_info.file_name)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Failed to delete folder '{folder_path}': {str(e)}")

database/buckets/config.py

@@ -0,0 +1,20 @@
+from enum import Enum
+import os
+from b2sdk.v2 import InMemoryAccountInfo, B2Api
+
+BUILDING_BUCKET_NAME = os.environ.get("B2_BUCKET_NAME")
+BUCKET_STORAGE_PREFIX = "https://f002.backblazeb2.com/file/"
+BUILDING_BUCKET_URL_PREFIX = BUCKET_STORAGE_PREFIX + BUILDING_BUCKET_NAME + "/"
+
+class BuildingBucketFolders(str, Enum):
+    MODELS = "models/"
+    IMAGES = "images/"
+
+
+b2_info = InMemoryAccountInfo()
+b2_api = B2Api(b2_info)
+b2_api.authorize_account(
+    "production",
+    os.environ.get("B2_KEY_ID"),
+    os.environ.get("B2_APP_KEY")
+)

database/metadata/building_client.py

@@ -0,0 +1,50 @@
+from supabase import Client
+from myapp.database.metadata.client import DatabaseSQLClient
+from myapp.database.metadata.config import Tables, database_client
+from myapp.models.Building import BuildingColumns, BuildingCreate, BuildingUpdateMetadata
+from myapp.logging.log import log_call
+
+
+class BuildingSQLClient(DatabaseSQLClient):
+    def __init__(self, database_connection: Client):
+        super().__init__(Tables.BUILDINGS.value, database_connection)
+        
+    @log_call("Inserted building '{building.name}' into metadata database")
+    def insert(self, building: BuildingCreate):
+        response = self.table_request().select(BuildingColumns.ID.value).eq(BuildingColumns.NAME.value, building.name).execute()
+        
+        point_wkt = f"SRID=4326;POINT({building.location.longitude} {building.location.latitude})" if building.location else None
+        data = {
+            BuildingColumns.NAME.value: building.name,
+            BuildingColumns.MODEL_URL.value: building.model_url,
+            BuildingColumns.LOCATION.value: point_wkt
+        }
+    
+        if response.data:
+            building_id = response.data[0][BuildingColumns.ID.value]
+            return super().update(building_id, data, BuildingColumns.ID.value)
+        else:
+            return super().insert(data)
+        
+    def update(self, building: BuildingUpdateMetadata):
+        point_wkt = f"SRID=4326;POINT({building.location.longitude} {building.location.latitude})" if building.location else None
+        data = {
+            BuildingColumns.LOCATION.value: point_wkt
+        }
+        return super().update(building.name, data, property_name=BuildingColumns.NAME.value)
+    
+    @log_call("Deleted building '{building_name}' from metadata database")
+    def delete(self, building_name: str):
+        return super().delete(building_name, property_name=BuildingColumns.NAME.value)
+    
+    def record_exists(self, building_name: str) -> bool:
+        return super().record_exists(building_name, property_name=BuildingColumns.NAME.value)
+    
+    def get_all_buildings_names(self) -> list[str]:
+        response = self.table_request().select(BuildingColumns.NAME.value).execute()
+        if response.data is None:
+            return []
+        return [record[BuildingColumns.NAME.value] for record in response.data]
+
+    
+building_metadata_client = BuildingSQLClient(database_connection=database_client)

database/metadata/client.py

@@ -0,0 +1,51 @@
+from fastapi import HTTPException
+from postgrest import SyncRequestBuilder
+from supabase import Client
+
+from myapp.models.Building import BuildingColumns, Location
+
+class DatabaseSQLClient:
+    def __init__(self, table: str, database_connection: Client):
+        self.table = table
+        self.client = database_connection
+        
+    def insert(self, data: dict):
+        response = self.client.table(self.table).insert(data).execute()
+        
+        if not response.data:
+            raise HTTPException(status_code=500, detail=f"Supabase insert failed: {response.data}")
+
+        inserted_row = response.data[0]
+        inserted_row[BuildingColumns.LOCATION.value] = _geojson_to_location(inserted_row[BuildingColumns.LOCATION.value])
+        
+        return inserted_row
+    
+    def update(self, property_value, data: dict, property_name: str = BuildingColumns.ID.value):
+        response = self.client.table(self.table).update(data).eq(property_name, property_value).execute()
+        
+        if not response.data:
+            raise HTTPException(status_code=500, detail=f"Supabase update failed: {response.data}")
+        
+        updated_row = response.data[0]
+        updated_row[BuildingColumns.LOCATION.value] = _geojson_to_location(updated_row[BuildingColumns.LOCATION.value])
+        
+        return updated_row
+    
+    def delete(self, property_value, property_name: str = BuildingColumns.ID.value):
+        return self.client.table(self.table).delete().eq(property_name, property_value).execute()
+    
+    def record_exists(self, property_value, property_name: str = BuildingColumns.ID.value) -> bool:
+        response = self.client.table(self.table).select(BuildingColumns.ID.value).eq(property_name, property_value).execute()
+        return bool(response.data)
+    
+    def table_request(self) -> SyncRequestBuilder:
+        return self.client.table(self.table)
+
+
+def _geojson_to_location(location_geojson: dict) -> Location:
+    try:
+        lon, lat = location_geojson["coordinates"]
+    except (KeyError, ValueError, TypeError):
+        raise ValueError("Invalid GeoJSON format for Point")
+
+    return Location(latitude=lat, longitude=lon)

database/metadata/config.py

@@ -0,0 +1,15 @@
+import os
+from enum import Enum
+from supabase import create_client, Client
+
+url: str = os.environ.get("SUPABASE_URL")
+key: str = os.environ.get("SUPABASE_KEY")
+database_client: Client = create_client(url, key)
+
+
+class Tables(str, Enum):
+    BUILDINGS = "buildings"
+    
+    
+class DatabaseQueries(str, Enum):
+    GET_NEARBY_PLACES = "get_nearby_places"

database/vectors/building_client.py

@@ -0,0 +1,41 @@
+import hashlib
+from pinecone import Pinecone, QueryResponse
+from myapp.database.vectors.client import DatabaseVectorClient
+from myapp.database.vectors.config import VectorIndexes, pinecone_client
+from myapp.logging.log import log_call
+from myapp.models.Building import BuildingColumns, BuildingVector
+
+
+class BuildingVectorClient(DatabaseVectorClient):
+    def __init__(self, database_connection: Pinecone):
+        super().__init__(database_connection, VectorIndexes.BUILDINGS.value)
+        
+    def upsert_vectors(self, vectors: list[BuildingVector]):
+        building_vectors = []
+        for vector in vectors:
+            vector_id = self._hash_image_url(vector.img_bytes)
+            building_vectors.append({
+                BuildingColumns.ID.value: vector_id,
+                "values": vector.values,
+                "metadata": {BuildingColumns.MODEL_URL.value: vector.model_url, "render_url": vector.render_url}
+            })
+        return super().upsert_vectors(building_vectors)
+    
+    @log_call("Searched top {top_k} vectors in building vector index")
+    def search(self, vector: list[float], top_k: int = 5, include_metadata: bool = True, filter: dict = None) -> QueryResponse:
+        return super().search(vector, top_k, include_metadata, filter)    
+        
+    @log_call("Deleted vectors with url: {model_url} from building vector index")
+    def delete_by_url(self, model_url: str):
+        """
+        Deletes all vectors whose metadata.url matches the given URL.
+        """
+        self.index.delete(filter={"model_url": {"$eq": model_url}})
+    
+    
+    def _hash_image_url(self, img_bytes: bytes) -> str:
+        """Generate SHA-256 hash of image content for a stable ID."""
+        return hashlib.sha256(img_bytes).hexdigest()
+        
+        
+building_vector_client = BuildingVectorClient(database_connection=pinecone_client)

database/vectors/client.py

@@ -0,0 +1,15 @@
+from pinecone import Pinecone, QueryResponse
+
+
+class DatabaseVectorClient:
+    def __init__(self, pinecone_client: Pinecone, index_name: str):
+        self.index_name = index_name
+        self.index = pinecone_client.Index(index_name)
+        
+    def upsert_vectors(self, vectors: list[dict]):
+        self.index.upsert(vectors)
+        
+    def search(self, vector: list[float], top_k: int = 5, include_metadata: bool = True, filter: dict = None) -> QueryResponse:
+        return self.index.query(vector=vector, top_k=top_k, include_metadata=include_metadata, filter=filter)
+
+    

database/vectors/config.py

@@ -0,0 +1,12 @@
+from enum import StrEnum
+import os
+from pinecone import Pinecone
+
+
+PINECONE_API_KEY = os.getenv("PINECONE_API_KEY")
+PINECONE_REGION = os.getenv("PINECONE_REGION")
+
+pinecone_client = Pinecone(api_key=PINECONE_API_KEY)
+
+class VectorIndexes(StrEnum):
+    BUILDINGS = "models-renderings"

logging/log.py

@@ -0,0 +1,73 @@
+import logging
+import json
+from functools import wraps
+from inspect import signature
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+
+def log_call(message: str, log_return: bool = False):
+    """
+    Decorator for string-based logging with argument placeholders.
+    Example: @log_call("Processing user {user_id}", log_return=True)
+    """
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            sig = signature(func)
+            bound_args = sig.bind(*args, **kwargs)
+            bound_args.apply_defaults()
+
+            # Pre-call log
+            try:
+                log_msg = message.format(**bound_args.arguments)
+            except Exception as e:
+                log_msg = f"{message} | (formatting failed: {e})"
+            logging.info(log_msg)
+
+            try:
+                result = func(*args, **kwargs)
+                if log_return:
+                    logging.info("Return value: %r", result)
+                return result
+            except Exception as e:
+                logging.exception("Exception in %s: %s", func.__name__, e)
+                raise
+        return wrapper
+    return decorator
+
+
+def log_call_json(log_return: bool = False):
+    """
+    Decorator for JSON-based logging.
+    Captures function name, args, return value, and errors.
+    """
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            sig = signature(func)
+            bound_args = sig.bind(*args, **kwargs)
+            bound_args.apply_defaults()
+
+            log_entry = {
+                "function": func.__name__,
+                "args": dict(bound_args.arguments),
+            }
+
+            try:
+                result = func(*args, **kwargs)
+                if log_return:
+                    log_entry["result"] = result
+                log_entry["status"] = "success"
+                logging.info(json.dumps(log_entry, default=str))
+                return result
+            except Exception as e:
+                log_entry["status"] = "error"
+                log_entry["error"] = {
+                    "type": type(e).__name__,
+                    "message": str(e),
+                }
+                logging.error(json.dumps(log_entry, default=str))
+                raise
+        return wrapper
+    return decorator

main.py

@@ -0,0 +1,16 @@
+from fastapi import FastAPI
+from myapp.routers import buildings_router
+from myapp.routers import buildings_search_router
+
+app = FastAPI(title="3D Model Search API", version="1.0.0")
+
+app.include_router(buildings_router.router)
+app.include_router(buildings_search_router.router)
+
+@app.get("/", response_description="API is running")
+async def root():
+    """
+    Root endpoint
+    """
+    return {"message": "API is running"}
+

models/Building.py

@@ -0,0 +1,48 @@
+from typing import List, Optional
+from enum import Enum
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+class Location(BaseModel):
+    latitude: float = Field(...)
+    longitude: float = Field(...)
+
+
+class BuildingCreate(BaseModel):
+    """
+    Model of 3D Building
+    """
+    name: str = Field(...)
+    location: Location = Field(...)
+    model_url: Optional[str] = Field(None)
+
+
+class Building(BaseModel):
+    id: str
+    name: str
+    model_url: str
+    location: Location
+    created_at: datetime
+    
+    
+class BuildingUpdateMetadata(BaseModel):
+    name: str = Field(...)
+    location: Location = Field(...)
+    
+class BuildingSearch(BaseModel):
+    id: str
+    model_url: str
+    
+class BuildingVector(BaseModel):
+    values: List[float]
+    img_bytes: bytes
+    model_url: str
+    render_url: str
+    
+    
+class BuildingColumns(Enum):
+    ID = "id"
+    NAME = "name"
+    MODEL_URL = "model_url"
+    LOCATION = "location"
+    CREATED_AT = "created_at"

pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "myapp"
+version = "0.1.0"
+description = ""
+authors = [
+    {name = "Your Name",email = "[email protected]"}
+]
+requires-python = ">=3.12,<3.14"
+dependencies = [
+    "fastapi (>=0.116.1,<0.117.0)",
+    "uvicorn (>=0.35.0,<0.36.0)",
+    "pydantic (>=2.11.9,<3.0.0)",
+    "supabase (>=2.18.1,<3.0.0)",
+    "b2sdk (>=2.10.0,<3.0.0)",
+    "python-multipart (>=0.0.20,<0.0.21)",
+    "torch (>=2.8.0,<3.0.0)",
+    "pinecone (>=7.3.0,<8.0.0)",
+    "pillow (>=11.3.0,<12.0.0)",
+    "clip @ git+https://github.com/openai/CLIP.git",
+    "redis (>=6.4.0,<7.0.0)",
+    "transformers (>=4.56.2,<5.0.0)",
+    "onnxruntime (>=1.23.0,<2.0.0)",
+    "opencv-python-headless (>=4.12.0.88,<5.0.0.0)",
+]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

requirements.txt

@@ -0,0 +1,2 @@
+fastapi
+uvicorn[standard]

routers/buildings_router.py

@@ -0,0 +1,155 @@
+from typing import List
+from fastapi import APIRouter, Body, File, Form, HTTPException, UploadFile, status
+from myapp.database.metadata.building_client import building_metadata_client
+from myapp.database.buckets.building_client import building_bucket_client
+from myapp.database.vectors.building_client import building_vector_client
+from myapp.models.Building import Building, BuildingCreate, BuildingUpdateMetadata, BuildingVector, BuildingColumns
+from myapp.database.buckets.config import BuildingBucketFolders
+from myapp.search.preprocess.embed_models import get_image_embeddings, process_building
+from myapp.utils.image_utils import get_image_stream
+
+
+router = APIRouter(
+    prefix="/buildings",
+    tags=["buildings"]
+)
+
+
+@router.post(
+    "/add/",
+    response_description="Building has been succesfully added!",
+    status_code=status.HTTP_200_OK,
+    response_model=Building,
+)
+async def add_building(
+    building = Form(...),
+    model_renders_files: List[UploadFile] = File(None),
+):  
+    building: Building = BuildingCreate.model_validate_json(building)
+    
+    if len(model_renders_files) < 4:
+        raise HTTPException(status_code=400, detail="At least 4 model renders must be provided.")
+    
+    # Upload model files to Bucket Storage
+    renders_vectors: List[BuildingVector] = []
+    file_folder_name = f"{BuildingBucketFolders.MODELS.value}{building.name}/"
+    print("Processing files...", building.name)
+    for model_render_file in model_renders_files:
+        remote_file_name: str = file_folder_name + model_render_file.filename
+        img_bytes = await model_render_file.read()
+        # await building_bucket_client.upload_model(img_bytes, remote_file_name)
+        # image = get_image_stream(img_bytes)
+        img_embeddings = process_building(img_bytes)
+        renders_vectors.append(BuildingVector(
+            values=img_embeddings,
+            img_bytes=img_bytes,
+            model_url=file_folder_name,
+            render_url=remote_file_name
+        ))
+    
+    # Upsert model renders vectors into Vector DB
+    print("Uploading vectors...")
+    for batch_start in range(0, len(renders_vectors), 25):
+        batch = renders_vectors[batch_start:batch_start + 25]
+        if batch:
+            building_vector_client.upsert_vectors(batch)
+    
+    # Insert building metadata into database
+    building.model_url = file_folder_name
+    building = building_metadata_client.insert(building) 
+    if not building:
+        raise HTTPException(status_code=500, detail="Failed to insert building model.")
+    
+    return building
+
+
+@router.delete(
+    "/{building_name}/",
+    response_description="Building has been succesfully deleted!",
+    status_code=status.HTTP_200_OK,
+)
+async def delete_building(building_name: str):
+    """
+    Delete building by name
+    """
+    if not building_metadata_client.record_exists(building_name):
+        raise HTTPException(status_code=404, detail=f"Building with name '{building_name}' not found.")
+    
+    response = building_metadata_client.table_request().select(BuildingColumns.MODEL_URL.value).eq(BuildingColumns.NAME.value, building_name).execute()
+    model_url = response.data[0].get(BuildingColumns.MODEL_URL.value, []) if response.data else []
+    
+    # Delete renders from Bucket Storage
+    # try:
+    #     await building_bucket_client.delete_folder(model_url)
+    # except Exception as e:
+    #     raise HTTPException(status_code=500, detail=f"Failed to delete building files from bucket: {str(e)}")
+    
+    # Delete vectors from Vector DB
+    building_vector_client.delete_by_url(model_url)
+    
+    # Delete building metadata from database
+    response = building_metadata_client.delete(building_name)
+    if not response.data:
+        raise HTTPException(status_code=500, detail="Failed to delete building.")
+    
+    return {"message": f"Building with name '{building_name}' has been deleted with its models files."}
+
+
+@router.get(
+    "/",
+    response_description="List all building names",
+    status_code=status.HTTP_200_OK,
+    response_model=list[str],
+)
+async def get_all_buildings_names() -> list[str]:
+    """
+    Return list of buildings names stored in database.
+    """
+    return await building_metadata_client.get_all_buildings_names()
+
+    
+    
+@router.post(
+    "/update_metadata/",
+    response_description="Building metadata has been succesfully updated!",
+    status_code=status.HTTP_200_OK,
+)
+async def update_building_metadata(building: BuildingUpdateMetadata = Body(...)):
+    """
+    Search for place matching to photo
+    """
+    building = building_metadata_client.update(building) 
+    return building
+
+
+# @router.post(
+#     "/add_model/",
+#     response_description="3D Model has been succesfully added!",
+#     status_code=status.HTTP_200_OK,
+# )
+# async def add_building_model(
+#     building_name: str = Form(...),
+#     model_file: UploadFile = File(...),
+# ):  
+#     """
+#     Upload 3D model file to existing building
+#     """
+#     response = building_metadata_client.table_request().select(BuildingColumns.MODELS_URLS.value).eq(BuildingColumns.NAME.value, building_name).execute()
+#     if not response.data:
+#         raise HTTPException(status_code=404, detail=f"Building with name '{building_name}' not found.")
+    
+#     current_models_urls: list[str] = response.data[0].get(BuildingColumns.MODELS_URLS.value, [])
+#     file_folder_name = f"{BuildingBucketFolders.MODELS.value}{building_name}/"
+#     remote_file_name = file_folder_name + {model_file.filename}
+#     new_model_url = BUILDING_BUCKET_URL_PREFIX + remote_file_name
+    
+#     if new_model_url in current_models_urls:
+#         raise HTTPException(status_code=400, detail=f"Model file already exists in the building's {BuildingColumns.MODELS_URLS.value}.")
+    
+#     # Upload the model file to Bucket Storage   
+#     building_bucket_client.upload_model(model_file, remote_file_name)
+    
+#     # Update the building's models_urls in the database
+#     updated_urls = current_models_urls + [file_folder_name]
+#     update_response = building_metadata_client.table_request().update({BuildingColumns.MODELS_URLS.value: updated_urls}).eq(BuildingColumns.NAME.value, building_name).execute()
+#     return update_response

routers/buildings_search_router.py

@@ -0,0 +1,44 @@
+from typing import List
+from fastapi import APIRouter, File, Form, HTTPException, UploadFile, status
+from fastapi.responses import Response
+from myapp.database.vectors.building_client import building_vector_client
+from myapp.database.buckets.building_client import building_bucket_client
+from myapp.models.Building import BuildingColumns, BuildingSearch, Location
+from myapp.search.search_utils import get_buildings_in_proximity, search_best_match
+
+
+router = APIRouter(
+    prefix="/buildings_search",
+    tags=["buildings_search"]
+)
+
+
+@router.post(
+    "/find/",
+    response_description="Get building",
+    status_code=status.HTTP_200_OK,
+)
+async def find_historical_models(location = Form(...), building_image: UploadFile = File(...)):
+    """
+    Search for place matching to photo
+    """
+    lat, lon = map(float, location.split(","))
+    location = Location(latitude=lat, longitude=lon)
+    
+    nearby_buildings: List[BuildingSearch] = get_buildings_in_proximity(location.latitude, location.longitude)
+    models_to_search = [building[BuildingColumns.MODEL_URL.value] for building in nearby_buildings]
+    
+    # if not models_to_search:
+    #     raise HTTPException(status_code=404, detail="No nearby buildings found.")
+    
+    img_bytes = await building_image.read() 
+    result_buildings = search_best_match(img_bytes, models_to_search, building_vector_client)
+    building_found_render_urls = [match["metadata"]["render_url"] for match in result_buildings if "metadata" in match and "render_url" in match["metadata"]]
+
+    if not building_found_render_urls:
+        raise HTTPException(status_code=404, detail="No matching renders found.")
+
+    image_url = building_found_render_urls[0]
+    image_file = building_bucket_client.get_file_by_url(image_url)
+
+    return Response(content=image_file, media_type="image/png")

search/models/config.py

@@ -0,0 +1,4 @@
+import torch
+
+
+device = "cuda" if torch.cuda.is_available() else "cpu"

search/models/depth_model.py

@@ -0,0 +1,7 @@
+from transformers import DPTImageProcessor, DPTForDepthEstimation
+from myapp.search.models.config import device
+
+
+depth_model_name = "Intel/dpt-hybrid-midas"
+depth_processor = DPTImageProcessor.from_pretrained(depth_model_name)
+depth_model = DPTForDepthEstimation.from_pretrained(depth_model_name).to(device)

search/models/edges_model.py

@@ -0,0 +1,28 @@
+import torch
+import torch.nn as nn
+import torchvision.models as models
+import torchvision.transforms as transforms
+
+
+class ResNet512(nn.Module):
+    def __init__(self):
+        super(ResNet512, self).__init__()
+        resnet = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)
+        self.features = nn.Sequential(*list(resnet.children())[:-1])
+        self.fc = nn.Linear(resnet.fc.in_features, 512)
+
+    def forward(self, x):
+        x = self.features(x)
+        x = torch.flatten(x, 1)
+        x = self.fc(x)
+        return x
+    
+edges_model = ResNet512()
+edges_model.eval()
+
+
+edges_transform = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+])

search/models/image_model.py

@@ -0,0 +1,4 @@
+import clip
+from myapp.search.models.config import device
+
+image_model, image_processor = clip.load("ViT-B/32", device=device)

search/models/segmentation_model.py

@@ -0,0 +1,8 @@
+from transformers import AutoImageProcessor, AutoModelForSemanticSegmentation
+from myapp.search.models.config import device
+
+
+seg_model_name = "nvidia/segformer-b0-finetuned-ade-512-512"
+seg_processor = AutoImageProcessor.from_pretrained(seg_model_name, use_fast=True)
+seg_model = AutoModelForSemanticSegmentation.from_pretrained(seg_model_name).to(device)
+seg_model.config.output_hidden_states = True