updates

.env

@@ -1,7 +1,10 @@
 # OpenAI API Key
-OPENAI_API_KEY="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"
+#OPENAI_API_KEY="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"
+OPENAI_API_KEY="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"
 # Google API Key (for Gemini)
 GOOGLE_API_KEY="AIzaSyCH4rdbuK1cfRpwkhpnpxbdWnrO8RsxAD8"
-MESHY_API_KEY=msy_WJfku90Ruj2JHSv6ulQspIRhmputFHdpJOCO
+MESHY_API_KEY="msy_UnUQpybrhKHfDdgIbpkYw4BEBWZ2WV2wEImI"
 SUPABASE_URL="https://blhjlpokxsdalllewjbx.supabase.co"
-SUPABASE_KEY="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImJsaGpscG9reHNkYWxsbGV3amJ4Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDgyNjY0MjksImV4cCI6MjA2Mzg0MjQyOX0.TsoeN7Lid7gmlTJ18Ayp31LEt6Xpyg5VbKt4J5EJGNE"
+SUPABASE_KEY="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImJsaGpscG9reHNkYWxsbGV3amJ4Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDgyNjY0MjksImV4cCI6MjA2Mzg0MjQyOX0.TsoeN7Lid7gmlTJ18Ayp31LEt6Xpyg5VbKt4J5EJGNE"
+STRIPE_SECRET_KEY=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
+#STRIPE_WEBHOOK_SECRET=

.gitignore

@@ -0,0 +1,232 @@
+ # Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# Node.js dependencies
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Coverage directory used by tools like istanbul
+coverage/
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage
+.grunt
+
+# Bower dependency directory
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons
+build/Release
+
+# Dependency directories
+jspm_packages/
+
+# TypeScript v1 declaration files
+typings/
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# parcel-bundler cache
+.cache
+.parcel-cache
+
+# next.js build output
+.next
+
+# nuxt.js build output
+.nuxt
+
+# vuepress build output
+.vuepress/dist
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# IDE and Editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Logs
+logs
+*.log
+
+# Database files
+*.db
+*.sqlite
+*.sqlite3
+
+# Temporary files
+*.tmp
+*.temp
+
+# Backup files
+*.bak
+*.backup

auth.py

@@ -5,6 +5,8 @@ from typing import Optional
 import os
 from dotenv import load_dotenv
 from pydantic import BaseModel
+import jwt
+from datetime import datetime, timedelta
 
 # Load environment variables
 load_dotenv()
@@ -37,11 +39,36 @@ class TokenData(BaseModel):
 
 async def get_current_user(credentials: HTTPAuthorizationCredentials = Depends(security)) -> User:
     """
-    Validate JWT token and return the current user
+    Validate JWT token and return the current user.
+    Supports both backend JWT tokens and Supabase tokens.
     """
+    token = credentials.credentials
+    
+    # First, try to decode as a backend JWT token
     try:
-        # Verify the JWT token with Supabase
-        user = supabase.auth.get_user(credentials.credentials)
+        secret_key = os.getenv("JWT_SECRET_KEY", "your-secret-key-change-this")
+        payload = jwt.decode(token, secret_key, algorithms=["HS256"])
+        user_id = payload.get("sub")
+        email = payload.get("email")
+        
+        if user_id and email:
+            print(f"✅ Successfully authenticated with backend JWT token for user: {email}")
+            return User(
+                id=user_id,
+                email=email,
+                role="user"
+            )
+    except jwt.InvalidTokenError:
+        # If JWT decoding fails, try Supabase token verification
+        print("🔄 Backend JWT decode failed, trying Supabase token...")
+        pass
+    except Exception as e:
+        # Log other JWT errors but continue to Supabase fallback
+        print(f"⚠️ JWT decode error: {str(e)}")
+    
+    # Fallback to Supabase token verification
+    try:
+        user = supabase.auth.get_user(token)
         if not user or not user.user:
             raise HTTPException(
                 status_code=status.HTTP_401_UNAUTHORIZED,
@@ -49,12 +76,14 @@ async def get_current_user(credentials: HTTPAuthorizationCredentials = Depends(s
                 headers={"WWW-Authenticate": "Bearer"},
             )
         # Use the user info from Supabase Auth directly
+        print(f"✅ Successfully authenticated with Supabase token for user: {user.user.email}")
         return User(
             id=user.user.id,
             email=user.user.email,
             role="user"  # Default role
         )
     except Exception as e:
+        print(f"❌ Both authentication methods failed: {str(e)}")
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
             detail=f"Authentication failed: {str(e)}",
@@ -82,4 +111,57 @@ def require_role(required_role: str):
                 detail="Not enough permissions"
             )
         return current_user
-    return role_checker 
+    return role_checker
+
+async def get_supabase_token(credentials: HTTPAuthorizationCredentials = Depends(security)) -> str:
+    """
+    Extract Supabase token from Authorization header
+    """
+    return credentials.credentials
+
+def verify_supabase_token(token: str) -> dict:
+    """
+    Verify Supabase token and return user data
+    """
+    try:
+        user_response = supabase.auth.get_user(token)
+        if not user_response or not user_response.user:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid Supabase token"
+            )
+        # Return user data as dictionary for easier handling
+        return {
+            "id": user_response.user.id,
+            "email": user_response.user.email,
+            "user_metadata": user_response.user.user_metadata or {},
+            "app_metadata": user_response.user.app_metadata or {},
+            "created_at": user_response.user.created_at,
+            "updated_at": user_response.user.updated_at
+        }
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=f"Token verification failed: {str(e)}"
+        )
+
+def create_backend_jwt_token(user_data: dict, expires_delta: Optional[timedelta] = None) -> str:
+    """
+    Create a backend JWT token for the user
+    """
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(days=7)  # Token expires in 7 days
+    
+    to_encode = {
+        "sub": user_data["id"],
+        "email": user_data["email"],
+        "exp": expire,
+        "iat": datetime.utcnow()
+    }
+    
+    # Use a secret key for JWT signing (you should set this in your .env file)
+    secret_key = os.getenv("JWT_SECRET_KEY", "your-secret-key-change-this")
+    encoded_jwt = jwt.encode(to_encode, secret_key, algorithm="HS256")
+    return encoded_jwt 

main.py

@@ -6,15 +6,19 @@ from contextlib import asynccontextmanager
 from dotenv import load_dotenv
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
-from auth import get_current_active_user, User, supabase
+from auth import get_current_active_user, User, supabase, get_supabase_token, verify_supabase_token, create_backend_jwt_token
 import logging
 import random
 from io import BytesIO
 from urllib.parse import unquote
 from fastapi.responses import StreamingResponse
+import stripe
+from typing import Optional
 
 load_dotenv()
 
+dev_mode = False
+
 class Settings:
     def __init__(self):
         self.mesh_api_key = "msy_slVFWXjDQvc2BR8ltSacK79YshK9KCXkaV3F"
@@ -23,6 +27,12 @@ class Settings:
         self.openai_api_key = os.getenv("OPENAI_API_KEY")
         if not self.openai_api_key:
             raise RuntimeError("OPENAI_API_KEY environment variable not set")
+        self.stripe_secret_key = os.getenv("STRIPE_SECRET_KEY")
+        if not self.stripe_secret_key:
+            raise RuntimeError("STRIPE_SECRET_KEY environment variable not set")
+        
+        # Initialize Stripe
+        stripe.api_key = self.stripe_secret_key
 
 settings = Settings()
 
@@ -63,6 +73,12 @@ class SignInRequest(BaseModel):
     email: str
     password: str
 
+class SyncUserRequest(BaseModel):
+    supabase_user_id: str
+    email: str
+    full_name: Optional[str] = None
+    avatar_url: Optional[str] = None
+
 class CompleteProfileRequest(BaseModel):
     address: str
     fullname: str
@@ -85,6 +101,13 @@ class PlaceOrderRequest(BaseModel):
     payment_status: str = "pending"
     transaction_id: str = None
 
+class CreatePaymentIntentRequest(BaseModel):
+    plan: str
+
+class ConfirmPaymentRequest(BaseModel):
+    payment_intent_id: str
+    plan: str
+
 # Auth endpoints
 @app.post("/auth/signup", tags=["Authentication"])
 async def signup(request: SignUpRequest):
@@ -111,7 +134,7 @@ async def signup(request: SignUpRequest):
                 # Initialize credits
                 supabase.from_("User_Credit_Account").insert({
                     "user_id": response.user.id,
-                    "num_of_available_gens": 3
+                    "num_of_available_gens": 0
                 }).execute()
 
                 print(f"User created successfully: {response.user}")
@@ -144,6 +167,69 @@ async def signin(request: SignInRequest):
         logging.error(f"SignIn error: {str(e)}")
         raise HTTPException(status_code=401, detail=f"Invalid credentials: {str(e)}")
 
+@app.post("/auth/sync-supabase-user", tags=["Authentication"])
+async def sync_supabase_user(request: SyncUserRequest, supabase_token: str = Depends(get_supabase_token)):
+    """
+    Sync a Supabase OAuth user (e.g., Google OAuth) with the backend database and return a backend JWT token.
+    """
+    try:
+        # Verify the Supabase token
+        supabase_user = verify_supabase_token(supabase_token)
+        
+        # Check if user already exists in our database
+        existing_user = supabase.from_("User").select("*").eq("user_id", supabase_user["id"]).execute()
+        
+        user_data = {
+            "user_id": supabase_user["id"],
+            "email": supabase_user["email"],
+            "address": None,
+            "fullname": request.full_name,
+            "phone_number": None
+        }
+        
+        if existing_user.data:
+            # Update existing user with any new information
+            if request.full_name:
+                supabase.from_("User").update({
+                    "fullname": request.full_name
+                }).eq("user_id", supabase_user["id"]).execute()
+        else:
+            # Create new user profile
+            supabase.from_("User").insert(user_data).execute()
+            
+            # Initialize credits for new user
+            supabase.from_("User_Credit_Account").insert({
+                "user_id": supabase_user["id"],
+                "num_of_available_gens": 3  # Give new users 3 free credits
+            }).execute()
+        
+        # Generate backend JWT token
+        backend_token = create_backend_jwt_token({
+            "id": supabase_user["id"],
+            "email": supabase_user["email"]
+        })
+        
+        # Get updated user profile
+        user_profile = supabase.from_("User").select("*").eq("user_id", supabase_user["id"]).single().execute()
+        
+        return {
+            "access_token": backend_token,
+            "token_type": "bearer",
+            "user": {
+                "id": supabase_user["id"],
+                "email": supabase_user["email"],
+                "profile": user_profile.data if user_profile.data else user_data
+            },
+            "message": "User synced successfully"
+        }
+        
+    except HTTPException:
+        # Re-raise HTTP exceptions as-is
+        raise
+    except Exception as e:
+        logging.error(f"Sync user error: {str(e)}")
+        raise HTTPException(status_code=400, detail=f"Failed to sync user: {str(e)}")
+
 # TODO: The signup also creates a profile, so this endpoint should either be removed or /signup updated.
 @app.post("/auth/complete-profile", tags=["Authentication"])
 async def complete_profile(request: CompleteProfileRequest, current_user: User = Depends(get_current_active_user)):
@@ -204,6 +290,28 @@ async def req_img_to_3d(
                 base64.b64encode(content).decode())
     payload = {"image_url": data_uri}
     headers = {"Authorization": f"Bearer {settings.mesh_api_key}"}
+
+    if dev_mode:
+        try:
+            supabase.from_("Generated_Models").insert({
+                "user_id": current_user.id,
+                "meshy_api_job_id": "0197458e-d2f6-7ff0-a211-b660ad057140",
+                "model_name": f"Image to 3D - {image.filename}",
+                "prompts_and_models_config": {
+                    "generation_type": "image_to_3d",
+                    "source_filename": image.filename,
+                    "content_type": image.content_type,
+                    "status": "processing",
+                    "meshy_response": "dev_mode"
+                }
+            }).execute()
+        except Exception as e:
+            logging.error(f"Failed to save model to database: {str(e)}")
+            # Don't fail the request if database save fails
+            return
+        
+        return {"id": "0197458e-d2f6-7ff0-a211-b660ad057140", "status": "processing", "meshy_response": "dev_mode"}
+
     resp = await app.state.client.post(
         "https://api.meshy.ai/openapi/v1/image-to-3d",
         json=payload,
@@ -308,6 +416,8 @@ async def req_text_to_3d(
     """
     # Credit check and decrement
     await check_and_decrement_credits(current_user.id)
+
+    
     
     # Save initial record to database immediately after credit check
     initial_record_id = None
@@ -378,6 +488,26 @@ async def req_text_to_3d(
     # Create Meshy Text-to-3D task
     meshy_payload = {"mode": "preview", "prompt": reframed}
     print(f"Sending to Meshy API: {meshy_payload}")
+
+    if dev_mode:
+        try:
+            supabase.from_("Generated_Models").update({
+                "meshy_api_job_id": "0197458e-d2f6-7ff0-a211-b660ad057140",
+                "prompts_and_models_config": {
+                    "generation_type": "text_to_3d",
+                    "original_prompt": prompt.text,
+                    "reframed_prompt": reframed,
+                    "status": "processing",
+                    "stage": "generating",
+                    "meshy_response": "dev_mode"
+                }
+            }).eq("generated_model_id", initial_record_id).execute()
+        except Exception as e:
+            print(f"Failed to update database with final response: {str(e)}")
+            # Don't fail the request if database save fails
+        
+        return {"id": initial_record_id, "meshy_task_id": "0197458e-d2f6-7ff0-a211-b660ad057140", "status": "processing", "original_prompt": prompt.text, "reframed_prompt": reframed, "meshy_response": "dev_mode"}
+
     
     meshy_resp = await app.state.client.post(
         "https://api.meshy.ai/openapi/v2/text-to-3d",
@@ -536,6 +666,110 @@ async def purchase_credits(request: PurchaseCreditsRequest, current_user: User =
         supabase.from_("User_Credit_Account").insert({"user_id": current_user.id, "num_of_available_gens": new_credits}).execute()
     return {"message": "Credits purchased successfully.", "total_credits": new_credits}
 
+# Stripe Payment endpoints
+@app.post("/payment/create-payment-intent", tags=["Payment"])
+async def create_payment_intent(
+    request: CreatePaymentIntentRequest, 
+    current_user: User = Depends(get_current_active_user)
+):
+    """
+    Create a Stripe payment intent for purchasing credits.
+    """
+    try:
+        # Define plan pricing (only one plan for now)
+        plan_pricing = {
+            "credits_15": {"credits": 15, "amount": 300, "currency": "gbp"}  # £3.00 in pence
+        }
+        
+        if request.plan not in plan_pricing:
+            raise HTTPException(status_code=400, detail="Invalid plan selected")
+        
+        plan = plan_pricing[request.plan]
+        
+        # Create payment intent
+        intent = stripe.PaymentIntent.create(
+            amount=plan["amount"],
+            currency=plan["currency"],
+            metadata={
+                "user_id": current_user.id,
+                "plan": request.plan,
+                "credits": plan["credits"]
+            }
+        )
+        
+        return {
+            "client_secret": intent.client_secret,
+            "amount": plan["amount"],
+            "currency": plan["currency"],
+            "credits": plan["credits"]
+        }
+    
+    except stripe.error.StripeError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logging.error(f"Failed to create payment intent: {str(e)}")
+        raise HTTPException(status_code=500, detail="Failed to create payment intent")
+
+@app.post("/payment/confirm-payment", tags=["Payment"])
+async def confirm_payment(
+    request: ConfirmPaymentRequest,
+    current_user: User = Depends(get_current_active_user)
+):
+    """
+    Confirm payment and add credits to user account.
+    """
+    try:
+        # Retrieve the payment intent to verify it succeeded
+        intent = stripe.PaymentIntent.retrieve(request.payment_intent_id)
+        
+        if intent.status != "succeeded":
+            raise HTTPException(status_code=400, detail="Payment has not succeeded")
+        
+        # Verify the payment belongs to the current user
+        if intent.metadata.get("user_id") != current_user.id:
+            raise HTTPException(status_code=403, detail="Payment does not belong to current user")
+        
+        # Check if this payment has already been processed
+        existing_record = supabase.from_("Credit_Order_History").select("*").eq("transaction_id", request.payment_intent_id).execute()
+        if existing_record.data:
+            return {"message": "Payment already processed", "total_credits": None}
+        
+        # Get plan details from metadata
+        credits_to_add = int(intent.metadata.get("credits", 0))
+        amount_paid = intent.amount / 100  # Convert from pence to pounds
+        
+        # Record the purchase in history
+        supabase.from_("Credit_Order_History").insert({
+            "user_id": current_user.id,
+            "price": amount_paid,
+            "number_of_generations": credits_to_add,
+            "order_date": "now()",
+            "payment_status": "paid",
+            "transaction_id": request.payment_intent_id
+        }).execute()
+        
+        # Update user credits
+        credit = supabase.from_("User_Credit_Account").select("num_of_available_gens").eq("user_id", current_user.id).single().execute()
+        current_credits = credit.data["num_of_available_gens"] if credit.data else 0
+        new_credits = current_credits + credits_to_add
+        
+        if credit.data:
+            supabase.from_("User_Credit_Account").update({"num_of_available_gens": new_credits}).eq("user_id", current_user.id).execute()
+        else:
+            supabase.from_("User_Credit_Account").insert({"user_id": current_user.id, "num_of_available_gens": new_credits}).execute()
+        
+        return {
+            "message": "Credits added successfully",
+            "credits_added": credits_to_add,
+            "total_credits": new_credits
+        }
+    
+    except stripe.error.StripeError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logging.error(f"Failed to confirm payment: {str(e)}")
+        raise HTTPException(status_code=500, detail="Failed to confirm payment")
+
 # User dashboard endpoints
 @app.get("/user/profile", tags=["User"])
 async def get_profile(current_user: User = Depends(get_current_active_user)):
@@ -567,6 +801,25 @@ async def get_model_by_task_id(task_id: str, current_user: User = Depends(get_cu
         raise HTTPException(status_code=404, detail="Model not found")
     return model.data
 
+@app.delete("/user/models/{generated_model_id}", tags=["User"])
+async def delete_model(
+    generated_model_id: str,
+    current_user: User = Depends(get_current_active_user)
+):
+    """
+    Delete a generated model for the current user.
+    """
+    try:
+        delete_result = supabase.from_("Generated_Models").delete().eq("generated_model_id", generated_model_id).eq("user_id", current_user.id).execute()
+
+        if not delete_result.data:
+            raise HTTPException(status_code=404, detail="Model not found or you do not have permission to delete it.")
+
+        return {"message": "Model deleted successfully."}
+    except Exception as e:
+        logging.error(f"Failed to delete model {generated_model_id}: {str(e)}")
+        raise HTTPException(status_code=500, detail="Failed to delete model.")
+
 @app.post("/user/models/{task_id}/refresh", tags=["User"])
 async def refresh_model_status(
     task_id: str, 

requirements.txt

@@ -7,4 +7,67 @@ python-dotenv>=0.21.0
 openai
 supabase>=2.0.0
 python-jose[cryptography]>=3.3.0
-passlib[bcrypt]>=1.7.4
+passlib[bcrypt]>=1.7.4
+stripe>=5.0.0annotated-types==0.7.0
+anyio==4.9.0
+fastapi==0.115.12
+idna==3.10
+pydantic==2.11.5
+pydantic_core==2.33.2
+sniffio==1.3.1
+starlette==0.46.2
+typing-inspection==0.4.1
+typing_extensions==4.14.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.11
+aiosignal==1.3.2
+annotated-types==0.7.0
+anyio==4.9.0
+attrs==25.3.0
+certifi==2025.4.26
+charset-normalizer==3.4.2
+click==8.2.1
+colorama==0.4.6
+deprecation==2.1.0
+dotenv==0.9.9
+fastapi==0.115.12
+frozenlist==1.6.2
+gotrue==2.12.0
+h11==0.16.0
+h2==4.2.0
+hpack==4.1.0
+httpcore==1.0.9
+httpx==0.28.1
+hyperframe==6.1.0
+idna==3.10
+iniconfig==2.1.0
+multidict==6.4.4
+packaging==25.0
+pluggy==1.6.0
+postgrest==1.0.2
+propcache==0.3.1
+pydantic==2.11.5
+pydantic_core==2.33.2
+Pygments==2.19.1
+PyJWT==2.10.1
+pytest==8.4.0
+pytest-mock==3.14.1
+python-dateutil==2.9.0.post0
+python-dotenv==1.1.0
+python-multipart==0.0.20
+realtime==2.4.3
+requests==2.32.3
+six==1.17.0
+sniffio==1.3.1
+starlette==0.46.2
+storage3==0.11.3
+StrEnum==0.4.15
+stripe==12.2.0
+supabase==2.15.2
+supafunc==0.9.4
+typing-inspection==0.4.1
+typing_extensions==4.14.0
+urllib3==2.4.0
+uvicorn==0.34.3
+websockets==14.2
+yarl==1.20.0