Adding Credit System

Author: derjogi

.gitignore

@@ -4,5 +4,4 @@ __pycache__/
 *.png
 helpers/.nltk_resources_cache
 **/.nltk
-.vscode/settings.json
-
+.vscode/settings.json

app/api/v1/dependencies/feature_flags.py

@@ -1,6 +1,6 @@
 from typing import Optional
 from fastapi import Request
-from app.core.settings import settings
+from app.core.config import settings
 
 async def check_advanced_features(request: Request) -> bool:
     """

app/api/v1/routes/auth.py

@@ -0,0 +1,18 @@
+from fastapi import APIRouter
+import supabase
+
+from app.core.security import authenticate_user, create_user
+from app.core.config import settings
+
+router = APIRouter(tags=["auth"])
+
+@router.post("/auth/signup")
+async def signup(email: str, password: str):
+    token_data = await create_user(email, password)
+    return {"access_token": token_data}
+
+@router.post("/auth/login")
+async def login(email: str, password: str):
+    token_data = await authenticate_user(email, password)
+    
+    return {"access_token": token_data}

app/api/v1/routes/ideas.py

@@ -1,10 +1,11 @@
-from fastapi import APIRouter, Depends, Request, Response
+from fastapi import APIRouter, Depends, HTTPException, Request, Response
 from typing import List
 import json
 
 from app.core.limiter import limiter
-from app.core.settings import settings
+from app.core.config import settings
 from app.services.clustering import summarize_clusters
+from app.services.credits import CreditService
 from ..dependencies.auth import verify_token
 
 from ....services.analyzer import centroid_analysis
@@ -19,9 +20,8 @@
 async def rank_ideas(
     request: Request,
     ideaRequest: IdeaRequest,
-    token: str = Depends(verify_token),   # No effect for now; verification is disabled
+    user_info: dict = Depends(verify_token),
 ) -> AnalysisResponse:
-    print('Ranking ideas')
     """
     Analyze and rank ideas based on semantic similarity.
     
@@ -31,96 +31,167 @@ async def rank_ideas(
     - Generate relationship graphs (optional)
     - Create pairwise similarity matrix (optional)
     
+    Credits required:
+    - Basic analysis: 1 credit per 100 ideas
+    - Relationship graph: 3 credits
+    - Cluster names: 5 credits
+    
     Returns:
         AnalysisResponse containing ranked ideas and optional advanced analysis
     
     Raises:
         HTTPException(400): If input data is invalid
+        HTTPException(402): If insufficient credits
         HTTPException(429): If rate limit is exceeded
     """
-        
-    # Extract raw ideas for analysis
+    print('Ranking ideas')
+    
     ideas = [item.idea for item in ideaRequest.ideas]
-    id_mapping = {item.idea: {'id': item.id or 1, 'author_id': item.author_id} for item in ideaRequest.ideas}
-    if len(ideas) < 4:
-      return Response(status_code=400, content='Please provide at least 4 items to analyze')
+    num_ideas = len(ideas)
+    total_bytes = sum(len(item.idea.encode('utf-8')) for item in ideaRequest.ideas)
+
+    if num_ideas < 4:
+        return Response(status_code=400, content='Please provide at least 4 items to analyze')
+
+    # Check credits for basic analysis
+    user_id = user_info["user_id"]
+    
+    operations = ["basic_analysis"]
+    
+    if ideaRequest.advanced_features:
+        if ideaRequest.advanced_features.relationship_graph:
+            operations.append("relationship_graph")
+        if ideaRequest.advanced_features.cluster_names:
+            operations.append("cluster_names")
+
+    if not await CreditService.has_sufficient_credits(
+        user_id, operations, num_ideas, total_bytes
+    ):
+        raise HTTPException(
+            status_code=402,
+            detail=f"Insufficient credits for analysis. Available credits: {await CreditService.get_credits(user_id)}"
+        )
 
     # Perform core analysis
     results, plot_data = centroid_analysis(ideas)
+    await CreditService.deduct_credits(user_id, "basic_analysis", num_ideas, total_bytes)
 
-    # Create ranked ideas response
+    response = await build_base_response(ideas, results, plot_data)
+
+    if ideaRequest.advanced_features:
+        response = await process_advanced_features(
+            ideaRequest, response, user_id, ideas, plot_data, num_ideas, total_bytes
+        )
+
+    print('Results calculated successfully!\n', response)
+    return AnalysisResponse(**response)
+
+def _generate_edges(ranked_ideas: List[RankedIdea], similarity_matrix: List[List[float]]) -> List[dict]:
+    """
+    Generate graph edges showing relationships between ideas and to centroid.
+    
+    Creates two types of edges:
+    1. Between ideas based on pairwise similarity
+    2. From each idea to the centroid based on similarity scores
+    """
+    edges = []
+    
+    # Create edges between ideas
+    for i, idea_from in enumerate(ranked_ideas):
+        if i+1 > len(similarity_matrix): 
+            break
+        for j, idea_to in enumerate(ranked_ideas[i+1:], i+1):
+            edges.append({
+                "from_id": idea_from.id,
+                "to_id": idea_to.id,
+                "similarity": similarity_matrix[i][j]
+            })
+    
+    # Create edges to centroid
+    for idea in ranked_ideas:
+        edges.append({
+            "from_id": idea.id,
+            "to_id": "Centroid",
+            "similarity": idea.similarity_score
+        })
+    
+    return edges
+
+async def build_base_response(ideas: List[str], results: Results, plot_data: PlotData) -> dict:
+    """Build base response with ranked ideas and similarity scores"""
     ranked_ideas = [
         RankedIdea(
-            id=id_mapping[idea]['id'],
-            author_id=id_mapping[idea]['author_id'],
+            id=str(idx),
             idea=idea,
-            similarity_score=results["similarity"][index],
-            cluster_id=plot_data["kmeans_data"]["cluster"][index],
+            similarity_score=results["similarity"][idx],
+            cluster_id=plot_data["kmeans_data"]["cluster"][idx],
         )
-        for index, idea in enumerate(results["ideas"])
+        for idx, idea in enumerate(results["ideas"])
     ]
 
-    # Sort by similarity score
     ranked_ideas.sort(key=lambda x: x.similarity_score, reverse=True)
 
-    # Build response with optional advanced features
-    response = {
+    return {
         "ranked_ideas": ranked_ideas,
         "relationship_graph": None,
         "pairwise_similarity_matrix": None,
         "cluster_names": None
     }
-    
 
-    if ideaRequest.advanced_features:
-        if ideaRequest.advanced_features.relationship_graph:
-            coords = plot_data.get("scatter_points", [])
-            nodes = [
-                  {
-                    "id": idea.id, 
-                    "coordinates": {
-                      "x": coords[i][0], 
-                      "y": coords[i][1]
-                    }
-                  } 
-                  for i, idea in enumerate(ranked_ideas)]
-            # Add the centroid:
-            nodes.append({"id": "Centroid", "coordinates": {"x": coords[-1][0], "y": coords[-1][0]}})
-            response["relationship_graph"] = RelationshipGraph(
-                nodes=nodes,
-                edges=_generate_edges(ranked_ideas, plot_data.get("pairwise_similarity", []))
-            )
-            
-        if ideaRequest.advanced_features.pairwise_similarity_matrix:
-            response["pairwise_similarity_matrix"] = plot_data.get("pairwise_similarity")
-            
-        if ideaRequest.advanced_features.cluster_names:
-            response["cluster_names"] = await summarize_clusters(ranked_ideas)
-    print('Results calculated successfully!\n', response)
-    return AnalysisResponse(**response)
+async def process_advanced_features(
+    request: IdeaRequest,
+    response: dict,
+    user_id: str,
+    ideas: List[str],
+    plot_data: PlotData,
+    num_ideas: int,
+    total_bytes: int
+) -> dict:
+    """Process and add advanced features if credits are available"""
+    if request.advanced_features.relationship_graph:
+        response["relationship_graph"] = build_relationship_graph(
+            response["ranked_ideas"], plot_data
+        )
+        CreditService.deduct_credits(user_id, "relationship_graph", num_ideas, total_bytes)
+    
+    if request.advanced_features.cluster_names:
+        response["cluster_names"] = await summarize_clusters(response["ranked_ideas"])
+        CreditService.deduct_credits(user_id, "cluster_names", num_ideas, total_bytes)
+           
+    if request.advanced_features.pairwise_similarity_matrix:
+        response["pairwise_similarity_matrix"] = plot_data.pairwise_similarity
+        
+    return response
 
-def _generate_edges(ranked_ideas: List[RankedIdea], similarity_matrix: List) -> List[dict]:
-    """Generate graph edges based on similarity scores"""
-    edges = []
+def build_relationship_graph(ranked_ideas: List[RankedIdea], plot_data: PlotData) -> RelationshipGraph:
+    """
+    Builds a graph representation of idea relationships including:
+    - Nodes with coordinates from MDS analysis
+    - Edges showing similarity between ideas
+    - Centroid connections
+    """
+    coords = plot_data.scatter_points
 
-    for i, idea_from in enumerate(ranked_ideas):
-      if i+1 > len(similarity_matrix): break
-      for j, idea_to in enumerate(ranked_ideas[i+1:], i+1):
-          edge = {
-                        "from_id": idea_from.id,
-                        "to_id": idea_to.id,
-                        "similarity": similarity_matrix[i][j]
-                    }
-          edges.append(edge)
-    
-    # Add edges to centroid
-    for i, idea in enumerate(ranked_ideas):
-        edge = {
-            "from_id": idea.id,
-            "to_id": "Centroid",  # centroid id
-            "similarity": idea.similarity_score
+    # Create nodes including centroid
+    nodes = [
+        {
+            "id": idea.id,
+            "coordinates": {
+                "x": coords[i][0],
+                "y": coords[i][1]
+            }
+        }
+        for i, idea in enumerate(ranked_ideas)
+    ]
+    nodes.append({
+        "id": "Centroid",
+        "coordinates": {
+            "x": coords[-1][0],
+            "y": coords[-1][1]
         }
-        edges.append(edge)
+    })
 
-
-    return edges
+    # Generate edges between ideas and to centroid
+    edges = _generate_edges(ranked_ideas, plot_data.pairwise_similarity)
+    
+    return RelationshipGraph(nodes=nodes, edges=edges)

app/core/config.py

@@ -0,0 +1,62 @@
+from pydantic_settings import SettingsConfigDict, BaseSettings
+from typing import Dict, TypedDict
+
+class OperationCost(TypedDict):
+    base_cost: int
+    per_hundred_items: int
+    per_kilobyte: int
+
+class Settings(BaseSettings):
+    PROJECT_NAME: str
+    
+    # List all published versions here. This enables us to manage them better; i.e. gradually phase them out etc...
+    API_V1_STR: str
+    API_V0_STR: str
+    
+    # Security
+    SECRET_KEY: str
+    ACCESS_TOKEN_EXPIRE_MINUTES: int
+    
+    # Rate Limiting
+    GLOBAL_RATE_LIMIT: str
+    RATE_LIMIT_PER_USER: str
+    
+    # MongoDB settings if we use it
+    MONGODB_URI: str
+    
+    # OpenAI if used:
+    OPENAI_API_KEY: str
+    
+    # Supabase postgres db settings
+    DATABASE_URL: str
+    DATABASE_POOLER_URL: str
+    DATABASE_KEY: str
+    DATABASE_PROJECT_URL: str
+    SUPABASE_SERVICE_ROLE_KEY: str
+    
+    OPERATION_COSTS: Dict[str, OperationCost] = {
+        "basic_analysis": {
+            "base_cost": 1,
+            "per_hundred_items": 1,
+            "per_kilobyte": 1
+        },
+        "relationship_graph": {
+            "base_cost": 3,
+            "per_hundred_items": 2,
+            "per_kilobyte": 1
+        },
+        "cluster_names": {
+            "base_cost": 3,
+            "per_hundred_items": 1,
+            "per_kilobyte": 1
+        }
+    }
+    
+    GUEST_DAILY_CREDITS: int
+    GUEST_MAX_CREDITS: int
+    USER_DAILY_CREDITS: int
+    USER_MAX_CREDITS: int
+    
+    model_config = SettingsConfigDict(env_file=".env")
+
+settings = Settings()

app/core/db.py

@@ -0,0 +1,7 @@
+from supabase import create_client, Client
+from .config import settings
+
+db: Client = create_client(
+  settings.DATABASE_PROJECT_URL, 
+  settings.SUPABASE_SERVICE_ROLE_KEY
+  )

app/core/limiter.py

@@ -9,10 +9,17 @@
 # slowapi:
 from slowapi import Limiter
 from slowapi.util import get_remote_address
+from app.core.config import settings
+
+def get_identifier(request):
+  """Get unique identifier for rate limiting based on auth status"""
+  if "authorization" in request.headers:
+      return request.headers["authorization"]
+  return get_remote_address(request)
 
 limiter = Limiter(
-  key_func=get_remote_address, 
-  default_limits=["1/minute"],
+  key_func=get_identifier,
+  default_limits=[settings.RATE_LIMIT_PER_USER],
   strategy="fixed-window",
   storage_uri="memory://",  # if we have auto-scaling / multiple servers we'd want to change this to a database
-)
+)