Merge branch 'main' into portable

Author: neurogen-dev

.github/README.md

@@ -61,7 +61,7 @@
 - Встроенные джейлбрейки для снятия цензуры
 - Контекст беседы
 - Режим endpoint для работы с API
-- Тонкая настройка модели
+- Изменение параметров генерации для gpt-моделей
 - Сохранение и загрузка истории диалогов
 
 <div align="center">

.github/README_EN.md

@@ -61,7 +61,7 @@ Given that this project doesn't use an official API but relies on reverse-engine
 - Built-in jailbreaks for removing censorship
 - Conversation context
 - API endpoint
-- Fine-tuning a model
+- Setting generation parameters for GPT models
 - Saving and loading dialogue history
 
 <div align="center">

backend.py

@@ -4,6 +4,8 @@
 import random
 import string
 import asyncio
+import async_timeout
+import aiohttp, aiofiles
 import requests
 import pytz
 import logging
@@ -13,10 +15,15 @@
 from fastapi.responses import JSONResponse, StreamingResponse
 from starlette.middleware.cors import CORSMiddleware
 from typing import Any
+import g4f
 from g4f import ChatCompletion, Provider, BaseProvider, models
 from cachetools import LRUCache
-import httpx
-import check
+
+import aiofiles
+import async_timeout
+
+from fp.fp import FreeProxy
+import concurrent.futures
 
 app = FastAPI()
 app.add_middleware(GZipMiddleware)
@@ -27,18 +34,18 @@
     allow_headers=["*"],
 )
 
-# Кэш для хранения данных из API
-api_cache = LRUCache(maxsize=1000)
+cache_ttl_secs = 600
+api_cache = LRUCache(maxseze=1000)
+
+def get_proxy():
+    proxy = FreeProxy(rand=True, timeout=1).get()
+    return proxy
 
-# Асинхронная функция для получения данных из API
-async def get_data_from_api(url: str) -> Any:
-    if url in api_cache:
-        return api_cache[url]
-    else:
-        async with httpx.AsyncClient() as client:
-            response = await client.get(url)
-            data = response.json()
-            api_cache[url] = data
+async def get_data_from_api(url, session):
+    async with async_timeout.timeout(cache_ttl_secs):
+        async with session.get(url) as response:
+            data = await response.json()
+            api_cache[url] = (data, datetime.now())
             return data
 
 @app.post("/chat/completions")
@@ -93,7 +100,7 @@ async def chat_completions(request: Request):
             },
         }
 
-    async def streaming():
+    def streaming():
         for chunk in response:
             completion_data = {
                 "id": f"chatcmpl-{completion_id}",
@@ -110,11 +117,11 @@ async def streaming():
                     }
                 ],
             }
-
+    
             content = json.dumps(completion_data, separators=(",", ":"))
             yield f"data: {content}\n\n"
-            await asyncio.sleep(0.1)
-
+            time.sleep(0.1)
+    
         end_completion_data: dict[str, Any] = {
             "id": f"chatcmpl-{completion_id}",
             "object": "chat.completion.chunk",
@@ -130,7 +137,7 @@ async def streaming():
         }
         content = json.dumps(end_completion_data, separators=(",", ":"))
         yield f"data: {content}\n\n"
-
+    
     return StreamingResponse(streaming(), media_type='text/event-stream')
 
 @app.get("/v1/dashboard/billing/subscription")
@@ -248,41 +255,94 @@ async def get_providers():
                 pass
     return JSONResponse(providers_data)
 
-def setup_logging():
-    root_logger = logging.getLogger()
-    root_logger.setLevel(logging.DEBUG)
+def process_provider(provider_name, model_name):
+    try:
+        p = getattr(g4f.Provider, provider_name)
+        provider_status = {
+            "provider": provider_name,
+            "model": model_name,
+            "url": p.url,
+            "status": ""
+        }
+
+        # Проверяем только модель 'gpt-3.5-turbo' для провайдеров Wewordle и Qidinam
+        if provider_name in ['Wewordle', 'Qidinam', 'DeepAi', 'GetGpt', 'Yqcloud'] and model_name != 'gpt-3.5-turbo':
+            provider_status['status'] = 'Inactive'
+            #print(f"{provider_name} with {model_name} skipped")
+            return provider_status
 
-    handler = logging.StreamHandler()
-    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-    handler.setFormatter(formatter)
+        try:
+            response = ChatCompletion.create(model=model_name, provider=p,
+                                                 messages=[{"role": "user", "content": "Say 'Hello World!'"}], stream=False)
+            if any(word in response for word in ['Hello World', 'Hello', 'hello', 'world']):
+                provider_status['status'] = 'Active'
+                #print(f"{provider_name} with {model_name} say: {response}")
+            else:
+                provider_status['status'] = 'Inactive'
+                #print(f"{provider_name} with {model_name} say: Inactive")
+        except Exception as e:
+            provider_status['status'] = 'Inactive'
+           # print(f"{provider_name} with {model_name} say: Error")
+
+        return provider_status
+    except:
+        return None
+
+async def run_check_script():
+    session = aiohttp.ClientSession()
+    while True:
+        models = [model for model in g4f.models.ModelUtils.convert if model.startswith('gpt-') or model.startswith('claude') or model.startswith('text-')]
+        providers = [provider for provider in dir(g4f.Provider) if not provider.startswith('__')]
+
+        status = {'data': []}
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            futures = []
+            for provider_name in providers:
+                for model_name in models:
+                    future = executor.submit(process_provider, provider_name, model_name)
+                    futures.append(future)
+
+            for future in concurrent.futures.as_completed(futures):
+                result = future.result()
+                if result is not None and result['status'] == 'Active':
+                    status['data'].append(result)
 
-    root_logger.addHandler(handler)
+        print(status)
+        status['key'] = "test"
+        tz = pytz.timezone('Asia/Shanghai')
+        now = datetime.now(tz)
+        print(now)
+        status['time'] = now.strftime("%Y-%m-%d %H:%M:%S")
+
+        if status['data']:
+            # Здесь мы используем aiofiles для асинхронного записывания в файл
+            async with aiofiles.open('status.json', 'w') as f:
+                await f.write(json.dumps(status))
+
+        # Pause for 5 minutes before starting the next cycle
+        time.sleep(360)
 
 # Асинхронная функция для обновления кэша данных из API
 async def update_api_cache():
     while True:
         try:
             # Обновление данных каждые 10 минут
-            await asyncio.sleep(600)
+            await asyncio.sleep(360)
             api_cache.clear()
         except:
             pass
 
 # Запуск асинхронных задач
 async def run_tasks():
-    tasks = [
-        asyncio.create_task(update_api_cache())
-    ]
-    await asyncio.gather(*tasks)
-
+    while True:
+        await asyncio.gather(run_check_script())
+        await asyncio.sleep(300)
+    
 # Запуск приложения
 def main():
-    setup_logging()
-    tz = pytz.timezone('Asia/Shanghai')
-    now = datetime.now(tz)
-    print(now)
-    asyncio.run(run_tasks())
-    check.main()
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(run_tasks())
+    loop.close()
 
 if __name__ == "__main__":
     main()

check.py

@@ -19,7 +19,7 @@ def process_provider(provider_name, model_name):
         }
 
         # Проверяем только модель 'gpt-3.5-turbo' для провайдеров Wewordle и Qidinam
-        if provider_name in ['Wewordle', 'Qidinam', 'DeepAi', 'ChatgptLogin'] and model_name != 'gpt-3.5-turbo':
+        if provider_name in ['Wewordle', 'Qidinam', 'DeepAi', 'GetGpt', 'Yqcloud'] and model_name != 'gpt-3.5-turbo':
             provider_status['status'] = 'Inactive'
             print(f"{provider_name} with {model_name} skipped")
             return provider_status

endpoint.py

@@ -1,38 +1,7 @@
-import os
-import time
-import json
-import random
-import time
-
-from fastapi import FastAPI, Request
-from fastapi.middleware.gzip import GZipMiddleware
-from fastapi.responses import JSONResponse, StreamingResponse
-import json
-from typing import List
-import os
-import random
-import time
-import asyncio
-from starlette.middleware.cors import CORSMiddleware
-
-import logging
 import uvicorn
 
-import g4f
-
 from multiprocessing import Process
 
-
-def setup_logging():
-    root_logger = logging.getLogger()
-    root_logger.setLevel(logging.DEBUG)
-    
-    handler = logging.StreamHandler()
-    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-    handler.setFormatter(formatter)
-
-    root_logger.addHandler(handler)
-
 def run_api_server():
     uvicorn.run("backend:app", host="0.0.0.0", port=1337)
 

g4f/Provider/Acytoo.py

@@ -7,48 +7,43 @@
 
 
 class Acytoo(BaseProvider):
-    url = "https://chat.acytoo.com/api/completions"
-    working = True
-    supports_stream = True
+    url                   = 'https://chat.acytoo.com/'
+    working               = True
     supports_gpt_35_turbo = True
-    supports_gpt_35_turbo_16k = True
-    supports_gpt_4 = True
-    supports_gpt_4_0613 = True
-    supports_gpt_4_32k = True
-
+    supports_stream = True
 
-    @staticmethod
+    @classmethod
     def create_completion(
+        cls,
         model: str,
         messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
-        headers = _create_header()
-        payload = _create_payload(messages, kwargs.get('temperature', 0.5))
-
-        url = "https://chat.acytoo.com/api/completions"
-        response = requests.post(url=url, headers=headers, json=payload)
+        stream: bool, **kwargs: Any) -> CreateResult:
+
+        response = requests.post(f'{cls.url}api/completions', 
+                                 headers=_create_header(), json=_create_payload(messages, kwargs.get('temperature', 0.5)))
+        
         response.raise_for_status()
-        response.encoding = "utf-8"
+        response.encoding = 'utf-8'
+        
         yield response.text
 
 
 def _create_header():
     return {
-        "accept": "*/*",
-        "content-type": "application/json",
+        'accept': '*/*',
+        'content-type': 'application/json',
     }
 
 
 def _create_payload(messages: list[dict[str, str]], temperature, model):
     payload_messages = [
-        message | {"createdAt": int(time.time()) * 1000} for message in messages
+        message | {'createdAt': int(time.time()) * 1000} for message in messages
     ]
+    
     return {
-        "key": "",
-        "model": model,
-        "messages": payload_messages,
-        "temperature": temperature,
-        "password": "",
-    }
+        'key'         : '',
+        'model'       : model,
+        'messages'    : payload_messages,
+        'temperature' : temperature,
+        'password'    : ''
+    }

g4f/Provider/AiService.py

@@ -6,7 +6,7 @@
 
 class AiService(BaseProvider):
     url = "https://aiservice.vercel.app/api/chat/answer"
-    working = False
+    working = True
     supports_gpt_35_turbo = True
 
     @staticmethod