使用谷歌免费翻译有概率出现漏翻以及输出空字符情况。

[994834669]

我的两台设备都出现了这样的情况，一个电信网、一个移动网

[R0sin]

猜测可能是 RenPy 版本兼容性导致的抽取问题，测试可以通过以下步骤解决一部分漏翻问题：

1. 使用官方最新的 sdk 替代工具里的官方翻译步骤，具体可以参考作者说明里之前删除的部分。
2. 生成翻译文件之后可以把工具一键翻译中的官方抽取勾选去掉后跑一遍即可。

[994834669]

猜测可能是 RenPy 版本兼容性导致的抽取问题，测试可以通过以下步骤解决一部分漏翻问题：

1. 使用官方最新的 sdk 替代工具里的官方翻译步骤，具体可以参考作者说明里之前删除的部分。
2. 生成翻译文件之后可以把工具一键翻译中的官方抽取勾选去掉后跑一遍即可。

还是会出现问题，看来应该是该软件提供谷歌翻译api不稳定导致的

[R0sin]

猜测可能是 RenPy 版本兼容性导致的抽取问题，测试可以通过以下步骤解决一部分漏翻问题：

1. 使用官方最新的 sdk 替代工具里的官方翻译步骤，具体可以参考作者说明里之前删除的部分。
2. 生成翻译文件之后可以把工具一键翻译中的官方抽取勾选去掉后跑一遍即可。

还是会出现问题，看来应该是该软件提供谷歌翻译api不稳定导致的

我抓包看了下确实是谷歌翻译接口中返回了大量空白，搜了下相关帖子可能是谷歌免费接口降级限制了白嫖行为。后面再看看有没有什么好的翻译引擎替代。

[R0sin]

现在偶尔翻译长文本时还是有遇到漏翻现象，之前用 AI 把代码中用到的谷歌翻译功能提取出来作为独立的脚本调用，作为备用方案试了几次好像都没问题，这里分享下。
脚本功能主要是为了控制单次调用 API 翻译的分片大小和间隔来提高整体翻译成功率（目前设置的 max_batch_size 单次调用翻译 100 条，调用间隔 1s），如果有兴趣的话可以尝试下。
脚本的配置方法参照官方文档，源和目标配置文件选择原本的 google.*.rst 即可。配置完之后记得在翻译界面切换翻译引擎。

def get_max_length():
    """
    Defines the maximum character length of a text chunk that CustomTranslate
    will pass to translate_queue. The _GoogleTranslate class inside
    translate_queue will handle further batching by item count.
    Google Translate has a general limit of ~5000 chars per query, but
    batching allows more. This value is for CustomTranslate's initial split.
    """
    return 10000000

def translate_single(app_key, app_secret, source, target, proxies, text):
    """
    This function is not used for Google Translate with batching.
    CustomTranslate will call translate_queue if is_queue is True.
    """
    pass

def translate_queue(app_key, app_secret, source_lang_code, target_lang_code, proxies_config, q_list):
    """
    Translates a list of texts using a Google Translate-like API.

    Args:
        app_key: API key (ignored for this Google Translate implementation).
        app_secret: API secret (ignored for this Google Translate implementation).
        source_lang_code: Source language code (e.g., 'en', 'auto').
        target_lang_code: Target language code (e.g., 'es', 'zh-CN').
        proxies_config: Dictionary of proxies to use for requests.
        q_list: A list of strings to translate.

    Returns:
        A list of dictionaries, where each dictionary has:
        {'untranslatedText': original_text, 'translatedText': translated_text}
        Returns an empty list or partially filled list on errors.
    """
    # --- All imports must be inside this function for dynamic loading ---
    import random
    import time
    import base64
    from typing import List, Union, Dict # Removed overload as it's for static analysis

    import requests
    try:
        import json # For json.JSONDecodeError
    except ImportError:
        # Fallback for environments where json might be part of a different module
        # This is highly unlikely in modern Python but as a safeguard.
        import sys
        if sys.version_info < (2, 6):
            import simplejson as json
        else:
            import json


    # --- Helper Classes (Integrated and adapted from the provided google_translate.py) ---
    class Null:
        """Represents a failed API call result."""
        def __init__(self, response: requests.Response):
            self.response = response
            status_code_lookup = getattr(requests.status_codes, '_codes', {})
            if not status_code_lookup and hasattr(requests.status_codes, 'codes'):
                status_code_lookup = {v: [k.upper()] for k, v in requests.status_codes.codes.items()}

            status_code_str_list = status_code_lookup.get(self.response.status_code, ["Unknown Status Code"])
            status_code_str = status_code_str_list[0] if status_code_str_list else "Unknown Status Code"
            
            try:
                response_text = self.response.text
            except Exception:
                response_text = self.response.content.decode('utf-8', errors='replace') if self.response.content else ""
            self.msg = f'{self.response.status_code}: {status_code_str}\n{response_text[:500]}' # Limit error message length

        def __repr__(self):
            return self.msg

    class _InternalTranslateResponse:
        """Internal representation of a translation result."""
        def __init__(self, translatedText: str, detectedSourceLanguage: str = None, model: str = None):
            self.translatedText = translatedText
            self.detectedSourceLanguage = detectedSourceLanguage
            self.model = model

        def __repr__(self):
            return self.__class__.__qualname__ + f'(translatedText={repr(self.translatedText)}, detectedSourceLanguage={repr(self.detectedSourceLanguage)}, model={repr(self.model)})'

    class _GoogleTranslate:
        """
        Handles the actual translation calls, adapted from the provided google_translate.py.
        """
        def __init__(
                self,
                target: str = 'zh-CN',
                source: str = 'auto',
                fmt: str = 'text', # Changed default to 'text'
                user_agent: str = None,
                domain: str = 'com',
                proxies: Dict = None,
                timeout: int = 10, # Default timeout for requests
                max_batch_size: int = 100 # Number of strings per API call
        ):
            self.target = target
            self.source = source
            self.fmt = fmt
            self.timeout = timeout
            self.max_batch_size = max_batch_size

            if user_agent is None:
                try:
                    random_android_version = random.randint(8, 13) # Adjusted upper bound
                    random_build_number = random.randint(10, 99)
                    random_sub_version = random.randint(100000000, 999999999)
                    random_device_model_part = base64.b64encode(str(random.random())[2:10].encode()).decode().rstrip('=')
                    user_agent = (
                        f'GoogleTranslate/6.{random_build_number}.0.06.{random_sub_version}'
                        f' (Linux; U; Android {random_android_version}; {random_device_model_part})'
                    )
                except Exception: # Fallback user agent
                    user_agent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'

            self.session = requests.Session()
            self.session.headers = {'User-Agent': user_agent}
            self.BASE_URL: str = 'https://translate.google.' + domain
            self.TRANSLATE_URL: str = f'{self.BASE_URL}/translate_a/t' # Using /t endpoint

            if proxies is not None:
                self.session.trust_env = False # Important when using custom proxies
                self.session.proxies = proxies

        def translate(
                self, q: List[str], target: str = None, source: str = None, fmt: str = None, timeout=...
        ) -> Union[List[_InternalTranslateResponse], Null]:
            if not q: return [] # Input is always a list for translate_queue

            texts_to_translate = q # q is already a list of strings
            if not texts_to_translate: return []

            all_translated_responses: List[_InternalTranslateResponse] = []
            current_timeout = timeout if timeout is not ... else self.timeout

            for i in range(0, len(texts_to_translate), self.max_batch_size):
                batch = texts_to_translate[i:i + self.max_batch_size]
                if not batch: continue

                # Filter out any non-string or purely empty items from batch if necessary,
                # though Google API might handle empty strings by returning empty translations.
                # current_batch = [s for s in batch if isinstance(s, str) and s.strip()]
                # if not current_batch: continue
                # For now, send as is, Google API usually handles empty strings in batch.
                current_batch = batch

                batch_params = {
                    'tl': target if target is not None else self.target,
                    'sl': source if source is not None else self.source,
                    'ie': 'UTF-8', 'oe': 'UTF-8', 'client': 'at',
                    'dj': '1', # Request JSON output with details
                    'format': fmt if fmt is not None else self.fmt,
                    'v': '1.0' # As in original pygtrans for /t endpoint
                }
                
                response = None
                time.sleep(1) # API call interval: 1 second
                for attempt in range(1, 4): # Retry logic
                    try:
                        response = self.session.post(
                            self.TRANSLATE_URL, params=batch_params,
                            data={'q': current_batch}, timeout=current_timeout # Send list as 'q' data
                        )
                        if response.status_code == 429: # Too Many Requests
                            if attempt == 3: return Null(response)
                            time.sleep(5 * attempt); continue
                        elif response.status_code == 200: break 
                        else: # Other non-200 status codes are errors for this batch
                            return Null(response) 
                    except requests.exceptions.RequestException as e:
                        if attempt == 3:
                            err_resp = requests.Response(); err_resp.status_code = 0; err_resp.reason = str(e)
                            err_resp._content = str(e).encode(); return Null(err_resp)
                        time.sleep(5 * attempt)
                
                if response is None or response.status_code != 200:
                    return Null(response if response is not None else requests.Response())

                try:
                    json_data = response.json()
                    batch_items_translated = []

                    if isinstance(json_data, dict) and 'sentences' in json_data and isinstance(json_data['sentences'], list):
                        src_lang_detected_batch = json_data.get('src')
                        for sent_data in json_data['sentences']:
                            if isinstance(sent_data, dict) and 'trans' in sent_data:
                                batch_items_translated.append(
                                    _InternalTranslateResponse(sent_data['trans'], detectedSourceLanguage=src_lang_detected_batch)
                                )
                            else: # Malformed item in sentences list
                                err_resp = response; err_resp.status_code = 500
                                err_resp._content = f"Malformed sentence data in API response (dj=1 structure). Item: {str(sent_data)[:100]}".encode('utf-8', 'replace')
                                return Null(err_resp)
                        all_translated_responses.extend(batch_items_translated)
                    
                    # Fallback for simpler list-based JSON (less likely with dj=1 for /t)
                    elif isinstance(json_data, list):
                        # This logic assumes a simpler response if dj=1 is ignored or for other endpoints.
                        # For /t with dj=1, the dict structure is expected.
                        if all(isinstance(item, str) for item in json_data):
                            for tr_str in json_data:
                                batch_items_translated.append(_InternalTranslateResponse(tr_str))
                        elif all(isinstance(item, list) and item and isinstance(item[0], str) for item in json_data):
                            for item_list in json_data:
                                src_lang_item = item_list[1] if len(item_list) > 1 and isinstance(item_list[1], str) else None
                                batch_items_translated.append(_InternalTranslateResponse(item_list[0], detectedSourceLanguage=src_lang_item))
                        else:
                            err_resp = response; err_resp.status_code = 500
                            err_resp._content = f"API response was a list, but not in a recognized simple format. Content: {response.text[:200]}".encode('utf-8', 'replace')
                            return Null(err_resp)
                        all_translated_responses.extend(batch_items_translated)

                    else: # Neither dict with 'sentences' nor a recognized list type.
                        err_resp = response; err_resp.status_code = 500
                        err_resp._content = f"API response (200 OK) JSON structure unexpected. Content: {response.text[:200]}".encode('utf-8', 'replace')
                        return Null(err_resp)

                except json.JSONDecodeError:
                    err_resp = response; err_resp.status_code = 500
                    err_resp._content = f"Failed to decode JSON from API response (200 OK). Content: {response.text[:200]}".encode('utf-8', 'replace')
                    return Null(err_resp)
                except Exception as e: # Catch-all for other parsing errors
                    err_resp = response; err_resp.status_code = 500
                    # Use traceback for more detailed error logging if needed, but keep it concise for Null msg
                    import traceback
                    detailed_error = traceback.format_exc()
                    err_resp._content = f"Generic error during API response parsing (200 OK). Error: {str(e)}. Details: {detailed_error[:200]}. Content: {response.text[:200]}".encode('utf-8', 'replace')
                    return Null(err_resp)

            if not all_translated_responses and texts_to_translate:
                # This case implies all batches might have failed cleanly or returned empty valid responses,
                # or input was e.g. [''] leading to _InternalTranslateResponse('') which is not empty.
                # This is more a safeguard for unexpected empty results when input was non-empty.
                final_response = requests.Response()
                final_response.status_code = 500
                final_response._content = b"Translation process resulted in no valid translated items for non-empty input."
                return Null(final_response)
                
            return all_translated_responses
    # --- End of embedded _GoogleTranslate class ---

    # --- Main logic for translate_queue ---
    if not q_list:
        return []

    # app_key and app_secret are ignored for this basic Google Translate client.
    # They are kept in the function signature for compatibility with CustomTranslate.

    results = []
    try:
        # Instantiate the internal GoogleTranslate client
        client = _GoogleTranslate(
            target=target_lang_code,
            source=source_lang_code,
            proxies=proxies_config,
            fmt='text', # Ensure text format for translations
            timeout=15  # Can be adjusted; requests timeout in seconds
        )

        # `client.translate` handles its own batching using `max_batch_size`.
        # `q_list` here is a chunk of texts from `CustomTranslate`.
        translated_responses_or_null = client.translate(
            q=q_list, # q_list is List[str]
            target=target_lang_code,
            source=source_lang_code
        )

        if isinstance(translated_responses_or_null, Null):
            # The entire call to client.translate for this q_list failed.
            # Log the error. For simplicity, printing to stdout.
            # In a real app, use `log_print` if available or Python's logging.
            print(f"Google Translate API Error for a batch: {translated_responses_or_null.msg}")
            # Return a list of dictionaries with original text to indicate failure for these items.
            for original_text in q_list:
                results.append({
                    'untranslatedText': original_text,
                    'translatedText': original_text # Fallback: return original if translation failed
                })
            return results
        
        # If successful, translated_responses_or_null is List[_InternalTranslateResponse]
        internal_translate_results = translated_responses_or_null

        if len(internal_translate_results) == len(q_list):
            for i, original_text in enumerate(q_list):
                trans_obj = internal_translate_results[i]
                results.append({
                    'untranslatedText': original_text,
                    'translatedText': trans_obj.translatedText
                })
        else:
            # This indicates a mismatch, which is unexpected if no Null was returned.
            # Google API usually preserves order and count for batch requests.
            print(f"Warning: Mismatch in translation result count for a batch. Expected {len(q_list)}, got {len(internal_translate_results)}. Check API behavior or batch content.")
            # Fallback: Try to map what's available, use original for the rest.
            min_len = min(len(q_list), len(internal_translate_results))
            for i in range(min_len):
                 results.append({
                    'untranslatedText': q_list[i],
                    'translatedText': internal_translate_results[i].translatedText
                })
            # For remaining original texts if q_list was longer
            for i in range(min_len, len(q_list)):
                results.append({
                    'untranslatedText': q_list[i],
                    'translatedText': q_list[i] # Fallback
                })
        
        return results

    except Exception as e:
        # Catch any other unexpected errors during the process
        # For simplicity, printing to stdout. In a real app, use proper logging.
        import traceback
        print(f"Unexpected error in translate_queue: {str(e)}\n{traceback.format_exc()}")
        # Fallback: return original texts for all items in q_list
        failed_results = []
        for text in q_list:
            failed_results.append({'untranslatedText': text, 'translatedText': text})
        return failed_results

[994834669]

我现在是在自定义引擎中添加了大佬你这段代码的脚本，然后源和目标套用的是谷歌的，url用的是“https://translate.google.com/”，勾选了支持队列输入，测试了一个游戏，目前表现来看好像是没问题了，可以使用了