Add auto proxy

config.json

@@ -1,8 +1,8 @@
 {
-    "site_config": {
-        "host" : "0.0.0.0",
-        "port" : 1338,
-        "debug": false
-    },
-    "openai_key": "sk-..."
-}
+	"site_config": {
+		"host": "0.0.0.0",
+		"port": 1338,
+		"debug": false
+	},
+	"use_auto_proxy": false
+}

server/auto_proxy.py

@@ -0,0 +1,106 @@
+import random  
+import requests  
+import time  
+import threading  
+from freeGPT import gpt3  
+  
+  
+def fetch_proxies():  
+    """Fetch a list of proxy servers from proxyscrape.com.  
+  
+    Returns:  
+        list: A list of proxy servers in the format "IP:Port".  
+    """  
+    url = "https://api.proxyscrape.com/v2/?request=displayproxies&protocol=http&timeout=1000&country=all&ssl=all&anonymity=all"  
+    response = requests.get(url)  
+    if response.status_code == 200:  
+        proxy_list = response.text.split("\r\n")[:-1]  
+        return proxy_list  
+    else:  
+        print(f"Error fetching proxies: {response.status_code}")  
+        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:  
+        start_time = time.time()  
+        res = gpt3.Completion.create(prompt=prompt, proxy=proxy)  
+        end_time = time.time()  
+        response_time = end_time - start_time  
+  
+        if response_time < timeout:  
+            response_time = int(response_time*1000)  
+            print(f'proxy: {proxy} [{response_time}ms] ✅')  
+            add_working_proxy((proxy))  
+    except Exception as e:  
+        pass  
+  
+  
+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))  
+        threads.append(thread)  
+        thread.start()  
+  
+    for t in threads:  
+        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)  # Update proxies list every 30 minutes  
+  
+  
+def get_random_proxy():  
+    """Get a random working proxy server from the global working_proxies list.  
+  
+    Returns:  
+        str: A random working proxy server in the format "IP:Port".  
+    """  
+    global working_proxies  
+    return random.choice(working_proxies)  

server/backend.py

@@ -1,19 +1,16 @@
-from time import time
+import threading
 from flask import request
-from hashlib import sha256
 from datetime import datetime
 from requests import get
-from requests import post
-from json import loads
 from freeGPT import gpt3
-
+from server.auto_proxy import get_random_proxy, remove_proxy, update_working_proxies
 from server.config import special_instructions
 
 
 class Backend_Api:
     def __init__(self, app, config: dict) -> None:
         self.app = app
-        self.openai_key = config['openai_key']
+        self.use_auto_proxy = config['use_auto_proxy']
         self.routes = {
             '/backend-api/v2/conversation': {
                 'function': self._conversation,
@@ -21,6 +18,11 @@ class Backend_Api:
             }
         }
 
+        if self.use_auto_proxy:
+            update_proxies = threading.Thread(
+                target=update_working_proxies, daemon=True)
+            update_proxies.start()
+
     def _conversation(self):
         try:
             jailbreak = request.json['jailbreak']
@@ -53,12 +55,32 @@ class Backend_Api:
                 extra + special_instructions[jailbreak] + \
                 _conversation + [prompt]
 
-            def stream():      
-              res = gpt3.Completion.create(prompt=conversation)      
-              response = res['text']    
-              yield response
-  
-            return self.app.response_class(stream(), mimetype='text/event-stream')  
+            def stream():
+                response = None
+
+                while self.use_auto_proxy:
+                    try:
+                        random_proxy = get_random_proxy()
+                        res = gpt3.Completion.create(
+                            prompt=conversation, proxy=random_proxy)
+                        response = res['text']
+                        break
+                    except Exception as e:
+                        print(f"Error with proxy {random_proxy}: {e}")
+                        remove_proxy(random_proxy)
+
+                if not self.use_auto_proxy:
+                    try:
+                        res = gpt3.Completion.create(prompt=conversation)
+                        response = res['text']
+                    except Exception as e:
+                        print(f"Error: {e}")
+
+                if response is not None:
+                    print(response)
+                    yield response
+
+            return self.app.response_class(stream(), mimetype='text/event-stream')
 
         except Exception as e:
             print(e)