#!/usr/bin/env python3
"""
Hugging Face Spaces Application - Fixed Version
"""
import os
import sys
import subprocess
import json
import time
# Install requirements first
def install_requirements():
try:
print("Installing requirements...")
subprocess.check_call([sys.executable, "-m", "pip", "install", "-r", "requirements.txt"])
print("Requirements installed successfully!")
except Exception as e:
print(f"Failed to install requirements: {e}")
# Try installing individually
try:
subprocess.check_call([sys.executable, "-m", "pip", "install", "flask"])
subprocess.check_call([sys.executable, "-m", "pip", "install", "flask-cors"])
subprocess.check_call([sys.executable, "-m", "pip", "install", "requests"])
except:
pass
# Install requirements
install_requirements()
# Now import the modules
try:
from flask import Flask, request, jsonify, Response, send_from_directory
from flask_cors import CORS
print("Flask modules imported successfully!")
except ImportError as e:
print(f"Failed to import Flask: {e}")
sys.exit(1)
# Create Flask app
app = Flask(__name__)
CORS(app)
# Configuration
CONFIG_FILE = "business_gemini_session.json"
# Load configuration
def load_config():
if os.path.exists(CONFIG_FILE):
with open(CONFIG_FILE, 'r', encoding='utf-8') as f:
return json.load(f)
return {
"proxy": "",
"proxy_enabled": False,
"accounts": [],
"models": []
}
# Save configuration
def save_config(config):
try:
with open(CONFIG_FILE, 'w', encoding='utf-8') as f:
json.dump(config, f, indent=2, ensure_ascii=False)
return True
except Exception as e:
print(f"Error saving config: {e}")
return False
# Routes
@app.route('/')
def index():
"""Main page - serve HTML if exists, otherwise show simple interface"""
if os.path.exists('index.html'):
return send_from_directory('.', 'index.html')
# Simple HTML interface if index.html doesn't exist
return """
Business Gemini Pool
🚀 Business Gemini Pool
"""
@app.route('/health')
def health():
"""Health check endpoint"""
return jsonify({
"status": "ok",
"timestamp": time.time(),
"message": "Business Gemini Pool is running"
})
@app.route('/v1/models')
def models():
"""List available models (OpenAI compatible)"""
config = load_config()
# Default model
default_models = [
{
"id": "gemini-enterprise",
"object": "model",
"created": int(time.time()),
"owned_by": "google"
},
{
"id": "gemini-3-pro-preview",
"object": "model",
"created": int(time.time()),
"owned_by": "google"
}
]
# Add custom models if configured
custom_models = config.get('models', [])
if custom_models:
for model in custom_models:
default_models.append({
"id": model.get('id', model.get('name', 'custom-model')),
"object": "model",
"created": int(time.time()),
"owned_by": "custom"
})
return jsonify({
"object": "list",
"data": default_models
})
@app.route('/v1/chat/completions', methods=['POST'])
def chat_completions():
"""Chat completions endpoint (OpenAI compatible)"""
try:
data = request.get_json()
if not data or 'messages' not in data:
return jsonify({"error": "Missing messages field"}), 400
# Check if accounts are configured
config = load_config()
accounts = config.get('accounts', [])
if not accounts:
return jsonify({
"error": {
"message": "No Gemini accounts configured. Please add an account through the web interface.",
"type": "invalid_request_error"
}
}), 400
# For now, return a placeholder response
# In production, this would call the actual Gemini API
return jsonify({
"id": "chatcmpl-" + str(int(time.time())),
"object": "chat.completion",
"created": int(time.time()),
"model": data.get("model", "gemini-enterprise"),
"choices": [{
"index": 0,
"message": {
"role": "assistant",
"content": "This is a placeholder response. The full Gemini integration requires your account credentials. Please configure your Gemini account through the web interface to get actual responses."
},
"finish_reason": "stop"
}],
"usage": {
"prompt_tokens": len(str(data.get('messages', []))),
"completion_tokens": 50,
"total_tokens": len(str(data.get('messages', []))) + 50
}
})
except Exception as e:
return jsonify({"error": str(e)}), 500
@app.route('/api/accounts', methods=['GET'])
def get_accounts():
"""Get all configured accounts"""
config = load_config()
accounts = config.get('accounts', [])
# Remove sensitive info for API response
safe_accounts = []
for acc in accounts:
safe_accounts.append({
"id": acc.get('id'),
"team_id": acc.get('team_id'),
"available": acc.get('available', True)
})
return jsonify(safe_accounts)
@app.route('/api/accounts', methods=['POST'])
def add_account():
"""Add a new account"""
try:
data = request.get_json()
if not data:
return jsonify({"error": "No data provided"}), 400
# Validate required fields
required_fields = ['team_id', 'secure_c_ses', 'host_c_oses', 'csesidx', 'user_agent']
for field in required_fields:
if not data.get(field):
return jsonify({"error": f"Missing required field: {field}"}), 400
config = load_config()
if 'accounts' not in config:
config['accounts'] = []
# Generate unique ID
account_id = str(int(time.time()))
data['id'] = account_id
data['available'] = True
config['accounts'].append(data)
if save_config(config):
return jsonify({"success": True, "id": account_id})
else:
return jsonify({"error": "Failed to save configuration"}), 500
except Exception as e:
return jsonify({"error": str(e)}), 500
@app.route('/v1/status')
def status():
"""Get system status"""
config = load_config()
return jsonify({
"status": "running",
"accounts_count": len(config.get('accounts', [])),
"proxy_enabled": config.get('proxy_enabled', False),
"proxy_url": config.get('proxy', ''),
"models": config.get('models', []),
"space_info": {
"environment": "huggingface",
"python_version": sys.version,
"platform": sys.platform
}
})
# Create initial config if doesn't exist
if not os.path.exists(CONFIG_FILE):
initial_config = {
"proxy": "",
"proxy_enabled": False,
"accounts": [],
"models": []
}
save_config(initial_config)
print(f"Created initial config file: {CONFIG_FILE}")
if __name__ == "__main__":
print("\n" + "="*60)
print("Business Gemini Pool for Hugging Face Spaces")
print("="*60)
print(f"Python version: {sys.version}")
print(f"Working directory: {os.getcwd()}")
print(f"Config file: {CONFIG_FILE}")
# Check if config exists
if os.path.exists(CONFIG_FILE):
config = load_config()
print(f"Accounts configured: {len(config.get('accounts', []))}")
else:
print("No config file found, will create on first run")
print("="*60)
print("Starting server...")
# Hugging Face Spaces uses port 7860
port = int(os.environ.get("PORT", 7860))
app.run(host="0.0.0.0", port=port, debug=False)