v 1.4.0 Обновление и рефакторинг g4f

Author: neurogen-dev

backend.py

@@ -0,0 +1,78 @@
+import os
+import g4f
+import json
+import time
+import pytz
+from datetime import datetime
+import concurrent.futures
+import asyncio
+from g4f import ChatCompletion
+
+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', 'ChatgptLogin'] and model_name != 'gpt-3.5-turbo':
+            provider_status['status'] = 'Inactive'
+            print(f"{provider_name} with {model_name} skipped")
+            return provider_status
+
+        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
+
+def main():
+    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)
+
+        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")
+
+        # Save the status data to a JSON file only if there are active providers
+        if status['data']:
+            with open('status.json', 'w') as f:
+                json.dump(status, f)
+
+        # Pause for 10 minutes before starting the next cycle
+        time.sleep(600)
+
+if __name__ == "__main__":
+    main()

check.py

@@ -0,0 +1,9 @@
+app = {
+    'host': '0.0.0.0',
+    'port': 1337,
+    'debug': True
+}
+
+request = {
+    'timeout': 60
+}

config.py

@@ -22,222 +22,6 @@
 
 from multiprocessing import Process
 
-app = FastAPI()
-
-app.add_middleware(GZipMiddleware)
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-@app.post("/chat/completions")
-@app.post("/v1/chat/completions")
-async def chat_completions(request: Request):
-    req_data = await request.json()
-    streaming = req_data.get('stream', False)
-    streaming_ = req_data.get('stream', False)
-    model = req_data.get('model')
-    messages = req_data.get('messages')
-    provider = req_data.get('provider', False)
-    if model == 'bing':
-        response = g4f.ChatCompletion.create(model=model, provider=g4f.Provider.BingHuan, stream=True,
-                                             messages=messages)
-    else:
-    
-        response = g4f.ChatCompletion.create(model=model, stream=streaming,
-                                     messages=messages)
-    
-    if not streaming:
-        while 'curl_cffi.requests.errors.RequestsError' in response:
-            response = g4f.ChatCompletion.create(model=model, stream=streaming,
-                                             messages=messages)
-
-        completion_timestamp = int(time.time())
-        completion_id = ''.join(random.choices(
-            'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789', k=28))
-
-        return {
-            'id': 'chatcmpl-%s' % completion_id,
-            'object': 'chat.completion',
-            'created': completion_timestamp,
-            'model': model,
-            'usage': {
-                'prompt_tokens': None,
-                'completion_tokens': None,
-                'total_tokens': None
-            },
-            'choices': [{
-                'message': {
-                    'role': 'assistant',
-                    'content': response
-                },
-                'finish_reason': 'stop',
-                'index': 0
-            }]
-        }
-
-    async def stream():
-        completion_data = {
-            'id': '',
-            'object': 'chat.completion.chunk',
-            'created': 0,
-            'model': 'gpt-3.5-turbo-0301',
-            'choices': [
-                {
-                    'delta': {
-                        'content': ""
-                    },
-                    'index': 0,
-                    'finish_reason': None
-                }
-            ]
-        }
-
-        for token in response:
-            completion_id = ''.join(
-                random.choices('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789', k=28))
-            completion_timestamp = int(time.time())
-            completion_data['id'] = f'chatcmpl-{completion_id}'
-            completion_data['created'] = completion_timestamp
-            completion_data['choices'][0]['delta']['content'] = token
-            if token.startswith("an error occured"):
-                completion_data['choices'][0]['delta']['content'] = "Server Response Error, please try again.\n"
-                completion_data['choices'][0]['delta']['stop'] = "error"
-                yield 'data: %s\n\ndata: [DONE]\n\n' % json.dumps(completion_data, separators=(',' ':'))
-                return
-            yield 'data: %s\n\n' % json.dumps(completion_data, separators=(',' ':'))
-            time.sleep(0.05)
-
-        completion_data['choices'][0]['finish_reason'] = "stop"
-        completion_data['choices'][0]['delta']['content'] = ""
-        yield 'data: %s\n\n' % json.dumps(completion_data, separators=(',' ':'))
-        yield 'data: [DONE]\n\n'
-    return StreamingResponse(stream(), media_type='text/event-stream')
-
-@app.get("/v1/dashboard/billing/subscription")
-@app.get("/dashboard/billing/subscription")
-async def billing_subscription():
-    return JSONResponse({
-  "object": "billing_subscription",
-  "has_payment_method": True,
-  "canceled": False,
-  "canceled_at": None,
-  "delinquent": None,
-  "access_until": 2556028800,
-  "soft_limit": 6944500,
-  "hard_limit": 166666666,
-  "system_hard_limit": 166666666,
-  "soft_limit_usd": 416.67,
-  "hard_limit_usd": 9999.99996,
-  "system_hard_limit_usd": 9999.99996,
-  "plan": {
-    "title": "Pay-as-you-go",
-    "id": "payg"
-  },
-  "primary": True,
-  "account_name": "OpenAI",
-  "po_number": None,
-  "billing_email": None,
-  "tax_ids": None,
-  "billing_address": {
-    "city": "New York",
-    "line1": "OpenAI",
-    "country": "US",
-    "postal_code": "NY10031"
-  },
-  "business_address": None
-}
-)
-
-
-@app.get("/v1/dashboard/billing/usage")
-@app.get("/dashboard/billing/usage")
-async def billing_usage():
-    return JSONResponse({
-  "object": "list",
-  "daily_costs": [
-    {
-      "timestamp": time.time(),
-      "line_items": [
-        {
-          "name": "GPT-4",
-          "cost": 0.0
-        },
-        {
-          "name": "Chat models",
-          "cost": 1.01
-        },
-        {
-          "name": "InstructGPT",
-          "cost": 0.0
-        },
-        {
-          "name": "Fine-tuning models",
-          "cost": 0.0
-        },
-        {
-          "name": "Embedding models",
-          "cost": 0.0
-        },
-        {
-          "name": "Image models",
-          "cost": 16.0
-        },
-        {
-          "name": "Audio models",
-          "cost": 0.0
-        }
-      ]
-    }
-  ],
-  "total_usage": 1.01
-}
-)
-
-@app.get("/v1/models")
-@app.get("/models")
-async def models():
-  import g4f.models
-  model = {"data":[]}
-  for i in g4f.models.ModelUtils.convert:
-    model['data'].append({
-            "id": i,
-            "object": "model",
-            "owned_by": g4f.models.ModelUtils.convert[i].base_provider,
-            "tokens": 99999,
-            "fallbacks": None,
-            "endpoints": [
-                "/v1/chat/completions"
-            ],
-            "limits": None,
-            "permission": []
-        })
-  return JSONResponse(model)
-
-@app.get("/v1/providers")
-@app.get("/providers")
-async def providers():
-  files = os.listdir("g4f/Provider/Providers")
-  files = [f for f in files if os.path.isfile(os.path.join("g4f/Provider/Providers", f))]
-  files.sort(key=str.lower)
-  providers_data = {"data":[]}
-  for file in files:
-      if file.endswith(".py"):
-          name = file[:-3]
-          try:
-              p = getattr(g4f.Provider,name)
-              providers_data["data"].append({
-              "provider": str(name),
-              "model": list(p.model),
-              "url": str(p.url),
-              "working": bool(p.working),
-              "supports_stream": bool(p.supports_stream)
-              })
-          except:
-                pass
-  return JSONResponse(providers_data)
 
 def setup_logging():
     root_logger = logging.getLogger()

endpoint.py

@@ -0,0 +1,54 @@
+import json
+
+import requests
+
+from ..typing import Any, CreateResult
+from .base_provider import BaseProvider
+
+
+class AItianhu(BaseProvider):
+    url = "https://ixlc0.aitianhu.site/api/chat-process"
+    working = True
+    supports_gpt_4 = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool,
+        **kwargs: Any,
+    ) -> CreateResult:
+        base = ""
+        for message in messages:
+            base += "%s: %s\n" % (message["role"], message["content"])
+        base += "assistant:"
+
+        headers = {
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36"
+        }
+        data: dict[str, Any] = {
+            "prompt": base,
+            "options": {},
+            "systemMessage": "You are ChatGPT, a large language model trained by OpenAI. Follow the user's instructions carefully. Respond using markdown.",
+            "temperature": kwargs.get("temperature", 0.8),
+            "top_p": kwargs.get("top_p", 1),
+        }
+        url = "https://ixlc0.aitianhu.site/api/chat-process"
+        response = requests.post(url, headers=headers, json=data)
+        response.raise_for_status()
+        lines = response.text.strip().split("\n")
+        res = json.loads(lines[-1])
+        yield res["text"]
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+            ("top_p", "int"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"