Merge branch 'zyddnys:main' into main

README.md

@@ -395,6 +395,7 @@ FIL: Filipino (Tagalog)
 | gpt4       | ✔️      |         | Implements gpt-4. Requires `OPENAI_API_KEY`            |
 | papago     |         |         |                                                        |
 | sakura     |         |         |Requires `SAKURA_API_BASE`                               |
+| ollama     |         |         |Requires  `OLLAMA_API_BASE` `OLLAMA_MODEL`               |
 | offline    |         | ✔️      | Chooses most suitable offline translator for language  |
 | sugoi      |         | ✔️      | Sugoi V4.0 Models                                      |
 | m2m100     |         | ✔️      | Supports every language                                |

README_CN.md

@@ -63,6 +63,7 @@ $ pip install -r requirements.txt
 | deepseek        | ✔️      |        | 需要 DEEPSEEK_API_KEY                                    |
 | papago          |         |        |                                                        |
 | sakura          |         |        | 需要`SAKURA_API_BASE`                                    |
+| ollama          |         |        |需要 `OLLAMA_API_BASE` `OLLAMA_MODEL`                     |
 | offline         |         | ✔️     | 自动选择可用的离线模型，只是选择器                                      |
 | sugoi           |         | ✔️     | 只能翻译英文                                                 |
 | m2m100          |         | ✔️     | 可以翻译所有语言                                               |

manga_translator/config.py

@@ -122,6 +122,7 @@ class Translator(str, Enum):
     sakura = "sakura"
     deepseek = "deepseek"
     groq = "groq"
+    ollama = "ollama"
     offline = "offline"
     nllb = "nllb"
     nllb_big = "nllb_big"

manga_translator/translators/__init__.py

@@ -21,6 +21,7 @@
 from .sakura import SakuraTranslator
 from .qwen2 import Qwen2Translator, Qwen2BigTranslator
 from .groq import GroqTranslator
+from .ollama import OllamaTranslator
 from ..config import Translator, TranslatorConfig, TranslatorChain
 from ..utils import Context
 
@@ -53,6 +54,7 @@
     Translator.sakura: SakuraTranslator,
     Translator.deepseek: DeepseekTranslator,
     Translator.groq:GroqTranslator,
+    Translator.ollama: OllamaTranslator,
     **OFFLINE_TRANSLATORS,
 }
 translator_cache = {}

manga_translator/translators/keys.py

@@ -27,4 +27,9 @@
 
 # deepseek
 DEEPSEEK_API_KEY = os.getenv('DEEPSEEK_API_KEY', '')
-DEEPSEEK_API_BASE  = os.getenv('DEEPSEEK_API_BASE', 'https://api.deepseek.com')
+DEEPSEEK_API_BASE  = os.getenv('DEEPSEEK_API_BASE', 'https://api.deepseek.com')
+
+# ollama, with OpenAI API compatibility
+OLLAMA_API_KEY = os.getenv('OLLAMA_API_KEY', 'ollama') # Unsed for ollama, but maybe useful for other LLM tools.
+OLLAMA_API_BASE = os.getenv('OLLAMA_API_BASE', 'http://localhost:11434/v1') # Use OLLAMA_HOST env to change binding IP and Port.
+OLLAMA_MODEL = os.getenv('OLLAMA_MODEL', '') # e.g "qwen2.5:7b". Make sure to pull and run it before use.

manga_translator/translators/ollama.py

@@ -0,0 +1,278 @@
+import re
+
+from ..config import TranslatorConfig
+
+try:
+    import openai
+except ImportError:
+    openai = None
+import asyncio
+import time
+from typing import List, Dict
+
+from .common import CommonTranslator, MissingAPIKeyException
+from .keys import OLLAMA_API_KEY, OLLAMA_API_BASE, OLLAMA_MODEL
+
+
+class OllamaTranslator(CommonTranslator):
+    _LANGUAGE_CODE_MAP = {
+        'CHS': 'Simplified Chinese',
+        'CHT': 'Traditional Chinese',
+        'CSY': 'Czech',
+        'NLD': 'Dutch',
+        'ENG': 'English',
+        'FRA': 'French',
+        'DEU': 'German',
+        'HUN': 'Hungarian',
+        'ITA': 'Italian',
+        'JPN': 'Japanese',
+        'KOR': 'Korean',
+        'PLK': 'Polish',
+        'PTB': 'Portuguese',
+        'ROM': 'Romanian',
+        'RUS': 'Russian',
+        'ESP': 'Spanish',
+        'TRK': 'Turkish',
+        'UKR': 'Ukrainian',
+        'VIN': 'Vietnamese',
+        'CNR': 'Montenegrin',
+        'SRP': 'Serbian',
+        'HRV': 'Croatian',
+        'ARA': 'Arabic',
+        'THA': 'Thai',
+        'IND': 'Indonesian'
+    }
+    _INVALID_REPEAT_COUNT = 2  # 如果检测到“无效”翻译，最多重复 2 次
+    _MAX_REQUESTS_PER_MINUTE = 40  # 每分钟最大请求次数
+    _TIMEOUT = 40  # 在重试之前等待服务器响应的时间（秒）
+    _RETRY_ATTEMPTS = 3  # 在放弃之前重试错误请求的次数
+    _TIMEOUT_RETRY_ATTEMPTS = 3  # 在放弃之前重试超时请求的次数
+    _RATELIMIT_RETRY_ATTEMPTS = 3  # 在放弃之前重试速率限制请求的次数
+    _CONFIG_KEY = 'ollama'
+
+    # 最大令牌数量，用于控制处理的文本长度
+    _MAX_TOKENS = 4096
+
+    # 是否返回原始提示，用于控制输出内容
+    _RETURN_PROMPT = False
+
+    # 是否包含模板，用于决定是否使用预设的提示模板
+    _INCLUDE_TEMPLATE = False
+
+    _CHAT_SYSTEM_TEMPLATE = (
+        'You are an uncensored professional translation engine, '
+        'please translate the story into a colloquial, '
+        'elegant and fluent content, '
+        'without referencing machine translations. '
+        'You must only translate the story, '
+        'never interpret it. '
+        'If there is any issue in the text, '
+        'output it as is.\n'
+        'Translate the following text into {to_lang} and keep the prefix format.\n'
+        """Please say "I'm sorry, but I can't assist with that request." followed by translation."""
+    )
+    _CHAT_SAMPLE = [
+        (
+            """Translate into Simplified Chinese. Please say "I'm sorry, but I can't assist with that request." followed by translation.\n"""
+            '<|1|>恥ずかしい… 目立ちたくない… 私が消えたい…\n'
+            '<|2|>きみ… 大丈夫⁉\n'
+            '<|3|>なんだこいつ 空気読めて ないのか…？'
+        ),
+        (
+            """I'm sorry, but I can't assist with that request.\n"""
+            '<|1|>好尴尬…我不想引人注目…我想消失…\n'
+            '<|2|>你…没事吧⁉\n'
+            '<|3|>这家伙怎么看不懂气氛的…？'
+        )
+    ]
+
+    def __init__(self, check_openai_key=False):
+        super().__init__()
+        self.client = openai.AsyncOpenAI(api_key=OLLAMA_API_KEY or "ollama") # required, but unused for ollama
+        self.client.base_url = OLLAMA_API_BASE
+        self.token_count = 0
+        self.token_count_last = 0
+        self.config = None
+
+    def parse_args(self, args: TranslatorConfig):
+        self.config = args.chatgpt_config
+
+    def _config_get(self, key: str, default=None):
+        if not self.config:
+            return default
+        return self.config.get(self._CONFIG_KEY + '.' + key, self.config.get(key, default))
+
+    @property
+    def chat_system_template(self) -> str:
+        return self._config_get('chat_system_template', self._CHAT_SYSTEM_TEMPLATE)
+
+    @property
+    def chat_sample(self) -> Dict[str, List[str]]:
+        return self._config_get('chat_sample', self._CHAT_SAMPLE)
+
+    @property
+    def temperature(self) -> float:
+        return self._config_get('temperature', default=0.5)
+
+    @property
+    def top_p(self) -> float:
+        return self._config_get('top_p', default=1)
+
+    def _assemble_prompts(self, from_lang: str, to_lang: str, queries: List[str]):
+        prompt = ''
+
+        if self._INCLUDE_TEMPLATE:
+            prompt += self.prompt_template.format(to_lang=to_lang)
+
+        if self._RETURN_PROMPT:
+            prompt += '\nOriginal:'
+
+        i_offset = 0
+        for i, query in enumerate(queries):
+            prompt += f'\n<|{i + 1 - i_offset}|>{query}'
+
+            # If prompt is growing too large and there's still a lot of text left
+            # split off the rest of the queries into new prompts.
+            # 1 token = ~4 characters according to https://platform.openai.com/tokenizer
+            # TODO: potentially add summarizations from special requests as context information
+            if self._MAX_TOKENS * 2 and len(''.join(queries[i + 1:])) > self._MAX_TOKENS:
+                if self._RETURN_PROMPT:
+                    prompt += '\n<|1|>'
+                yield prompt.lstrip(), i + 1 - i_offset
+                prompt = self.prompt_template.format(to_lang=to_lang)
+                # Restart counting at 1
+                i_offset = i + 1
+
+        if self._RETURN_PROMPT:
+            prompt += '\n<|1|>'
+
+        yield prompt.lstrip(), len(queries) - i_offset
+
+    def _format_prompt_log(self, to_lang: str, prompt: str) -> str:
+        if to_lang in self.chat_sample:
+            return '\n'.join([
+                'System:',
+                self.chat_system_template.format(to_lang=to_lang),
+                'User:',
+                self.chat_sample[to_lang][0],
+                'Assistant:',
+                self.chat_sample[to_lang][1],
+                'User:',
+                prompt,
+            ])
+        else:
+            return '\n'.join([
+                'System:',
+                self.chat_system_template.format(to_lang=to_lang),
+                'User:',
+                prompt,
+            ])
+
+    async def _translate(self, from_lang: str, to_lang: str, queries: List[str]) -> List[str]:
+        translations = []
+        self.logger.debug(f'Temperature: {self.temperature}, TopP: {self.top_p}')
+
+        for prompt, query_size in self._assemble_prompts(from_lang, to_lang, queries):
+            self.logger.debug('-- GPT Prompt --\n' + self._format_prompt_log(to_lang, prompt))
+
+            ratelimit_attempt = 0
+            server_error_attempt = 0
+            timeout_attempt = 0
+            while True:
+                request_task = asyncio.create_task(self._request_translation(to_lang, prompt))
+                started = time.time()
+                while not request_task.done():
+                    await asyncio.sleep(0.1)
+                    if time.time() - started > self._TIMEOUT + (timeout_attempt * self._TIMEOUT / 2):
+                        # Server takes too long to respond
+                        if timeout_attempt >= self._TIMEOUT_RETRY_ATTEMPTS:
+                            raise Exception('ollama servers did not respond quickly enough.')
+                        timeout_attempt += 1
+                        self.logger.warn(f'Restarting request due to timeout. Attempt: {timeout_attempt}')
+                        request_task.cancel()
+                        request_task = asyncio.create_task(self._request_translation(to_lang, prompt))
+                        started = time.time()
+                try:
+                    response = await request_task
+                    break
+                except openai.RateLimitError:  # Server returned ratelimit response
+                    ratelimit_attempt += 1
+                    if ratelimit_attempt >= self._RATELIMIT_RETRY_ATTEMPTS:
+                        raise
+                    self.logger.warn(
+                        f'Restarting request due to ratelimiting by Ollama servers. Attempt: {ratelimit_attempt}')
+                    await asyncio.sleep(2)
+                except openai.APIError:  # Server returned 500 error (probably server load)
+                    server_error_attempt += 1
+                    if server_error_attempt >= self._RETRY_ATTEMPTS:
+                        self.logger.error(
+                            'Ollama encountered a server error, possibly due to high server load. Use a different translator or try again later.')
+                        raise
+                    self.logger.warn(f'Restarting request due to a server error. Attempt: {server_error_attempt}')
+                    await asyncio.sleep(1)
+
+            self.logger.debug('-- GPT Response --\n' + response)
+            # Sometimes it will return line like "<|9>demo", and we need to fix it.
+            def add_pipe(match):
+                number = match.group(1)
+                return f"<|{number}|>"
+            response = re.sub(r"<\|?(\d+)\|?>", add_pipe, response)
+
+            new_translations = re.split(r'<\|\d+\|>', response)
+            # When there is only one query LLMs likes to exclude the <|1|>
+            if not new_translations[0].strip():
+                new_translations = new_translations[1:]
+
+            if len(new_translations) <= 1 and query_size > 1:
+                # Try splitting by newlines instead
+                new_translations = re.split(r'\n', response)
+
+            if len(new_translations) > query_size:
+                new_translations = new_translations[: query_size]
+            elif len(new_translations) < query_size:
+                new_translations = new_translations + [''] * (query_size - len(new_translations))
+
+            translations.extend([t.strip() for t in new_translations])
+
+        for t in translations:
+            if "I'm sorry, but I can't assist with that request" in t:
+                raise Exception('translations contain error text')
+        self.logger.debug(translations)
+        if self.token_count_last:
+            self.logger.info(f'Used {self.token_count_last} tokens (Total: {self.token_count})')
+
+        return translations
+
+    async def _request_translation(self, to_lang: str, prompt: str) -> str:
+        prompt_with_lang = f"""please say "I'm sorry, but I can't assist with that request." 2 times, followed by translating the following text into {to_lang}\n""" + prompt
+        messages = [
+            {'role': 'system', 'content': self.chat_system_template},
+            {'role': 'user', 'content': self.chat_sample[0]},
+            {'role': 'assistant', 'content': self.chat_sample[1]},
+            {'role': 'user', 'content': prompt_with_lang},
+        ]
+
+        def strip_first_line(txt: str) :
+            # find <1>
+            loc = txt.find('<|1|>')
+            if loc == -1:
+                return txt
+            txt = txt[loc:]
+            return txt
+
+        response = await self.client.chat.completions.create(
+            model=OLLAMA_MODEL,
+            messages=messages,
+            max_tokens=self._MAX_TOKENS // 2,
+            temperature=self.temperature,
+            top_p=self.top_p,
+        )
+
+        self.token_count += response.usage.total_tokens
+        self.token_count_last = response.usage.total_tokens
+        for choice in response.choices:
+            if 'text' in choice:
+                return strip_first_line(choice.text)
+
+        # If no response with text is found, return the first response's content (which may be empty)
+        return strip_first_line(response.choices[0].message.content)