Fix circular

app.py

@@ -31,20 +31,6 @@ from helper.assets import (
     is_base64_image,
     asset_router,
 )
-from helper.misc import (
-    extract_user_text,
-    calculate_messages_size,
-    is_long_context,
-    contains_code,
-    is_math_heavy,
-    is_structured_task,
-    multiple_questions,
-    is_code_heavy,
-    normalize_prompt_value,
-    enforce_prompt_size,
-    resolve_bound_subject,
-    get_usage_snapshot_for_subject,
-)
 
 from helper.ratelimit import (
     enforce_rate_limit,
@@ -58,6 +44,18 @@ from helper.ratelimit import (
     MAX_GROQ_PROMPT_CHARS,
     MAX_MEDIA_PROMPT_BYTES,
     MAX_MEDIA_PROMPT_CHARS,
+    extract_user_text,
+    calculate_messages_size,
+    is_long_context,
+    contains_code,
+    is_math_heavy,
+    is_structured_task,
+    multiple_questions,
+    is_code_heavy,
+    normalize_prompt_value,
+    enforce_prompt_size,
+    resolve_bound_subject,
+    get_usage_snapshot_for_subject,
 )
 
 app = FastAPI()

helper/misc.py

@@ -1,158 +0,0 @@
-import time
-import asyncio
-
-from helper.ratelimit import CLIENT_BIND_TTL_SECONDS, MAX_CLIENT_ID_LENGTH, client_subject_bindings
-from helper.subscriptions import USAGE_PERIODS, usage_locks, usage_store, TIER_CONFIG
-from fastapi import Request, HTTPException
-from typing import Optional, Dict, Any, List
-import re
-import hashlib
-
-def extract_user_text(messages: list) -> str:
-    return " ".join(
-        message_content_to_text(m.get("content"))
-        for m in messages
-        if isinstance(m, dict) and m.get("role") == "user"
-    ).lower()
-
-def get_usage_period_key(metric: str) -> str:
-    now = time.gmtime()
-    period = USAGE_PERIODS.get(metric, "daily")
-    if period == "weekly":
-        iso_year, iso_week, _ = time.strftime("%G %V %u", now).split(" ")
-        return f"{iso_year}-W{iso_week}"
-    return time.strftime("%Y-%m-%d", now)
-
-
-def sanitize_client_id(raw_client_id: Optional[str]) -> Optional[str]:
-    if not isinstance(raw_client_id, str):
-        return None
-    trimmed = raw_client_id.strip()
-    if not trimmed or len(trimmed) > MAX_CLIENT_ID_LENGTH:
-        return None
-    if not re.match(r"^[A-Za-z0-9._:-]+$", trimmed):
-        return None
-    return trimmed
-
-
-def get_usage_lock(metric: str, subject: str) -> asyncio.Lock:
-    metric_locks = usage_locks.get(metric)
-    if metric_locks is None:
-        metric_locks = {}
-        usage_locks[metric] = metric_locks
-    lock = metric_locks.get(subject)
-    if lock is None:
-        lock = asyncio.Lock()
-        metric_locks[subject] = lock
-    return lock
-
-
-def build_default_subject(request: Request, client_id: Optional[str]) -> str:
-    if client_id:
-        client_hash = hashlib.sha256(client_id.encode("utf-8")).hexdigest()[:24]
-        return f"client:{client_hash}"
-    host = request.client.host if request.client else "unknown"
-    user_agent = request.headers.get("user-agent", "")
-    ua_hash = (
-        hashlib.sha256(user_agent.encode("utf-8")).hexdigest()[:12]
-        if user_agent
-        else "noua"
-    )
-    return f"anon:{host}:{ua_hash}"
-
-
-def bind_client_subject(client_id: Optional[str], subject: str, plan_key: str):
-    if not client_id:
-        return
-    client_subject_bindings[client_id] = {
-        "subject": subject,
-        "plan_key": plan_key,
-        "expires_at": time.time() + CLIENT_BIND_TTL_SECONDS,
-    }
-
-
-def resolve_bound_subject(client_id: Optional[str], fallback_subject: str) -> str:
-    if not client_id:
-        return fallback_subject
-    bound = client_subject_bindings.get(client_id)
-    if not bound:
-        return fallback_subject
-    if bound.get("expires_at", 0) <= time.time():
-        client_subject_bindings.pop(client_id, None)
-        return fallback_subject
-    return bound.get("subject", fallback_subject)
-
-
-def normalize_prompt_value(prompt: Optional[str], field_name: str = "prompt") -> str:
-    if not isinstance(prompt, str):
-        raise HTTPException(status_code=400, detail=f"{field_name} is required")
-    normalized = prompt.strip()
-    if not normalized:
-        raise HTTPException(status_code=400, detail=f"{field_name} is required")
-    return normalized
-
-
-def enforce_prompt_size(prompt: str, max_chars: int, max_bytes: int, context: str):
-    char_len = len(prompt)
-    byte_len = len(prompt.encode("utf-8"))
-    if char_len > max_chars or byte_len > max_bytes:
-        raise HTTPException(
-            status_code=413,
-            detail=(
-                f"{context} is too large ({char_len} chars, {byte_len} bytes). "
-                f"Max allowed is {max_chars} chars or {max_bytes} bytes."
-            ),
-        )
-
-
-def message_content_to_text(content: Any) -> str:
-    if isinstance(content, str):
-        return content
-    if isinstance(content, list):
-        parts: List[str] = []
-        for item in content:
-            if isinstance(item, str):
-                parts.append(item)
-                continue
-            if isinstance(item, dict):
-                text = item.get("text")
-                if isinstance(text, str):
-                    parts.append(text)
-        return " ".join(parts)
-    return ""
-
-
-def calculate_messages_size(messages: list) -> tuple[int, int]:
-    total_chars = 0
-    total_bytes = 0
-    for message in messages:
-        if not isinstance(message, dict):
-            continue
-        text = message_content_to_text(message.get("content"))
-        if not text:
-            continue
-        total_chars += len(text)
-        total_bytes += len(text.encode("utf-8"))
-    return total_chars, total_bytes
-
-
-def get_usage_snapshot_for_subject(plan_key: str, subject: str) -> Dict[str, Dict[str, Any]]:
-    plan = TIER_CONFIG.get(plan_key) or TIER_CONFIG["free"]
-    plan_limits = plan.get("limits", {})
-    snapshot: Dict[str, Dict[str, Any]] = {}
-    for metric in usage_store.keys():
-        limit = plan_limits.get(metric)
-        window_key = get_usage_period_key(metric)
-        entry = usage_store[metric].get(subject)
-        used = 0
-        if entry and entry.get("window") == window_key:
-            used = max(0, int(entry.get("count", 0)))
-        remaining = None if limit is None else max(0, int(limit) - used)
-        snapshot[metric] = {
-            "limit": limit,
-            "used": used,
-            "remaining": remaining,
-            "window": window_key,
-            "period": USAGE_PERIODS.get(metric, "daily"),
-        }
-    return snapshot

helper/ratelimit.py

@@ -1,32 +1,67 @@
+import asyncio
+import hashlib
+import os
+import re
 import time
-from typing import Optional, Dict
+from typing import Any, Dict, List, Optional
+
 from fastapi import HTTPException, Request
-from helper.misc import sanitize_client_id, get_usage_lock, get_usage_period_key, build_default_subject, bind_client_subject, resolve_bound_subject
-from helper.subscriptions import fetch_subscription, usage_store, normalize_plan_key, TIER_CONFIG
-import os
+
+from helper.subscriptions import (
+    TIER_CONFIG,
+    USAGE_PERIODS,
+    fetch_subscription,
+    normalize_plan_key,
+    usage_locks,
+    usage_store,
+)
+
+
+# -------------------------------------------------------------------
+# Configuration / Constants
+# -------------------------------------------------------------------
+
 IDENTITY_CACHE_TTL_SECONDS = 60
-identity_cache = {}
+
 CLIENT_BIND_TTL_SECONDS = int(
     os.getenv("CLIENT_BIND_TTL_SECONDS", str(8 * 24 * 60 * 60))
 )
+
 MAX_CLIENT_ID_LENGTH = 128
-client_subject_bindings = {}
 
 MAX_CHAT_PROMPT_CHARS = int(os.getenv("MAX_CHAT_PROMPT_CHARS", "120000"))
 MAX_CHAT_PROMPT_BYTES = int(os.getenv("MAX_CHAT_PROMPT_BYTES", "500000"))
+
 MAX_GROQ_PROMPT_CHARS = int(os.getenv("MAX_GROQ_PROMPT_CHARS", "90000"))
 MAX_GROQ_PROMPT_BYTES = int(os.getenv("MAX_GROQ_PROMPT_BYTES", "350000"))
+
 MAX_MEDIA_PROMPT_CHARS = int(os.getenv("MAX_MEDIA_PROMPT_CHARS", "4000"))
 MAX_MEDIA_PROMPT_BYTES = int(os.getenv("MAX_MEDIA_PROMPT_BYTES", "16000"))
 
+
+# -------------------------------------------------------------------
+# In-memory state
+# -------------------------------------------------------------------
+
+identity_cache: Dict[str, Dict[str, Any]] = {}
+
+client_subject_bindings: Dict[str, Dict[str, Any]] = {}
+
+
+# -------------------------------------------------------------------
+# Public Rate Limit APIs
+# -------------------------------------------------------------------
+
 async def resolve_rate_limit_identity(
     request: Request,
     authorization: Optional[str],
     client_id: Optional[str] = None,
 ) -> tuple[str, str]:
     now = time.time()
+
     normalized_client_id = sanitize_client_id(client_id)
     default_subject = build_default_subject(request, normalized_client_id)
+
     if not authorization or not authorization.startswith("Bearer "):
         return "free", resolve_bound_subject(normalized_client_id, default_subject)
 
@@ -38,6 +73,7 @@ async def resolve_rate_limit_identity(
     if cached and cached.get("expires_at", 0) > now:
         plan_key = cached.get("plan_key", "free")
         subject = cached.get("subject", default_subject)
+
         bind_client_subject(normalized_client_id, subject, plan_key)
         return plan_key, subject
 
@@ -56,12 +92,15 @@ async def resolve_rate_limit_identity(
         subject = default_subject
 
     plan_key = normalize_plan_key(sub.get("plan_key"))
+
     identity_cache[token] = {
         "plan_key": plan_key,
         "subject": subject,
         "expires_at": now + IDENTITY_CACHE_TTL_SECONDS,
     }
+
     bind_client_subject(normalized_client_id, subject, plan_key)
+
     return plan_key, subject
 
 
@@ -77,15 +116,20 @@ async def enforce_rate_limit(
     plan_key, subject = await resolve_rate_limit_identity(
         request, authorization, client_id
     )
+
     plan = TIER_CONFIG.get(plan_key) or TIER_CONFIG["free"]
     plan_limits = plan.get("limits", {})
     limit = plan_limits.get(metric)
 
     window_key = get_usage_period_key(metric)
+
     lock = get_usage_lock(metric, subject)
+
     async with lock:
         bucket = usage_store[metric]
+
         entry = bucket.get(subject)
+
         if not entry or entry.get("window") != window_key:
             entry = {"window": window_key, "count": 0}
             bucket[subject] = entry
@@ -97,7 +141,9 @@ async def enforce_rate_limit(
             )
 
         entry["count"] += 1
+
         remaining = None if limit is None else max(0, int(limit) - entry["count"])
+
         return {
             "plan_key": plan_key,
             "remaining": remaining,
@@ -129,3 +175,216 @@ async def check_video_rate_limit(
 ):
     await enforce_rate_limit(request, authorization, "videosDaily", client_id)
 
+
+# -------------------------------------------------------------------
+# Prompt Utilities
+# -------------------------------------------------------------------
+
+def normalize_prompt_value(prompt: Optional[str], field_name: str = "prompt") -> str:
+    if not isinstance(prompt, str):
+        raise HTTPException(status_code=400, detail=f"{field_name} is required")
+
+    normalized = prompt.strip()
+
+    if not normalized:
+        raise HTTPException(status_code=400, detail=f"{field_name} is required")
+
+    return normalized
+
+
+def enforce_prompt_size(prompt: str, max_chars: int, max_bytes: int, context: str):
+    char_len = len(prompt)
+    byte_len = len(prompt.encode("utf-8"))
+
+    if char_len > max_chars or byte_len > max_bytes:
+        raise HTTPException(
+            status_code=413,
+            detail=(
+                f"{context} is too large ({char_len} chars, {byte_len} bytes). "
+                f"Max allowed is {max_chars} chars or {max_bytes} bytes."
+            ),
+        )
+
+
+def calculate_messages_size(messages: list) -> tuple[int, int]:
+    total_chars = 0
+    total_bytes = 0
+
+    for message in messages:
+        if not isinstance(message, dict):
+            continue
+
+        text = message_content_to_text(message.get("content"))
+
+        if not text:
+            continue
+
+        total_chars += len(text)
+        total_bytes += len(text.encode("utf-8"))
+
+    return total_chars, total_bytes
+
+
+def extract_user_text(messages: list) -> str:
+    return " ".join(
+        message_content_to_text(m.get("content"))
+        for m in messages
+        if isinstance(m, dict) and m.get("role") == "user"
+    ).lower()
+
+
+# -------------------------------------------------------------------
+# Usage / Rate Limit Internals
+# -------------------------------------------------------------------
+
+def get_usage_period_key(metric: str) -> str:
+    now = time.gmtime()
+
+    period = USAGE_PERIODS.get(metric, "daily")
+
+    if period == "weekly":
+        iso_year, iso_week, _ = time.strftime("%G %V %u", now).split(" ")
+        return f"{iso_year}-W{iso_week}"
+
+    return time.strftime("%Y-%m-%d", now)
+
+
+def get_usage_lock(metric: str, subject: str) -> asyncio.Lock:
+    metric_locks = usage_locks.get(metric)
+
+    if metric_locks is None:
+        metric_locks = {}
+        usage_locks[metric] = metric_locks
+
+    lock = metric_locks.get(subject)
+
+    if lock is None:
+        lock = asyncio.Lock()
+        metric_locks[subject] = lock
+
+    return lock
+
+
+def get_usage_snapshot_for_subject(
+    plan_key: str, subject: str
+) -> Dict[str, Dict[str, Any]]:
+    plan = TIER_CONFIG.get(plan_key) or TIER_CONFIG["free"]
+
+    plan_limits = plan.get("limits", {})
+
+    snapshot: Dict[str, Dict[str, Any]] = {}
+
+    for metric in usage_store.keys():
+        limit = plan_limits.get(metric)
+
+        window_key = get_usage_period_key(metric)
+
+        entry = usage_store[metric].get(subject)
+
+        used = 0
+
+        if entry and entry.get("window") == window_key:
+            used = max(0, int(entry.get("count", 0)))
+
+        remaining = None if limit is None else max(0, int(limit) - used)
+
+        snapshot[metric] = {
+            "limit": limit,
+            "used": used,
+            "remaining": remaining,
+            "window": window_key,
+            "period": USAGE_PERIODS.get(metric, "daily"),
+        }
+
+    return snapshot
+
+
+# -------------------------------------------------------------------
+# Identity / Client helpers
+# -------------------------------------------------------------------
+
+def sanitize_client_id(raw_client_id: Optional[str]) -> Optional[str]:
+    if not isinstance(raw_client_id, str):
+        return None
+
+    trimmed = raw_client_id.strip()
+
+    if not trimmed or len(trimmed) > MAX_CLIENT_ID_LENGTH:
+        return None
+
+    if not re.match(r"^[A-Za-z0-9._:-]+$", trimmed):
+        return None
+
+    return trimmed
+
+
+def build_default_subject(request: Request, client_id: Optional[str]) -> str:
+    if client_id:
+        client_hash = hashlib.sha256(client_id.encode("utf-8")).hexdigest()[:24]
+        return f"client:{client_hash}"
+
+    host = request.client.host if request.client else "unknown"
+
+    user_agent = request.headers.get("user-agent", "")
+
+    ua_hash = (
+        hashlib.sha256(user_agent.encode("utf-8")).hexdigest()[:12]
+        if user_agent
+        else "noua"
+    )
+
+    return f"anon:{host}:{ua_hash}"
+
+
+def bind_client_subject(client_id: Optional[str], subject: str, plan_key: str):
+    if not client_id:
+        return
+
+    client_subject_bindings[client_id] = {
+        "subject": subject,
+        "plan_key": plan_key,
+        "expires_at": time.time() + CLIENT_BIND_TTL_SECONDS,
+    }
+
+
+def resolve_bound_subject(client_id: Optional[str], fallback_subject: str) -> str:
+    if not client_id:
+        return fallback_subject
+
+    bound = client_subject_bindings.get(client_id)
+
+    if not bound:
+        return fallback_subject
+
+    if bound.get("expires_at", 0) <= time.time():
+        client_subject_bindings.pop(client_id, None)
+        return fallback_subject
+
+    return bound.get("subject", fallback_subject)
+
+
+# -------------------------------------------------------------------
+# Message parsing helpers
+# -------------------------------------------------------------------
+
+def message_content_to_text(content: Any) -> str:
+    if isinstance(content, str):
+        return content
+
+    if isinstance(content, list):
+        parts: List[str] = []
+
+        for item in content:
+            if isinstance(item, str):
+                parts.append(item)
+                continue
+
+            if isinstance(item, dict):
+                text = item.get("text")
+
+                if isinstance(text, str):
+                    parts.append(text)
+
+        return " ".join(parts)
+
+    return ""