Add auto support params method

g4f/Provider/AItianhu.py

@@ -71,21 +71,8 @@ class AItianhu(AsyncGeneratorProvider):
 
                     if "detail" not in line:
                         raise RuntimeError(f"Response: {line}")
-                    
-                    content = line["detail"]["choices"][0]["delta"].get("content")
-                    if content:
-                        yield content
 
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("proxy", "str"),
-            ("temperature", "float"),
-            ("top_p", "int"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
+                    if content := line["detail"]["choices"][0]["delta"].get(
+                        "content"
+                    ):
+                        yield content

g4f/Provider/ChatBase.py

@@ -58,15 +58,4 @@ class ChatBase(AsyncGeneratorProvider):
                     for incorrect_response in cls.list_incorrect_responses:
                         if incorrect_response in response_data:
                             raise RuntimeError("Incorrect response")
-                    yield stream.decode()
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
+                    yield stream.decode()

g4f/Provider/ChatForAi.py

@@ -57,16 +57,6 @@ class ChatForAi(AsyncGeneratorProvider):
                         raise RuntimeError(f"Response: {chunk.decode()}")
                     yield chunk.decode()
 
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
     
 def generate_signature(timestamp: int, message: str, id: str):
     buffer = f"{timestamp}:{id}:{message}:7YN8z6d6"

g4f/Provider/FreeGpt.py

@@ -47,16 +47,6 @@ class FreeGpt(AsyncGeneratorProvider):
                         raise RuntimeError("Rate limit reached")
                     yield chunk
 
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
     
 def generate_signature(timestamp: int, message: str, secret: str = ""):
     data = f"{timestamp}:{message}:{secret}"

g4f/Provider/GeekGpt.py

@@ -70,16 +70,4 @@ class GeekGpt(BaseProvider):
                     raise RuntimeError(f'error | {e} :', json_data)
                 
                 if content:
-                    yield content
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ('model', 'str'),
-            ('messages', 'list[dict[str, str]]'),
-            ('stream', 'bool'),
-            ('temperature', 'float'),
-        ]
-        param = ', '.join([': '.join(p) for p in params])
-        return f'g4f.provider.{cls.__name__} supports: ({param})'
+                    yield content

g4f/Provider/GptGo.py

@@ -62,21 +62,5 @@ class GptGo(AsyncGeneratorProvider):
                         line = json.loads(line[len(start):-1])
                         if line["choices"][0]["finish_reason"] == "stop":
                             break
-                        
-                        content = line["choices"][0]["delta"].get("content"):
-                        if content:
-                            yield content
-
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("proxy", "str"),
-            ("temperature", "float"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
+                        if content := line["choices"][0]["delta"].get("content"):
+                            yield content

g4f/Provider/Liaobots.py

@@ -97,17 +97,3 @@ class Liaobots(AsyncGeneratorProvider):
                 async for stream in response.content.iter_any():
                     if stream:
                         yield stream.decode()
-
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("proxy", "str"),
-            ("auth", "str"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/Opchatgpts.py

@@ -56,16 +56,4 @@ class Opchatgpts(AsyncGeneratorProvider):
                         if line["type"] == "live":
                             yield line["data"]
                         elif line["type"] == "end":
-                            break
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("proxy", "str"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
+                            break

g4f/Provider/Ylokh.py

@@ -55,21 +55,4 @@ class Ylokh(AsyncGeneratorProvider):
                                 yield content
                 else:
                     chat = await response.json()
-                    yield chat["choices"][0]["message"].get("content")
-
-
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("proxy", "str"),
-            ("timeout", "int"),
-            ("temperature", "float"),
-            ("top_p", "float"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
+                    yield chat["choices"][0]["message"].get("content")

g4f/Provider/base_provider.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 from asyncio import AbstractEventLoop
 from concurrent.futures import ThreadPoolExecutor
 from abc import ABC, abstractmethod
+from inspect import signature, Parameter
+from types import NoneType
 
 from .helper import get_event_loop, get_cookies, format_prompt
 from ..typing import CreateResult, AsyncResult, Messages
@@ -52,17 +54,42 @@ class BaseProvider(ABC):
             executor,
             create_func
         )
-
+    
     @classmethod
     @property
     def params(cls) -> str:
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
+        if issubclass(cls, AsyncGeneratorProvider):
+            sig = signature(cls.create_async_generator)
+        elif issubclass(cls, AsyncProvider):
+            sig = signature(cls.create_async)
+        else:
+            sig = signature(cls.create_completion)
+
+        def get_type_name(annotation: type) -> str:
+            if hasattr(annotation, "__name__"):
+                annotation = annotation.__name__
+            elif isinstance(annotation, NoneType):
+                annotation = "None"
+            return str(annotation)
+        
+        args = "";
+        for name, param in sig.parameters.items():
+            if name in ("self", "kwargs"):
+                continue
+            if name == "stream" and not cls.supports_stream:
+                continue
+            if args:
+                args += ", "
+            args += "\n"
+            args += "    " + name
+            if name != "model" and param.annotation is not Parameter.empty:
+                args += f": {get_type_name(param.annotation)}"
+            if param.default == "":
+                args += ' = ""'
+            elif param.default is not Parameter.empty:
+                args += f" = {param.default}"
+        
+        return f"g4f.Provider.{cls.__name__} supports: ({args}\n)"
 
 
 class AsyncProvider(BaseProvider):

g4f/Provider/deprecated/Aibn.py

@@ -39,18 +39,6 @@ class Aibn(AsyncGeneratorProvider):
                 response.raise_for_status()
                 async for chunk in response.iter_content():
                     yield chunk.decode()
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("temperature", "float"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
     
 
 def generate_signature(timestamp: int, message: str, secret: str = "undefined"):

g4f/Provider/deprecated/Ails.py

@@ -77,19 +77,6 @@ class Ails(AsyncGeneratorProvider):
                             yield token
 
 
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("temperature", "float"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
-
-
 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"])}'
 

g4f/Provider/deprecated/Aivvm.py

@@ -69,16 +69,4 @@ class Aivvm(BaseProvider):
             try:
                 yield chunk.decode("utf-8")
             except UnicodeDecodeError:
-                yield chunk.decode("unicode-escape")
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ('model', 'str'),
-            ('messages', 'list[dict[str, str]]'),
-            ('stream', 'bool'),
-            ('temperature', 'float'),
-        ]
-        param = ', '.join([': '.join(p) for p in params])
-        return f'g4f.provider.{cls.__name__} supports: ({param})'
+                yield chunk.decode("unicode-escape")

g4f/Provider/deprecated/ChatgptDuo.py

@@ -44,15 +44,4 @@ class ChatgptDuo(AsyncProvider):
 
     @classmethod
     def get_sources(cls):
-        return cls._sources
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
+        return cls._sources

g4f/Provider/deprecated/CodeLinkAva.py

@@ -47,17 +47,4 @@ class CodeLinkAva(AsyncGeneratorProvider):
                             break
                         line = json.loads(line[6:-1])
                         if content := line["choices"][0]["delta"].get("content"):
-                            yield content
-
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("temperature", "float"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
+                            yield content

g4f/Provider/deprecated/DfeHub.py

@@ -60,18 +60,3 @@ class DfeHub(BaseProvider):
             if b"content" in chunk:
                 data = json.loads(chunk.decode().split("data: ")[1])
                 yield (data["choices"][0]["delta"]["content"])
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("temperature", "float"),
-            ("presence_penalty", "int"),
-            ("frequency_penalty", "int"),
-            ("top_p", "int"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/deprecated/EasyChat.py

@@ -87,21 +87,4 @@ class EasyChat(BaseProvider):
                     splitData = chunk.decode().split("data:")
 
                     if len(splitData) > 1:
-                        yield json.loads(splitData[1])["choices"][0]["delta"]["content"]
-
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("temperature", "float"),
-            ("presence_penalty", "int"),
-            ("frequency_penalty", "int"),
-            ("top_p", "int"),
-            ("active_server", "int"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
+                        yield json.loads(splitData[1])["choices"][0]["delta"]["content"]

g4f/Provider/deprecated/Equing.py

@@ -66,15 +66,4 @@ class Equing(BaseProvider):
                 if b'content' in line:
                     line_json = json.loads(line.decode('utf-8').split('data: ')[1])
                     if token := line_json['choices'][0]['delta'].get('content'):
-                        yield token
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
+                        yield token

g4f/Provider/deprecated/FastGpt.py

@@ -74,15 +74,4 @@ class FastGpt(BaseProvider):
                         ):
                             yield token
                 except:
-                    continue
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
+                    continue

g4f/Provider/deprecated/GetGpt.py

@@ -55,22 +55,6 @@ class GetGpt(BaseProvider):
                 line_json = json.loads(line.decode('utf-8').split('data: ')[1])
                 yield (line_json['choices'][0]['delta']['content'])
 
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ('model', 'str'),
-            ('messages', 'list[dict[str, str]]'),
-            ('stream', 'bool'),
-            ('temperature', 'float'),
-            ('presence_penalty', 'int'),
-            ('frequency_penalty', 'int'),
-            ('top_p', 'int'),
-            ('max_tokens', 'int'),
-        ]
-        param = ', '.join([': '.join(p) for p in params])
-        return f'g4f.provider.{cls.__name__} supports: ({param})'
-
 
 def _encrypt(e: str):
     t = os.urandom(8).hex().encode('utf-8')

g4f/Provider/deprecated/H2o.py

@@ -86,22 +86,4 @@ class H2o(AsyncGeneratorProvider):
                 f"{cls.url}/conversation/{conversationId}",
                 proxy=proxy,
             ) as response:
-                response.raise_for_status()
-
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("temperature", "float"),
-            ("truncate", "int"),
-            ("max_new_tokens", "int"),
-            ("do_sample", "bool"),
-            ("repetition_penalty", "float"),
-            ("return_full_text", "bool"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
+                response.raise_for_status()

g4f/Provider/deprecated/Lockchat.py

@@ -48,16 +48,4 @@ class Lockchat(BaseProvider):
             if b"content" in token:
                 token = json.loads(token.decode("utf-8").split("data: ")[1])
                 if token := token["choices"][0]["delta"].get("content"):
-                    yield (token)
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("temperature", "float"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
+                    yield (token)

g4f/Provider/deprecated/Myshell.py

@@ -98,18 +98,6 @@ class Myshell(AsyncGeneratorProvider):
                         raise RuntimeError(f"Received unexpected message: {data_type}")
 
 
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
-
-
 def generate_timestamp() -> str:
     return str(
         int(

g4f/Provider/deprecated/V50.py

@@ -58,17 +58,4 @@ class V50(BaseProvider):
         )
 
         if "https://fk1.v50.ltd" not in response.text:
-            yield response.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})"
+            yield response.text

g4f/Provider/deprecated/Vitalentum.py

@@ -50,18 +50,4 @@ class Vitalentum(AsyncGeneratorProvider):
                             break
                         line = json.loads(line[6:-1])
                         if content := line["choices"][0]["delta"].get("content"):
-                            yield content
-
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("proxy", "str"),
-            ("temperature", "float"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
+                            yield content

g4f/Provider/deprecated/Wuguokai.py

@@ -54,15 +54,4 @@ class Wuguokai(BaseProvider):
         if len(_split) > 1:
             yield _split[1].strip()
         else:
-            yield _split[0].strip()
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool")
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
+            yield _split[0].strip()