@zzzen/pyright-internal 1.2.0-dev.20240908 → 1.2.0-dev.20240922

package/dist/localization/package.nls.zh-tw.json

@@ -1,7 +1,7 @@
 {
     "CodeAction": {
-        "createTypeStub": "建立類型虛設常式",
-        "createTypeStubFor": "建立 \"{moduleName}\" 的類型虛設常式",
+        "createTypeStub": "建立類型 Stub",
+        "createTypeStubFor": "建立 \"{moduleName}\" 的類型 Stub",
         "executingCommand": "執行命令",
         "filesToAnalyzeCount": "要分析的 {count} 個檔案",
         "filesToAnalyzeOne": "1 個要分析的檔案",
@@ -18,12 +18,12 @@
         "annotatedMetadataInconsistent": "標註的中繼資料類型 \"{metadataType}\" 與類型 \"{type}\" 不相容",
         "annotatedParamCountMismatch": "參數註釋計數不符: 應為 {expected}，但收到 {received}",
         "annotatedTypeArgMissing": "預期 \"Annotated\" 有一個類型引數和一或多個註釋",
-        "annotationBytesString": "類型註釋無法使用位元組字串常值",
-        "annotationFormatString": "類型註釋不能使用格式字串常值 (f-strings)",
+        "annotationBytesString": "類型運算式無法使用位元組字串常值",
+        "annotationFormatString": "類型運算式不能使用格式字串常值 (f-strings)",
         "annotationNotSupported": "此陳述式不支援類型註釋",
-        "annotationRawString": "類型註釋無法使用原始字串常值",
-        "annotationSpansStrings": "型別註釋無法跨越多個字串常值",
-        "annotationStringEscape": "型別註釋不可包含逸出字元",
+        "annotationRawString": "類型運算式無法使用原始字串常值",
+        "annotationSpansStrings": "型別運算式無法跨越多個字串常值",
+        "annotationStringEscape": "型別運算式不可包含逸出字元",
         "argAssignment": "類型 \"{argType}\" 的引數不能指派至類型 \"{paramType}\" 的參數",
         "argAssignmentFunction": "類型 \"{argType}\" 的引數不能指派至函式 \"{functionName}\" 中類型 \"{paramType}\" 的參數",
         "argAssignmentParam": "類型 \"{argType}\" 的引數不能指派至類型 \"{paramType}\" 的參數 \"{paramName}\"",
@@ -43,21 +43,21 @@
         "assignmentExprComprehension": "指派運算式目標 \"{name}\" 不能使用與目標 comprehension 相同的名稱",
         "assignmentExprContext": "Assignment 運算式必須在模組、函式或 Lambda 內",
         "assignmentExprInSubscript": "下標內的 Assignment 運算式僅在 Python 3.10 和更新版本中支援",
-        "assignmentInProtocol": "必須在類別主體內明確宣告通訊協定類別內的執行個體或類別變數",
+        "assignmentInProtocol": "必須在類別主體內明確宣告 Protocol 類別內的執行個體或類別變數",
         "assignmentTargetExpr": "運算式不能是指派目標",
-        "asyncNotInAsyncFunction": "不允許在非同步函式之外使用 \"async\"",
+        "asyncNotInAsyncFunction": "不允許在非 async 之外使用 \"async\"",
         "awaitIllegal": "使用 \"await\" 需要 Python 3.5 或更新版本",
-        "awaitNotAllowed": "類型註釋不能使用 “await”",
-        "awaitNotInAsync": "只在非同步函式內允許 \"await\"",
+        "awaitNotAllowed": "類型運算式不能使用 \"await\"",
+        "awaitNotInAsync": "只在 async 函式內允許 \"await\"",
         "backticksIllegal": "Python 3.x 中不支援以反引號括住的運算式; 請改為使用 repr",
         "baseClassCircular": "類別無法從本身衍生",
-        "baseClassFinal": "基底類別 \"{type}\" 標示為 Final，且不能設為子類別",
+        "baseClassFinal": "基底類別 \"{type}\" 標示為 final，且不能設為子類別",
         "baseClassIncompatible": "{type} 的基底類別互不相容",
         "baseClassInvalid": "類別的引數必須是基底類別",
         "baseClassMethodTypeIncompatible": "類別 \"{classType}\" 的基底類別以不相容的方式定義方法 \"{name}\"",
         "baseClassUnknown": "基底類別類型未知，遮蔽衍生類別的類型",
         "baseClassVariableTypeIncompatible": "類別 \"{classType}\" 的基底類別以不相容的方式定義變數 \"{name}\"",
-        "binaryOperationNotAllowed": "類型註釋中不允許二元運算子",
+        "binaryOperationNotAllowed": "類型運算式中不允許二元運算子",
         "bindTypeMismatch": "無法繫結方法 \"{methodName}\"，因為 \"{type}\" 無法指派給參數 \"{paramName}\"",
         "breakOutsideLoop": "\"break\" 只能在迴圈內使用",
         "callableExtraArgs": "預期 \"Callable\" 只有兩個類型引數",
@@ -70,7 +70,7 @@
         "classDefinitionCycle": "\"{name}\" 的類別定義視其本身而定",
         "classGetItemClsParam": "__class_getitem__ 覆寫應接受 \"cls\" 參數",
         "classMethodClsParam": "類別方法應採用 \"cls\" 參數",
-        "classNotRuntimeSubscriptable": "類別 \"{name}\" 的下標會產生執行階段例外; 以引號括住類型註釋",
+        "classNotRuntimeSubscriptable": "類別 \"{name}\" 的下標會產生執行階段例外; 以引號括住類型運算式",
         "classPatternBuiltInArgPositional": "類別模式僅接受位置子模式",
         "classPatternPositionalArgCount": "類別 \"{type}\" 的位置模式太多;預期 {expected} 但收到 {received}",
         "classPatternTypeAlias": "無法在類別模式中使用 \"{type}\"，因為它是特殊的型別別名",
@@ -87,7 +87,7 @@
         "comparisonAlwaysFalse": "條件一律會評估為 False，因為類型 \"{leftType}\" 和 \"{rightType}\" 沒有重疊",
         "comparisonAlwaysTrue": "條件一律會評估為 True，因為類型 \"{leftType}\" 和 \"{rightType}\" 沒有重疊",
         "comprehensionInDict": "理解不能與其他字典項目搭配使用",
-        "comprehensionInSet": "Comprehension 無法與其他集合輸入項目一起使用",
+        "comprehensionInSet": "Comprehension 無法與其他 set 輸入項目一起使用",
         "concatenateContext": "此內容中不允許 \"Concatenate\"",
         "concatenateParamSpecMissing": "\"Concatenate\" 的最後一個類型引數必須是 ParamSpec 或 \"...\"",
         "concatenateTypeArgsMissing": "\"Concatenate\" 至少需要兩個型別引數",
@@ -111,7 +111,7 @@
         "dataClassPostInitType": "欄位 \"{fieldName}\" 的 Dataclass __post_init__ 方法參數類型不符",
         "dataClassSlotsOverwrite": "__slots__已定義在類別中",
         "dataClassTransformExpectedBoolLiteral": "應為靜態評估為 True 或 False 的運算式",
-        "dataClassTransformFieldSpecifier": "應為類別或函式的元組，但收到的型別為 \"{type}\"",
+        "dataClassTransformFieldSpecifier": "應為類別或函式的 tuple，但收到的類別為 \"{type}\"",
         "dataClassTransformPositionalParam": "\"dataclass_transform\" 的所有引數都必須是關鍵字引數",
         "dataClassTransformUnknownArgument": "dataclass_transform 不支援引數 \"{name}\"",
         "dataProtocolInSubclassCheck": "issubclass 呼叫中不允許資料通訊協定 (包含非方法屬性)",
@@ -127,20 +127,20 @@
         "deprecatedDescriptorSetter": "描述項 \"{name}\" 的 \"__set__\" 方法已被取代",
         "deprecatedFunction": "函式 \"{name}\" 已取代",
         "deprecatedMethod": "類別 \"{className}\" 中的方法 \"{name}\" 已取代",
-        "deprecatedPropertyDeleter": "屬性 \"{name}\" 的 deleter 已被取代",
-        "deprecatedPropertyGetter": "屬性 \"{name}\" 的 getter 已被取代",
-        "deprecatedPropertySetter": "屬性 \"{name}\" 的 setter 已被取代",
+        "deprecatedPropertyDeleter": "The deleter for property \"{name}\" is deprecated",
+        "deprecatedPropertyGetter": "The getter for property \"{name}\" is deprecated",
+        "deprecatedPropertySetter": "The setter for property \"{name}\" is deprecated",
         "deprecatedType": "此類型已隨著 Python {version} 取代; 請改為使用 \"{replacement}\"",
         "dictExpandIllegalInComprehension": "理解中不允許字典擴充",
-        "dictInAnnotation": "類型註釋中不允許字典運算式",
+        "dictInAnnotation": "類型運算式中不允許字典運算式",
         "dictKeyValuePairs": "字典項目必須包含金鑰/值組",
         "dictUnpackIsNotMapping": "預期為字典解壓縮運算子的對應",
         "dunderAllSymbolNotPresent": "\"{name}\" 已在 __all__ 中指定，但在模組中不存在",
         "duplicateArgsParam": "只允許一個 \"*\" 參數",
         "duplicateBaseClass": "不允許重複的基底類別",
         "duplicateCapturePatternTarget": "擷取目標 \"{name}\" 不能在相同模式中出現一次以上",
-        "duplicateCatchAll": "只允許一個 catch-all 例外子句",
-        "duplicateEnumMember": "已宣告列舉成員 \"{name}\"",
+        "duplicateCatchAll": "只允許一個 catch-all except 子句",
+        "duplicateEnumMember": "已宣告 Enum 成員 \"{name}\"",
         "duplicateGenericAndProtocolBase": "只允許一個 Generic[...] 或 Protocol[...] 基底類別",
         "duplicateImport": "\"{importName}\" 已匯入多次",
         "duplicateKeywordOnly": "只允許一個 \"*\" 分隔符號",
@@ -149,14 +149,14 @@
         "duplicatePositionOnly": "僅允許一個 \"/\" 參數",
         "duplicateStarPattern": "模式序列中僅允許一個 \"*\" 模式",
         "duplicateStarStarPattern": "僅允許輸入一個 \"**\"",
-        "duplicateUnpack": "清單中僅允許一個解除封裝作業",
+        "duplicateUnpack": "list 中僅允許一個解除封裝作業",
         "ellipsisAfterUnpacked": "\"...\" 不能與解壓縮的 TypeVarTuple 或 tuple 一起使用",
         "ellipsisContext": "此內容中不允許 \"...\"",
         "ellipsisSecondArg": "\"...\" 只允許做為兩個引數的第二個",
-        "enumClassOverride": "列舉類別 \"{name}\" 為 Final，且不能設為子類別",
-        "enumMemberDelete": "無法刪除列舉成員 \"{name}\"",
-        "enumMemberSet": "無法指派列舉成員 \"{name}\"",
-        "enumMemberTypeAnnotation": "列舉成員不允許類型註釋",
+        "enumClassOverride": "Enum 類別 \"{name}\" 為 final，且不能設為子類別",
+        "enumMemberDelete": "Enum member \"{name}\" cannot be deleted",
+        "enumMemberSet": "Enum member \"{name}\" cannot be assigned",
+        "enumMemberTypeAnnotation": "Type annotations are not allowed for enum members",
         "exceptionGroupIncompatible": "例外群組語法 (\"except*\") 需要 Python 3.11 或更新版本",
         "exceptionGroupTypeIncorrect": "except* 中的例外狀況類型不能衍生自 BaseGroupException",
         "exceptionTypeIncorrect": "\"{type}\" 不是衍生自 BaseException",
@@ -189,7 +189,7 @@
         "expectedIdentifier": "應為識別碼",
         "expectedImport": "預期為 \"import\"",
         "expectedImportAlias": "\"as\" 之後預期為符號",
-        "expectedImportSymbols": "預期匯入後為一或多個符號名稱",
+        "expectedImportSymbols": "預期 \"import\" 後為一或多個符號名稱",
         "expectedIn": "預期為 \"in\"",
         "expectedInExpr": "\"in\" 後預期為運算式",
         "expectedIndentedBlock": "預期為縮排區塊",
@@ -209,10 +209,10 @@
         "expectedTypeNotString": "預期為類型，但收到字串常值",
         "expectedTypeParameterName": "應為型別參數名稱",
         "expectedYieldExpr": "yield 陳述式中應有運算式",
-        "finalClassIsAbstract": "類別 \"{type}\" 標示為 Final，且必須實作所有抽象符號",
+        "finalClassIsAbstract": "類別 \"{type}\" 標示為 final，且必須實作所有抽象符號",
         "finalContext": "此內容中不允許 \"Final\"",
         "finalInLoop": "無法在迴圈內指派 \"Final\" 變數",
-        "finalMethodOverride": "方法 \"{name}\" 不能覆寫類別 \"{className}\" 中定義的 Final 方法",
+        "finalMethodOverride": "方法 \"{name}\" 不能覆寫類別 \"{className}\" 中定義的 final 方法",
         "finalNonMethod": "無法將函式 \"{name}\" 標示為 @final，因為它不是方法",
         "finalReassigned": "\"{name}\" 已宣告為 Final，因此無法重新指派",
         "finalRedeclaration": "\"{name}\" 先前已宣告為 Final",
@@ -234,7 +234,7 @@
         "functionInConditionalExpression": "條件運算式參考函式，一律評估為 True",
         "functionTypeParametersIllegal": "函式型別參數語法需要 Python 3.12 或較新的版本",
         "futureImportLocationNotAllowed": "來自 __future__ 的匯入必須位於檔案的開頭",
-        "generatorAsyncReturnType": "非同步產生器函式的傳回類型必須與 \"AsyncGenerator[{yieldType}, Any]\" 相容",
+        "generatorAsyncReturnType": "Return type of async generator function must be compatible with \"AsyncGenerator[{yieldType}, Any]\"",
         "generatorNotParenthesized": "如果不是唯一引數，則必須將產生器運算式用括弧括住",
         "generatorSyncReturnType": "產生器函式的傳回類型必須與 \"Generator[{yieldType}, Any, Any]\" 相容",
         "genericBaseClassNotAllowed": "\"Generic\" 基底類別不能與型別參數語法一起使用",
@@ -265,16 +265,16 @@
         "instanceMethodSelfParam": "執行個體方法應該採用 \"self\" 參數",
         "instanceVarOverridesClassVar": "執行個體變數 \"{name}\" 覆寫類別 \"{className}\" 中相同名稱的類別變數",
         "instantiateAbstract": "無法將抽象類別 \"{type}\" 具現化",
-        "instantiateProtocol": "無法將通訊協定類別 \"{type}\" 具現化",
+        "instantiateProtocol": "無法將 Protocol 類別 \"{type}\" 具現化",
         "internalBindError": "繫結檔案 \"{file}\" 時發生內部錯誤: {message}",
         "internalParseError": "剖析檔案 \"{file}\" 時發生內部錯誤: {message}",
         "internalTypeCheckingError": "類型檢查檔案 \"{file}\" 時發生內部錯誤: {message}",
         "invalidIdentifierChar": "識別碼中的字元無效",
-        "invalidStubStatement": "陳述式在類型虛設常式檔案內沒有意義",
+        "invalidStubStatement": "陳述式在類型 stub 檔案內沒有意義",
         "invalidTokenChars": "權杖中的字元 \"{text}\" 無效",
-        "isInstanceInvalidType": "\"isinstance\" 的第二個引數必須是類別或類別的元組",
-        "isSubclassInvalidType": "\"issubclass\" 的第二個引數必須是類別的類別或 Tuple",
-        "keyValueInSet": "組合內不允許金鑰/值組",
+        "isInstanceInvalidType": "\"isinstance\" 的第二個引數必須是類別或類別的tuple",
+        "isSubclassInvalidType": "\"issubclass\" 的第二個引數必須是類別的類別或 tuple",
+        "keyValueInSet": "set 內不允許金鑰/值組",
         "keywordArgInTypeArgument": "關鍵字引數無法用於型別引數清單",
         "keywordArgShortcutIllegal": "關鍵字引數快速鍵需要 Python 3.14 或更新版本",
         "keywordOnlyAfterArgs": "\"*\" 參數之後不允許僅限關鍵字的引數分隔符號",
@@ -283,13 +283,13 @@
         "lambdaReturnTypePartiallyUnknown": "Lambda 的傳回類型 \"{returnType}\" 部分未知",
         "lambdaReturnTypeUnknown": "Lambda 的傳回類型未知",
         "listAssignmentMismatch": "類型 \"{type}\" 的運算式不能指派至目標清單",
-        "listInAnnotation": "類型註釋中不允許清單運算式",
+        "listInAnnotation": "型別運算式中不允許 List 運算式",
         "literalEmptyArgs": "\"Literal\" 後面應有一或多個型別引數",
         "literalNamedUnicodeEscape": "\"Literal\" 字串常值中不支援具名 Unicode 逸出序列",
         "literalNotAllowed": "沒有類型參數，\"Literal\" 不能在此內容中使用",
-        "literalNotCallable": "常值類型不能具現化",
-        "literalUnsupportedType": "\"Literal\" 的類型引數必須是 None、常值 (int、bool、str 或 bytes) 或列舉值",
-        "matchIncompatible": "比對陳述式需要 Python 3.10 或更新版本",
+        "literalNotCallable": "Literal 類型不能具現化",
+        "literalUnsupportedType": "\"Literal\" 的類型引數必須是 None、literal (int、bool、str 或 bytes) 或 enum 值",
+        "matchIncompatible": "Match 陳述式需要 Python 3.10 或更新版本",
         "matchIsNotExhaustive": "match 陳述式內的案例並未完整處理所有值",
         "maxParseDepthExceeded": "超過剖析深度上限; 將運算式分成較小的子運算式",
         "memberAccess": "無法存取類別 \"{type}\" 的屬性 \"{name}\"",
@@ -304,30 +304,31 @@
         "methodOverridden": "\"{name}\" 以不相容型別 \"{type}\" 覆寫類別 \"{className}\" 中具有相同名稱的方法",
         "methodReturnsNonObject": "\"{name}\" 方法未傳回物件",
         "missingSuperCall": "方法 \"{methodName}\" 未呼叫父類別中相同名稱的方法",
+        "mixingBytesAndStr": "無法串連 Bytes 和 str 值",
         "moduleAsType": "模組不能當作型別來使用",
         "moduleNotCallable": "模組無法呼叫",
         "moduleUnknownMember": "\"{memberName}\" 不是模組 \"{moduleName}\" 的已知屬性",
         "namedExceptAfterCatchAll": "catch-all except 子句後面不能出現具名 except 子句",
         "namedParamAfterParamSpecArgs": "關鍵字參數 \"{name}\" 不能在簽章中出現在 ParamSpec args 參數之後",
-        "namedTupleEmptyName": "具名元組內的名稱不可為空白",
-        "namedTupleEntryRedeclared": "無法覆寫 \"{name}\"，因為父代類別 \"{className}\" 是具名的 Tuple",
-        "namedTupleFirstArg": "預期為具名 Tuple 類別名稱作為第一個引數",
+        "namedTupleEmptyName": "具名 tuple 內的名稱不可為空白",
+        "namedTupleEntryRedeclared": "無法覆寫 \"{name}\"，因為父代類別 \"{className}\" 是具名的 tuple",
+        "namedTupleFirstArg": "預期為具名 tuple 類別名稱作為第一個引數",
         "namedTupleMultipleInheritance": "不支援使用 NamedTuple 的多重繼承",
         "namedTupleNameKeyword": "欄位名稱不能是關鍵字",
-        "namedTupleNameType": "指定項目名稱和類型預期有兩個項目 Tuple",
-        "namedTupleNameUnique": "具名 Tuple 內的名稱必須是唯一的",
+        "namedTupleNameType": "指定輸入項目名稱和類型預期有兩個輸入項目 tuple",
+        "namedTupleNameUnique": "具名 tuple 內的名稱必須是唯一的",
         "namedTupleNoTypes": "\"namedtuple\" 未提供 Tuple 項目的類型; 請改為使用 \"NamedTuple\"",
-        "namedTupleSecondArg": "預期為具名 Tuple 項目清單作為第二個引數",
+        "namedTupleSecondArg": "預期為具名 tuple 項目 list 作為第二個引數",
         "newClsParam": "__new__ 覆寫應接受 \"cls\" 參數",
         "newTypeAnyOrUnknown": "NewType 的第二個引數必須是已知的類別，不能是 Any 或 Unknown",
         "newTypeBadName": "NewType 的第一個引數必須是字串常值",
-        "newTypeLiteral": "NewType 不能與常值類型搭配使用",
+        "newTypeLiteral": "NewType 不能與 Literal 類型搭配使用",
         "newTypeNameMismatch": "NewType 必須指派給名稱相同的變數",
         "newTypeNotAClass": "預期類別為 NewType 的第二個引數",
         "newTypeParamCount": "NewType 需要兩個位置引數",
-        "newTypeProtocolClass": "NewType 無法與結構類型 (通訊協定或 TypedDict 類別) 搭配使用",
+        "newTypeProtocolClass": "NewType 無法與結構類型 (Protocol 或 TypedDict 類別) 搭配使用",
         "noOverload": "\"{name}\" 沒有任何多載符合提供的引數",
-        "noReturnContainsReturn": "宣告傳回類型為 \"NoReturn\" 的函式不能包含 return 陳述式",
+        "noReturnContainsReturn": "宣告 return 類型為 \"NoReturn\" 的函式不能包含 return 陳述式",
         "noReturnContainsYield": "宣告傳回類型為 \"NoReturn\" 的函式不能包含 yield 陳述式",
         "noReturnReturnsNone": "宣告類型為 \"NoReturn\" 的函式不能傳回 \"None\"",
         "nonDefaultAfterDefault": "非預設引數遵循預設引數",
@@ -338,7 +339,7 @@
         "noneNotCallable": "無法呼叫型別 \"None\" 的物件",
         "noneNotIterable": "類型 \"None\" 的物件不能作為可疊代的值",
         "noneNotSubscriptable": "型別 \"None\" 的物件不能下標",
-        "noneNotUsableWith": "類型 \"None\" 的物件不能與 \"with\" 搭配使用",
+        "noneNotUsableWith": "Object of type \"None\" cannot be used with \"with\"",
         "noneOperator": "\"None\" 不支援運算子 \"{operator}\"",
         "noneUnknownMember": "\"{name}\" 不是 \"None\" 的已知屬性",
         "notRequiredArgCount": "預期 \"NotRequired\" 之後為單一類型引數",
@@ -364,9 +365,9 @@
         "overloadImplementationMismatch": "多載的實作與多載 {index} 的簽章不一致",
         "overloadReturnTypeMismatch": "\"{name}\" 的多載 {prevIndex} 與多載 {newIndex} 重疊，並傳回不相容的類型",
         "overloadStaticMethodInconsistent": "\"{name}\" 的多載不一致地使用 @staticmethod",
-        "overloadWithoutImplementation": "\"{name}\" 標示為多載，但未提供實作",
-        "overriddenMethodNotFound": "方法 \"{name}\" 已標示為覆寫，但不存在相同名稱的基底方法",
-        "overrideDecoratorMissing": "方法 \"{name}\" 未標示為覆寫，但正在覆寫類別 \"{className}\" 中的方法",
+        "overloadWithoutImplementation": "\"{name}\" 標示為 overload，但未提供實作",
+        "overriddenMethodNotFound": "方法 \"{name}\" 已標示為 override，但不存在相同名稱的基底方法",
+        "overrideDecoratorMissing": "方法 \"{name}\" 未標示為 override，但正在覆寫類別 \"{className}\" 中的方法",
         "paramAfterKwargsParam": "參數無法接在 \"**\" 參數後面",
         "paramAlreadyAssigned": "已指派參數 \"{name}\"",
         "paramAnnotationMissing": "參數 \"{name}\" 遺漏了型別註釋",
@@ -377,7 +378,7 @@
         "paramSpecArgsUsage": "只有搭配 *args 參數使用時，ParamSpec 的 \"args\" 屬性才有效",
         "paramSpecAssignedName": "ParamSpec 必須指派至名為 \"{name}\" 的變數",
         "paramSpecContext": "此內容中不允許 ParamSpec",
-        "paramSpecDefaultNotTuple": "ParamSpec 的預設值必須是省略符號、元組運算式或 ParamSpec",
+        "paramSpecDefaultNotTuple": "ParamSpec 的預設值必須是省略符號、tuple 運算式或 ParamSpec",
         "paramSpecFirstArg": "應以 ParamSpec 的名稱作為第一個引數",
         "paramSpecKwargsUsage": "只有搭配 **kwargs 參數使用時，ParamSpec 的 \"kwargs\" 屬性才有效",
         "paramSpecNotUsedByOuterScope": "ParamSpec \"{name}\" 在此內容中沒有意義",
@@ -387,7 +388,7 @@
         "paramTypeCovariant": "不能在參數類型中使用共變數類型變數",
         "paramTypePartiallyUnknown": "參數 \"{paramName}\" 的類型部分未知",
         "paramTypeUnknown": "參數 \"{paramName}\" 的類型未知",
-        "parenthesizedContextManagerIllegal": "\"with\" 陳述式內的括弧需要 Python 3.9 或較新的版本",
+        "parenthesizedContextManagerIllegal": "Parentheses within \"with\" statement requires Python 3.9 or newer",
         "patternNeverMatches": "模式永遠不會符合主體類型 \"{type}\"",
         "positionArgAfterNamedArg": "位置引數不能出現在關鍵字引數之後",
         "positionOnlyAfterArgs": "\"*\" 參數之後不允許 Position-only 參數分隔符號",
@@ -398,18 +399,18 @@
         "privateImportFromPyTypedModule": "\"{name}\" 未從模組 \"{module}\" 匯出",
         "privateUsedOutsideOfClass": "\"{name}\" 為私人，並用於宣告其所在的類別之外",
         "privateUsedOutsideOfModule": "\"{name}\" 為私人，並用於宣告其所在的模組之外",
-        "propertyOverridden": "\"{name}\" 不正確地覆寫了類別 \"{className}\" 中相同名稱的屬性",
-        "propertyStaticMethod": "屬性 getter、setter 或 deleter 不允許靜態方法",
+        "propertyOverridden": "\"{name}\" 不正確地覆寫了類別 \"{className}\" 中相同名稱的 property",
+        "propertyStaticMethod": "Static methods not allowed for property getter, setter or deleter",
         "protectedUsedOutsideOfClass": "\"{name}\" 受到保護，並用於其宣告所在的類別之外",
-        "protocolBaseClass": "通訊協定類別 \"{classType}\" 不能衍生自非通訊協定類別 \"{baseType}\"",
-        "protocolBaseClassWithTypeArgs": "使用型別參數語法時，通訊協定類別不允許使用型別引數",
+        "protocolBaseClass": "Protocol 類別 \"{classType}\" 不能衍生自非 Protocol 類別 \"{baseType}\"",
+        "protocolBaseClassWithTypeArgs": "使用型別參數語法時，Protocol 類別不允許使用型別引數",
         "protocolIllegal": "使用 \"Protocol\" 需要 Python 3.7 或更新版本",
         "protocolNotAllowed": "\"Protocol\" 不能用在此內容中",
         "protocolTypeArgMustBeTypeParam": "“Protocol” 的型別引數必須是型別參數",
         "protocolUnsafeOverlap": "類別以不安全方式重疊 \"{name}\"，且可能會在運行時間產生相符專案",
-        "protocolVarianceContravariant": "一般通訊協定 \"{class}\" 中使用的型別變數 \"{variable}\" 必須為逆變數",
-        "protocolVarianceCovariant": "一般通訊協定 \"{class}\" 中使用的型別變數 \"{variable}\" 必須為共變數",
-        "protocolVarianceInvariant": "一般通訊協定 \"{class}\" 中使用的型別變數 \"{variable}\" 必須為不變數",
+        "protocolVarianceContravariant": "一般 Protocol \"{class}\" 中使用的類別變數 \"{variable}\" 必須為逆變數",
+        "protocolVarianceCovariant": "一般 Protocol \"{class}\" 中使用的類型變數 \"{variable}\" 必須為共變數",
+        "protocolVarianceInvariant": "一般 Protocol \"{class}\" 中使用的類別變數 \"{variable}\" 必須為不變數",
         "pyrightCommentInvalidDiagnosticBoolValue": "Pyright 註解指示詞後面必須接著 \"=\"，且值為 true 或 false",
         "pyrightCommentInvalidDiagnosticSeverityValue": "Pyright 註解指示詞後面必須接著 \"=\"，且值為 true、false、error、warning、information 或 none",
         "pyrightCommentMissingDirective": "Pyright 註解後面必須接著指示詞 (basic 或 strict) 或診斷規則",
@@ -423,11 +424,11 @@
         "relativeImportNotAllowed": "相對匯入不能與 \"import .a\" 格式搭配使用; 請改為使用 \"from . import a\"",
         "requiredArgCount": "\"Required\" 後面應有單一型別引數",
         "requiredNotInTypedDict": "此內容中不允許 \"Required\"",
-        "returnInAsyncGenerator": "非同步產生器中不允許具有值的 return 陳述式",
+        "returnInAsyncGenerator": "Return statement with value is not allowed in async generator",
         "returnMissing": "宣告類型為 \"{returnType}\" 的函式必須在所有程式碼路徑上傳回值",
         "returnOutsideFunction": "\"return\" 只能在函式內使用",
         "returnTypeContravariant": "逆變數型別變數不能用在傳回型別中",
-        "returnTypeMismatch": "類型 \"{exprType}\" 的運算式與傳回型別 \"{returnType}\" 不相容",
+        "returnTypeMismatch": "型別 \"{exprType}\" 無法指派給傳回型別 \"{returnType}\"",
         "returnTypePartiallyUnknown": "傳回類型 \"{returnType}\" 部分未知",
         "returnTypeUnknown": "傳回類型未知",
         "revealLocalsArgs": "\"reveal_locals\" 呼叫不應有任何引數",
@@ -439,7 +440,7 @@
         "selfTypeContext": "\"Self\" 在此內容中無效",
         "selfTypeMetaclass": "“Self” 不能用於 Metaclass 内 (“type” 的子類別)",
         "selfTypeWithTypedSelfOrCls": "\"Self\" 不能用在具有 `self` 或 `cls` 參數的函式中，其類型註釋不是 \"Self\"",
-        "setterGetterTypeMismatch": "屬性 setter 數值類型不能指派至 getter 傳回類型",
+        "setterGetterTypeMismatch": "Property setter 數值類型不能指派至 getter 傳回類型",
         "singleOverload": "\"{name}\" 標示為多載，但遺失其他多載",
         "slotsAttributeError": "未在__slots__中指定 \"{name}\"",
         "slotsClassVarConflict": "\"{name}\" 與在 __slots__ 中宣告的執行個體變數衝突",
@@ -449,12 +450,12 @@
         "staticClsSelfParam": "靜態方法不應採用 \"self\" 或 \"cls\" 參數",
         "stdlibModuleOverridden": "\"{path}\" 正在覆寫 stdlib 模組 \"{name}\"",
         "stringNonAsciiBytes": "位元組字串常值中不允許非 ASCII 字元",
-        "stringNotSubscriptable": "字串運算式不能在類型註釋中下標; 以引號括住整個註釋",
+        "stringNotSubscriptable": "字串運算式不能在類型運算式中下標; 以引號括住整個運算式",
         "stringUnsupportedEscape": "字串常值中不支援的逸出序列",
         "stringUnterminated": "字串常值未結束",
-        "stubFileMissing": "找不到 \"{importName}\" 的虛設常式檔案",
-        "stubUsesGetAttr": "類型虛設常式檔案不完整; \"__getattr__\" 會遮蔽模組的類型錯誤",
-        "sublistParamsIncompatible": "Python 3.x 不支援子清單參數",
+        "stubFileMissing": "找不到 \"{importName}\" 的 stub 檔案",
+        "stubUsesGetAttr": "類型 stub 檔案不完整; \"__getattr__\" 會遮蔽模組的類型錯誤",
+        "sublistParamsIncompatible": "Python 3.x 不支援 sublist 參數",
         "superCallArgCount": "\"super\" 呼叫不應有兩個以上的引數",
         "superCallFirstArg": "預期的類別類型為 \"super\" 呼叫的第一個引數，但收到 \"{type}\"",
         "superCallSecondArg": "\"super\" 呼叫的第二個引數必須是衍生自 \"{type}\" 的物件或類別",
@@ -464,45 +465,46 @@
         "symbolIsUnbound": "\"{name}\" 未繫結",
         "symbolIsUndefined": "\"{name}\" 未定義",
         "symbolOverridden": "\"{name}\" 會覆寫類別 \"{className}\" 中相同名稱的符號",
-        "ternaryNotAllowed": "類型註釋中不允許三元運算式",
+        "ternaryNotAllowed": "類型運算式中不允許三元運算式",
         "totalOrderingMissingMethod": "類別必須定義 \"__lt__\"、\"__le__\"、\"__gt__\" 或 \"__ge__\" 其中一個，才能使用 total_ordering",
         "trailingCommaInFromImport": "後置逗號不允許未使用括弧",
         "tryWithoutExcept": "Try 陳述式必須至少有一個 except 或 finally 子句",
-        "tupleAssignmentMismatch": "無法將型別 \"{type}\" 的運算式指派至目標元組",
-        "tupleInAnnotation": "型別註釋中不允許元組運算式",
+        "tupleAssignmentMismatch": "無法將型別 \"{type}\" 的運算式指派至目標 tuple",
+        "tupleInAnnotation": "型別運算式中不允許 Tuple 運算式",
         "tupleIndexOutOfRange": "索引 {index} 超過類型 {type} 的範圍",
         "typeAliasIllegalExpressionForm": "類型別名定義無效的運算式格式",
         "typeAliasIsRecursiveDirect": "型別別名 \"{name}\" 無法在其定義中使用它自己",
         "typeAliasNotInModuleOrClass": "TypeAlias 只能在模組或類別範圍內定義",
         "typeAliasRedeclared": "\"{name}\" 宣告為 TypeAlias，且只能指派一次",
-        "typeAliasStatementBadScope": "類型陳述式只能在模組或類別範圍內使用",
+        "typeAliasStatementBadScope": "A type statement can be used only within a module or class scope",
         "typeAliasStatementIllegal": "類型別名陳述式需要 Python 3.12 或更新版本",
         "typeAliasTypeBaseClass": "\"type\" 陳述式中定義的類型別名不能做為基底類別使用",
         "typeAliasTypeMustBeAssigned": "TypeAliasType 必須指派給與型別別名相同的變數",
         "typeAliasTypeNameArg": "TypeAliasType 的第一個引數必須是代表型別別名名稱的字串常值",
         "typeAliasTypeNameMismatch": "類型別名的名稱必須與指派它的變數名稱相符",
-        "typeAliasTypeParamInvalid": "型別參數清單必須是只包含 TypeVar、TypeVarTuple 或 ParamSpec 的元組",
+        "typeAliasTypeParamInvalid": "型別參數清單必須是只包含 TypeVar、TypeVarTuple 或 ParamSpec 的 tuple",
         "typeAnnotationCall": "型別運算式中不允許呼叫運算式",
         "typeAnnotationVariable": "型別運算式中不允許變數",
         "typeAnnotationWithCallable": "\"type\" 的類型引數必須是類別; 不支援可呼叫項目",
-        "typeArgListExpected": "預期為 ParamSpec、省略符號或類型清單",
-        "typeArgListNotAllowed": "此型別引數不允許清單運算式",
+        "typeArgListExpected": "預期為 ParamSpec、省略符號或類型 list",
+        "typeArgListNotAllowed": "此型別引數不允許 list 運算式",
         "typeArgsExpectingNone": "預期類別 \"{name}\" 沒有類型引數",
         "typeArgsMismatchOne": "預期為一個類型引數，但收到 {received}",
         "typeArgsMissingForAlias": "預期為一般類型別名 \"{name}\" 的類型引數",
         "typeArgsMissingForClass": "應為一般類別 \"{name}\" 的型別引數",
         "typeArgsTooFew": "為 \"{name}\" 提供太少類型引數; 預期為 {expected} 但收到 {received}",
         "typeArgsTooMany": "已為 \"{name}\" 提供太多型別引數; 應為 {expected} 但收到 {received}",
-        "typeAssignmentMismatch": "類型 \"{sourceType}\" 的運算式與宣告的類型 \"{destType}\" 不相容",
-        "typeAssignmentMismatchWildcard": "匯入符號 \"{name}\" 具有類型 \"{sourceType}\"，與宣告的類型 \"{destType}\" 不相容",
-        "typeCallNotAllowed": "不應在類型註釋中使用 type() 呼叫",
+        "typeAssignmentMismatch": "型別 \"{sourceType}\" 無法指派給宣告的型別 \"{destType}\"",
+        "typeAssignmentMismatchWildcard": "匯入符號 \"{name}\" 具有型別 \"{sourceType}\"，該型別無法指派給宣告的型別 \"{destType}\"",
+        "typeCallNotAllowed": "不應在類型運算式中使用 type() 呼叫",
         "typeCheckOnly": "\"{name}\" 已標示為 @type_check_only，只能在型別註釋中使用",
-        "typeCommentDeprecated": "使用類型註解已取代; 請改為使用類型註釋",
+        "typeCommentDeprecated": "使用 type 註解已取代; 請改為使用 type 註釋",
         "typeExpectedClass": "預期的類別，但已收到 \"{type}\"",
+        "typeFormArgs": "\"TypeForm\" 接受單一位置引數",
         "typeGuardArgCount": "預期 \"TypeGuard\" 或 \"TypeIs\" 之後為單一類型引數",
         "typeGuardParamCount": "使用者定義的類型防護函式和方法至少必須有一個輸入參數",
         "typeIsReturnType": "TypeIs 的傳回類型 (\"{returnType}\") 與值參數類型 (\"{type}\") 不一致",
-        "typeNotAwaitable": "\"{type}\" 不可等候",
+        "typeNotAwaitable": "\"{type}\" 不可 awaitable",
         "typeNotIntantiable": "\"{type}\" 不能具現化",
         "typeNotIterable": "\"{type}\" 無法疊代",
         "typeNotSpecializable": "無法將型別 \"{type}\" 特殊化",
@@ -537,7 +539,7 @@
         "typeVarSingleConstraint": "TypeVar 至少必須有兩個限制類型",
         "typeVarTupleConstraints": "TypeVarTuple 不能有值條件約束",
         "typeVarTupleContext": "此內容中不允許 TypeVarTuple",
-        "typeVarTupleDefaultNotUnpacked": "TypeVarTuple 預設型別必須是未封裝的元組或 TypeVarTuple",
+        "typeVarTupleDefaultNotUnpacked": "TypeVarTuple 預設型別必須是未封裝的 tuple 或 TypeVarTuple",
         "typeVarTupleMustBeUnpacked": "TypeVarTuple 值需要解除封裝運算子",
         "typeVarTupleUnknownParam": "\"{name}\" 是 TypeVarTuple 的未知參數",
         "typeVarUnknownParam": "\"{name}\" 對 TypeVar 是未知的參數",
@@ -552,8 +554,8 @@
         "typedDictBadVar": "TypedDict 類別只能包含型別註釋",
         "typedDictBaseClass": "TypedDict 類別的所有基底類別也必須是 TypedDict 類別",
         "typedDictBoolParam": "預期 \"{name}\" 參數的值為 True 或 False",
-        "typedDictClosedExtras": "基底類別 \"{name}\" 是已關閉的 TypedDict; 額外項目必須為型別 \"{type}\"",
-        "typedDictClosedNoExtras": "基底類別 \"{name}\" 是已關閉的 TypedDict; 不允許額外項目",
+        "typedDictClosedExtras": "基底類別 \"{name}\" 是 closed 的 TypedDict; 額外項目必須為型別 \"{type}\"",
+        "typedDictClosedNoExtras": "基底類別 \"{name}\" 是 closed 的 TypedDict; 不允許額外項目",
         "typedDictDelete": "無法刪除 TypedDict 中的項目",
         "typedDictEmptyName": "TypedDict 內的名稱不可為空白",
         "typedDictEntryName": "字典項目名稱預期為字串常值",
@@ -565,7 +567,7 @@
         "typedDictFirstArg": "預期 TypedDict 類別名稱作為第一個引數",
         "typedDictInitsubclassParameter": "TypedDict 不支援__init_subclass__參數 \"{name}\"",
         "typedDictNotAllowed": "\"TypedDict\" 不能用在此內容中",
-        "typedDictSecondArgDict": "預期為字典或關鍵字參數作為第二個參數",
+        "typedDictSecondArgDict": "預期為 dict 或關鍵字參數作為第二個參數",
         "typedDictSecondArgDictEntry": "應為簡單字典輸入項目",
         "typedDictSet": "無法在 TypedDict 中指派項目",
         "unaccessedClass": "未存取類別 \"{name}\"",
@@ -574,34 +576,36 @@
         "unaccessedSymbol": "未存取 \"{name}\"",
         "unaccessedVariable": "未存取變數 \"{name}\"",
         "unannotatedFunctionSkipped": "因為未標註函式 \"{name}\"，所以略過其分析",
-        "unaryOperationNotAllowed": "類型註釋中不允許一元運算子",
+        "unaryOperationNotAllowed": "類型運算式中不允許一元運算子",
         "unexpectedAsyncToken": "預期為 \"def\"、\"with\" 或 \"for\" 來追蹤 \"async\"",
         "unexpectedExprToken": "運算式結尾未預期的權杖",
         "unexpectedIndent": "未預期的縮排",
         "unexpectedUnindent": "取消縮排未預期",
         "unhashableDictKey": "字典索引鍵必須是可雜湊的",
-        "unhashableSetEntry": "設定項目必須是可雜湊",
-        "uninitializedAbstractVariables": "抽象基底類別中定義的變數未在 Final 類別 \"{classType}\" 中初始化",
+        "unhashableSetEntry": "Set 項目必須是可雜湊",
+        "uninitializedAbstractVariables": "抽象基底類別中定義的變數未在 final 類別 \"{classType}\" 中初始化",
         "uninitializedInstanceVariable": "執行個體變數 \"{name}\" 未在類別本文或 __init__ 方法上初始化",
-        "unionForwardReferenceNotAllowed": "聯集語法不能與字串運算元搭配使用; 使用引號括住整個運算式",
+        "unionForwardReferenceNotAllowed": "Union 語法不能與字串運算元搭配使用; 使用引號括住整個運算式",
         "unionSyntaxIllegal": "聯集的替代語法需要 Python 3.10 或更新版本",
-        "unionTypeArgCount": "聯集需要兩個或多個類型引數",
-        "unionUnpackedTuple": "集合聯集不能包含未封裝的 Tuple",
-        "unionUnpackedTypeVarTuple": "集合聯集不能包含未封裝的 TypeVarTuple",
+        "unionTypeArgCount": "Union 需要兩個或多個類型引數",
+        "unionUnpackedTuple": "Union 不能包含未封裝的 tuple",
+        "unionUnpackedTypeVarTuple": "Union 不能包含未封裝的 TypeVarTuple",
         "unnecessaryCast": "不必要的 \"cast\" 呼叫; 型別已是 \"{type}\"",
         "unnecessaryIsInstanceAlways": "不必要的 isinstance 呼叫; \"{testType}\" 一律是 \"{classType}\" 的執行個體",
+        "unnecessaryIsInstanceNever": "Unnecessary isinstance call; \"{testType}\" is never an instance of \"{classType}\"",
         "unnecessaryIsSubclassAlways": "不必要的 issubclass 呼叫; \"{testType}\"永遠是 \"{classType}\" 的子類別",
+        "unnecessaryIsSubclassNever": "Unnecessary issubclass call; \"{testType}\" is never a subclass of \"{classType}\"",
         "unnecessaryPyrightIgnore": "不必要的 \"# pyright: ignore\" 註解",
         "unnecessaryPyrightIgnoreRule": "不必要的 \"# pyright: ignore\" 規則: \"{name}\"",
         "unnecessaryTypeIgnore": "不必要的 \"# type: ignore\" 註解",
         "unpackArgCount": "\"Unpack\" 後面應為單一型別引數",
         "unpackExpectedTypeVarTuple": "預期 TypeVarTuple 或 tuple 作為 Unpack 的類型引數",
-        "unpackExpectedTypedDict": "應為解除封裝的 TypedDict 型別引數",
+        "unpackExpectedTypedDict": "應為 Unpack 的 TypedDict 型別引數",
         "unpackIllegalInComprehension": "理解中不允許解壓縮作業",
-        "unpackInAnnotation": "類型註釋中不允許解壓縮運算子",
+        "unpackInAnnotation": "類型運算式中不允許解壓縮運算子",
         "unpackInDict": "字典中不允許解壓縮作業",
-        "unpackInSet": "集合內不允許將運算子解除封裝",
-        "unpackNotAllowed": "此內容中不允許解壓縮",
+        "unpackInSet": "Unpack operator not allowed within a set",
+        "unpackNotAllowed": "此內容中不允許 Unpack",
         "unpackOperatorNotAllowed": "此內容中不允許解壓縮作業",
         "unpackTuplesIllegal": "Python 3.8 之前的 Tuple 中不允許解壓縮作業",
         "unpackedArgInTypeArgument": "無法在此內容中使用未封裝的引數",
@@ -616,35 +620,35 @@
         "unreachableExcept": "無法連接 Except 子句，因為例外已處理",
         "unsupportedDunderAllOperation": "不支援 \"__all__\" 上的作業，因此匯出的符號清單可能不正確",
         "unusedCallResult": "呼叫運算式的結果是 \"{type}\" 型別，而且未使用; 如果這是刻意的，則指派給變數 \"_\"",
-        "unusedCoroutine": "未使用非同步函式呼叫的結果; 使用 \"await\" 或指派結果至變數",
+        "unusedCoroutine": "未使用 async 函式呼叫的結果; 使用 \"await\" 或指派結果至變數",
         "unusedExpression": "未使用運算式值",
-        "varAnnotationIllegal": "變數的類型註釋需要 Python 3.6 或更新版本; 使用類型註解以獲得與先前版本的相容性",
+        "varAnnotationIllegal": "變數的 type 註釋需要 Python 3.6 或更新版本; 使用類型註解以獲得與先前版本的相容性",
         "variableFinalOverride": "變數 \"{name}\" 標示為 Final，且會覆寫類別 \"{className}\" 中相同名稱的非 Final 變數",
         "variadicTypeArgsTooMany": "類型引數清單最多只能有一個解壓縮的 TypeVarTuple 或 tuple",
         "variadicTypeParamTooManyAlias": "類型別名最多只能有一個 TypeVarTuple 類型參數，但收到多個 ({names})",
         "variadicTypeParamTooManyClass": "一般類別最多只能有一個 TypeVarTuple 類型參數，但收到多個 ({names})",
         "walrusIllegal": "運算子 \":=\" 需要 Python 3.8 或更新版本",
         "walrusNotAllowed": "此內容中不允許未使用括弧括住的運算子 \":=\"",
-        "wildcardInFunction": "類別或函式內不允許萬用字元匯入",
-        "wildcardLibraryImport": "不允許從程式庫匯入萬用字元",
+        "wildcardInFunction": "類別或函式內不允許萬用字元 import",
+        "wildcardLibraryImport": "不允許從程式庫 import 萬用字元",
         "wildcardPatternTypePartiallyUnknown": "萬用字元模式擷取的類型部分未知",
         "wildcardPatternTypeUnknown": "萬用字元模式擷取的型別不明",
         "yieldFromIllegal": "使用 \"yield from\" 需要 Python 3.3 或更新版本",
-        "yieldFromOutsideAsync": "非同步函式中不允許 \"yield from\"",
+        "yieldFromOutsideAsync": "\"yield from\" not allowed in an async function",
         "yieldOutsideFunction": "在函式或 lambda 外部不允許 \"yield\"",
         "yieldWithinComprehension": "理解內不允許 \"yield\"",
         "zeroCaseStatementsFound": "Match 陳述式必須至少包含一個 case 陳述式",
-        "zeroLengthTupleNotAllowed": "此內容中不允許零長度 Tuple"
+        "zeroLengthTupleNotAllowed": "此內容中不允許零長度 tuple"
     },
     "DiagnosticAddendum": {
-        "annotatedNotAllowed": "[已標註] 特殊表單不可與執行個體和類別檢查一起使用",
+        "annotatedNotAllowed": "[Annotated] 特殊表單不可與執行個體和類別檢查一起使用",
         "argParam": "引數對應至參數 \"{paramName}\"",
         "argParamFunction": "引數對應至函式 \"{functionName}\" 中的參數 \"{paramName}\"",
         "argsParamMissing": "參數 \"*{paramName}\" 沒有對應的參數",
         "argsPositionOnly": "僅限位置的參數不符; 應為 {expected}，但收到 {received}",
         "argumentType": "引數類型為 \"{type}\"",
         "argumentTypes": "引數型別: ({types})",
-        "assignToNone": "類型與 \"None\" 不相容",
+        "assignToNone": "型別無法指派給「None」",
         "asyncHelp": "您是指 \"async with\" 嗎?",
         "baseClassIncompatible": "基底類別 \"{baseClass}\" 與類型 \"{type}\" 不相容",
         "baseClassIncompatibleSubclass": "基底類別 \"{baseClass}\" 衍生自與類型 \"{type}\" 不相容的 \"{subclass}\"",
@@ -657,7 +661,7 @@
         "dataProtocolUnsupported": "\"{name}\" 是個資料通訊協定",
         "descriptorAccessBindingFailed": "無法為描述項類別 \"{className}\" 繫結方法 \"{name}\"",
         "descriptorAccessCallFailed": "無法呼叫描述項類別 \"{className}\" 的方法 \"{name}\"",
-        "finalMethod": "最終方法",
+        "finalMethod": "Final 方法",
         "functionParamDefaultMissing": "參數 \"{name}\" 遺漏了預設引數",
         "functionParamName": "參數名稱不符: \"{destName}\" 與 \"{srcName}\"",
         "functionParamPositionOnly": "僅位置參數不符；參數 \"{name}\" 不是僅限位置",
@@ -665,9 +669,9 @@
         "functionTooFewParams": "函式接受太少位置參數; 預期 {expected}，但收到 {received}",
         "functionTooManyParams": "函式接受太多位置參數; 預期 {expected}，但收到 {received}",
         "genericClassNotAllowed": "執行個體或類別檢查不允許具有類型引數的泛型類型",
-        "incompatibleDeleter": "屬性 deleter 方法不相容",
-        "incompatibleGetter": "屬性 getter 方法不相容",
-        "incompatibleSetter": "屬性 setter 方法不相容",
+        "incompatibleDeleter": "Property deleter 方法不相容",
+        "incompatibleGetter": "Property getter 方法不相容",
+        "incompatibleSetter": "Property setter 方法不相容",
         "initMethodLocation": "__init__ 方法於類別 \"{type}\" 中定義",
         "initMethodSignature": "__init__ 的簽章為 \"{type}\"",
         "initSubclassLocation": "__init_subclass__ 方法已於類別 \"{name}\" 中定義",
@@ -681,14 +685,14 @@
         "keyUndefined": "\"{name}\" 不是 \"{type}\" 中定義的金鑰",
         "kwargsParamMissing": "參數 \"**{paramName}\" 沒有對應的參數",
         "listAssignmentMismatch": "類型 \"{type}\" 與目標清單不相容",
-        "literalAssignmentMismatch": "\"{sourceType}\" 與類型 \"{destType}\" 不相容",
+        "literalAssignmentMismatch": "\"{sourceType}\" 無法指派給型別 \"{destType}\"",
         "matchIsNotExhaustiveHint": "如果不需要徹底處理，請新增 \"case _: pass\"",
         "matchIsNotExhaustiveType": "未處理的類型: \"{type}\"",
         "memberAssignment": "無法將型別 \"{type}\" 的運算式指派給類別 \"{classType}\" 的屬性 \"{name}\"",
         "memberIsAbstract": "\"{type}.{name}\" 未實作",
         "memberIsAbstractMore": "和其他 {count} 人...",
         "memberIsClassVarInProtocol": "\"{name}\" 定義為通訊協定中的 ClassVar",
-        "memberIsInitVar": "\"{name}\" 是僅限初始化的欄位",
+        "memberIsInitVar": "\"{name}\" 是 init-only 的欄位",
         "memberIsInvariant": "\"{name}\" 為不變數，因為它可變動",
         "memberIsNotClassVarInClass": "\"{name}\" 必須定義為 ClassVar，才能與通訊協定相容",
         "memberIsNotClassVarInProtocol": "\"{name}\" 未定義為通訊協定中的 ClassVar",
@@ -699,9 +703,9 @@
         "memberTypeMismatch": "\"{name}\" 是不相容的類型",
         "memberUnknown": "屬性 \"{name}\" 不明",
         "metaclassConflict": "Metaclass「{metaclass1}」與「{metaclass2}」衝突",
-        "missingDeleter": "屬性 deleter 方法遺失",
-        "missingGetter": "屬性 getter 方法遺失",
-        "missingSetter": "遺漏了屬性 setter 方法",
+        "missingDeleter": "Property deleter 方法遺失",
+        "missingGetter": "Property getter 方法遺失",
+        "missingSetter": "遺漏了 property setter 方法",
         "namedParamMissingInDest": "額外參數 \"{name}\"",
         "namedParamMissingInSource": "遺失關鍵詞參數 \"{name}\"",
         "namedParamTypeMismatch": "類型 \"{sourceType}\" 的關鍵字參數 \"{name}\" 與類型 \"{destType}\" 不相容",
@@ -741,13 +745,13 @@
         "paramType": "參數類型為 \"{paramType}\"",
         "privateImportFromPyTypedSource": "改為從 \"{module}\" 匯入",
         "propertyAccessFromProtocolClass": "通訊協定類別中定義的屬性無法存取為類別變數",
-        "propertyMethodIncompatible": "屬性方法 \"{name}\" 不相容",
-        "propertyMethodMissing": "覆寫中遺漏了屬性方法 \"{name}\"",
-        "propertyMissingDeleter": "屬性 \"{name}\" 沒有定義的 deleter",
-        "propertyMissingSetter": "屬性 \"{name}\" 沒有定義的 setter",
+        "propertyMethodIncompatible": "Property 方法 \"{name}\" 不相容",
+        "propertyMethodMissing": "覆寫中遺漏了 property 方法 \"{name}\"",
+        "propertyMissingDeleter": "Property \"{name}\" 沒有定義的 deleter",
+        "propertyMissingSetter": "Property \"{name}\" 沒有定義的 setter",
         "protocolIncompatible": "\"{sourceType}\" 與通訊協定 \"{destType}\" 不相容",
         "protocolMemberMissing": "\"{name}\" 不存在",
-        "protocolRequiresRuntimeCheckable": "通訊協定類別必須為 @runtime_checkable，才能搭配執行個體和類別檢查使用",
+        "protocolRequiresRuntimeCheckable": "Protocol 類別必須為 @runtime_checkable，才能搭配執行個體和類別檢查使用",
         "protocolSourceIsNotConcrete": "\"{sourceType}\" 不是實體類別型別，因此無法指派給型別 \"{destType}\"",
         "protocolUnsafeOverlap": "\"{name}\" 的屬性與通訊協定的名稱相同",
         "pyrightCommentIgnoreTip": "使用 \"# pyright: ignore[<diagnostic rules>]\" 來隱藏單行的診斷",
@@ -759,17 +763,17 @@
         "seeParameterDeclaration": "請參閱參數宣告",
         "seeTypeAliasDeclaration": "請參閱類型別名宣告",
         "seeVariableDeclaration": "請參閱變數宣告",
-        "tupleAssignmentMismatch": "型別 \"{type}\" 與目標元組不相容",
+        "tupleAssignmentMismatch": "型別 \"{type}\" 與目標 tuple 不相容",
         "tupleEntryTypeMismatch": "Tuple 項目 {entry} 的類型不正確",
-        "tupleSizeIndeterminateSrc": "元組大小不符; 預期為 {expected}，但收到不確定的大小",
-        "tupleSizeIndeterminateSrcDest": "元組大小不符; 預期為 {expected} 或其他，但收到不確定的大小",
-        "tupleSizeMismatch": "元組大小不符; 預期為 {expected}，但收到 {received}",
-        "tupleSizeMismatchIndeterminateDest": "元組大小不符; 預期為 {expected} 或其他，但收到 {received}",
+        "tupleSizeIndeterminateSrc": "Tuple 大小不符; 預期為 {expected}，但收到不確定的大小",
+        "tupleSizeIndeterminateSrcDest": "Tuple 大小不符; 預期為 {expected} 或其他，但收到不確定的大小",
+        "tupleSizeMismatch": "Tuple 大小不符; 預期為 {expected}，但收到 {received}",
+        "tupleSizeMismatchIndeterminateDest": "Tuple 大小不符; 預期為 {expected} 或其他，但收到 {received}",
         "typeAliasInstanceCheck": "使用 \"type\" 陳述式建立的類型別名不能搭配執行個體和類別檢查使用",
-        "typeAssignmentMismatch": "類型 \"{sourceType}\" 與類型 \"{destType}\" 不相容",
-        "typeBound": "類型 \"{sourceType}\" 與類型變數 \"{name}\" 的繫結類型 \"{destType}\" 不相容",
-        "typeConstrainedTypeVar": "類型 \"{type}\" 與限制類型變數 \"{name}\" 不相容",
-        "typeIncompatible": "\"{sourceType}\" 與 \"{destType}\" 不相容",
+        "typeAssignmentMismatch": "型別 \"{sourceType}\" 無法指派給型別 \"{destType}\"",
+        "typeBound": "型別 \"{sourceType}\" 無法指派給型別變數 \"{name}\" 的上限 \"{destType}\"",
+        "typeConstrainedTypeVar": "型別 \"{type}\" 無法指派給限制型別變數 \"{name}\"",
+        "typeIncompatible": "\"{sourceType}\" 無法指派給 \"{destType}\"",
         "typeNotClass": "\"{type}\" 不是類別",
         "typeNotStringLiteral": "\"{type}\" 不是字串常值",
         "typeOfSymbol": "\"{name}\" 的型別為 \"{type}\"",
@@ -780,7 +784,7 @@
         "typeVarIsCovariant": "型別參數 \"{name}\" 具有共變性，但 \"{sourceType}\" 不是 \"{destType}\" 的子型別",
         "typeVarIsInvariant": "型別參數 \"{name}\" 具有不變性，但 \"{sourceType}\" 與 \"{destType}\" 不同",
         "typeVarNotAllowed": "執行個體或類別檢查不允許 TypeVar",
-        "typeVarTupleRequiresKnownLength": "TypeVarTuple 無法繫結至長度不明的元組",
+        "typeVarTupleRequiresKnownLength": "TypeVarTuple 無法繫結至長度不明的 tuple",
         "typeVarUnnecessarySuggestion": "改用 {type}",
         "typeVarUnsolvableRemedy": "提供多載，其指定未提供引數時的傳回類型",
         "typeVarsMissing": "遺失類型變數: {names}",
@@ -803,9 +807,9 @@
         "unhashableType": "型別 \"{type}\" 無法雜湊",
         "uninitializedAbstractVariable": "執行個體變數 \"{name}\" 在抽象基底類別 \"{classType}\" 中定義，但未初始化",
         "unreachableExcept": "\"{exceptionType}\" 是 \"{parentType}\" 的子類別",
-        "useDictInstead": "使用 Dict[T1，T2] 來表示字典型別",
-        "useListInstead": "使用 List[T] 來表示清單型別，或使用 Union [T1, T2] 來表示等位型別",
-        "useTupleInstead": "使用 tuple[T1, ..., Tn] 來指出 Tuple 類型或 Union[T1, T2] 來指出聯集類型",
+        "useDictInstead": "使用 Dict[T1, T2] 來表示字典型別",
+        "useListInstead": "使用 List[T] 來指出 list 類型，或使用 Union[T1, T2] 來指出 union 類型",
+        "useTupleInstead": "使用 tuple[T1, ..., Tn] 來指出 tuple 類型，或使用 Union[T1, T2] 來指出 union 類型",
         "useTypeInstead": "改為使用 Type[T]",
         "varianceMismatchForClass": "型別引數 \"{typeVarName}\" 的變異數與基底類別 \"{className}\" 不相容",
         "varianceMismatchForTypeAlias": "型別引數 \"{typeVarName}\" 的變異數與 \"{typeAliasParam}\" 不相容"