first

.dockerignore

@@ -0,0 +1,9 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env
+venv
+.env
+.git

.gitignore

@@ -0,0 +1 @@
+*.txt

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+COPY ./requirements.txt /app/requirements.txt
+COPY ./app.py /app/app.py
+
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,12 +1,9 @@
 ---
-title: Flash2
-emoji: 👀
-colorFrom: yellow
-colorTo: blue
+title: Flash API Forwarder
+emoji: 🚀
+colorFrom: blue
+colorTo: red
 sdk: docker
-pinned: false
-license: apache-2.0
-short_description: test rest api
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+FastAPI service for forwarding AI API requests

app.py

@@ -0,0 +1,471 @@
+from fastapi import FastAPI, HTTPException, UploadFile, File, Form
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse
+from pydantic import BaseModel
+from fastapi import FastAPI, HTTPException, Request
+from asyncio import TimeoutError
+import asyncio
+from typing import Optional
+import requests
+import uvicorn
+import shutil
+import datetime  # Add this import
+import logging
+from logging.handlers import RotatingFileHandler
+import time
+from typing import List, Dict, Optional
+import json
+import os
+import psutil
+import sys
+from typing import Dict
+import tempfile
+import re
+import random
+import aiohttp 
+app = FastAPI()
+
+# Add USER_AGENTS constant
+USER_AGENTS = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36"
+]
+# Configure logging
+# Configure detailed logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+# Request counter
+request_counter = {
+    "analyze": 0,
+    "compareAnalyze": 0,
+    "total": 0
+}
+
+# Add CORS middleware
+# Add CORS middleware with both HTTP and HTTPS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://*",
+        "https://*"
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class AskRequest(BaseModel):
+    prompt: str
+    model: str = "GEMINI"
+
+
+@app.get("/")
+async def health_check():
+    return {
+        "health": "ok",
+        "timestamp": datetime.datetime.now().isoformat(),
+        "service": "AI API Forwarding Service",
+        "version": "1.0"
+    }
+        
+
+@app.post("/ask")
+async def forward_ask(request: AskRequest):
+    request_counter["total"] += 1
+    try:
+        response = requests.post(
+            "http://s5.serv00.com:9081/ask",
+            headers={'Content-Type': 'application/json'},
+            json=request.dict()
+        )
+        return response.json()
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/analyze")
+async def forward_analyze(image: UploadFile = File(...), model: str = Form(...)):
+    request_counter["analyze"] += 1
+    request_counter["total"] += 1
+    try:
+        files = {'image': (image.filename, image.file, image.content_type)}
+        data = {'model': model}
+        response = requests.post(
+            "http://s5.serv00.com:9081/analyze",
+            files=files,
+            data=data
+        )
+        return response.json()
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/compareAnalyze")
+async def forward_compare_analyze(image: UploadFile = File(...)):
+    request_counter["compareAnalyze"] += 1
+    request_counter["total"] += 1
+    try:
+        files = {'image': (image.filename, image.file, image.content_type)}
+        response = requests.post(
+            "http://s5.serv00.com:9081/compareAnalyze",
+            files=files
+        )
+        return response.json()
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/status")
+async def forward_status():
+    start_time = time.time()
+    logger.info(f"Received status request at {datetime.datetime.now()}")
+    logger.info(f"Current request counter: {request_counter}")
+    
+    try:
+        logger.info("Attempting to contact upstream server...")
+        response = requests.get("http://s5.serv00.com:9081/status")
+        elapsed_time = time.time() - start_time
+        
+        logger.info(f"Upstream server responded in {elapsed_time:.2f} seconds")
+        logger.info(f"Response status code: {response.status_code}")
+        logger.info(f"Response content: {response.text[:200]}...")
+        
+        return response.json()
+    except Exception as e:
+        logger.error(f"Error occurred: {str(e)}")
+        logger.error(f"Error type: {type(e).__name__}")
+        return {
+            "status": "running",
+            "requests": request_counter,
+            "error": str(e),
+            "timestamp": datetime.datetime.now().isoformat()
+        }
+
+@app.get("/check", response_class=HTMLResponse)
+async def forward_check():
+    try:
+        response = requests.get("http://s5.serv00.com:9081/check")
+        return response.text
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+
+# Add new models
+class Translation(BaseModel):
+    translation: str
+    type: str
+
+class Phrase(BaseModel):
+    phrase: str
+    translation: str
+
+class Word(BaseModel):
+    word: str
+    translations: List[dict]  # Changed to accept dictionary format
+    phrases: List[Phrase] = []  # Made optional with default empty list
+    level: str = ""  # Add level field with default empty string
+
+# Add global word map
+word_map: Dict[str, Word] = {}
+
+def get_level_from_filename(filename: str) -> str:
+    # Extract level from filenames like "1-初中-顺序.json"
+    match = re.match(r'\d+-(.+?)-顺序\.json', filename)
+    return match.group(1) if match else "unknown"
+# Add initialization function
+def init_word_map():
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    json_dir = os.path.join(current_dir, "json")
+    stats = {
+        "total_words": 0,
+        "total_files": 0,
+        "file_stats": {}
+    }
+    
+    try:
+        for filename in os.listdir(json_dir):
+            if filename.endswith('.json'):
+                try:
+                    level = get_level_from_filename(filename)
+                    with open(os.path.join(json_dir, filename), 'r', encoding='utf-8') as f:
+                        words = json.load(f)
+                        word_count = len(words)
+                        stats["total_words"] += word_count
+                        stats["total_files"] += 1
+                        stats["file_stats"][filename] = word_count
+                        for word_data in words:
+                            # Convert legacy format to new format
+                            if 'translations' not in word_data:
+                                word_data['translations'] = [{
+                                    'translation': word_data.get('translation', ''),
+                                    'type': word_data.get('type', '')
+                                }]
+                            if 'phrases' not in word_data:
+                                word_data['phrases'] = []
+                                
+                            word_data['level'] = level
+                            word = Word(**word_data)
+                            word_map[word.word.lower()] = word
+                    logger.info(f"Loaded {filename}: {word_count} words")
+                except Exception as e:
+                    logger.error(f"Error loading {filename}: {str(e)}")
+                    continue
+        
+        logger.info(f"Dictionary initialization complete:")
+        logger.info(f"Total files processed: {stats['total_files']}")
+        logger.info(f"Total words loaded: {stats['total_words']}")
+        return stats
+    except Exception as e:
+        logger.error(f"Fatal error in init_word_map: {str(e)}")
+        return stats
+
+
+# Add cache configuration
+# Update cache file location
+CACHE_DIR = os.path.join(tempfile.gettempdir(), "flash_api_cache")
+CACHE_FILE = os.path.join(CACHE_DIR, "ai_translation_cache.json")
+ai_cache: Dict[str, dict] = {}
+
+# Load cache on startup
+def save_cache():
+    try:
+        # Create cache directory if it doesn't exist
+        os.makedirs(CACHE_DIR, exist_ok=True)
+        
+        with open(CACHE_FILE, 'w', encoding='utf-8') as f:
+            json.dump(ai_cache, f, ensure_ascii=False, indent=2)
+            logger.info(f"Cache saved to: {CACHE_FILE}")
+    except PermissionError as pe:
+        logger.error(f"Permission denied writing to cache: {pe}")
+    except Exception as e:
+        logger.error(f"Error saving cache: {e}")
+
+def load_cache():
+    global ai_cache
+    try:
+        if os.path.exists(CACHE_FILE):
+            with open(CACHE_FILE, 'r', encoding='utf-8') as f:
+                ai_cache = json.load(f)
+                logger.info(f"Loaded {len(ai_cache)} cached translations from: {CACHE_FILE}")
+    except Exception as e:
+        logger.error(f"Error loading cache: {e}")
+        ai_cache = {}
+
+# Add translate endpoint
+@app.get("/translate/{word}")
+async def translate_word(word: str):
+    start_time = time.time()
+    logger.info(f"Translation request received for word: {word}")
+    
+    try:
+        word = word.lower().strip()
+        logger.debug(f"Processed word: {word}")
+        
+        # Check word map
+        # if word in word_map:
+        #     logger.info(f"Word found in map: {word}")
+        #     word_data = word_map[word]
+        #     logger.debug(f"Word data: {word_data}")
+            
+        #     # Format all translations
+        #     translations_text = []
+        #     for trans in word_data.translations:
+        #         translation = trans['translation']
+        #         type_info = trans['type']
+        #         translations_text.append(f"({type_info}) {translation}")
+            
+        #     # Join translations with separators
+        #     translations_combined = " | ".join(translations_text)
+        #     logger.debug(f"Combined translations: {translations_combined}")
+            
+        #     # Handle examples
+        #     examples = []
+        #     if word_data.phrases:
+        #         examples = [f"{p.phrase}: {p.translation}" for p in word_data.phrases[:3]]
+        #         logger.debug(f"Examples found: {examples}")
+            
+        #     # Build response with proper formatting
+        #     formatted_response = f"{word} [{word_data.level}]: {translations_combined}"
+        #     if examples:
+        #         formatted_response += f"\n\n例句：\n{chr(10).join(examples)}"
+            
+        #     elapsed = time.time() - start_time
+        #     logger.info(f"Word map translation completed in {elapsed:.2f}s")
+            
+        #     return {
+        #         "status": 200,
+        #         "data": {
+        #             "response": formatted_response,
+        #             "word": word,
+        #             "level": word_data.level,  # Add level info here
+        #             "translations": word_data.translations,
+        #             "examples": examples
+        #         }
+        #     }
+        
+        # Check AI cache
+        # if word in ai_cache:
+        #     logger.info(f"Word found in AI cache: {word}")
+        #     elapsed = time.time() - start_time
+        #     logger.info(f"Cache hit completed in {elapsed:.2f}s")
+        #     return ai_cache[word]
+        
+        # Fallback to AI translation
+        logger.info("Word not found in cache, calling AI API")
+        # Fallback to AI translation
+        logger.info("Word not found in map, falling back to AI translation")
+        try:
+            request = AskRequest(
+                prompt=f'''翻译以下英文
+            {word}
+            每行一个 格式参考,不要任何md格式,分别要有音标，单词属性(名词，动词，形容词),中文翻译，英文解析，例句，近义词，反义词，词性
+            格式参考:
+            hello:/həˈləʊ/| n. vt. int.|你好，问候语，|例句：Hello, how are you? 你好，你好吗？|近义词：hi, hey, |反义词:sick, bad.''',
+                model="GEMINI"
+            )
+            logger.debug(f"AI Request: {request}")
+            
+            result = await forward_ask(request)
+            
+             # Cache the result
+            #ai_cache[word] = result
+           #save_cache()
+            logger.debug(f"AI Response: {result}")
+            
+            elapsed = time.time() - start_time
+            logger.info(f"AI translation completed in {elapsed:.2f}s")
+            return result
+            
+        except Exception as e:
+            logger.error(f"AI translation error: {str(e)}", exc_info=True)
+            raise HTTPException(status_code=500, detail=str(e))
+            
+    except Exception as e:
+        logger.error(f"Translation error: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Add cleanup functions
+def cleanup_temp_files():
+    try:
+        # Clean temp directory
+        temp_dir = os.path.join(tempfile.gettempdir(), "flash_api_cache")
+        if os.path.exists(temp_dir):
+            shutil.rmtree(temp_dir)
+            logger.info(f"Cleaned up temp directory: {temp_dir}")
+    except Exception as e:
+        logger.error(f"Error cleaning temp files: {e}")
+
+def cleanup_cache():
+    global ai_cache
+    ai_cache = {}
+    logger.info("Cache cleared")
+
+
+# Initialize word map on startup
+@app.on_event("startup")
+async def startup_event():
+    #init_word_map()// waste of memory
+    #load_cache()
+    cleanup_temp_files()
+    cleanup_cache()
+    logger.info(f"Memory usage after init: {get_memory_usage()}")
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    # Cleanup on shutdown
+    cleanup_temp_files()
+    cleanup_cache()
+    logger.info("Application shutdown cleanup complete")
+def get_memory_usage():
+    process = psutil.Process()
+    memory_info = process.memory_info()
+    
+    # Get system memory info
+    system = psutil.virtual_memory()
+    
+    return {
+        "process": {
+            "rss": f"{memory_info.rss / 1024 / 1024:.2f} MB",
+            "rss_percent": f"{memory_info.rss / system.total * 100:.2f}%",
+            "vms": f"{memory_info.vms / 1024 / 1024:.2f} MB",
+            "vms_percent": f"{memory_info.vms / system.total * 100:.2f}%"
+        },
+        "system": {
+            "total": f"{system.total / 1024 / 1024:.2f} MB",
+            "available": f"{system.available / 1024 / 1024:.2f} MB",
+            "used_percent": f"{system.percent:.2f}%"
+        },
+        "word_map": {
+            "entries": len(word_map),
+            "memory": f"{sys.getsizeof(word_map) / 1024 / 1024:.2f} MB",
+            "memory_percent": f"{sys.getsizeof(word_map) / system.total * 100:.4f}%"
+        }
+    }
+
+@app.get("/memory")
+async def memory_status():
+    return get_memory_usage()
+
+# Add new endpoint
+@app.get("/proxy")
+async def proxy_request(url: str, request: Request):
+    try:
+        # Get random user agent
+        user_agent = random.choice(USER_AGENTS)
+        
+        #print url
+        
+        logger.info(f"Proxy request received for: {url}")
+        
+        # Prepare headers
+        headers = {
+            'User-Agent': user_agent,
+            'Accept': 'application/json, text/plain, */*',
+            'Accept-Language': 'en-US,en;q=0.9',
+            'Origin': 'https://www.youtube.com',
+            'Referer': 'https://www.youtube.com/',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-site',
+            'Connection': 'keep-alive'
+        }
+
+        # Set timeout
+        timeout = aiohttp.ClientTimeout(total=10)  # 10 seconds timeout
+        
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            async with session.get(url, headers=headers) as response:
+                # Check HTTP status
+                if response.status != 200:
+                    raise HTTPException(
+                        status_code=response.status,
+                        detail=f"HTTP error: {response.status}"
+                    )
+                
+                # Parse JSON response
+                data = await response.json()
+                
+                #print data's length
+                
+                logger.info(f"Received youtube subtile data: {len(data)} bytes")
+                
+                
+                # Validate data format
+                if not data or 'events' not in data:
+                    raise HTTPException(
+                        status_code=400,
+                        detail="Invalid subtitle data format"
+                    )
+                
+                return data
+
+    except TimeoutError:
+        raise HTTPException(status_code=408, detail="Request timeout")
+    except Exception as e:
+        logger.error(f"Proxy error: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

restapi.js

@@ -0,0 +1,438 @@
+import express from 'express';
+import multer from 'multer';
+import { GoogleGenerativeAI } from "@google/generative-ai";
+import { HarmCategory, HarmBlockThreshold } from '@google/generative-ai';
+import { Mistral } from "@mistralai/mistralai";
+import dotenv from "dotenv";
+import sharp from 'sharp';
+import rateLimit from 'express-rate-limit';
+dotenv.config();
+
+// Configure rate limiter
+const limiter = rateLimit({
+    windowMs: 60 * 1000, // 1 minute
+    max: 10, // 1 request per window
+    message: {
+        status: 429,
+        error: "Too many requests, please try again after 1 minute"
+    },
+    standardHeaders: true,
+    legacyHeaders: false
+});
+
+const app = express();
+const upload = multer({ storage: multer.memoryStorage() });
+const port = 9081;
+
+// Add after imports
+let requestCounter = {
+    analyze: 0,
+    compareAnalyze: 0,
+    total: 0
+};
+// Model type enum
+const ModelType = {
+    GEMINI: 'GEMINI',
+    MIXTRAL: 'MIXTRAL',
+    GEMINI_THINKING: 'GEMINI_THINKING'
+};
+
+class ImageAnalysisClient {
+    constructor() {
+        this.init();
+    }
+
+    init() {
+        // Initialize Gemini
+         // Initialize Gemini models
+         const geminiApiKey = process.env.API_KEY6;
+         const geminiThinkingApiKey = process.env.API_KEY5;
+         if (!geminiApiKey) throw new Error("Gemini API_KEY not found");
+         if (!geminiThinkingApiKey) throw new Error("Gemini Thinking API_KEY not found");
+         
+         this.genAI = new GoogleGenerativeAI(geminiApiKey);
+         this.genAIThinking = new GoogleGenerativeAI(geminiThinkingApiKey);
+ 
+         // Initialize Mixtral
+         const mixtralApiKey = process.env.API_KEY_MIXTRAL12;
+         if (!mixtralApiKey) throw new Error("Mixtral API_KEY not found");
+         this.mistral = new Mistral({ apiKey: mixtralApiKey });
+    }
+
+    async analyzeImage(imageBuffer, modelType) {
+        const processedImageBuffer = await sharp(imageBuffer)
+            .grayscale()
+            .jpeg({ quality: 100, progressive: true })
+            .toBuffer();
+        const base64Image = processedImageBuffer.toString('base64');
+
+        const prompt = `Analyze the image for production date and expiration date. Return in JSON format.
+
+    Rules:
+    - Only extract dates that are explicitly labeled or clearly marked
+    - If no clear production date or manufacturing date is found, set production_date to null
+    - If no clear expiration date or 保质期 or 质期 is found, set expiration_date to null
+    - Do not make assumptions or guess dates EXCEPT:
+      * If only one date is found with no label:
+        - If date is future (after ${new Date().toISOString().split('T')[0]}), set as expiration_date
+        - If date is past, set as production_date
+    - Date format must be YYYY.MM.DD when found
+    - Production date and expiration date cannot be the same day
+    
+    Example responses:
+    Case 1 - Labeled dates:
+    {
+        "production_date": "2024.08.20",    
+        "expiration_date": "2026.08.20",    
+        "production_id": null,
+        "additional_info": null
+    }
+
+    Case 2 - Single unlabeled future date:
+    {
+        "production_date": null,
+        "expiration_date": "2025.04.01",    // Future date assumed as expiration
+        "production_id": null,
+        "additional_info": "Single unlabeled date found"
+    }
+
+    Case 3 - Single unlabeled past date:
+    {
+        "production_date": "2023.04.01",    // Past date assumed as production
+        "expiration_date": null,
+        "production_id": null,
+        "additional_info": "Single unlabeled date found"
+    }
+    
+    Important: Return null for any field where the information is not explicitly visible in the image.`;
+
+        try {
+            if (modelType === ModelType.GEMINI) {
+                return await this.analyzeWithGemini(base64Image, prompt);
+            } else if (modelType === ModelType.GEMINI_THINKING) {
+                return await this.analyzeWithGeminiThinking(base64Image, prompt);
+            } else {
+                return await this.analyzeWithMixtral(base64Image, prompt);
+            }
+        } catch (error) {
+            console.error(`Error analyzing with ${modelType}:`, error);
+            throw error;
+        }
+    }
+
+    async analyzeWithGemini(base64Image, prompt) {
+        const model = this.genAI.getGenerativeModel({ model: "gemini-2.0-flash-exp" });
+        const result = await model.generateContent([
+            { text: prompt },
+            {
+                inlineData: {
+                    data: base64Image,
+                    mimeType: "image/jpeg"
+                }
+            }
+        ]);
+
+        const text = result.response.text();
+        const jsonMatch = text.match(/```json\s*([\s\S]*?)\s*```/);
+        if (jsonMatch) {
+            return JSON.parse(jsonMatch[1]);
+        }
+        throw new Error("No JSON content found in Gemini response");
+    }
+
+    async analyzeWithMixtral(base64Image, prompt) {
+        try {
+            const result = await this.mistral.chat.stream({
+                model: "pixtral-large-latest",
+                messages: [
+                    {
+                        role: "user",
+                        content: [
+                            { type: "text", text: prompt },
+                            {
+                                type: "image_url",
+                                imageUrl: `data:image/jpeg;base64,${base64Image}`,
+                            },
+                        ]
+                    }
+                ],
+                max_tokens: 1024,
+                temperature: 0.8,
+            });
+    
+            let response = "";
+            for await (const chunk of result) {
+                response += chunk.data.choices[0].delta.content;
+            }
+    
+            const jsonMatch = response.match(/```json\s*([\s\S]*?)\s*```/);
+            if (jsonMatch) {
+                return JSON.parse(jsonMatch[1]);
+            }
+            return {
+                production_date: null,
+                expiration_date: null,
+                production_id: null,
+                additional_info: "Error: No valid JSON found in Mixtral response"
+            };
+        } catch (error) {
+            console.error("Mixtral API error:", error);
+            return {
+                production_date: null,
+                expiration_date: null,
+                production_id: null,
+                additional_info: `Mixtral Error: ${error.message}`
+            };
+        }
+    }
+
+    async analyzeWithGeminiThinking(base64Image, prompt) {
+        const model = this.genAIThinking.getGenerativeModel({ model: "gemini-2.0-flash-thinking-exp-1219" });
+        const result = await model.generateContent([
+            { text: prompt },
+            {
+                inlineData: {
+                    data: base64Image,
+                    mimeType: "image/jpeg"
+                }
+            }
+        ]);
+
+        const text = result.response.text();
+        const jsonMatch = text.match(/```json\s*([\s\S]*?)\s*```/);
+        if (jsonMatch) {
+            return JSON.parse(jsonMatch[1]);
+        }
+        throw new Error("No JSON content found in Gemini Thinking response");
+    }
+
+    async ask(prompt, modelType) {
+        try {
+            if (modelType === ModelType.GEMINI || modelType === ModelType.GEMINI_THINKING) {
+                const genAI = modelType === ModelType.GEMINI ? this.genAI : this.genAIThinking;
+                const modelName = modelType === ModelType.GEMINI ? "gemini-2.0-flash-exp" : "gemini-2.0-flash-thinking-exp-1219";
+                const model = genAI.getGenerativeModel({ model: modelName });
+                
+                const chat = model.startChat({
+                    generationConfig: {
+                        maxOutputTokens: 8192,
+                        temperature: 1,
+                    },
+                    safetySettings: [
+                        { category: HarmCategory.HARM_CATEGORY_HATE_SPEECH, threshold: HarmBlockThreshold.BLOCK_NONE },
+                        { category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT, threshold: HarmBlockThreshold.BLOCK_NONE },
+                        { category: HarmCategory.HARM_CATEGORY_HARASSMENT, threshold: HarmBlockThreshold.BLOCK_NONE },
+                        { category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, threshold: HarmBlockThreshold.BLOCK_NONE },
+                    ]
+                });
+
+                let totalResponse = "";
+                const result = await chat.sendMessageStream(prompt);
+                for await (const chunk of result.stream) {
+                    const chunkText = chunk.text();
+                    totalResponse += chunkText;
+                }
+                return { response: totalResponse };
+            } else {
+                // Mixtral handling
+                const result = await this.mistral.chat.stream({
+                    model: "mistral-large-latest",
+                    messages: [{ role: "user", content: prompt }],
+                    max_tokens: 1024*128,
+                    temperature: 0.8,
+                });
+                
+                let response = "";
+                for await (const chunk of result) {
+                    response += chunk.data.choices[0].delta.content;
+                }
+                return { response };
+            }
+        } catch (error) {
+            if (error.toString().includes("Too Many Requests") || 
+                error.toString().includes("Please try again later")) {
+                throw new Error("Rate limit exceeded, please try again later");
+            }
+            console.error(`Error in ${modelType} ask:`, error);
+            throw error;
+        }
+    }
+}
+
+const client = new ImageAnalysisClient();
+
+app.post('/analyze', limiter,upload.single('image'), async (req, res) => {
+    requestCounter.analyze++;
+    requestCounter.total++;
+    try {
+        if (!req.file) {
+            return res.status(400).json({ status: 400, error: "No image file provided" });
+        }
+
+        const modelType = req.body.model?.toUpperCase();
+        if (!ModelType[modelType]) {
+            return res.status(400).json({ status: 400, error: "Invalid model type. Use GEMINI or MIXTRAL" });
+        }
+
+        const result = await client.analyzeImage(req.file.buffer, modelType);
+        res.json({ status: 200, data: result });
+    } catch (error) {
+        console.error("Analysis error:", error);
+        res.status(500).json({ status: 500, error: error.message });
+    }
+});
+
+
+// Update HTML form
+app.get('/check', limiter, (req, res) => {
+    res.send(`
+        <html>
+            <body>
+                <h1>AI API Service</h1>
+                <h2>API Endpoints:</h2>
+                <ul>
+                    <li>POST /analyze - Upload image for analysis</li>
+                    <li>POST /ask - Ask AI a question</li>
+                    <li>GET /status - Check API status</li>
+                </ul>
+                
+                <h2>Image Analysis Form:</h2>
+                <form action="/analyze" method="post" enctype="multipart/form-data">
+                    <p>Select image file: <input type="file" name="image" accept="image/*" required></p>
+                    <p>Select model: 
+                        <select name="model" required>
+                            <option value="GEMINI">GEMINI</option>
+                            <option value="MIXTRAL">MIXTRAL</option>
+                            <option value="GEMINI_THINKING">GEMINI THINKING</option>
+                        </select>
+                    </p>
+                    <input type="submit" value="Analyze">
+                </form>
+
+                <h2>Ask AI Form:</h2>
+                <form id="askForm">
+                    <p>Question: <input type="text" id="prompt" required style="width:300px"></p>
+                    <p>Select model: 
+                        <select id="model" required>
+                            <option value="GEMINI">GEMINI</option>
+                            <option value="MIXTRAL">MIXTRAL</option>
+                            <option value="GEMINI_THINKING">GEMINI THINKING</option>
+                        </select>
+                    </p>
+                    <button type="submit">Ask</button>
+                    <pre id="result"></pre>
+                </form>
+
+                <script>
+                document.getElementById('askForm').onsubmit = async (e) => {
+                    e.preventDefault();
+                    const response = await fetch('/ask', {
+                        method: 'POST',
+                        headers: {'Content-Type': 'application/json'},
+                        body: JSON.stringify({
+                            prompt: document.getElementById('prompt').value,
+                            model: document.getElementById('model').value
+                        })
+                    });
+                    const data = await response.json();
+                    document.getElementById('result').textContent = 
+                        JSON.stringify(data, null, 2);
+                };
+                </script>
+            </body>
+        </html>
+    `);
+});
+
+app.post('/compareAnalyze',limiter, upload.single('image'), async (req, res) => {
+    requestCounter.compareAnalyze++;
+    requestCounter.total++;
+    try {
+        if (!req.file) {
+            return res.status(400).json({ status: 400, error: "No image file provided" });
+        }
+
+        const [geminiResult, mixtralResult, geminiThinkingResult] = await Promise.all([
+            client.analyzeImage(req.file.buffer, ModelType.GEMINI)
+                .catch(error => ({
+                    production_date: null,
+                    expiration_date: null,
+                    production_id: null,
+                    additional_info: null
+                })),
+            client.analyzeImage(req.file.buffer, ModelType.MIXTRAL)
+                .catch(error => ({
+                    production_date: null,
+                    expiration_date: null,
+                    production_id: null,
+                    additional_info: null
+                })),
+            client.analyzeImage(req.file.buffer, ModelType.GEMINI_THINKING)
+                .catch(error => ({
+                    production_date: null,
+                    expiration_date: null,
+                    production_id: null,
+                    additional_info: null
+                }))
+        ]);
+
+        res.json({
+            status: 200,
+            datas: [geminiResult, mixtralResult, geminiThinkingResult]
+        });
+    } catch (error) {
+        console.error("Comparison analysis error:", error);
+        res.status(500).json({
+            status: 500,
+            error: 'Unknown error, please contact the administrator'
+        });
+    }
+});
+// Add status endpoint
+// Update status endpoint
+app.get('/status', (req, res) => {
+    res.json({
+        status: "running",
+        models: "model",
+        version: "1.0.0",
+        copyright: "sonygod",
+        requests: {
+            f1: requestCounter.analyze,
+            f2: requestCounter.compareAnalyze,
+            total: requestCounter.total
+        }
+    });
+});
+
+app.post('/ask', limiter, express.json(), async (req, res) => {
+    requestCounter.total++;
+    try {
+        const { prompt, model } = req.body;
+        
+        if (!prompt) {
+            return res.status(400).json({ 
+                status: 400, 
+                error: "No prompt provided" 
+            });
+        }
+
+        const modelType = model?.toUpperCase();
+        if (!ModelType[modelType]) {
+            return res.status(400).json({ 
+                status: 400, 
+                error: "Invalid model type. Use GEMINI, MIXTRAL, or GEMINI_THINKING" 
+            });
+        }
+
+        const result = await client.ask(prompt, modelType);
+        res.json({ status: 200, data: result });
+    } catch (error) {
+        console.error("Ask error:", error);
+        res.status(500).json({ status: 500, error: error.message });
+    }
+});
+
+// Change server binding
+app.listen(port, '0.0.0.0', () => {
+    console.log(`Server running on port ${port} (0.0.0.0)`);
+});

tunner.py

@@ -0,0 +1,67 @@
+from pathlib import Path
+import subprocess
+from importlib import import_module
+import time
+import sys
+
+message = """
+- Ready!
+- Open VSCode on your laptop and open the command prompt
+- Select: 'Remote-Tunnels: Connect to Tunnel' to connect to colab
+""".strip()
+
+dir_path = "/etc/noteable/project"
+local_folder = '/etc/noteable/project'
+
+def start_tunnel() -> None:
+    command = f"cd {dir_path} &&./code tunnel --accept-server-license-terms --random-name"
+    p = subprocess.Popen(
+        command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
+    )
+    
+    show_outputs = False
+    while True:
+        line = p.stdout.readline().decode("utf-8")
+        if show_outputs:
+            print(line.strip())
+        if "To grant access to the server" in line:
+            print(line.strip())
+        if "Open this link" in line:
+            print("Starting the tunnel")
+            time.sleep(5)
+            print(message)
+            print("Logs:")
+            show_outputs = True
+            line = ""
+        if line == "" and p.poll() is not None:
+            break
+    return None
+
+
+def run(command: str) -> None:
+    process = subprocess.run(command.split())
+    if process.returncode == 0:
+        print(f"Ran: {command}")
+
+def connect() -> None:
+    # Create a folder to store all the code files
+    Path(local_folder).mkdir(parents=True, exist_ok=True)
+
+    print("Installing python libraries...")
+    run("pip3 install --user flake8 black ipywidgets twine")
+    run("pip3 install -U ipykernel")
+    run("apt install htop -y")
+
+    print("Installing vscode-cli...")
+    run(
+         f"curl -Lk https://code.visualstudio.com/sha/download?build=stable&os=cli-alpine-x64  -o {dir_path}/vscode_cli.tar.gz"
+    )
+    run(f"tar -xf {dir_path}/vscode_cli.tar.gz -C {dir_path}")
+
+    print("Starting the tunnel")
+    start_tunnel()
+
+
+# To run the function, simply call: connect()
+
+connect()