chore: update something

lightweight_embeddings/__init__.py

@@ -124,11 +124,23 @@ def call_embeddings_api(user_input: str, selected_model: str) -> str:
 
     try:
         data = response.json()
-        return json.dumps(data, indent=2)
+        return json.dumps(data, indent=2, ensure_ascii=False)
     except ValueError:
         return "❌ Failed to parse JSON from API response."
 
 
+def call_stats_api() -> str:
+    """
+    Calls the /v1/stats endpoint to retrieve analytics data.
+    Returns the JSON response as a formatted string.
+    """
+    url = "https://lamhieu-lightweight-embeddings.hf.space/v1/stats"
+    response = requests.get(url)
+    if response.status_code != 200:
+        raise ValueError(f"Failed to fetch stats: {response.text}")
+    return json.dumps(response.json(), indent=2, ensure_ascii=False)
+
+
 def create_main_interface():
     """
     Creates a Gradio Blocks interface showing project info and an embeddings playground.
@@ -147,10 +159,7 @@ def create_main_interface():
     ]
 
     with gr.Blocks(title="Lightweight Embeddings", theme="default") as demo:
-        # Project Info
-        gr.Markdown(APP_DESCRIPTION)
-
-        # Split Layout: Playground and cURL Examples
+        # ...existing code...
         with gr.Row():
             with gr.Column():
                 gr.Markdown("### 🔬 Try the Embeddings Playground")
@@ -171,7 +180,6 @@ def create_main_interface():
                     interactive=False,
                 )
 
-                # Link button to inference function
                 generate_btn.click(
                     fn=call_embeddings_api,
                     inputs=[input_text, model_dropdown],
@@ -214,6 +222,14 @@ def create_main_interface():
                   """
                 )
 
+        # NEW STATS SECTION
+        with gr.Accordion("Analytics Stats"):
+            stats_btn = gr.Button("Get Stats")
+            stats_json = gr.Textbox(
+                label="Stats API Response", lines=10, interactive=False
+            )
+            stats_btn.click(fn=call_stats_api, inputs=[], outputs=stats_json)
+
     return demo
 
 

lightweight_embeddings/analytics.py

@@ -0,0 +1,78 @@
+import asyncio
+import redis.asyncio as redis
+from datetime import datetime
+from collections import defaultdict
+from typing import Dict
+
+
+class Analytics:
+    def __init__(self, redis_url: str, sync_interval: int = 60):
+        """
+        Initializes the Analytics class with an async Redis connection and sync interval.
+
+        Parameters:
+        - redis_url: Redis connection URL (e.g., 'redis://localhost:6379/0')
+        - sync_interval: Interval in seconds for syncing with Redis.
+        """
+        self.pool = redis.ConnectionPool.from_url(redis_url, decode_responses=True)
+        self.redis_client = redis.Redis(connection_pool=self.pool)
+        self.local_buffer = defaultdict(
+            lambda: defaultdict(int)
+        )  # {period: {model_id: count}}
+        self.sync_interval = sync_interval
+        self.lock = asyncio.Lock()  # Async lock for thread-safe updates
+        asyncio.create_task(self._start_sync_task())
+
+    def _get_period_keys(self) -> tuple:
+        """
+        Returns keys for day, week, month, and year based on the current date.
+        """
+        now = datetime.utcnow()
+        day_key = now.strftime("%Y-%m-%d")
+        week_key = f"{now.year}-W{now.strftime('%U')}"
+        month_key = now.strftime("%Y-%m")
+        year_key = now.strftime("%Y")
+        return day_key, week_key, month_key, year_key
+
+    async def access(self, model_id: str):
+        """
+        Records an access for a specific model_id.
+        """
+        day_key, week_key, month_key, year_key = self._get_period_keys()
+
+        async with self.lock:
+            self.local_buffer[day_key][model_id] += 1
+            self.local_buffer[week_key][model_id] += 1
+            self.local_buffer[month_key][model_id] += 1
+            self.local_buffer[year_key][model_id] += 1
+            self.local_buffer["total"][model_id] += 1
+
+    async def stats(self) -> Dict[str, Dict[str, int]]:
+        """
+        Returns statistics for all models from the local buffer.
+        """
+        async with self.lock:
+            return {
+                period: dict(models) for period, models in self.local_buffer.items()
+            }
+
+    async def _sync_to_redis(self):
+        """
+        Synchronizes local buffer data with Redis.
+        """
+        async with self.lock:
+            pipeline = self.redis_client.pipeline()
+            for period, models in self.local_buffer.items():
+                for model_id, count in models.items():
+                    redis_key = f"analytics:{period}"
+                    pipeline.hincrby(redis_key, model_id, count)
+            await pipeline.execute()
+            self.local_buffer.clear()  # Clear the buffer after sync
+
+    async def _start_sync_task(self):
+        """
+        Starts a background task that periodically syncs data to Redis.
+        """
+        while True:
+            await asyncio.sleep(self.sync_interval)
+            await self._sync_to_redis()

lightweight_embeddings/router.py

@@ -20,12 +20,15 @@ Supported Image Model IDs:
 from __future__ import annotations
 
 import logging
-from typing import List, Union
+import os
+from typing import Dict, Any, List, Union
 from enum import Enum
+from datetime import datetime
 
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, BackgroundTasks, HTTPException
 from pydantic import BaseModel, Field
 
+from .analytics import Analytics
 from .service import (
     ModelConfig,
     TextModelType,
@@ -120,12 +123,29 @@ class RankResponse(BaseModel):
     probabilities: List[List[float]]
     cosine_similarities: List[List[float]]
 
+
+class StatsResponse(BaseModel):
+    """Analytics stats response model"""
+
+    total: Dict[str, int]
+    daily: Dict[str, int]
+    weekly: Dict[str, int]
+    monthly: Dict[str, int]
+    yearly: Dict[str, int]
+
+
 service_config = ModelConfig()
 embeddings_service = EmbeddingsService(config=service_config)
 
+analytics = Analytics(
+    redis_url=os.environ.get("REDIS_URL", "redis://localhost:6379/0"), sync_interval=60
+)
+
 
 @router.post("/embeddings", response_model=EmbeddingResponse, tags=["embeddings"])
-async def create_embeddings(request: EmbeddingRequest):
+async def create_embeddings(
+    request: EmbeddingRequest, background_tasks: BackgroundTasks
+):
     """
     Generates embeddings for the given input (text or image).
     """
@@ -144,6 +164,8 @@ async def create_embeddings(request: EmbeddingRequest):
             input_data=request.input, modality=mkind.value
         )
 
+        background_tasks.add_task(analytics.access, request.model)
+
         # 4) Estimate tokens for text only
         total_tokens = 0
         if mkind == ModelKind.TEXT:
@@ -158,6 +180,7 @@ async def create_embeddings(request: EmbeddingRequest):
                 "total_tokens": total_tokens,
             },
         }
+
         for idx, emb in enumerate(embeddings):
             resp["data"].append(
                 {
@@ -179,7 +202,7 @@ async def create_embeddings(request: EmbeddingRequest):
 
 
 @router.post("/rank", response_model=RankResponse, tags=["rank"])
-async def rank_candidates(request: RankRequest):
+async def rank_candidates(request: RankRequest, background_tasks: BackgroundTasks):
     """
     Ranks candidate texts against the given queries (which can be text or image).
     """
@@ -196,6 +219,9 @@ async def rank_candidates(request: RankRequest):
             candidates=request.candidates,
             modality=mkind.value,
         )
+
+        background_tasks.add_task(analytics.access, request.model)
+
         return results
 
     except Exception as e:
@@ -205,3 +231,25 @@ async def rank_candidates(request: RankRequest):
         )
         logger.error(msg)
         raise HTTPException(status_code=500, detail=msg)
+
+
+@router.get("/stats", response_model=StatsResponse, tags=["stats"])
+async def get_stats():
+    """Get usage statistics for all models"""
+    try:
+        stats = await analytics.stats()
+
+        return {
+            "total": stats.get("total", {}),
+            "daily": stats.get(datetime.utcnow().strftime("%Y-%m-%d"), {}),
+            "weekly": stats.get(
+                f"{datetime.utcnow().year}-W{datetime.utcnow().strftime('%U')}", {}
+            ),
+            "monthly": stats.get(datetime.utcnow().strftime("%Y-%m"), {}),
+            "yearly": stats.get(datetime.utcnow().strftime("%Y"), {}),
+        }
+
+    except Exception as e:
+        msg = f"Failed to fetch analytics stats: {str(e)}"
+        logger.error(msg)
+        raise HTTPException(status_code=500, detail=msg)

requirements.txt

@@ -7,3 +7,4 @@ sentence-transformers[onnx]==3.3.1
 sentencepiece==0.2.0
 torch==2.4.0
 transformers==4.45.0
+redis-py=5.2.1