@zzzen/pyright-internal 1.2.0-dev.20240825 → 1.2.0-dev.20240901

package/dist/localization/package.nls.cs.json

@@ -356,8 +356,8 @@
         "orPatternMissingName": "Všechny dílčí vzory v rámci vzoru or musí cílit na stejné názvy",
         "overlappingKeywordArgs": "Slovník silného typu se překrývá s parametrem klíčového slova: {names}",
         "overlappingOverload": "Přetížení {obscured} pro {name} se nikdy nepoužije, protože jeho parametry se překrývají s přetížením {obscuredBy}",
-        "overloadAbstractImplMismatch": "Overloads must match abstract status of implementation",
-        "overloadAbstractMismatch": "Overloads must all be abstract or not",
+        "overloadAbstractImplMismatch": "Přetížení musí odpovídat abstraktnímu stavu implementace.",
+        "overloadAbstractMismatch": "Buď musí být všechna přetížení abstraktní, nebo naopak nesmí být žádné z nich abstraktní.",
         "overloadClassMethodInconsistent": "Přetížení pro {name} používají @classmethod nekonzistentně.",
         "overloadFinalInconsistencyImpl": "Přetížení pro „{name}“ je označené @final ale implementace není",
         "overloadFinalInconsistencyNoImpl": "Přetížení {index} pro „{name}“ je označené @final ale přetížení 1 není",
@@ -692,8 +692,8 @@
         "memberIsInvariant": "{name} je invariantní, protože je proměnlivé",
         "memberIsNotClassVarInClass": "„{name}“ musí být definováno jako ClassVar, aby bylo kompatibilní s protokolem.",
         "memberIsNotClassVarInProtocol": "„{name}“ není v protokolu definován jako ClassVar.",
-        "memberIsNotReadOnlyInProtocol": "\"{name}\" is not read-only in protocol",
-        "memberIsReadOnlyInProtocol": "\"{name}\" is read-only in protocol",
+        "memberIsNotReadOnlyInProtocol": "{name} není v protokolu jen pro čtení.",
+        "memberIsReadOnlyInProtocol": "{name} je v protokolu jen pro čtení.",
         "memberIsWritableInProtocol": "{name} se dá zapisovat do protokolu.",
         "memberSetClassVar": "Atribut {name} nelze přiřadit prostřednictvím instance třídy, protože jde o ClassVar.",
         "memberTypeMismatch": "{name} je nekompatibilní typ",

package/dist/localization/package.nls.de.json

@@ -356,8 +356,8 @@
         "orPatternMissingName": "Alle Teilmuster innerhalb eines \"or\"-Musters müssen auf dieselben Namen zielen.",
         "overlappingKeywordArgs": "Typisierte Wörterbuchüberlappungen mit Schlüsselwortparameter: {names}",
         "overlappingOverload": "Überladung {obscured} für \"{name}\" wird nie verwendet, da sich die Parameter überlappen, {obscuredBy}",
-        "overloadAbstractImplMismatch": "Overloads must match abstract status of implementation",
-        "overloadAbstractMismatch": "Overloads must all be abstract or not",
+        "overloadAbstractImplMismatch": "Überladungen müssen dem abstrakten Status der Implementierung entsprechen.",
+        "overloadAbstractMismatch": "Überladungen müssen alle abstrakt sein oder nicht.",
         "overloadClassMethodInconsistent": "Überladungen für \"{name}\" verwenden @classmethod inkonsistent",
         "overloadFinalInconsistencyImpl": "Die Überladung für „{name}“ ist @final markiert, die Implementierung ist es jedoch nicht.",
         "overloadFinalInconsistencyNoImpl": "Überladung {index} für „{name}“ ist als @final markiert, Überladung 1 ist es jedoch nicht.",
@@ -692,8 +692,8 @@
         "memberIsInvariant": "\"{name}\" ist invariant, da es änderbar ist.",
         "memberIsNotClassVarInClass": "„{name}“ muss als ClassVar definiert sein, um mit dem Protokoll kompatibel zu sein.",
         "memberIsNotClassVarInProtocol": "„{name}“ ist nicht als ClassVar im Protokoll definiert.",
-        "memberIsNotReadOnlyInProtocol": "\"{name}\" is not read-only in protocol",
-        "memberIsReadOnlyInProtocol": "\"{name}\" is read-only in protocol",
+        "memberIsNotReadOnlyInProtocol": "\"{name}\" ist im Protokoll nicht schreibgeschützt.",
+        "memberIsReadOnlyInProtocol": "\"{name}\" ist im Protokoll schreibgeschützt.",
         "memberIsWritableInProtocol": "\"{name}\" ist im Protokoll beschreibbar.",
         "memberSetClassVar": "Attribut „{name}“ kann nicht über eine Klasseninstanz zugewiesen werden, da es sich um eine ClassVar handelt",
         "memberTypeMismatch": "\"{name}\" ist ein inkompatibler Typ.",

package/dist/localization/package.nls.en-us.json

@@ -21,12 +21,12 @@
             "message": "Expected one type argument and one or more annotations for \"Annotated\"",
             "comment": "{Locked='Annotated'}"
         },
-        "annotationBytesString": "Type annotations cannot use bytes string literals",
-        "annotationFormatString": "Type annotations cannot use format string literals (f-strings)",
+        "annotationBytesString": "Type expressions cannot use bytes string literals",
+        "annotationFormatString": "Type expressions cannot use format string literals (f-strings)",
         "annotationNotSupported": "Type annotation not supported for this statement",
-        "annotationRawString": "Type annotations cannot use raw string literals",
-        "annotationSpansStrings": "Type annotations cannot span multiple string literals",
-        "annotationStringEscape": "Type annotations cannot contain escape characters",
+        "annotationRawString": "Type expressions cannot use raw string literals",
+        "annotationSpansStrings": "Type expressions cannot span multiple string literals",
+        "annotationStringEscape": "Type expressions cannot contain escape characters",
         "argAssignment": "Argument of type \"{argType}\" cannot be assigned to parameter of type \"{paramType}\"",
         "argAssignmentFunction": "Argument of type \"{argType}\" cannot be assigned to parameter of type \"{paramType}\" in function \"{functionName}\"",
         "argAssignmentParam": "Argument of type \"{argType}\" cannot be assigned to parameter \"{paramName}\" of type \"{paramType}\"",
@@ -50,7 +50,7 @@
         "assignmentTargetExpr": "Expression cannot be assignment target",
         "asyncNotInAsyncFunction": "Use of \"async\" not allowed outside of async function",
         "awaitIllegal": "Use of \"await\" requires Python 3.5 or newer",
-        "awaitNotAllowed": "Type annotations cannot use \"await\"",
+        "awaitNotAllowed": "Type expressions cannot use \"await\"",
         "awaitNotInAsync": "\"await\" allowed only within async function",
         "backticksIllegal": "Expressions surrounded by backticks are not supported in Python 3.x; use repr instead",
         "baseClassCircular": "Class cannot derive from itself",
@@ -60,7 +60,7 @@
         "baseClassMethodTypeIncompatible": "Base classes for class \"{classType}\" define method \"{name}\" in incompatible way",
         "baseClassUnknown": "Base class type is unknown, obscuring type of derived class",
         "baseClassVariableTypeIncompatible": "Base classes for class \"{classType}\" define variable \"{name}\" in incompatible way",
-        "binaryOperationNotAllowed": "Binary operator not allowed in type annotation",
+        "binaryOperationNotAllowed": "Binary operator not allowed in type expression",
         "bindTypeMismatch": "Could not bind method \"{methodName}\" because \"{type}\" is not assignable to parameter \"{paramName}\"",
         "breakOutsideLoop": "\"break\" can be used only within a loop",
         "callableExtraArgs": "Expected only two type arguments to \"Callable\"",
@@ -73,7 +73,7 @@
         "classDefinitionCycle": "Class definition for \"{name}\" depends on itself",
         "classGetItemClsParam": "__class_getitem__ override should take a \"cls\" parameter",
         "classMethodClsParam": "Class methods should take a \"cls\" parameter",
-        "classNotRuntimeSubscriptable": "Subscript for class \"{name}\" will generate runtime exception; enclose type annotation in quotes",
+        "classNotRuntimeSubscriptable": "Subscript for class \"{name}\" will generate runtime exception; enclose type expression in quotes",
         "classPatternBuiltInArgPositional": "Class pattern accepts only positional sub-pattern",
         "classPatternPositionalArgCount": "Too many positional patterns for class \"{type}\"; expected {expected} but received {received}",
         "classPatternTypeAlias": "\"{type}\" cannot be used in a class pattern because it is a specialized type alias",
@@ -135,7 +135,7 @@
         "deprecatedPropertySetter": "The setter for property \"{name}\" is deprecated",
         "deprecatedType": "This type is deprecated as of Python {version}; use \"{replacement}\" instead",
         "dictExpandIllegalInComprehension": "Dictionary expansion not allowed in comprehension",
-        "dictInAnnotation": "Dictionary expression not allowed in type annotation",
+        "dictInAnnotation": "Dictionary expression not allowed in type expression",
         "dictKeyValuePairs": "Dictionary entries must contain key/value pairs",
         "dictUnpackIsNotMapping": "Expected mapping for dictionary unpack operator",
         "dunderAllSymbolNotPresent": "\"{name}\" is specified in __all__ but is not present in module",
@@ -295,7 +295,7 @@
         "lambdaReturnTypePartiallyUnknown": "Return type of lambda, \"{returnType}\", is partially unknown",
         "lambdaReturnTypeUnknown": "Return type of lambda is unknown",
         "listAssignmentMismatch": "Expression with type \"{type}\" cannot be assigned to target list",
-        "listInAnnotation": "List expression not allowed in type annotation",
+        "listInAnnotation": "List expression not allowed in type expression",
         "literalEmptyArgs": "Expected one or more type arguments after \"Literal\"",
         "literalNamedUnicodeEscape": "Named unicode escape sequences are not supported in \"Literal\" string annotations",
         "literalNotAllowed": "\"Literal\" cannot be used in this context without a type argument",
@@ -439,7 +439,7 @@
         "returnMissing": "Function with declared return type \"{returnType}\" must return value on all code paths",
         "returnOutsideFunction": "\"return\" can be used only within a function",
         "returnTypeContravariant": "Contravariant type variable cannot be used in return type",
-        "returnTypeMismatch": "Expression of type \"{exprType}\" is incompatible with return type \"{returnType}\"",
+        "returnTypeMismatch": "Type \"{exprType}\" is not assignable to return type \"{returnType}\"",
         "returnTypePartiallyUnknown": "Return type, \"{returnType}\", is partially unknown",
         "returnTypeUnknown": "Return type is unknown",
         "revealLocalsArgs": "Expected no arguments for \"reveal_locals\" call",
@@ -461,7 +461,7 @@
         "staticClsSelfParam": "Static methods should not take a \"self\" or \"cls\" parameter",
         "stdlibModuleOverridden": "\"{path}\" is overriding the stdlib module \"{name}\"",
         "stringNonAsciiBytes": "Non-ASCII character not allowed in bytes string literal",
-        "stringNotSubscriptable": "String expression cannot be subscripted in type annotation; enclose entire annotation in quotes",
+        "stringNotSubscriptable": "String expression cannot be subscripted in type expression; enclose entire expression in quotes",
         "stringUnsupportedEscape": "Unsupported escape sequence in string literal",
         "stringUnterminated": "String literal is unterminated",
         "stubFileMissing": "Stub file not found for \"{importName}\"",
@@ -476,12 +476,12 @@
         "symbolIsUnbound": "\"{name}\" is unbound",
         "symbolIsUndefined": "\"{name}\" is not defined",
         "symbolOverridden": "\"{name}\" overrides symbol of same name in class \"{className}\"",
-        "ternaryNotAllowed": "Ternary expression not allowed in type annotation",
+        "ternaryNotAllowed": "Ternary expression not allowed in type expression",
         "totalOrderingMissingMethod": "Class must define one of \"__lt__\", \"__le__\", \"__gt__\", or \"__ge__\" to use total_ordering",
         "trailingCommaInFromImport": "Trailing comma not allowed without surrounding parentheses",
         "tryWithoutExcept": "Try statement must have at least one except or finally clause",
         "tupleAssignmentMismatch": "Expression with type \"{type}\" cannot be assigned to target tuple",
-        "tupleInAnnotation": "Tuple expression not allowed in type annotation",
+        "tupleInAnnotation": "Tuple expression not allowed in type expression",
         "tupleIndexOutOfRange": "Index {index} is out of range for type {type}",
         "typeAliasIllegalExpressionForm": "Invalid expression form for type alias definition",
         "typeAliasIsRecursiveDirect": "Type alias \"{name}\" cannot use itself in its definition",
@@ -505,9 +505,9 @@
         "typeArgsMissingForClass": "Expected type arguments for generic class \"{name}\"",
         "typeArgsTooFew": "Too few type arguments provided for \"{name}\"; expected {expected} but received {received}",
         "typeArgsTooMany": "Too many type arguments provided for \"{name}\"; expected {expected} but received {received}",
-        "typeAssignmentMismatch": "Expression of type \"{sourceType}\" is incompatible with declared type \"{destType}\"",
-        "typeAssignmentMismatchWildcard": "Import symbol \"{name}\" has type \"{sourceType}\", which is incompatible with declared type \"{destType}\"",
-        "typeCallNotAllowed": "type() call should not be used in type annotation",
+        "typeAssignmentMismatch": "Type \"{sourceType}\" is not assignable to declared type \"{destType}\"",
+        "typeAssignmentMismatchWildcard": "Import symbol \"{name}\" has type \"{sourceType}\", which is not assignable to declared type \"{destType}\"",
+        "typeCallNotAllowed": "type() call should not be used in type expression",
         "typeCheckOnly": "\"{name}\" is marked as @type_check_only and can be used only in type annotations",
         "typeCommentDeprecated": "Use of type comments is deprecated; use type annotation instead",
         "typeExpectedClass": "Expected class but received \"{type}\"",
@@ -586,7 +586,7 @@
         "unaccessedSymbol": "\"{name}\" is not accessed",
         "unaccessedVariable": "Variable \"{name}\" is not accessed",
         "unannotatedFunctionSkipped": "Analysis of function \"{name}\" is skipped because it is unannotated",
-        "unaryOperationNotAllowed": "Unary operator not allowed in type annotation",
+        "unaryOperationNotAllowed": "Unary operator not allowed in type expression",
         "unexpectedAsyncToken": "Expected \"def\", \"with\" or \"for\" to follow \"async\"",
         "unexpectedExprToken": "Unexpected token at end of expression",
         "unexpectedIndent": "Unexpected indentation",
@@ -610,7 +610,7 @@
         "unpackExpectedTypeVarTuple": "Expected TypeVarTuple or tuple as type argument for Unpack",
         "unpackExpectedTypedDict": "Expected TypedDict type argument for Unpack",
         "unpackIllegalInComprehension": "Unpack operation not allowed in comprehension",
-        "unpackInAnnotation": "Unpack operator not allowed in type annotation",
+        "unpackInAnnotation": "Unpack operator not allowed in type expression",
         "unpackInDict": "Unpack operation not allowed in dictionaries",
         "unpackInSet": "Unpack operator not allowed within a set",
         "unpackNotAllowed": "Unpack is not allowed in this context",
@@ -656,7 +656,7 @@
         "argsPositionOnly": "Position-only parameter mismatch; expected {expected} but received {received}",
         "argumentType": "Argument type is \"{type}\"",
         "argumentTypes": "Argument types: ({types})",
-        "assignToNone": "Type is incompatible with \"None\"",
+        "assignToNone": "Type is not assignable to \"None\"",
         "asyncHelp": "Did you mean \"async with\"?",
         "baseClassIncompatible": "Base class \"{baseClass}\" is incompatible with type \"{type}\"",
         "baseClassIncompatibleSubclass": "Base class \"{baseClass}\" derives from \"{subclass}\" which is incompatible with type \"{type}\"",
@@ -693,7 +693,7 @@
         "keyUndefined": "\"{name}\" is not a defined key in \"{type}\"",
         "kwargsParamMissing": "Parameter \"**{paramName}\" has no corresponding parameter",
         "listAssignmentMismatch": "Type \"{type}\" is incompatible with target list",
-        "literalAssignmentMismatch": "\"{sourceType}\" is incompatible with type \"{destType}\"",
+        "literalAssignmentMismatch": "\"{sourceType}\" is not assignable to type \"{destType}\"",
         "matchIsNotExhaustiveHint": "If exhaustive handling is not intended, add \"case _: pass\"",
         "matchIsNotExhaustiveType": "Unhandled type: \"{type}\"",
         "memberAssignment": "Expression of type \"{type}\" cannot be assigned to attribute \"{name}\" of class \"{classType}\"",
@@ -778,10 +778,10 @@
         "tupleSizeMismatch": "Tuple size mismatch; expected {expected} but received {received}",
         "tupleSizeMismatchIndeterminateDest": "Tuple size mismatch; expected {expected} or more but received {received}",
         "typeAliasInstanceCheck": "Type alias created with \"type\" statement cannot be used with instance and class checks",
-        "typeAssignmentMismatch": "Type \"{sourceType}\" is incompatible with type \"{destType}\"",
-        "typeBound": "Type \"{sourceType}\" is incompatible with bound type \"{destType}\" for type variable \"{name}\"",
-        "typeConstrainedTypeVar": "Type \"{type}\" is incompatible with constrained type variable \"{name}\"",
-        "typeIncompatible": "\"{sourceType}\" is incompatible with \"{destType}\"",
+        "typeAssignmentMismatch": "Type \"{sourceType}\" is not assignable to type \"{destType}\"",
+        "typeBound": "Type \"{sourceType}\" is not assignable to upper bound \"{destType}\" for type variable \"{name}\"",
+        "typeConstrainedTypeVar": "Type \"{type}\" is not assignable to constrained type variable \"{name}\"",
+        "typeIncompatible": "\"{sourceType}\" is not assignable to \"{destType}\"",
         "typeNotClass": "\"{type}\" is not a class",
         "typeNotStringLiteral": "\"{type}\" is not a string literal",
         "typeOfSymbol": "Type of \"{name}\" is \"{type}\"",

package/dist/localization/package.nls.es.json

@@ -356,8 +356,8 @@
         "orPatternMissingName": "Todos los subpatrones de un patrón \"o\" deben tener los mismos nombres",
         "overlappingKeywordArgs": "El diccionario escrito se superpone con el parámetro de palabra clave: {names}",
         "overlappingOverload": "La sobrecarga {obscured} para \"{name}\" nunca se utilizará porque sus parámetros se superpone con la sobrecarga {obscuredBy}.",
-        "overloadAbstractImplMismatch": "Overloads must match abstract status of implementation",
-        "overloadAbstractMismatch": "Overloads must all be abstract or not",
+        "overloadAbstractImplMismatch": "Las sobrecargas deben coincidir con el estado abstracto de la implementación",
+        "overloadAbstractMismatch": "Todos los métodos sobrecargados deben ser abstractos o no",
         "overloadClassMethodInconsistent": "Las sobrecargas de \"{name}\" usan @classmethod de forma incoherente",
         "overloadFinalInconsistencyImpl": "La sobrecarga de \"{name}\" está marcada @final pero la implementación no",
         "overloadFinalInconsistencyNoImpl": "La sobrecarga {index} para \"{name}\" está marcada @final pero la sobrecarga 1 no lo está.",
@@ -692,8 +692,8 @@
         "memberIsInvariant": "\"{name}\" es invariable porque es mutable",
         "memberIsNotClassVarInClass": "\"{name}\" debe definirse como ClassVar para que sea compatible con el protocolo",
         "memberIsNotClassVarInProtocol": "\"{name}\" no está definido como ClassVar en el protocolo",
-        "memberIsNotReadOnlyInProtocol": "\"{name}\" is not read-only in protocol",
-        "memberIsReadOnlyInProtocol": "\"{name}\" is read-only in protocol",
+        "memberIsNotReadOnlyInProtocol": "\"{name}\" no es de solo lectura en el protocolo",
+        "memberIsReadOnlyInProtocol": "\"{name}\" es de solo lectura en el protocolo",
         "memberIsWritableInProtocol": "\"{name}\" se puede escribir en el protocolo",
         "memberSetClassVar": "El atributo \"{name}\" no se puede asignar a través de una instancia de clase porque es un ClassVar.",
         "memberTypeMismatch": "\"{name}\" es un tipo incompatible",

package/dist/localization/package.nls.fr.json

@@ -356,8 +356,8 @@
         "orPatternMissingName": "Tous les sous-modèles d’un modèle « or » doivent cibler les mêmes noms",
         "overlappingKeywordArgs": "Le dictionnaire tapé chevauche avec le mot clé paramètre : {names}",
         "overlappingOverload": "La surcharge {obscured} pour « {name} » ne sera jamais utilisée, car ses paramètres chevauchent la surcharge {obscuredBy}",
-        "overloadAbstractImplMismatch": "Overloads must match abstract status of implementation",
-        "overloadAbstractMismatch": "Overloads must all be abstract or not",
+        "overloadAbstractImplMismatch": "Les surcharges doivent correspondre à l’état abstrait de l’implémentation",
+        "overloadAbstractMismatch": "Les surcharges doivent toutes être abstraites ou non",
         "overloadClassMethodInconsistent": "Les surcharges pour « {name} » utilisent @classmethod de manière incohérente",
         "overloadFinalInconsistencyImpl": "La surcharge pour « {name} » est marquée @final, mais l’implémentation ne l’est pas",
         "overloadFinalInconsistencyNoImpl": "La surcharge {index} pour « {name} » est marquée @final mais la surcharge 1 n’est pas",
@@ -692,8 +692,8 @@
         "memberIsInvariant": "« {name} » est invariant, car il est mutable",
         "memberIsNotClassVarInClass": "« {name} » doit être défini en tant que ClassVar pour être compatible avec le protocole",
         "memberIsNotClassVarInProtocol": "« {name} » n’est pas défini en tant que ClassVar dans le protocole",
-        "memberIsNotReadOnlyInProtocol": "\"{name}\" is not read-only in protocol",
-        "memberIsReadOnlyInProtocol": "\"{name}\" is read-only in protocol",
+        "memberIsNotReadOnlyInProtocol": "« {name} » n’est pas en lecture seule dans le protocole",
+        "memberIsReadOnlyInProtocol": "« {name} » est en lecture seule dans le protocole",
         "memberIsWritableInProtocol": "« {name} » est accessible en écriture dans le protocole",
         "memberSetClassVar": "L’attribut « {name} » ne peut pas être attribué via une instance de classe car il s’agit d’une ClassVar",
         "memberTypeMismatch": "« {name} » est un type incompatible",

package/dist/localization/package.nls.it.json

@@ -356,8 +356,8 @@
         "orPatternMissingName": "Tutti i criteri secondari all'interno di un criterio \"or\" devono avere come destinazione gli stessi nomi",
         "overlappingKeywordArgs": "Il dizionario tipizzato si sovrappone al parametro della parola chiave: {names}",
         "overlappingOverload": "L'overload {obscured} per \"{name}\" non verrà mai usato perché i parametri si sovrappongono all'overload {obscuredBy}",
-        "overloadAbstractImplMismatch": "Overloads must match abstract status of implementation",
-        "overloadAbstractMismatch": "Overloads must all be abstract or not",
+        "overloadAbstractImplMismatch": "Gli overload devono corrispondere allo stato astratto dell'implementazione",
+        "overloadAbstractMismatch": "Gli overload devono essere tutti astratti o no",
         "overloadClassMethodInconsistent": "Gli overload per \"{name}\" usano @classmethod in modo incoerente",
         "overloadFinalInconsistencyImpl": "L'overload per “{name}” è contrassegnato @final ma l'implementazione non lo è",
         "overloadFinalInconsistencyNoImpl": "L'overload {index} per “{name}” è contrassegnato @final ma l'overload 1 non lo è",
@@ -692,8 +692,8 @@
         "memberIsInvariant": "\"{name}\" è invariante perché modificabile",
         "memberIsNotClassVarInClass": "\"{name}\" deve essere definito come ClassVar per essere compatibile con il protocollo",
         "memberIsNotClassVarInProtocol": "“{name}” non è definito come ClassVar nel protocollo",
-        "memberIsNotReadOnlyInProtocol": "\"{name}\" is not read-only in protocol",
-        "memberIsReadOnlyInProtocol": "\"{name}\" is read-only in protocol",
+        "memberIsNotReadOnlyInProtocol": "\"{name}\" non è di sola lettura nel protocollo",
+        "memberIsReadOnlyInProtocol": "\"{name}\" è di sola lettura nel protocollo",
         "memberIsWritableInProtocol": "\"{name}\" è scrivibile nel protocollo",
         "memberSetClassVar": "Non è possibile assegnare l'attributo \"{name}\" tramite un'istanza di classe perché è una ClassVar",
         "memberTypeMismatch": "\"{name}\" è un tipo non compatibile",

package/dist/localization/package.nls.ja.json

@@ -356,8 +356,8 @@
         "orPatternMissingName": "\"or\" パターン内のすべてのサブパターンは、同じ名前をターゲットにする必要があります",
         "overlappingKeywordArgs": "入力された辞書はキーワード パラメーターと重複しています: {names}",
         "overlappingOverload": "パラメーターがオーバーロード {obscuredBy} と重複しているため、\"{name}\" のオーバーロード {obscured} は使用されません",
-        "overloadAbstractImplMismatch": "Overloads must match abstract status of implementation",
-        "overloadAbstractMismatch": "Overloads must all be abstract or not",
+        "overloadAbstractImplMismatch": "オーバーロードは実装の抽象状態と一致する必要があります",
+        "overloadAbstractMismatch": "オーバーロードはすべて抽象であるか抽象でない必要があります",
         "overloadClassMethodInconsistent": "\"{name}\" のオーバーロードでは、@classmethod を不整合に使用します",
         "overloadFinalInconsistencyImpl": "\"{name}\" のオーバーロードは @final としてマークされていますが、実装は @final としてマークされていません",
         "overloadFinalInconsistencyNoImpl": "\"{name}\" のオーバーロード {index} は @final としてマークされていますが、オーバーロード 1 は @final としてマークされていません",
@@ -692,8 +692,8 @@
         "memberIsInvariant": "\"{name}\" は変更可能であるため、不変です",
         "memberIsNotClassVarInClass": "プロトコルと互換性を持たせるには、\"{name}\" を ClassVar として定義する必要があります",
         "memberIsNotClassVarInProtocol": "\"{name}\" はプロトコルで ClassVar として定義されていません",
-        "memberIsNotReadOnlyInProtocol": "\"{name}\" is not read-only in protocol",
-        "memberIsReadOnlyInProtocol": "\"{name}\" is read-only in protocol",
+        "memberIsNotReadOnlyInProtocol": "\"{name}\" はプロトコルで読み取り専用ではありません",
+        "memberIsReadOnlyInProtocol": "\"{name}\" はプロトコルで読み取り専用です",
         "memberIsWritableInProtocol": "\"{name}\" はプロトコルで書き込み可能です",
         "memberSetClassVar": "属性 \"{name}\" は ClassVar であるため、クラス インスタンスを介して割り当てることはできません",
         "memberTypeMismatch": "\"{name}\" は互換性のない型です",

package/dist/localization/package.nls.ko.json

@@ -356,8 +356,8 @@
         "orPatternMissingName": "\"or\" 패턴 내의 모든 하위 패턴은 동일한 이름을 대상으로 해야 합니다.",
         "overlappingKeywordArgs": "형식화된 사전이 키워드 매개 변수 {names}과(와) 겹칩니다.",
         "overlappingOverload": "매개 변수가 오버로드 {obscuredBy}과(와) 겹치므로 \"{name}\"에 대한 오버로드 {obscured}이(가) 사용되지 않습니다.",
-        "overloadAbstractImplMismatch": "Overloads must match abstract status of implementation",
-        "overloadAbstractMismatch": "Overloads must all be abstract or not",
+        "overloadAbstractImplMismatch": "오버로드는 구현의 추상 상태와 일치해야 합니다.",
+        "overloadAbstractMismatch": "오버로드는 모두 추상이거나 아니어야 합니다",
         "overloadClassMethodInconsistent": "\"{name}\"의 오버로드가 @classmethod를 일관되지 않게 사용합니다.",
         "overloadFinalInconsistencyImpl": "\"{name}\"에 대한 오버로드가 @final로 표시되었지만 구현은 아닙니다.",
         "overloadFinalInconsistencyNoImpl": "\"{name}\"에 대한 오버로드 {index}는 @final로 표시되지만 오버로드 1은 표시되지 않습니다.",
@@ -692,8 +692,8 @@
         "memberIsInvariant": "\"{name}\"은(는) 변경 가능하므로 고정되지 않습니다.",
         "memberIsNotClassVarInClass": "\"{name}\"은(는) 프로토콜과 호환되려면 ClassVar로 정의해야 합니다.",
         "memberIsNotClassVarInProtocol": "\"{name}\"이(가) 프로토콜에서 ClassVar로 정의되지 않았습니다.",
-        "memberIsNotReadOnlyInProtocol": "\"{name}\" is not read-only in protocol",
-        "memberIsReadOnlyInProtocol": "\"{name}\" is read-only in protocol",
+        "memberIsNotReadOnlyInProtocol": "\"{name}\"(이)가 프로토콜에서 읽기 전용이 아닙니다.",
+        "memberIsReadOnlyInProtocol": "\"{name}\"은(는) 프로토콜에서 읽기 전용입니다.",
         "memberIsWritableInProtocol": "\"{name}\"은(는) 프로토콜에서 쓸 수 있습니다.",
         "memberSetClassVar": "\"{name}\" 특성은 ClassVar이므로 클래스 인스턴스를 통해 할당할 수 없음",
         "memberTypeMismatch": "\"{name}\"은(는) 호환되지 않는 형식입니다.",

package/dist/localization/package.nls.pl.json

@@ -356,8 +356,8 @@
         "orPatternMissingName": "Wszystkie wzorce podrzędne we wzorcu „or” muszą dotyczyć tych samych nazw",
         "overlappingKeywordArgs": "Wpisany słownik nakłada się na parametr słowa kluczowego: {names}",
         "overlappingOverload": "Przeciążenie {obscured} dla nazwy „{name}” nigdy nie zostanie użyte, ponieważ jego parametry nakładają się na przeciążenie {obscuredBy}",
-        "overloadAbstractImplMismatch": "Overloads must match abstract status of implementation",
-        "overloadAbstractMismatch": "Overloads must all be abstract or not",
+        "overloadAbstractImplMismatch": "Przeciążenia muszą być zgodne ze stanem abstrakcyjnym implementacji",
+        "overloadAbstractMismatch": "Przeciążenia muszą być abstrakcyjne lub nieabstrakcyjne",
         "overloadClassMethodInconsistent": "Przeciążenia dla nazwy „{name}” używają metody @classmethod niekonsekwentnie",
         "overloadFinalInconsistencyImpl": "Przeciążenie elementu „{name}” jest oznaczone @final, ale implementacja nie jest",
         "overloadFinalInconsistencyNoImpl": "Przeciążenie {index} dla elementu „{name}” jest oznaczone @final, ale przeciążenie 1 nie jest",
@@ -692,8 +692,8 @@
         "memberIsInvariant": "Nazwa „{name}” jest niezmienna, ponieważ jest modyfikowalna",
         "memberIsNotClassVarInClass": "Element „{name}” musi być zdefiniowany jako ClassVar, aby był zgodny z protokołem",
         "memberIsNotClassVarInProtocol": "Element „{name}” nie jest zdefiniowany jako ClassVar w protokole",
-        "memberIsNotReadOnlyInProtocol": "\"{name}\" is not read-only in protocol",
-        "memberIsReadOnlyInProtocol": "\"{name}\" is read-only in protocol",
+        "memberIsNotReadOnlyInProtocol": "„{name}” nie jest tylko do odczytu w protokole",
+        "memberIsReadOnlyInProtocol": "„{name}” jest tylko do odczytu w protokole",
         "memberIsWritableInProtocol": "Nazwa „{name}” jest zapisywalna w protokole",
         "memberSetClassVar": "Atrybut „{name}” nie może zostać przypisany przez wystąpienie klasy, ponieważ jest to element ClassVar",
         "memberTypeMismatch": "Nazwa „{name}” jest niezgodnym typem",

package/dist/localization/package.nls.pt-br.json

@@ -356,8 +356,8 @@
         "orPatternMissingName": "Todos os subpadrões dentro de um padrão \"ou\" devem ter como destino os mesmos nomes",
         "overlappingKeywordArgs": "O dicionário digitado se sobrepõe ao parâmetro de palavra-chave: {names}",
         "overlappingOverload": "A sobrecarga {obscured} para \"{name}\" nunca será usada porque seus parâmetros se sobrepõem à sobrecarga {obscuredBy}",
-        "overloadAbstractImplMismatch": "Overloads must match abstract status of implementation",
-        "overloadAbstractMismatch": "Overloads must all be abstract or not",
+        "overloadAbstractImplMismatch": "As sobrecargas devem corresponder ao status abstrato da implementação",
+        "overloadAbstractMismatch": "As sobrecargas devem ser abstratas ou não",
         "overloadClassMethodInconsistent": "Sobrecargas para \"{name}\" usam @classmethod inconsistentemente",
         "overloadFinalInconsistencyImpl": "A sobrecarga para \"{name}\" está marcada como @final mas a implementação não está",
         "overloadFinalInconsistencyNoImpl": "A sobrecarga {index} para \"{name}\" está marcada como @final mas a sobrecarga 1 não está",
@@ -692,8 +692,8 @@
         "memberIsInvariant": "\"{name}\" é invariável porque é mutável",
         "memberIsNotClassVarInClass": "\"{name}\" deve ser definido como um ClassVar para ser compatível com o protocolo",
         "memberIsNotClassVarInProtocol": "\"{name}\" não está definido como um ClassVar no protocolo",
-        "memberIsNotReadOnlyInProtocol": "\"{name}\" is not read-only in protocol",
-        "memberIsReadOnlyInProtocol": "\"{name}\" is read-only in protocol",
+        "memberIsNotReadOnlyInProtocol": "\"{name}\" não é somente leitura no protocolo",
+        "memberIsReadOnlyInProtocol": "\"{name}\" é somente leitura no protocolo",
         "memberIsWritableInProtocol": "\"{name}\" é gravável no protocolo",
         "memberSetClassVar": "O atributo \"{name}\" não pode ser atribuído por meio de uma instância de classe porque é um ClassVar",
         "memberTypeMismatch": "\"{name}\" é um tipo incompatível",

package/dist/localization/package.nls.ru.json

@@ -356,8 +356,8 @@
         "orPatternMissingName": "Все вложенные шаблоны в шаблоне \"or\" должны быть привязаны к одним и тем же именам",
         "overlappingKeywordArgs": "Типизированный словарь перекрывается с параметром ключевого слова: {names}",
         "overlappingOverload": "Перегрузка {obscured} для \"{name}\" никогда не будет использоваться, так как ее параметры перекрывают перегрузку {obscuredBy}",
-        "overloadAbstractImplMismatch": "Overloads must match abstract status of implementation",
-        "overloadAbstractMismatch": "Overloads must all be abstract or not",
+        "overloadAbstractImplMismatch": "Перегрузки должны соответствовать абстрактному статусу реализации",
+        "overloadAbstractMismatch": "Все перегрузки должны быть абстрактными или не абстрактными",
         "overloadClassMethodInconsistent": "Перегрузки для \"{name}\" используют @classmethod несогласованно",
         "overloadFinalInconsistencyImpl": "Перегрузка для \"{name}\" помечена как @окончательная, но реализация — нет",
         "overloadFinalInconsistencyNoImpl": "Перегрузка {index} для \"{name}\" помечена как @окончательная, но перегрузка 1 — нет",
@@ -692,8 +692,8 @@
         "memberIsInvariant": "Элемент \"{name}\" инвариантен, поскольку помечен как mutable",
         "memberIsNotClassVarInClass": "Необходимо определить \"{name}\" как ClassVar для совместимости с протоколом.",
         "memberIsNotClassVarInProtocol": "\"{name}\" не определено как класс ClassVar в протоколе",
-        "memberIsNotReadOnlyInProtocol": "\"{name}\" is not read-only in protocol",
-        "memberIsReadOnlyInProtocol": "\"{name}\" is read-only in protocol",
+        "memberIsNotReadOnlyInProtocol": "\"{name}\" не является элементом только для чтения в протоколе",
+        "memberIsReadOnlyInProtocol": "\"{name}\" в протоколе только для чтения",
         "memberIsWritableInProtocol": "\"{name}\" доступно для записи в протоколе",
         "memberSetClassVar": "Атрибут \"{name}\" не может быть назначен через экземпляр класса, так как это ClassVar",
         "memberTypeMismatch": "\"{name}\" является несовместимым типом",

package/dist/localization/package.nls.tr.json

@@ -356,8 +356,8 @@
         "orPatternMissingName": "Bir \"or\" deseni içindeki tüm alt desenlerde aynı adlar hedeflenmeli",
         "overlappingKeywordArgs": "Türü belirlenmiş sözlük anahtar sözcük parametresiyle çakışıyor: {names}",
         "overlappingOverload": "Parametreleri {obscuredBy} aşırı yüklemesi ile çakıştığından \"{name}\" {obscured} aşırı yüklemesi hiçbir zaman kullanılmayacak",
-        "overloadAbstractImplMismatch": "Overloads must match abstract status of implementation",
-        "overloadAbstractMismatch": "Overloads must all be abstract or not",
+        "overloadAbstractImplMismatch": "Aşırı yüklemeler uygulamanın özet durumuyla eşleşmelidir",
+        "overloadAbstractMismatch": "Aşırı yüklemelerin tümü soyut olmalı veya tümü olmamalıdır",
         "overloadClassMethodInconsistent": "\"{name}\" için aşırı yüklemeler, @classmethod yöntemini tutarlı kullanıyor",
         "overloadFinalInconsistencyImpl": "\"{name}\" için aşırı yükleme @final olarak işaretlendi ancak uygulama işaretlenmedi",
         "overloadFinalInconsistencyNoImpl": "\"{name}\" için aşırı yükleme {index} @final olarak işaretlendi ancak aşırı yükleme 1 işaretlenmedi",
@@ -692,8 +692,8 @@
         "memberIsInvariant": "\"{name}\" değiştirilebilir olduğundan sabit ayarlanır",
         "memberIsNotClassVarInClass": "\"{name}\" protokolle uyumlu olması için ClassVar olarak tanımlanmalıdır",
         "memberIsNotClassVarInProtocol": "\"{name}\" protokolde ClassVar olarak tanımlanmadı",
-        "memberIsNotReadOnlyInProtocol": "\"{name}\" is not read-only in protocol",
-        "memberIsReadOnlyInProtocol": "\"{name}\" is read-only in protocol",
+        "memberIsNotReadOnlyInProtocol": "\"{name}\" protokolde salt okunur durumda değil",
+        "memberIsReadOnlyInProtocol": "\"{name}\" protokolde salt okunur durumda",
         "memberIsWritableInProtocol": "\"{name}\" protokolde yazılabilir",
         "memberSetClassVar": "\"{name}\" özniteliği bir ClassVar olduğundan sınıf örneği aracılığıyla atanamaz",
         "memberTypeMismatch": "\"{name}\" uyumsuz bir tür",

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

@@ -356,8 +356,8 @@
         "orPatternMissingName": "“or”模式中的所有子节点必须以相同的名称为目标",
         "overlappingKeywordArgs": "类型化字典与以下关键字参数重叠: {names}",
         "overlappingOverload": "永远不会使用“{name}”的重载 {obscured}，因为其参数与重载 {obscuredBy} 重叠",
-        "overloadAbstractImplMismatch": "Overloads must match abstract status of implementation",
-        "overloadAbstractMismatch": "Overloads must all be abstract or not",
+        "overloadAbstractImplMismatch": "重载必须与实现的抽象状态匹配",
+        "overloadAbstractMismatch": "重载必须全是抽象重载，或者全都不是抽象重载",
         "overloadClassMethodInconsistent": "“{name}”的重载使用 @classmethod 的方式不一致",
         "overloadFinalInconsistencyImpl": "“{name}”的重载被标记为 @final，但实施未被标记",
         "overloadFinalInconsistencyNoImpl": "“{name}”的重载 {index} 被标记为 @final，但重载 1 未被标记",
@@ -692,8 +692,8 @@
         "memberIsInvariant": "“{name}”是固定的，因为它是可变的",
         "memberIsNotClassVarInClass": "“{name}”必须定义为 ClassVar 才能与协议兼容",
         "memberIsNotClassVarInProtocol": "“{name}”未在协议中定义为 ClassVar",
-        "memberIsNotReadOnlyInProtocol": "\"{name}\" is not read-only in protocol",
-        "memberIsReadOnlyInProtocol": "\"{name}\" is read-only in protocol",
+        "memberIsNotReadOnlyInProtocol": "“{name}”在协议中不是只读的",
+        "memberIsReadOnlyInProtocol": "“{name}”在协议中是只读的",
         "memberIsWritableInProtocol": "“{name}”在协议中是可写入的",
         "memberSetClassVar": "无法通过类实例分配属性“{name}”，因为它是 ClassVar",
         "memberTypeMismatch": "\"{name}\"是不兼容的类型",

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

@@ -356,8 +356,8 @@
         "orPatternMissingName": "\"or\" 模式內的所有子模式都必須以相同的名稱為目標",
         "overlappingKeywordArgs": "輸入的字典與關鍵字參數重疊:: {names}",
         "overlappingOverload": "\"{name}\" 的多載 {obscured} 將永遠不會使用，因為它的參數與多載 {obscuredBy} 重疊",
-        "overloadAbstractImplMismatch": "Overloads must match abstract status of implementation",
-        "overloadAbstractMismatch": "Overloads must all be abstract or not",
+        "overloadAbstractImplMismatch": "多載必須符合實作的抽象狀態",
+        "overloadAbstractMismatch": "多載必須全為抽象或不抽象",
         "overloadClassMethodInconsistent": "\"{name}\" 的多載不一致地使用 @classmethod",
         "overloadFinalInconsistencyImpl": "\"{name}\" 的多載已標示為 @final 但未實作",
         "overloadFinalInconsistencyNoImpl": "\"{name}\" 的多載 {index} 標示為 @final 但多載 1 未標示",
@@ -692,8 +692,8 @@
         "memberIsInvariant": "\"{name}\" 為不變數，因為它可變動",
         "memberIsNotClassVarInClass": "\"{name}\" 必須定義為 ClassVar，才能與通訊協定相容",
         "memberIsNotClassVarInProtocol": "\"{name}\" 未定義為通訊協定中的 ClassVar",
-        "memberIsNotReadOnlyInProtocol": "\"{name}\" is not read-only in protocol",
-        "memberIsReadOnlyInProtocol": "\"{name}\" is read-only in protocol",
+        "memberIsNotReadOnlyInProtocol": "通訊協定中的 “{name}” 不是唯讀的",
+        "memberIsReadOnlyInProtocol": "通訊協定中的 “{name}” 是唯讀的",
         "memberIsWritableInProtocol": "\"{name}\" 在通訊協定中是可寫入的",
         "memberSetClassVar": "無法透過類別執行個體指派屬性 \"{name}\"，因為它是 ClassVar",
         "memberTypeMismatch": "\"{name}\" 是不相容的類型",

package/dist/tests/typeEvaluator2.test.js

@@ -240,10 +240,10 @@ test('isInstance3', () => {
     const configOptions = new configOptions_1.ConfigOptions(uri_1.Uri.empty());
     configOptions.defaultPythonVersion = pythonVersion_1.pythonVersion3_9;
     const analysisResults1 = TestUtils.typeAnalyzeSampleFiles(['isinstance3.py'], configOptions);
-    TestUtils.validateResults(analysisResults1, 5);
+    TestUtils.validateResults(analysisResults1, 6);
     configOptions.defaultPythonVersion = pythonVersion_1.pythonVersion3_10;
     const analysisResults2 = TestUtils.typeAnalyzeSampleFiles(['isinstance3.py'], configOptions);
-    TestUtils.validateResults(analysisResults2, 5);
+    TestUtils.validateResults(analysisResults2, 6);
 });
 test('isInstance4', () => {
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['isinstance4.py']);

package/dist/tests/typeEvaluator4.test.js

@@ -46,7 +46,7 @@ test('Final2', () => {
 });
 test('Final3', () => {
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['final3.py']);
-    TestUtils.validateResults(analysisResults, 42);
+    TestUtils.validateResults(analysisResults, 41);
 });
 test('Final4', () => {
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['final4.pyi']);