Фикс работы ендпоинта, откат провайдеров

Author: neurogen-dev

auto_proxy.py

@@ -1,65 +1,121 @@
-import random
-import requests
-import time
-import threading
+import random  
+import requests  
+import time  
+import threading  
 import socket
-import redis
-
-
-# Создаем подключение к redis
-r = redis.StrictRedis(host='localhost', port=6379, db=0)
 
 
 def fetch_proxies():
-    url = "https://api.proxyscrape.com/v2/?request=displayproxies&protocol=http"
+    """Fetch a list of proxy servers from proxyscrape.com.  
+  
+    Returns:  
+        list: A list of proxy servers in the format "IP:Port".  
+    """  
+    url = "https://www.proxy-list.download/api/v1/get?type=https"
     response = requests.get(url)
     if response.status_code == 200:
         return response.text.split("\r\n")[:-1]
     print(f"Error fetching proxies: {response.status_code}")
-    return [] 
+    return []  
 
 
 def test_proxy(proxy, prompt, timeout):
+    """Test the given proxy server with a specified prompt and timeout.
+
+    Args:
+        proxy (str): The proxy server in the format "IP:Port".
+        prompt (str): The test prompt to be used for testing.
+        timeout (int): The maximum time in seconds allowed for the test.
+    """
     try:
-        ip, port = proxy.split(':') 
+        # Split IP and Port
+        ip, port = proxy.split(':')
+        
+        # Create a socket object
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        
+        # Start the timer
         start_time = time.time()
+        
+        # Connect to the proxy server
         sock.connect((ip, int(port)))
+        
+        # Stop the timer and calculate the elapsed time
         end_time = time.time()
         elapsed_time = end_time - start_time
+        
+        # Print the elapsed time
+        #print(f"Elapsed time: {elapsed_time} seconds")
+        
+        # Close the socket
         sock.close()
-
+        
+        # Check if the elapsed time is below the timeout
         if elapsed_time < timeout:
             print(f"proxy: {proxy} ✅ | Elapsed time: {elapsed_time} seconds")
-            r.rpush('working_proxies', proxy)  # Сохраняем рабочего прокси в redis
+            add_working_proxy(proxy)
     except Exception as e:
         pass
 
 
-def get_working_proxies(prompt, timeout=1):  
-    proxy_list = fetch_proxies()  
-    threads = []
-    r.delete('working_proxies')  # Очищаем список рабочих прокси в redis перед обновлением
+def add_working_proxy(proxy):  
+    """Add a working proxy server to the global working_proxies list.  
+  
+    Args:  
+        proxy (str): The proxy server in the format "IP:Port". 
+    """  
+    global working_proxies  
+    working_proxies.append(proxy)  
+
+
+def remove_proxy(proxy):  
+    """Remove a proxy server from the global working_proxies list.  
+  
+    Args:  
+        proxy (str): The proxy server in the format "IP:Port".  
+    """  
+    global working_proxies  
+    if proxy in working_proxies:  
+        working_proxies.remove(proxy)  
+
+
+def get_working_proxies(prompt, timeout=5):  
+    """Fetch and test proxy servers, adding working proxies to the global working_proxies list.  
   
+    Args:  
+        prompt (str): The test prompt to be used for testing.  
+        timeout (int, optional): The maximum time in seconds allowed for testing. Defaults to 5.  
+    """  
+    proxy_list = fetch_proxies()  
+    threads = []  
+
     for proxy in proxy_list:  
-        thread = threading.Thread(target=test_proxy, args=(proxy, prompt, timeout))  
+        thread = threading.Thread(target=test_proxy, args=(  
+            proxy, prompt, timeout))  
         threads.append(thread)  
         thread.start()  
-  
+
     for t in threads:  
-        t.join(timeout)
+        t.join(timeout)  
 
 
 def update_working_proxies():  
+    """Continuously update the global working_proxies list with working proxy servers."""  
+    global working_proxies  
     test_prompt = "What is the capital of France?"  
- 
+
     while True:  
+        working_proxies = []  # Clear the list before updating  
         get_working_proxies(test_prompt)  
         print('proxies updated')  
-        time.sleep(1800)  # Обновляем список прокси каждые 30 минут
-  
+        time.sleep(1800)  # Update proxies list every 30 minutes  
+
+
+def get_random_proxy():  
+    """Get a random working proxy server from the global working_proxies list.  
   
-def get_random_proxy(): 
-    # Получаем случайного прокси из рабочих 
-    working_proxies = r.lrange('working_proxies', 0, -1)
-    return random.choice(working_proxies)
+    Returns:  
+        str: A random working proxy server in the format "IP:Port".  
+    """  
+    global working_proxies  
+    return random.choice(working_proxies)  

backend.py

@@ -50,20 +50,7 @@ async def chat_completions(request: Request):
     top_p = req_data.get('top_p', 1.0)
     max_tokens = req_data.get('max_tokens', 4096)
 
-    # Получение данных о провайдерах из API
-    # Загрузка данных о провайдерах из локального файла
-    with open('status.json', 'r') as f:
-        provider_data = json.load(f)
-    
-    active_providers = [data['provider'] for data in provider_data['data'] if data['model'] == model and data['status'] == 'Active']
-    
-    if not active_providers:
-        return JSONResponse({"error": "No active provider found for the model"})
-
-    provider_name = random.choice(active_providers)
-    provider = getattr(Provider, provider_name)
-
-    response = ChatCompletion.create(model=model, stream=stream, messages=messages, provider=provider, temperature=temperature, top_p=top_p, max_tokens=max_tokens, system_prompt="")
+    response = ChatCompletion.create(model=model, stream=stream, messages=messages, temperature=temperature, top_p=top_p, max_tokens=max_tokens, system_prompt="")
 
     completion_id = "".join(random.choices(string.ascii_letters + string.digits, k=28))
     completion_timestamp = int(time.time())
@@ -79,7 +66,7 @@ async def chat_completions(request: Request):
                     "index": 0,
                     "message": {
                         "role": "assistant",
-                        "content": response.encode().decode(),
+                        "content": response,
                     },
                     "finish_reason": "stop",
                 }
@@ -102,7 +89,7 @@ def streaming():
                     {
                         "index": 0,
                         "delta": {
-                            "content": chunk.encode().decode(),
+                            "content": chunk,
                         },
                         "finish_reason": None,
                     }

check.py

@@ -10,6 +10,7 @@
 from fp.fp import FreeProxy
 import threading  
 import socket  
+from auto_proxy import get_random_proxy, update_working_proxies
 
 def process_provider(provider_name, model_name):
     try:
@@ -22,16 +23,17 @@ def process_provider(provider_name, model_name):
         }
 
         # Проверяем только модель 'gpt-3.5-turbo' для провайдеров Wewordle и Qidinam
-        if provider_name in ['Wewordle', 'Qidinam', 'DeepAi', 'GetGpt', 'Yqcloud'] and model_name != 'gpt-3.5-turbo':
+        if provider_name in ['Wewordle', 'Qidinam', 'DeepAi', 'GetGpt', 'Yqcloud', 'WewordleApple'] and model_name != 'gpt-3.5-turbo':
             provider_status['status'] = 'Inactive'
             print(f"{provider_name} with {model_name} skipped")
             return provider_status
 
         try:
+            proxy = get_random_proxy().decode("utf-8")
+            formatted_proxy = f'https://{proxy}'
 
             response = ChatCompletion.create(model=model_name, provider=p,
                                                  messages=[{"role": "user", "content": "Say 'Hello World!'"}], stream=False)
-            print(f"Using proxy: {proxy}")
             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}")
@@ -77,7 +79,7 @@ def main():
                 json.dump(status, f)
 
         # Pause for 10 minutes before starting the next cycle
-        #time.sleep(600)
+        time.sleep(600)
 
 if __name__ == "__main__":
     main()

g4f/Provider/AItianhu.py

@@ -7,17 +7,16 @@
 
 
 class AItianhu(BaseProvider):
-    url = "https://ixlc0.aitianhu.site/api/chat-process"
-    working = True
-    supports_gpt_4 = True
+    url = "https://www.aitianhu.com/"
+    working = False
+    supports_gpt_35_turbo = True
 
     @staticmethod
     def create_completion(
         model: str,
         messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
         base = ""
         for message in messages:
             base += "%s: %s\n" % (message["role"], message["content"])
@@ -33,7 +32,7 @@ def create_completion(
             "temperature": kwargs.get("temperature", 0.8),
             "top_p": kwargs.get("top_p", 1),
         }
-        url = "https://ixlc0.aitianhu.site/api/chat-process"
+        url = "https://www.aitianhu.com/api/chat-process"
         response = requests.post(url, headers=headers, json=data)
         response.raise_for_status()
         lines = response.text.strip().split("\n")

g4f/Provider/Acytoo.py

@@ -10,7 +10,6 @@ class Acytoo(BaseProvider):
     url                   = 'https://chat.acytoo.com/'
     working               = True
     supports_gpt_35_turbo = True
-    supports_stream = True
 
     @classmethod
     def create_completion(
@@ -35,14 +34,14 @@ def _create_header():
     }
 
 
-def _create_payload(messages: list[dict[str, str]], temperature, model):
+def _create_payload(messages: list[dict[str, str]], temperature):
     payload_messages = [
         message | {'createdAt': int(time.time()) * 1000} for message in messages
     ]
 
     return {
         'key'         : '',
-        'model'       : model,
+        'model'       : 'gpt-3.5-turbo',
         'messages'    : payload_messages,
         'temperature' : temperature,
         'password'    : ''

g4f/Provider/AiService.py

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

g4f/Provider/Aichat.py

@@ -5,20 +5,17 @@
 
 
 class Aichat(BaseProvider):
-    url = "https://chat-gpt.org/chat"
-    working = True
-    supports_stream = True
+    url                   = "https://chat-gpt.org/chat"
+    working               = True
     supports_gpt_35_turbo = True
 
     @staticmethod
     def create_completion(
         model: str,
         messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
         base = ""
-
         for message in messages:
             base += "%s: %s\n" % (message["role"], message["content"])
         base += "assistant:"