Upload 10 files

Dockerfile

@@ -0,0 +1,28 @@
+FROM python:3.9-slim
+
+# Install necessary system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libffi-dev \
+    libssl-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create and switch to a non-root user
+RUN useradd -m -u 1000 user
+USER user
+
+# Set PATH so pip installs to user dir are available
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+# Install Python dependencies
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy all app files
+COPY --chown=user . /app
+
+# Run the app
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README (2).md

@@ -0,0 +1,11 @@
+---
+title: Embedding
+emoji: 🏢
+colorFrom: gray
+colorTo: red
+sdk: docker
+pinned: false
+license: mit
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

config.yml

@@ -0,0 +1,25 @@
+base_embedding_model: Qwen/Qwen3-Embedding-0.6B
+ngrok_endpoint : ""
+base_gpt_llm: gpt-4o-mini
+base_ollama_llm: llama3.1:8b
+hugging_face_url: Qwen/Qwen3-Embedding-0.6B
+last_update_embedding_finetune: '2003-04-07T20:15:00.000Z'
+last_update_faiss_push: '2025-03-02 02:25:23'
+last_updates_preprocess_json: '2025-03-02 02:21:54'
+server_url: 127.0.0.1
+unique_titles:
+- Conclusion
+- Issue
+- doc_citations
+- doc_bench
+- doc_title
+- Analysis of the law
+- pre_2
+- Petitioner's Argument
+- docsource_main
+- Precedent Analysis
+- pre_1
+- Court's Reasoning
+- Fact
+- Respondent's Argument
+- doc_author

get_embedding.py

@@ -0,0 +1,130 @@
+# get_embedding.py
+from __future__ import annotations
+
+import asyncio
+import os
+import yaml
+import torch
+from typing import List, Optional
+
+from huggingface_hub import snapshot_download
+from langchain_huggingface import HuggingFaceEmbeddings
+
+# If you have an auth helper, we keep it
+from login import HuggingFaceLogin
+
+
+class EmbeddingFetcher:
+    """
+    Async-friendly wrapper around a HuggingFace embedding model.
+
+    - Lazily initializes the model and downloads repo snapshot at app startup.
+    - Runs blocking HF / Torch operations in a worker thread via asyncio.to_thread.
+    - Thread-safe through an asyncio.Lock to prevent duplicate initialization.
+    """
+
+    def __init__(self, config_path: str = "config.yml") -> None:
+        self._config_path = config_path
+        self._ready = False
+        self._init_lock = asyncio.Lock()
+
+        self._model: Optional[HuggingFaceEmbeddings] = None
+        self._local_model_path: Optional[str] = None
+
+        # Authenticate early (likely blocking), but off main thread in ensure_ready()
+        self._login = HuggingFaceLogin()
+
+        # Config defaults (overridden by config.yml)
+        self._repo_id: str = "SPAL0028/default-model"
+        self._normalize_embeddings: bool = False
+
+        # Device
+        self._device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    # -----------------------
+    # Public properties
+    # -----------------------
+    @property
+    def model_id(self) -> str:
+        return self._local_model_path or self._repo_id
+
+    @property
+    def device_str(self) -> str:
+        return str(self._device)
+
+    # -----------------------
+    # Initialization
+    # -----------------------
+    async def ensure_ready(self) -> None:
+        """
+        Idempotent async initializer. Safe to call multiple times.
+        """
+        if self._ready:
+            return
+
+        async with self._init_lock:
+            if self._ready:
+                return
+
+            # 1) Login (may prompt environment-based auth); keep this off the main loop
+            await asyncio.to_thread(self._login.authenticate)
+
+            # 2) Load config
+            cfg = await asyncio.to_thread(self._load_config)
+            self._repo_id = cfg.get("hugging_face_url", self._repo_id)
+            self._normalize_embeddings = bool(cfg.get("normalize_embeddings", self._normalize_embeddings))
+
+            # 3) Download snapshot if needed (blocking IO) off main thread
+            self._local_model_path = await asyncio.to_thread(
+                snapshot_download,
+                self._repo_id
+            )
+
+            # 4) Build embeddings (blocking CPU-bound creation) off main thread
+            def _build_embeddings():
+                return HuggingFaceEmbeddings(
+                    model_name=self._local_model_path,
+                    model_kwargs={"device": self._device},
+                    encode_kwargs={"normalize_embeddings": self._normalize_embeddings},
+                )
+
+            self._model = await asyncio.to_thread(_build_embeddings)
+
+            self._ready = True
+
+    # -----------------------
+    # Core API
+    # -----------------------
+    async def embed(self, texts: List[str] | str) -> List[List[float]]:
+        """
+        Generate embeddings for a list of texts.
+        Ensures the model is initialized and runs blocking ops using a thread.
+        """
+        await self.ensure_ready()
+
+        if isinstance(texts, str):
+            texts = [texts]
+
+        if not texts:
+            raise ValueError("No texts provided for embedding.")
+
+        # Defensive strip to avoid empty items sneaking through
+        sanitized = [t if isinstance(t, str) else str(t) for t in texts]
+        sanitized = [t.strip() for t in sanitized if t and t.strip()]
+
+        if not sanitized:
+            raise ValueError("All provided texts are empty after sanitization.")
+
+        # langchain_huggingface.HuggingFaceEmbeddings.embed_documents is blocking
+        vectors = await asyncio.to_thread(self._model.embed_documents, sanitized)  # type: ignore[union-attr]
+        return vectors
+
+    # -----------------------
+    # Helpers
+    # -----------------------
+    def _load_config(self) -> dict:
+        if not os.path.exists(self._config_path):
+            # Keep behavior predictable if config is missing
+            return {}
+        with open(self._config_path, "r", encoding="utf-8") as f:
+            return yaml.safe_load(f) or {}

gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

gitignore

@@ -0,0 +1,3 @@
+# .gitignore
+.env
+*.env

login.py

@@ -0,0 +1,92 @@
+# login.py
+from __future__ import annotations
+
+import os
+import threading
+import logging
+from typing import Optional
+
+from dotenv import load_dotenv
+from huggingface_hub import login as hf_login
+
+_logger = logging.getLogger(__name__)
+
+
+class HuggingFaceLogin:
+    """
+    Lightweight, idempotent wrapper around Hugging Face Hub login.
+
+    - Reads token from environment (.env supported).
+    - Safe to call authenticate() multiple times (thread-safe).
+    - Avoids writing to git credential store by default.
+    """
+
+    _env_loaded = False
+    _env_lock = threading.Lock()
+
+    def __init__(
+        self,
+        token: Optional[str] = None,
+        *,
+        read_dotenv: bool = True,
+        add_to_git_credential: bool = False,
+    ) -> None:
+        # Load env only once per process (thread-safe)
+        if read_dotenv:
+            with self._env_lock:
+                if not self._env_loaded:
+                    load_dotenv()
+                    self.__class__._env_loaded = True
+
+        # Accept explicit token or fall back to common env vars
+        self._token = token or self._read_token_from_env()
+        if not self._token:
+            raise ValueError(
+                "Hugging Face API token not found. "
+                "Set one of HF_TOKEN / HUGGINGFACEHUB_API_TOKEN / HUGGINGFACE_TOKEN in your environment "
+                "or pass token=... to HuggingFaceLogin()."
+            )
+
+        self._add_to_git_credential = add_to_git_credential
+        self._did_authenticate = False
+        self._auth_lock = threading.Lock()
+
+    # -----------------------
+    # Public API
+    # -----------------------
+    def authenticate(self) -> bool:
+        """
+        Perform a one-time login to the Hugging Face Hub.
+        Safe to call multiple times (no-op after first success).
+        Returns True if authenticated in this call or previously.
+        """
+        if self._did_authenticate:
+            return True
+
+        with self._auth_lock:
+            if self._did_authenticate:
+                return True
+
+            # Perform an in-process login; do not persist to git credentials by default
+            hf_login(
+                token=self._token,
+                add_to_git_credential=self._add_to_git_credential,
+            )
+            self._did_authenticate = True
+            _logger.info("✅ Authenticated with Hugging Face Hub.")
+            return True
+
+    @property
+    def is_authenticated(self) -> bool:
+        return self._did_authenticate
+
+    # -----------------------
+    # Helpers
+    # -----------------------
+    def _read_token_from_env(self) -> Optional[str]:
+        # Check common env var names in order of preference
+        for key in ("HF_TOKEN", "HUGGINGFACEHUB_API_TOKEN", "HUGGINGFACE_TOKEN"):
+            val = os.getenv(key)
+            if val and val.strip():
+                return val.strip()
+        return None

main.py

@@ -0,0 +1,132 @@
+# main.py
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import List, Optional, Dict, Any
+
+from fastapi import FastAPI, HTTPException, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field, validator
+
+from get_embedding import EmbeddingFetcher
+
+
+# -----------------------------
+# Request / Response Schemas
+# -----------------------------
+class TextListRequest(BaseModel):
+    texts: List[str] = Field(..., description="List of strings to embed", min_items=1)
+
+    @validator("texts")
+    def non_empty_texts(cls, v: List[str]) -> List[str]:
+        if any((t is None or not isinstance(t, str) or t.strip() == "") for t in v):
+            raise ValueError("All items in 'texts' must be non-empty strings.")
+        return v
+
+
+class EmbeddingResponse(BaseModel):
+    model_id: str
+    device: str
+    dims: int
+    count: int
+    elapsed_ms: float
+    embeddings: List[List[float]]
+
+
+# -----------------------------
+# App factory with lifespan
+# -----------------------------
+def create_app() -> FastAPI:
+    app = FastAPI(title="Embedding API", version="1.0.0")
+
+    # CORS: keep your original open policy (tighten in production)
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Global container for services
+    app.state.container: Dict[str, Any] = {}
+    app.state.init_lock = asyncio.Lock()
+
+    @app.on_event("startup")
+    async def on_startup() -> None:
+        # Initialize the EmbeddingFetcher once, asynchronously
+        async with app.state.init_lock:
+            if "embedder" not in app.state.container:
+                fetcher = EmbeddingFetcher()
+                # Build models / download snapshots off the main thread
+                await fetcher.ensure_ready()
+                app.state.container["embedder"] = fetcher
+
+    @app.on_event("shutdown")
+    async def on_shutdown() -> None:
+        # Nothing special is required, but the hook is here for future cleanup
+        pass
+
+    # ---------------
+    # Dependencies
+    # ---------------
+    def get_embedder() -> EmbeddingFetcher:
+        fetcher: Optional[EmbeddingFetcher] = app.state.container.get("embedder")
+        if fetcher is None:
+            # Defensive: if a request sneaks in before startup finishes
+            raise HTTPException(status_code=503, detail="Service not ready. Try again shortly.")
+        return fetcher
+
+    # ---------------
+    # Routes
+    # ---------------
+    @app.get("/", tags=["meta"])
+    async def home():
+        return {"status": "ok", "message": "Embedding service is running."}
+
+    @app.get("/healthz", tags=["meta"])
+    async def healthz():
+        # Lightweight health; could add a test encode if you want deeper checks
+        return {"status": "healthy"}
+
+    @app.post("/get-embedding/", response_model=EmbeddingResponse, tags=["embedding"])
+    async def get_embedding(request: TextListRequest, embedder: EmbeddingFetcher = Depends(get_embedder)):
+        # Offload embedding to the service (async wrapper over blocking HF/Torch calls)
+        start = time.perf_counter()
+        try:
+            vectors = await embedder.embed(request.texts)
+        except ValueError as ve:
+            raise HTTPException(status_code=400, detail=str(ve)) from ve
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Embedding failed: {e}") from e
+
+        elapsed_ms = (time.perf_counter() - start) * 1000.0
+        dims = len(vectors[0]) if vectors and len(vectors[0]) else 0
+
+        return EmbeddingResponse(
+            model_id=embedder.model_id,
+            device=embedder.device_str,
+            dims=dims,
+            count=len(vectors),
+            elapsed_ms=round(elapsed_ms, 3),
+            embeddings=vectors,
+        )
+
+    return app
+
+
+app = create_app()
+
+# Optional: run via `python main.py` in development
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(
+        "main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True,          # Turn off in production
+        workers=1,            # Use a process manager (e.g., gunicorn) to scale
+        log_level="info",
+      )

requirements.txt

@@ -0,0 +1,57 @@
+annotated-types
+anyio
+certifi
+charset-normalizer
+click
+colorama
+fastapi
+filelock
+fsspec
+h11
+httpcore
+httptools
+httpx
+huggingface-hub
+idna
+Jinja2
+joblib
+jsonpatch
+jsonpointer
+langchain-core
+langchain-huggingface
+langsmith
+MarkupSafe
+mpmath
+networkx
+numpy
+orjson
+packaging
+pillow
+pydantic
+pydantic_core
+python-dotenv
+PyYAML
+regex
+requests
+requests-toolbelt
+safetensors
+scikit-learn
+scipy
+sentence-transformers
+sniffio
+starlette
+sympy
+tenacity
+threadpoolctl
+tokenizers
+torch
+tqdm
+transformers
+typing-inspection
+typing_extensions
+urllib3
+uvicorn
+watchfiles
+websockets
+yml
+zstandard