Download utils/usage.py from Basel0/qshub: direct link, hf CLI and curl.
- Browser
- Download file 7.09 kB
-
https://huggingface.co/spaces/Basel0/qshub/resolve/main/utils/usage.py
- Command line
-
hf download hf://spaces/Basel0/qshub/utils/usage.py
-
curl -L -o usage.py https://huggingface.co/spaces/Basel0/qshub/resolve/main/utils/usage.py
7.09 kB
| """Usage accounting and entitlement enforcement.""" | |
| from __future__ import annotations | |
| import json | |
| from typing import Any | |
| from utils.db import safe_execute, safe_query | |
| from utils.plans import get_plan_for_user, ttl_cache | |
| from utils.db import is_sqlite | |
| EVENT_PROJECT = "project_created" | |
| EVENT_AI_CALL = "ai_call" | |
| EVENT_EXPORT = "export" | |
| def log_usage( | |
| user_id: int | None, | |
| event_type: str, | |
| quantity: int = 1, | |
| project_id: int | None = None, | |
| metadata: dict[str, Any] | None = None, | |
| ) -> None: | |
| safe_execute( | |
| """ | |
| INSERT INTO qto_usage_logs (user_id, project_id, event_type, quantity, metadata) | |
| VALUES (%s, %s, %s, %s, %s) | |
| """, | |
| ( | |
| user_id, | |
| project_id, | |
| event_type, | |
| quantity, | |
| json.dumps(metadata or {}, ensure_ascii=False, default=str), | |
| ), | |
| ) | |
| def monthly_usage(user_id: int, event_type: str, feature: str = "qto") -> int: | |
| if is_sqlite(): | |
| df = safe_query( | |
| """ | |
| SELECT quantity, metadata | |
| FROM qto_usage_logs | |
| WHERE user_id=%s | |
| AND event_type=%s | |
| AND created_at >= date('now', 'start of month') | |
| """, | |
| (user_id, event_type), | |
| ) | |
| else: | |
| df = safe_query( | |
| """ | |
| SELECT quantity, metadata | |
| FROM qto_usage_logs | |
| WHERE user_id=%s | |
| AND event_type=%s | |
| AND created_at >= DATE_FORMAT(CURRENT_DATE, '%%Y-%%m-01') | |
| """, | |
| (user_id, event_type), | |
| ) | |
| if df.empty: | |
| return 0 | |
| total = 0 | |
| for _, row in df.iterrows(): | |
| try: | |
| meta = json.loads(row["metadata"] or "{}") | |
| row_feature = meta.get("feature", "qto") | |
| if row_feature == feature: | |
| total += int(row["quantity"] or 0) | |
| except Exception: | |
| pass | |
| return total | |
| def lifetime_usage(user_id: int, event_type: str, feature: str = "qto") -> int: | |
| """Total count of an event for a feature over the account's whole lifetime | |
| (no monthly reset). Used for the one-time free project each new user gets.""" | |
| df = safe_query( | |
| "SELECT quantity, metadata FROM qto_usage_logs WHERE user_id=%s AND event_type=%s", | |
| (user_id, event_type), | |
| ) | |
| if df.empty: | |
| return 0 | |
| total = 0 | |
| for _, row in df.iterrows(): | |
| try: | |
| meta = json.loads(row["metadata"] or "{}") | |
| if meta.get("feature", "qto") == feature: | |
| total += int(row["quantity"] or 0) | |
| except Exception: | |
| pass | |
| return total | |
| # Every new user gets this many free projects PER TOOL, once (lifetime), before | |
| # they ever subscribe — so they can try each tool on a real project for free. | |
| FREE_PROJECTS_PER_FEATURE = 1 | |
| def project_entitlement(user: dict, feature: str = "qto") -> dict: | |
| """Single source of truth for 'can this user create a project right now?'. | |
| Monthly model: the tier gives `base` projects PER MONTH (resets monthly). | |
| Add-ons are ONE-TIME credits consumed only when creating beyond the monthly | |
| base — they are not a permanent bump. On top of that, an unsubscribed user | |
| (no paid tier) gets ONE free project per tool for their whole lifetime, so a | |
| user can create when they still have monthly room OR hold an unused add-on | |
| credit OR still have their free project. | |
| """ | |
| user_id = int(user.get("id")) | |
| role = user.get("role") | |
| is_admin = role == "admin" | |
| plan = get_plan_for_user(user_id, role, feature) | |
| base = plan.projects | |
| from utils.features import extra_projects_for | |
| try: | |
| credits = 0 if is_admin else extra_projects_for(user_id, feature) | |
| except Exception as e: | |
| print(f"Error fetching extra projects: {e}") | |
| credits = 0 | |
| used = monthly_usage(user_id, EVENT_PROJECT, feature) | |
| # One-time free project for users without a paid plan (base == 0). | |
| free_base = FREE_PROJECTS_PER_FEATURE if (base == 0 and not is_admin) else 0 | |
| free_used = lifetime_usage(user_id, EVENT_PROJECT, feature) if free_base else 0 | |
| free_left = max(free_base - free_used, 0) | |
| can_create = is_admin or (used < base) or (credits > 0) or (free_left > 0) | |
| return { | |
| "base": base, "used": used, "credits": credits, | |
| "free_base": free_base, "free_left": free_left, | |
| "can_create": can_create, "is_admin": is_admin, | |
| } | |
| def check_limit(user: dict, event_type: str, amount: int = 1, feature: str = "qto") -> tuple[bool, str]: | |
| user_id = int(user.get("id")) | |
| role = user.get("role") | |
| plan = get_plan_for_user(user_id, role, feature) | |
| if event_type == EVENT_PROJECT: | |
| ent = project_entitlement(user, feature) | |
| if ent["can_create"]: | |
| return True, "OK" | |
| return False, ( | |
| f"Monthly project limit reached for {feature}: {ent['used']}/{ent['base']} this month, " | |
| f"and you have 0 extra projects left. Add a project or upgrade your plan." | |
| ) | |
| # AI calls / exports still scale with any unused add-ons the user holds. | |
| from utils.features import extra_projects_for | |
| try: | |
| extra_projects = extra_projects_for(user_id, feature) | |
| except Exception: | |
| extra_projects = 0 | |
| limits = { | |
| EVENT_AI_CALL: plan.ai_calls + (extra_projects * 20), | |
| EVENT_EXPORT: plan.exports + (extra_projects * 5), | |
| } | |
| limit = limits.get(event_type) | |
| if limit is None: | |
| return True, "OK" | |
| used = monthly_usage(user_id, event_type, feature) | |
| if used + amount > limit: | |
| return False, f"Plan limit reached for {event_type} ({feature}): {used}/{limit}" | |
| return True, "OK" | |
| def settle_project_creation(user: dict, feature: str = "qto", metadata: dict | None = None) -> None: | |
| """Log a newly-created project AND spend one add-on credit if it went beyond | |
| the monthly tier quota. Call this INSTEAD of log_usage at creation time. | |
| """ | |
| user_id = int(user.get("id")) | |
| role = user.get("role") | |
| md = dict(metadata or {}) | |
| if feature != "qto": | |
| md.setdefault("feature", feature) | |
| # Count what existed BEFORE this project (fresh, not the 60s-cached value). | |
| monthly_usage.clear() | |
| used_before = monthly_usage(user_id, EVENT_PROJECT, feature) | |
| log_usage(user_id, EVENT_PROJECT, metadata=md) | |
| monthly_usage.clear() | |
| if role != "admin": | |
| plan = get_plan_for_user(user_id, role, feature) | |
| if used_before >= plan.projects: | |
| # Monthly quota was already full → this one is covered by a one-time add-on. | |
| from utils.features import consume_extra_project | |
| consume_extra_project(user_id, feature, 1) | |
| def check_file_size(user: dict, size_bytes: int) -> tuple[bool, str]: | |
| plan = get_plan_for_user(int(user.get("id")), user.get("role")) | |
| max_bytes = plan.max_file_mb * 1024 * 1024 | |
| if size_bytes > max_bytes: | |
| return False, f"File exceeds plan limit: {plan.max_file_mb} MB" | |
| return True, "OK" | |