Add files via upload

Author: VadimBoev

g4f/Provider/deprecated/Acytoo.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from aiohttp import ClientSession
+
+from ...typing import AsyncResult, Messages
+from ..base_provider import AsyncGeneratorProvider
+
+
+class Acytoo(AsyncGeneratorProvider):
+    url                   = 'https://chat.acytoo.com'
+    working               = False
+    supports_message_history = True
+    supports_gpt_35_turbo = True
+
+    @classmethod
+    async def create_async_generator(
+        cls,
+        model: str,
+        messages: Messages,
+        proxy: str = None,
+        **kwargs
+    ) -> AsyncResult:
+        async with ClientSession(
+            headers=_create_header()
+        ) as session:
+            async with session.post(
+                f'{cls.url}/api/completions',
+                proxy=proxy,
+                json=_create_payload(messages, **kwargs)
+            ) as response:
+                response.raise_for_status()
+                async for stream in response.content.iter_any():
+                    if stream:
+                        yield stream.decode()
+
+
+def _create_header():
+    return {
+        'accept': '*/*',
+        'content-type': 'application/json',
+    }
+
+
+def _create_payload(messages: Messages, temperature: float = 0.5, **kwargs):
+    return {
+        'key'         : '',
+        'model'       : 'gpt-3.5-turbo',
+        'messages'    : messages,
+        'temperature' : temperature,
+        'password'    : ''
+    }

g4f/Provider/deprecated/AiService.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import requests
+
+from ...typing import Any, CreateResult, Messages
+from ..base_provider import BaseProvider
+
+
+class AiService(BaseProvider):
+    url = "https://aiservice.vercel.app/"
+    working = False
+    supports_gpt_35_turbo = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: Messages,
+        stream: bool,
+        **kwargs: Any,
+    ) -> CreateResult:
+        base = (
+            "\n".join(
+                f"{message['role']}: {message['content']}" for message in messages
+            )
+            + "\nassistant: "
+        )
+        headers = {
+            "accept": "*/*",
+            "content-type": "text/plain;charset=UTF-8",
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            "Referer": "https://aiservice.vercel.app/chat",
+        }
+        data = {"input": base}
+        url = "https://aiservice.vercel.app/api/chat/answer"
+        response = requests.post(url, headers=headers, json=data)
+        response.raise_for_status()
+        yield response.json()["data"]

g4f/Provider/deprecated/Aibn.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import time
+import hashlib
+
+from ...typing import AsyncResult, Messages
+from ...requests import StreamSession
+from ..base_provider import AsyncGeneratorProvider
+
+
+class Aibn(AsyncGeneratorProvider):
+    url = "https://aibn.cc"
+    working = False
+    supports_message_history = True
+    supports_gpt_35_turbo = True
+
+    @classmethod
+    async def create_async_generator(
+        cls,
+        model: str,
+        messages: Messages,
+        proxy: str = None,
+        timeout: int = 120,
+        **kwargs
+    ) -> AsyncResult:
+        async with StreamSession(
+            impersonate="chrome107",
+            proxies={"https": proxy},
+            timeout=timeout
+        ) as session:
+            timestamp = int(time.time())
+            data = {
+                "messages": messages,
+                "pass": None,
+                "sign": generate_signature(timestamp, messages[-1]["content"]),
+                "time": timestamp
+            }
+            async with session.post(f"{cls.url}/api/generate", json=data) as response:
+                response.raise_for_status()
+                async for chunk in response.iter_content():
+                    yield chunk.decode()
+    
+
+def generate_signature(timestamp: int, message: str, secret: str = "undefined"):
+    data = f"{timestamp}:{message}:{secret}"
+    return hashlib.sha256(data.encode()).hexdigest()

g4f/Provider/deprecated/Ails.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import hashlib
+import time
+import uuid
+import json
+from datetime import datetime
+from aiohttp import ClientSession
+
+from ...typing import SHA256, AsyncResult, Messages
+from ..base_provider import AsyncGeneratorProvider
+
+
+class Ails(AsyncGeneratorProvider):
+    url = "https://ai.ls"
+    working = False
+    supports_message_history = True
+    supports_gpt_35_turbo = True
+
+    @staticmethod
+    async def create_async_generator(
+        model: str,
+        messages: Messages,
+        stream: bool,
+        proxy: str = None,
+        **kwargs
+    ) -> AsyncResult:
+        headers = {
+            "authority": "api.caipacity.com",
+            "accept": "*/*",
+            "accept-language": "en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3",
+            "authorization": "Bearer free",
+            "client-id": str(uuid.uuid4()),
+            "client-v": "0.1.278",
+            "content-type": "application/json",
+            "origin": "https://ai.ls",
+            "referer": "https://ai.ls/",
+            "sec-ch-ua": '"Not.A/Brand";v="8", "Chromium";v="114", "Google Chrome";v="114"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "cross-site",
+            "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",
+            "from-url": "https://ai.ls/?chat=1"
+        }
+        async with ClientSession(
+                headers=headers
+            ) as session:
+            timestamp = _format_timestamp(int(time.time() * 1000))
+            json_data = {
+                "model": "gpt-3.5-turbo",
+                "temperature": kwargs.get("temperature", 0.6),
+                "stream": True,
+                "messages": messages,
+                "d": datetime.now().strftime("%Y-%m-%d"),
+                "t": timestamp,
+                "s": _hash({"t": timestamp, "m": messages[-1]["content"]}),
+            }
+            async with session.post(
+                        "https://api.caipacity.com/v1/chat/completions",
+                        proxy=proxy,
+                        json=json_data
+                    ) as response:
+                response.raise_for_status()
+                start = "data: "
+                async for line in response.content:
+                    line = line.decode('utf-8')
+                    if line.startswith(start) and line != "data: [DONE]":
+                        line = line[len(start):-1]
+                        line = json.loads(line)
+                        token = line["choices"][0]["delta"].get("content")
+                        
+                        if token:
+                            if "ai.ls" in token or "ai.ci" in token:
+                                raise Exception(f"Response Error: {token}")
+                            yield token
+
+
+def _hash(json_data: dict[str, str]) -> SHA256:
+    base_string: str = f'{json_data["t"]}:{json_data["m"]}:WI,2rU#_r:r~aF4aJ36[.Z(/8Rv93Rf:{len(json_data["m"])}'
+
+    return SHA256(hashlib.sha256(base_string.encode()).hexdigest())
+
+
+def _format_timestamp(timestamp: int) -> str:
+    e = timestamp
+    n = e % 10
+    r = n + 1 if n % 2 == 0 else n
+    return str(e - n + r)

g4f/Provider/deprecated/Aivvm.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+import requests
+
+from ..base_provider import BaseProvider
+from ...typing import CreateResult, Messages
+from json import dumps
+
+# to recreate this easily, send a post request to https://chat.aivvm.com/api/models
+models = {
+    'gpt-3.5-turbo': {'id': 'gpt-3.5-turbo', 'name': 'GPT-3.5'},
+    'gpt-3.5-turbo-0613': {'id': 'gpt-3.5-turbo-0613', 'name': 'GPT-3.5-0613'},
+    'gpt-3.5-turbo-16k': {'id': 'gpt-3.5-turbo-16k', 'name': 'GPT-3.5-16K'},
+    'gpt-3.5-turbo-16k-0613': {'id': 'gpt-3.5-turbo-16k-0613', 'name': 'GPT-3.5-16K-0613'},
+    'gpt-4': {'id': 'gpt-4', 'name': 'GPT-4'},
+    'gpt-4-0613': {'id': 'gpt-4-0613', 'name': 'GPT-4-0613'},
+    'gpt-4-32k': {'id': 'gpt-4-32k', 'name': 'GPT-4-32K'},
+    'gpt-4-32k-0613': {'id': 'gpt-4-32k-0613', 'name': 'GPT-4-32K-0613'},
+}
+
+class Aivvm(BaseProvider):
+    url                   = 'https://chat.aivvm.com'
+    supports_stream       = True
+    working               = False
+    supports_gpt_35_turbo = True
+    supports_gpt_4        = True
+
+    @classmethod
+    def create_completion(cls,
+        model: str,
+        messages: Messages,
+        stream: bool,
+        **kwargs
+    ) -> CreateResult:
+        if not model:
+            model = "gpt-3.5-turbo"
+        elif model not in models:
+            raise ValueError(f"Model is not supported: {model}")
+
+        json_data = {
+            "model"       : models[model],
+            "messages"    : messages,
+            "key"         : "",
+            "prompt"      : kwargs.get("system_message", "You are ChatGPT, a large language model trained by OpenAI. Follow the user's instructions carefully. Respond using markdown."),
+            "temperature" : kwargs.get("temperature", 0.7)
+        }
+
+        data = dumps(json_data)
+
+        headers = {
+            "accept"            : "text/event-stream",
+            "accept-language"   : "en-US,en;q=0.9",
+            "content-type"      : "application/json",
+            "content-length"    : str(len(data)),
+            "sec-ch-ua"         : "\"Chrome\";v=\"117\", \"Not;A=Brand\";v=\"8\", \"Chromium\";v=\"117\"",
+            "sec-ch-ua-mobile"  : "?0",
+            "sec-ch-ua-platform": "\"Windows\"",
+            "sec-fetch-dest"    : "empty",
+            "sec-fetch-mode"    : "cors",
+            "sec-fetch-site"    : "same-origin",
+            "sec-gpc"           : "1",
+            "referrer"          : "https://chat.aivvm.com/",
+            "user-agent"        : "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36"
+        }
+
+        response = requests.post("https://chat.aivvm.com/api/chat", headers=headers, data=data, stream=True)
+        response.raise_for_status()
+
+        for chunk in response.iter_content(chunk_size=4096):
+            try:
+                yield chunk.decode("utf-8")
+            except UnicodeDecodeError:
+                yield chunk.decode("unicode-escape")

g4f/Provider/deprecated/ChatgptDuo.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from ...typing import Messages
+from curl_cffi.requests import AsyncSession
+from ..base_provider import AsyncProvider, format_prompt
+
+
+class ChatgptDuo(AsyncProvider):
+    url                   = "https://chatgptduo.com"
+    supports_gpt_35_turbo = True
+    working               = False
+
+    @classmethod
+    async def create_async(
+        cls,
+        model: str,
+        messages: Messages,
+        proxy: str = None,
+        timeout: int = 120,
+        **kwargs
+    ) -> str:
+        async with AsyncSession(
+            impersonate="chrome107",
+            proxies={"https": proxy},
+            timeout=timeout
+        ) as session:
+            prompt = format_prompt(messages),
+            data = {
+                "prompt": prompt,
+                "search": prompt,
+                "purpose": "ask",
+            }
+            response = await session.post(f"{cls.url}/", data=data)
+            response.raise_for_status()
+            data = response.json()
+
+            cls._sources = [{
+                "title": source["title"],
+                "url": source["link"],
+                "snippet": source["snippet"]
+            } for source in data["results"]]
+
+            return data["answer"]
+
+    @classmethod
+    def get_sources(cls):
+        return cls._sources