@zzzen/pyright-internal 1.2.0-dev.20240128 → 1.2.0-dev.20240225

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

@@ -285,6 +285,7 @@
         "namedParamAfterParamSpecArgs": "Keyword parameter \"{name}\" cannot appear in signature after ParamSpec args parameter",
         "namedTupleEmptyName": "Names within a named tuple cannot be empty",
         "namedTupleMultipleInheritance": "Multiple inheritance with NamedTuple is not supported",
+        "namedTupleEntryRedeclared": "Cannot override \"{name}\" because parent class \"{className}\" is a named tuple",
         "namedTupleFirstArg": "Expected named tuple class name as first argument",
         "namedTupleNameKeyword": "Field names cannot be a keyword",
         "namedTupleNameType": "Expected two-entry tuple specifying entry name and type",
@@ -364,10 +365,11 @@
         "patternNeverMatches": "Pattern will never be matched for subject type \"{type}\"",
         "positionArgAfterNamedArg": "Positional argument cannot appear after keyword arguments",
         "privateImportFromPyTypedModule": "\"{name}\" is not exported from module \"{module}\"",
-        "positionOnlyAfterArgs": "Position-only argument separator not allowed after \"*\" parameter",
+        "positionOnlyAfterArgs": "Position-only parameter separator not allowed after \"*\" parameter",
         "positionOnlyAfterKeywordOnly": "\"/\" parameter must appear before \"*\" parameter",
-        "positionOnlyIncompatible": "Position-only argument separator requires Python 3.8 or newer",
-        "positionOnlyFirstParam": "Position-only argument separator not allowed as first parameter",
+        "positionOnlyAfterNon": "Position-only parameter not allowed after parameter that is not position-only",
+        "positionOnlyIncompatible": "Position-only parameter separator requires Python 3.8 or newer",
+        "positionOnlyFirstParam": "Position-only parameter separator not allowed as first parameter",
         "privateUsedOutsideOfClass": "\"{name}\" is private and used outside of the class in which it is declared",
         "privateUsedOutsideOfModule": "\"{name}\" is private and used outside of the module in which it is declared",
         "propertyOverridden": "\"{name}\" incorrectly overrides property of same name in class \"{className}\"",
@@ -474,14 +476,16 @@
         "typedDictBadVar": "TypedDict classes can contain only type annotations",
         "typedDictBaseClass": "All base classes for TypedDict classes must also be TypedDict classes",
         "typedDictBoolParam": "Expected \"{name}\" parameter to have a value of True or False",
+        "typedDictClosedExtras": "Base class \"{name}\" is a closed TypedDict; extra items must be type \"{type}\"",
+        "typedDictClosedNoExtras": "Base class \"{name}\" is a closed TypedDict; extra items are not allowed",
         "typedDictDelete": "Could not delete item in TypedDict",
         "typedDictEmptyName": "Names within a TypedDict cannot be empty",
         "typedDictEntryName": "Expected string literal for dictionary entry name",
         "typedDictEntryUnique": "Names within a dictionary must be unique",
         "typedDictExtraArgs": "Extra TypedDict arguments not supported",
-        "typedDictFieldNotRequiredRedefinition": "TypedDict field \"{name}\" cannot be redefined as NotRequired",
-        "typedDictFieldReadOnlyRedefinition": "TypedDict field \"{name}\" cannot be redefined as ReadOnly",
-        "typedDictFieldRequiredRedefinition": "TypedDict field \"{name}\" cannot be redefined as Required",
+        "typedDictFieldNotRequiredRedefinition": "TypedDict item \"{name}\" cannot be redefined as NotRequired",
+        "typedDictFieldReadOnlyRedefinition": "TypedDict item \"{name}\" cannot be redefined as ReadOnly",
+        "typedDictFieldRequiredRedefinition": "TypedDict item \"{name}\" cannot be redefined as Required",
         "typedDictFirstArg": "Expected TypedDict class name as first argument",
         "typedDictInitsubclassParameter": "TypedDict does not support __init_subclass__ parameter \"{name}\"",
         "typedDictNotAllowed": "\"TypedDict\" cannot be used in this context",
@@ -489,8 +493,9 @@
         "typedDictSecondArgDictEntry": "Expected simple dictionary entry",
         "typedDictSet": "Could not assign item in TypedDict",
         "typeExpectedClass": "Expected type expression but received \"{type}\"",
-        "typeGuardArgCount": "Expected a single type argument after \"TypeGuard\"",
+        "typeGuardArgCount": "Expected a single type argument after \"TypeGuard\" or \"TypeIs\"",
         "typeGuardParamCount": "User-defined type guard functions and methods must have at least one input parameter",
+        "typeIsReturnType": "Return type of TypeIs (\"{returnType}\") is not consistent with value parameter type (\"{type}\")",
         "typeNotAwaitable": "\"{type}\" is not awaitable",
         "typeNotIntantiable": "\"{type}\" cannot be instantiated",
         "typeNotIterable": "\"{type}\" is not iterable",
@@ -555,8 +560,6 @@
         "uninitializedInstanceVariable": "Instance variable \"{name}\" is not initialized in the class body or __init__ method",
         "unionUnpackedTuple": "Union cannot include an unpacked tuple",
         "unionUnpackedTypeVarTuple": "Union cannot include an unpacked TypeVarTuple",
-        "unmatchedEndregionComment": "#endregion is missing corresponding #region",
-        "unmatchedRegionComment": "#region is missing corresponding #endregion",
         "unnecessaryCast": "Unnecessary \"cast\" call; type is already \"{type}\"",
         "unnecessaryIsInstanceAlways": "Unnecessary isinstance call; \"{testType}\" is always an instance of \"{classType}\"",
         "unnecessaryIsSubclassAlways": "Unnecessary issubclass call; \"{testType}\" is always a subclass of \"{classType}\"",
@@ -605,6 +608,7 @@
         "zeroLengthTupleNotAllowed": "Zero-length tuple is not allowed in this context"
     },
     "DiagnosticAddendum": {
+        "annotatedNotAllowed": "\"Annotated\" special form cannot be used with instance and class checks",
         "argParam": "Argument corresponds to parameter \"{paramName}\"",
         "argParamFunction": "Argument corresponds to parameter \"{paramName}\" in function \"{functionName}\"",
         "argsParamMissing": "Parameter \"*{paramName}\" has no corresponding parameter",
@@ -671,6 +675,7 @@
         "namedParamMissingInDest": "Keyword parameter \"{name}\" is missing in destination",
         "namedParamMissingInSource": "Keyword parameter \"{name}\" is missing in source",
         "namedParamTypeMismatch": "Keyword parameter \"{name}\" of type \"{sourceType}\" cannot be assigned to type \"{destType}\"",
+        "namedTupleNotAllowed": "NamedTuple cannot be used for instance or class checks",
         "newMethodLocation": "The __new__ method is defined in class \"{type}\"",
         "newMethodSignature": "Signature of __new__ is \"{type}\"",
         "newTypeClassNotAllowed": "Class created with NewType cannot be used with instance and class checks",
@@ -726,21 +731,29 @@
         "seeVariableDeclaration": "See variable declaration",
         "tupleEntryTypeMismatch": "Tuple entry {entry} is incorrect type",
         "tupleAssignmentMismatch": "Type \"{type}\" is incompatible with target tuple",
-        "tupleSizeIndeterminate": "Tuple size mismatch; expected {expected} but received indeterminate",
+        "tupleSizeIndeterminateSrc": "Tuple size mismatch; expected {expected} but received indeterminate",
+        "tupleSizeIndeterminateSrcDest": "Tuple size mismatch; expected {expected} or more but received indeterminate",
         "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}\" cannot be assigned to 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}\"",
         "typedDictBaseClass": "Class \"{type}\" is not a TypedDict",
         "typedDictClassNotAllowed": "TypedDict class not allowed for instance or class checks",
+        "typedDictExtraFieldNotAllowed": "\"{name}\" is not present in \"{type}\"",
+        "typedDictExtraFieldTypeMismatch": "Type of \"{name}\" is incompatible with type of \"__extra_items__\" in \"{type}\"",
         "typedDictFieldMissing": "\"{name}\" is missing from \"{type}\"",
+        "typedDictClosedExtraNotAllowed": "Cannot add item \"{name}\"",
+        "typedDictClosedExtraTypeMismatch": "Cannot add item \"{name}\" with type \"{type}\"",
+        "typedDictClosedFieldNotRequired": "Cannot add item \"{name}\" because it must be NotRequired",
         "typedDictFieldNotReadOnly": "\"{name}\" is not read-only in \"{type}\"",
         "typedDictFieldNotRequired": "\"{name}\" is not required in \"{type}\"",
         "typedDictFieldRequired": "\"{name}\" is required in \"{type}\"",
-        "typedDictFieldTypeMismatch": "Type \"{type}\" is not assignable to field \"{name}\"",
-        "typedDictFieldUndefined": "\"{name}\" is an undefined field in type \"{type}\"",
+        "typedDictFieldTypeMismatch": "Type \"{type}\" is not assignable to item \"{name}\"",
+        "typedDictFieldUndefined": "\"{name}\" is an undefined item in type \"{type}\"",
         "typedDictFinalMismatch": "\"{sourceType}\" is incompatible with \"{destType}\" because of a @final mismatch",
+        "typedDictNotAllowed": "TypedDict cannot be used for instance or class checks",
         "typeIncompatible": "\"{sourceType}\" is incompatible with \"{destType}\"",
         "typeNotClass": "\"{type}\" is not a class",
         "typeParamSpec": "Type \"{type}\" is incompatible with ParamSpec \"{name}\"",

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

@@ -147,6 +147,7 @@
         "duplicateStarPattern": "Solo se permite un patrón \"*\" en una secuencia de patrones",
         "duplicateStarStarPattern": "Solo se permite una entrada \"**\"",
         "duplicateUnpack": "Solo se permite una operación de desempaquetado en la lista",
+        "ellipsisAfterUnpacked": "\"...\" no se puede usar con una TypeVarTuple o tupla sin empaquetar",
         "ellipsisContext": "\"...\" no está permitido en este contexto",
         "ellipsisSecondArg": "\"...\" está permitido sólo como el segundo de dos argumentos",
         "enumClassOverride": "La clase Enum \"{name}\" es final y no puede ser subclasificada",
@@ -201,7 +202,7 @@
         "expectedTypeNotString": "Se esperaba un tipo pero se ha recibido una cadena literal",
         "expectedTypeParameterName": "Nombre de parámetro de tipo esperado",
         "expectedYieldExpr": "Expresión esperada en la instrucción yield",
-        "finalClassIsAbstract": "Class \"{type}\" is marked final and must implement all abstract symbols",
+        "finalClassIsAbstract": "La clase \"{type}\" está marcada como final y debe implementar todos los símbolos abstractos",
         "finalContext": "\"Final\" no está permitido en este contexto",
         "finalMethodOverride": "El método \"{name}\" no puede anular el método final definido en la clase \" {className}\"",
         "finalNonMethod": "La función \"{name}\" no se puede marcar @final porque no es un método",
@@ -231,6 +232,7 @@
         "genericBaseClassNotAllowed": "La clase base \"Generic\" no se puede usar con la sintaxis de parámetro de tipo",
         "genericClassAssigned": "No se puede asignar un tipo de clase genérico",
         "genericClassDeleted": "No se puede eliminar el tipo de clase genérica",
+        "genericInstanceVariableAccess": "El acceso a la variable de instancia genérica a través de la clase es ambiguo",
         "genericNotAllowed": "\"Generic\" no es válido en este contexto",
         "genericTypeAliasBoundTypeVar": "Los alias de tipo genérico dentro de una clase no pueden utilizar variables de tipo vinculadas {names}.",
         "genericTypeArgMissing": "\"Generic\" requiere al menos un argumento de tipo",
@@ -296,6 +298,7 @@
         "namedExceptAfterCatchAll": "Una cláusula except con nombre no puede aparecer después de la cláusula catch-all except",
         "namedParamAfterParamSpecArgs": "El parámetro de palabra clave \"{name}\" no puede aparecer en la firma después del parámetro ParamSpec args",
         "namedTupleEmptyName": "Los nombres de una tupla con nombre no pueden estar vacíos",
+        "namedTupleEntryRedeclared": "No se puede invalidar \"{name}\" porque la clase primaria \"{className}\" es una tupla con nombre",
         "namedTupleFirstArg": "Nombre de clase de tupla como primer argumento",
         "namedTupleMultipleInheritance": "No se admite la herencia múltiple con NamedTuple",
         "namedTupleNameKeyword": "Los nombres de campo no pueden ser una palabra clave",
@@ -460,7 +463,7 @@
         "typeAliasRedeclared": "\"{name}\" se declara como TypeAlias y solo puede asignarse una vez",
         "typeAliasStatementBadScope": "Una instrucción de tipo solo se puede usar en el ámbito de un módulo o de una clase",
         "typeAliasStatementIllegal": "La sentencia Type alias requiere Python 3.12 o posterior",
-        "typeAliasTypeBaseClass": "A type alias defined in a \"type\" statement cannot be used as a base class",
+        "typeAliasTypeBaseClass": "Un alias de tipo definido en una instrucción \"type\" no se puede usar como clase base",
         "typeAliasTypeMustBeAssigned": "TypeAliasType debe asignarse a una variable con el mismo nombre que el alias de tipo",
         "typeAliasTypeNameArg": "El primer argumento de TypeAliasType debe ser un literal de cadena que represente el nombre del alias de tipo",
         "typeAliasTypeNameMismatch": "El nombre del alias de tipo debe coincidir con el nombre de la variable a la que se asigna",
@@ -567,8 +570,6 @@
         "unionTypeArgCount": "La unión requiere dos o más argumentos de tipo",
         "unionUnpackedTuple": "La unión no puede incluir una tupla desempaquetada",
         "unionUnpackedTypeVarTuple": "La unión no puede incluir un TypeVarTuple desempaquetado",
-        "unmatchedEndregionComment": "A #endregion le falta la #region correspondiente",
-        "unmatchedRegionComment": "Falta la #región correspondiente #endregion",
         "unnecessaryCast": "Llamada \"cast\" innecesaria; el tipo ya es \"{type}\"",
         "unnecessaryIsInstanceAlways": "Llamada isinstance innecesaria; \"{testType}\" es siempre una instancia de \"{classType}\"",
         "unnecessaryIsSubclassAlways": "Llamada de issubclass innecesaria; \"{testType}\" siempre es una subclase de \"{classType}\"",
@@ -576,7 +577,7 @@
         "unnecessaryPyrightIgnoreRule": "Regla innecesaria \"# pyright: ignore\": \"{name}\"",
         "unnecessaryTypeIgnore": "Comentario \"# type: ignore\" innecesario",
         "unpackArgCount": "Se esperaba un único argumento de tipo después de \"Desempaquetar\"",
-        "unpackExpectedTypeVarTuple": "Se esperaba TypeVarTuple o Tuple como argumento de tipo para desempaquetar",
+        "unpackExpectedTypeVarTuple": "Se esperaba TypeVarTuple o tupla como argumento de tipo para desempaquetar",
         "unpackExpectedTypedDict": "Se esperaba un argumento de tipo TypedDict para Unpack",
         "unpackIllegalInComprehension": "Operación de desempaquetado no permitida en la comprensión",
         "unpackInAnnotation": "No se permite el operador desempaquetado en la anotación de tipo",
@@ -600,7 +601,7 @@
         "unusedExpression": "El valor de expresión no se usa",
         "varAnnotationIllegal": "Las anotaciones de tipo para variables requieren Python 3.6 o posterior; utilice el comentario de tipo para la compatibilidad con versiones anteriores.",
         "variableFinalOverride": "La variable \"{name}\" está marcada como Final y anula la variable no Final del mismo nombre en la clase \"{className}\".",
-        "variadicTypeArgsTooMany": "La lista de argumentos de tipo puede tener como máximo una TypeVarTuple o Tupla desempaquetada",
+        "variadicTypeArgsTooMany": "La lista de argumentos de tipo puede tener como máximo una TypeVarTuple o tupla desempaquetada",
         "variadicTypeParamTooManyAlias": "Los alias de tipo pueden tener como máximo un parámetro de tipo TypeVarTuple, pero reciben varios ({names})",
         "variadicTypeParamTooManyClass": "La clase genérica puede tener como máximo un parámetro de tipo TypeVarTuple pero recibió múltiples ({names})",
         "walrusIllegal": "El operador \":=\" requiere Python 3.8 o posterior",
@@ -617,6 +618,7 @@
         "zeroLengthTupleNotAllowed": "La tupla de longitud cero no está permitida en este contexto"
     },
     "DiagnosticAddendum": {
+        "annotatedNotAllowed": "El formulario especial \"Anotado\" no se puede usar con comprobaciones de instancia y clase",
         "argParam": "El argumento corresponde al parámetro \"{paramName}\"",
         "argParamFunction": "El argumento corresponde al parámetro \"{paramName}\" en la función \"{functionName}\"",
         "argsParamMissing": "El parámetro \"*{paramName}\" no tiene ningún parámetro correspondiente",
@@ -663,13 +665,13 @@
         "matchIsNotExhaustiveHint": "Si no se pretende un tratamiento exhaustivo, agregue \"case _: pass\"",
         "matchIsNotExhaustiveType": "Tipo no manejado: \"{type}\"",
         "memberAssignment": "La expresión de tipo \"{type}\" no se puede asignar al miembro \"{name}\" de la clase \"{classType}\"",
-        "memberIsAbstract": "\"{type}.{name}\" is not implemented",
+        "memberIsAbstract": "\"{type}. {name}\" no está implementado",
         "memberIsAbstractMore": "y {count} más",
         "memberIsClassVarInProtocol": "\"{name}\" se define como ClassVar en el protocolo",
         "memberIsFinalInProtocol": "\"{name}\" está marcado como Final en el protocolo",
         "memberIsInitVar": "El miembro \"{name}\" es un campo solo de inicialización",
         "memberIsInvariant": "\"{name}\" es invariable porque es mutable",
-        "memberIsNotClassVarInClass": "\"{name}\" must be defined as a ClassVar to be compatible with protocol",
+        "memberIsNotClassVarInClass": "\"{name}\" debe definirse como ClassVar para que sea compatible con el protocolo",
         "memberIsNotClassVarInProtocol": "\"{name}\" no está definido como ClassVar en el protocolo",
         "memberIsNotFinalInProtocol": "\"{name}\" no está marcado como Final en el protocolo",
         "memberIsWritableInProtocol": "\"{name}\" se puede escribir en el protocolo",
@@ -683,6 +685,7 @@
         "namedParamMissingInDest": "Falta el parámetro de palabra clave \"{name}\" en el destino",
         "namedParamMissingInSource": "Falta el parámetro de palabra clave \"{name}\" en el origen",
         "namedParamTypeMismatch": "El parámetro de palabra clave \"{name}\" del tipo \"{sourceType}\" no puede asignarse al tipo \"{destType}\"",
+        "namedTupleNotAllowed": "No se puede usar NamedTuple para comprobaciones de instancia o clase",
         "newMethodLocation": "El método __new__ está definido en la clase \"{type}\"",
         "newMethodSignature": "La firma de __new__ es \"{type}\"",
         "newTypeClassNotAllowed": "La clase creada con NewType no se puede usar con comprobaciones de instancia y clase",
@@ -738,9 +741,11 @@
         "seeVariableDeclaration": "declaración de variable out",
         "tupleAssignmentMismatch": "El tipo \"{type}\" no es compatible con la tupla de destino",
         "tupleEntryTypeMismatch": "La entrada {entry} de la tupla es de tipo incorrecto",
-        "tupleSizeIndeterminate": "El tamaño de la tupla no coincide; se esperaba {expected} pero se recibió uno indeterminado",
+        "tupleSizeIndeterminateSrc": "El tamaño de la tupla no coincide; se esperaba {expected} pero se recibió uno indeterminado",
+        "tupleSizeIndeterminateSrcDest": "El tamaño de la tupla no coincide; se esperaba {expected} o más, pero se recibió uno indeterminado",
         "tupleSizeMismatch": "El tamaño de la tupla no coincide; se esperaba {expected} pero se recibió {received}",
-        "typeAliasInstanceCheck": "Type alias created with \"type\" statement cannot be used with instance and class checks",
+        "tupleSizeMismatchIndeterminateDest": "El tamaño de la tupla no coincide; se esperaba {expected} o más, pero se recibió {received}",
+        "typeAliasInstanceCheck": "El alias de tipo creado con la instrucción \"type\" no se puede usar con comprobaciones de instancia y clase",
         "typeAssignmentMismatch": "El tipo \"{sourceType}\" no puede asignarse al tipo \"{destType}\"",
         "typeBound": "El tipo \"{sourceType}\" es incompatible con el tipo \"{destType}\" vinculado para la variable de tipo \"{name}\"",
         "typeConstrainedTypeVar": "El tipo \"{type}\" no es compatible con la variable de tipo restringido \"{name}\"",
@@ -768,6 +773,7 @@
         "typedDictFieldTypeMismatch": "El tipo \"{type}\" no se puede asignar al campo \"{name}\"",
         "typedDictFieldUndefined": "\"{name}\" es un campo no definido en el tipo \"{type}\"",
         "typedDictFinalMismatch": "\"{sourceType}\" no es compatible con \"{destType}\" debido a una discrepancia @final",
+        "typedDictNotAllowed": "No se puede usar TypedDict para comprobaciones de instancia o clase",
         "unhashableType": "El tipo \"{type}\" no admite hash",
         "uninitializedAbstractVariable": "La variable de instancia \"{name}\" está definida en la clase base abstracta \"{classType} \" pero no inicializada.",
         "unreachableExcept": "\"{exceptionType}\" es una subclase de \"{parentType}\"",

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

@@ -147,6 +147,7 @@
         "duplicateStarPattern": "Un seul motif \"*\" autorisé dans une séquence de motifs",
         "duplicateStarStarPattern": "Une seule entrée \"**\" autorisée",
         "duplicateUnpack": "Une seule opération de décompression autorisée dans la liste",
+        "ellipsisAfterUnpacked": "\"...\" ne peut pas être utilisé avec un TypeVarTuple ou un tuple décompressé",
         "ellipsisContext": "« ... » n’est pas autorisé dans ce contexte",
         "ellipsisSecondArg": "« ... » n’est autorisé qu’en tant que second des deux arguments",
         "enumClassOverride": "La classe Enum « {name} » est finale et ne peut pas être sous-classée",
@@ -201,7 +202,7 @@
         "expectedTypeNotString": "Type attendu mais réception d’un littéral de chaîne",
         "expectedTypeParameterName": "Nom de paramètre de type attendu",
         "expectedYieldExpr": "Expression attendue dans l'instruction yield",
-        "finalClassIsAbstract": "Class \"{type}\" is marked final and must implement all abstract symbols",
+        "finalClassIsAbstract": "La classe « {type} » est marquée comme finale et doit implémenter toutes les symboles abstraits",
         "finalContext": "« Final » n’est pas autorisé dans ce contexte",
         "finalMethodOverride": "La méthode « {name} » ne peut pas remplacer la méthode finale définie dans la classe « {className} »",
         "finalNonMethod": "La fonction « {name} » ne peut pas être marquée @final, car il ne s’agit pas d’une méthode",
@@ -231,6 +232,7 @@
         "genericBaseClassNotAllowed": "La classe de base \"générique\" ne peut pas être utilisée avec la syntaxe de paramètre de type",
         "genericClassAssigned": "Impossible d’attribuer le type de classe générique",
         "genericClassDeleted": "Le type de classe générique ne peut pas être supprimé",
+        "genericInstanceVariableAccess": "L’accès à une variable d’instance générique via une classe est ambigu",
         "genericNotAllowed": "« Générique » n’est pas valide dans ce contexte",
         "genericTypeAliasBoundTypeVar": "L’alias de type générique dans la classe ne peut pas utiliser les variables de type lié {names}",
         "genericTypeArgMissing": "« Générique » nécessite au moins un argument de type",
@@ -296,6 +298,7 @@
         "namedExceptAfterCatchAll": "Une clause except nommée ne peut pas apparaître après une clause except fourre-tout",
         "namedParamAfterParamSpecArgs": "Le paramètre de mot clé « {name} » ne peut pas apparaître dans la signature après le paramètre ParamSpec args",
         "namedTupleEmptyName": "Les noms dans un tuple nommé ne peuvent pas être vides",
+        "namedTupleEntryRedeclared": "Impossible de remplacer « {name} », car la classe parente « {className} » est un tuple nommé",
         "namedTupleFirstArg": "Nom de classe de tuple nommé attendu en tant que premier argument",
         "namedTupleMultipleInheritance": "L’héritage multiple avec NamedTuple n’est pas pris en charge",
         "namedTupleNameKeyword": "Les noms de champs ne peuvent pas être un mot-clé",
@@ -460,7 +463,7 @@
         "typeAliasRedeclared": "« {name} » est déclaré en tant que TypeAlias et ne peut être attribué qu’une seule fois",
         "typeAliasStatementBadScope": "Une instruction de type ne peut être utilisée que dans une étendue de module ou de classe",
         "typeAliasStatementIllegal": "L’instruction d’alias de type nécessite Python 3.12 ou version ultérieure",
-        "typeAliasTypeBaseClass": "A type alias defined in a \"type\" statement cannot be used as a base class",
+        "typeAliasTypeBaseClass": "Un alias de type défini dans une instruction « type » ne peut pas être utilisé en tant que classe de base",
         "typeAliasTypeMustBeAssigned": "TypeAliasType doit être affecté à une variable portant le même nom que l'alias de type",
         "typeAliasTypeNameArg": "Le premier argument de TypeAliasType doit être un littéral de chaîne représentant le nom de l'alias de type",
         "typeAliasTypeNameMismatch": "Le nom de l’alias de type doit correspondre au nom de la variable à laquelle il est affecté",
@@ -567,8 +570,6 @@
         "unionTypeArgCount": "L’union requiert au moins deux arguments de type",
         "unionUnpackedTuple": "Union ne peut pas inclure un tuple décompressé",
         "unionUnpackedTypeVarTuple": "Union ne peut pas inclure un TypeVarTuple décompressé",
-        "unmatchedEndregionComment": "#endregion n’a pas de #region correspondante",
-        "unmatchedRegionComment": "#region n’a pas de #endregion correspondante",
         "unnecessaryCast": "Appel \"cast\" inutile ; le type est déjà \"{type}\"",
         "unnecessaryIsInstanceAlways": "Appel d’isinstance inutile ; « {testType} » est toujours une instance de « {classType} »",
         "unnecessaryIsSubclassAlways": "Appel issubclass inutile ; \"{testType}\" est toujours une sous-classe de \"{classType}\"",
@@ -576,7 +577,7 @@
         "unnecessaryPyrightIgnoreRule": "Règle inutile « #ightight: ignore » : « {name} »",
         "unnecessaryTypeIgnore": "Commentaire \"# type: ignore\" inutile",
         "unpackArgCount": "Attendu un seul argument de type après \"Unpack\"",
-        "unpackExpectedTypeVarTuple": "TypeVarTuple ou Tuple attendu en tant qu’argument de type pour Unpack",
+        "unpackExpectedTypeVarTuple": "TypeVarTuple ou tuple attendu en tant qu’argument de type pour décompresser",
         "unpackExpectedTypedDict": "Argument de type TypedDict attendu pour Unpack",
         "unpackIllegalInComprehension": "Opération de décompression non autorisée dans la compréhension",
         "unpackInAnnotation": "Opérateur de décompression non autorisé dans l’annotation de type",
@@ -600,7 +601,7 @@
         "unusedExpression": "La valeur de l'expression n'est pas utilisée",
         "varAnnotationIllegal": "Les annotations de type pour les variables nécessitent Python 3.6 ou une version ultérieure ; utiliser le commentaire de type pour la compatibilité avec les versions précédentes",
         "variableFinalOverride": "La variable « {name} » est marquée comme finale et remplace la variable non finale du même nom dans la classe « {className} »",
-        "variadicTypeArgsTooMany": "La liste d’arguments de type peut avoir au plus un TypeVarTuple ou Tuple unpacked",
+        "variadicTypeArgsTooMany": "La liste d’arguments de type peut avoir au plus un TypeVarTuple ou tuple décompressé",
         "variadicTypeParamTooManyAlias": "L’alias de type peut avoir au plus un paramètre de type TypeVarTuple, mais a reçu plusieurs ({names})",
         "variadicTypeParamTooManyClass": "La classe générique peut avoir au plus un paramètre de type TypeVarTuple, mais en a reçu plusieurs ({names})",
         "walrusIllegal": "L’opérateur « := » nécessite Python 3.8 ou version ultérieure",
@@ -617,6 +618,7 @@
         "zeroLengthTupleNotAllowed": "Le tuple de longueur nulle n’est pas autorisé dans ce contexte"
     },
     "DiagnosticAddendum": {
+        "annotatedNotAllowed": "Impossible d’utiliser le formulaire spécial « Annoté » avec les vérifications d’instance et de classe",
         "argParam": "L’argument correspond au paramètre « {paramName} »",
         "argParamFunction": "L’argument correspond au paramètre « {paramName} » dans la fonction « {functionName} »",
         "argsParamMissing": "Le paramètre \"*{paramName}\" n'a pas de paramètre correspondant",
@@ -663,13 +665,13 @@
         "matchIsNotExhaustiveHint": "Si la gestion exhaustive n’est pas prévue, ajoutez « case _: pass »",
         "matchIsNotExhaustiveType": "Type non géré : « {type} »",
         "memberAssignment": "L'expression de type \"{type}\" ne peut pas être attribuée au membre \"{name}\" de la classe \"{classType}\"",
-        "memberIsAbstract": "\"{type}.{name}\" is not implemented",
+        "memberIsAbstract": "« {type}.{name} » n’est pas implémenté",
         "memberIsAbstractMore": "et {count} autres...",
         "memberIsClassVarInProtocol": "« {name} » est défini en tant que ClassVar dans le protocole",
         "memberIsFinalInProtocol": "« {name} » est marqué final dans le protocole",
         "memberIsInitVar": "Le membre « {name} » est un champ d’initialisation uniquement",
         "memberIsInvariant": "« {name} » est invariant, car il est mutable",
-        "memberIsNotClassVarInClass": "\"{name}\" must be defined as a ClassVar to be compatible with protocol",
+        "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",
         "memberIsNotFinalInProtocol": "\"{name}\" n'est pas marqué Final dans le protocole",
         "memberIsWritableInProtocol": "« {name} » est accessible en écriture dans le protocole",
@@ -683,6 +685,7 @@
         "namedParamMissingInDest": "Le paramètre de mot clé « {name} » est manquant dans la destination",
         "namedParamMissingInSource": "Le paramètre de mot-clé \"{name}\" est manquant dans la source",
         "namedParamTypeMismatch": "Impossible d’affecter le paramètre de mot clé « {name} » de type « {sourceType} » au type « {destType} »",
+        "namedTupleNotAllowed": "NamedTuple ne peut pas être utilisé pour les vérifications d’instance ou de classe",
         "newMethodLocation": "La méthode __new__ est définie dans la classe « {type} »",
         "newMethodSignature": "La signature de __new__ est « {type} »",
         "newTypeClassNotAllowed": "La classe créée avec NewType ne peut pas être utilisée avec des vérifications de instance et de classe",
@@ -738,9 +741,11 @@
         "seeVariableDeclaration": "Voir déclaration de variable",
         "tupleAssignmentMismatch": "Le type \"{type}\" est incompatible avec le tuple cible",
         "tupleEntryTypeMismatch": "Le type de l’entrée de tuple {entry} est incorrect",
-        "tupleSizeIndeterminate": "Incompatibilité de taille de tuple ; attendu {expected} mais reçu pour une durée indéterminée",
+        "tupleSizeIndeterminateSrc": "Incompatibilité de taille de tuple ; attendu {expected} mais reçu pour une durée indéterminée",
+        "tupleSizeIndeterminateSrcDest": "Incompatibilité de taille de tuple : attente de {expected} ou plus, mais réception indéterminée",
         "tupleSizeMismatch": "Incompatibilité de taille de tuple ; attendu {expected} mais reçu {received}",
-        "typeAliasInstanceCheck": "Type alias created with \"type\" statement cannot be used with instance and class checks",
+        "tupleSizeMismatchIndeterminateDest": "Incompatibilité de taille de tuple : attente de {expected} ou plus, mais réception de {received}",
+        "typeAliasInstanceCheck": "L’alias de type créé avec l’instruction « type » ne peut pas être utilisé avec des vérifications d’instance et de classe",
         "typeAssignmentMismatch": "Impossible d’affecter le type « {sourceType} » au type « {destType} »",
         "typeBound": "Le type « {sourceType} » n’est pas compatible avec le type lié « {destType} » pour la variable de type « {name} »",
         "typeConstrainedTypeVar": "Le «{type}» de type n’est pas compatible avec les «{name}» de variable de type contrainte",
@@ -768,6 +773,7 @@
         "typedDictFieldTypeMismatch": "Le type \"{type}\" n'est pas attribuable au champ \"{name}\"",
         "typedDictFieldUndefined": "« {name} » est un champ non défini dans le type « {type} »",
         "typedDictFinalMismatch": "« {sourceType} » n’est pas compatible avec « {destType} » en raison d’une incompatibilité de @final",
+        "typedDictNotAllowed": "TypedDict ne peut pas être utilisé pour les vérifications d’instance ou de classe",
         "unhashableType": "Le type \"{type}\" n'est pas hachable",
         "uninitializedAbstractVariable": "La variable d’instance « {name} » est définie dans la classe de base abstraite « {classType} » mais n’est pas initialisée",
         "unreachableExcept": "« {exceptionType} » est une sous-classe de « {parentType} »",

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

@@ -147,6 +147,7 @@
         "duplicateStarPattern": "In una sequenza di criteri è consentito un solo criterio \"*\"",
         "duplicateStarStarPattern": "È consentita una sola voce \"**\"",
         "duplicateUnpack": "Nell'elenco è consentita una sola operazione di decompressione",
+        "ellipsisAfterUnpacked": "\"...\" non può essere usato con una tupla o una tupla o TypeVarTuple non compressa",
         "ellipsisContext": "\"...\" non è consentito in questo contesto",
         "ellipsisSecondArg": "\"...\" è consentito solo come secondo di due argomenti",
         "enumClassOverride": "La classe di enumerazione \"{name}\" è finale e non può essere sottoclassata",
@@ -201,7 +202,7 @@
         "expectedTypeNotString": "È previsto un tipo ma è stato ricevuto un valore letterale stringa",
         "expectedTypeParameterName": "Nome del parametro del tipo previsto",
         "expectedYieldExpr": "Espressione prevista nell'istruzione yield",
-        "finalClassIsAbstract": "Class \"{type}\" is marked final and must implement all abstract symbols",
+        "finalClassIsAbstract": "La classe \"{type}\" è contrassegnata come finale e deve implementare tutti i simboli astratti",
         "finalContext": "\"Finale\" non è consentito in questo contesto",
         "finalMethodOverride": "Il metodo \"{name}\" non può eseguire l'override del metodo finale definito nella classe \"{className}\"",
         "finalNonMethod": "Impossibile contrassegnare la funzione “{name}” @final perché non è un metodo",
@@ -231,6 +232,7 @@
         "genericBaseClassNotAllowed": "Non è possibile usare la classe di base \"Generic\" con la sintassi del parametro di tipo",
         "genericClassAssigned": "Non è possibile assegnare il tipo di classe generico",
         "genericClassDeleted": "Non è possibile eliminare il tipo di classe generico",
+        "genericInstanceVariableAccess": "L'accesso alla variabile di istanza generica tramite la classe è ambiguo",
         "genericNotAllowed": "\"Generic\" non valido in questo contesto",
         "genericTypeAliasBoundTypeVar": "L'alias di tipo generico all'interno della classe non può usare variabili di tipo associate {names}",
         "genericTypeArgMissing": "\"Generico\" richiede almeno un argomento di tipo",
@@ -296,6 +298,7 @@
         "namedExceptAfterCatchAll": "Una clausola except denominata non può trovarsi dopo la clausola catch-all except",
         "namedParamAfterParamSpecArgs": "Il parametro della parola chiave \"{name}\" non può essere visualizzato nella firma dopo il parametro ParamSpec args",
         "namedTupleEmptyName": "I nomi all'interno di una tupla denominata non possono essere vuoti",
+        "namedTupleEntryRedeclared": "Non è possibile eseguire l'override di \"{name}\" perché la classe padre \"{className}\" è una tupla denominata",
         "namedTupleFirstArg": "Previsto nome della classe di tupla denominata come primo argomento",
         "namedTupleMultipleInheritance": "L'ereditarietà multipla con NamedTuple non è supportata",
         "namedTupleNameKeyword": "I nomi dei campi non possono essere una parola chiave",
@@ -460,7 +463,7 @@
         "typeAliasRedeclared": "\"{name}\" è dichiarato come TypeAlias e può essere assegnato una sola volta",
         "typeAliasStatementBadScope": "Un'istruzione Tipo può essere usata solo all'interno di un modulo o di un ambito della classe",
         "typeAliasStatementIllegal": "L'istruzione alias di tipo richiede Python 3.12 o versione successiva",
-        "typeAliasTypeBaseClass": "A type alias defined in a \"type\" statement cannot be used as a base class",
+        "typeAliasTypeBaseClass": "Impossibile utilizzare come classe di base un alias di tipo definito in un'istruzione \"type\"",
         "typeAliasTypeMustBeAssigned": "TypeAliasType deve essere assegnato a una variabile con lo stesso nome dell'alias di tipo",
         "typeAliasTypeNameArg": "Il primo argomento di TypeAliasType deve essere un valore letterale stringa che rappresenta il nome dell'alias di tipo",
         "typeAliasTypeNameMismatch": "Il nome dell'alias di tipo deve corrispondere al nome della variabile a cui è assegnato",
@@ -567,8 +570,6 @@
         "unionTypeArgCount": "L'unione richiede due o più argomenti di tipo",
         "unionUnpackedTuple": "L'unione non può includere una tupla decompressa",
         "unionUnpackedTypeVarTuple": "L'unione non può includere un TypeVarTuple non compresso",
-        "unmatchedEndregionComment": "#endregion #region corrispondente mancante",
-        "unmatchedRegionComment": "#region #endregion corrispondente mancante",
         "unnecessaryCast": "Chiamata \"cast\" non necessaria; il tipo è già \"{type}\"",
         "unnecessaryIsInstanceAlways": "Chiamata isinstance non necessaria; \"{testType}\" è sempre un'istanza di \"{classType}\"",
         "unnecessaryIsSubclassAlways": "Chiamata issubclass non necessaria; \"{testType}\" è sempre una sottoclasse di \"{classType}\"",
@@ -576,7 +577,7 @@
         "unnecessaryPyrightIgnoreRule": "Regola \"# pyright: ignore\" non necessaria: \"{name}\"",
         "unnecessaryTypeIgnore": "Commento \"# tipo: ignora\" non necessario",
         "unpackArgCount": "Previsto un singolo argomento tipo dopo \"Decomprimi\"",
-        "unpackExpectedTypeVarTuple": "È previsto TypeVarTuple o Tuple come argomento di tipo per Unpack",
+        "unpackExpectedTypeVarTuple": "È previsto TypeVarTuple o tupla come argomento di tipo per Unpack",
         "unpackExpectedTypedDict": "Previsto argomento di tipo TypedDict per Decomprimi",
         "unpackIllegalInComprehension": "Operazione di decompressione non consentita nella comprensione",
         "unpackInAnnotation": "Operatore di decompressione non consentito nell'annotazione di tipo",
@@ -617,6 +618,7 @@
         "zeroLengthTupleNotAllowed": "Tupla di lunghezza zero non è consentita in questo contesto"
     },
     "DiagnosticAddendum": {
+        "annotatedNotAllowed": "Non è possibile usare il modulo speciale \"Annotato\" con controlli di istanza e classe",
         "argParam": "L'argomento corrisponde al parametro \"{paramName}\"",
         "argParamFunction": "L'argomento corrisponde al parametro \"{paramName}\" nella funzione \"{functionName}\"",
         "argsParamMissing": "Il parametro \"*{paramName}\" non ha un parametro corrispondente",
@@ -663,13 +665,13 @@
         "matchIsNotExhaustiveHint": "Se la gestione completa non è prevista, aggiungere \"case _: pass\"",
         "matchIsNotExhaustiveType": "Tipo non gestito: \"{type}\"",
         "memberAssignment": "L'espressione di tipo \"{type}\" non può essere assegnata al membro \"{name}\" della classe \"{classType}\".",
-        "memberIsAbstract": "\"{type}.{name}\" is not implemented",
+        "memberIsAbstract": "\"{type}.{name}\" non implementato",
         "memberIsAbstractMore": "e {{count}} altro...",
         "memberIsClassVarInProtocol": "“{name}” è definito come ClassVar nel protocollo",
         "memberIsFinalInProtocol": "\"{name}\" è contrassegnato come Finale nel protocollo",
         "memberIsInitVar": "Il membro \"{name}\" è un campo solo init",
         "memberIsInvariant": "\"{name}\" è invariante perché modificabile",
-        "memberIsNotClassVarInClass": "\"{name}\" must be defined as a ClassVar to be compatible with protocol",
+        "memberIsNotClassVarInClass": "\"{name}\" deve essere definito come ClassVar per essere compatibile con il protocollo",
         "memberIsNotClassVarInProtocol": "“{name}” non è definito come ClassVar nel protocollo",
         "memberIsNotFinalInProtocol": "\"{name}\" non è contrassegnato come Finale nel protocollo",
         "memberIsWritableInProtocol": "\"{name}\" è scrivibile nel protocollo",
@@ -683,6 +685,7 @@
         "namedParamMissingInDest": "Il parametro della parola chiave \"{name}\" non è presente nella destinazione",
         "namedParamMissingInSource": "Parametro della parola chiave \"{name}\" mancante nell’origine",
         "namedParamTypeMismatch": "Non è possibile assegnare il parametro di parola chiave \"{name}\" di tipo \"{sourceType}\" al tipo \"{destType}\"",
+        "namedTupleNotAllowed": "Non è possibile usare NamedTuple per i controlli di istanze o classi",
         "newMethodLocation": "Il metodo __new__ è definito nella classe \"{type}\"",
         "newMethodSignature": "La firma del __new__ è \"{type}\"",
         "newTypeClassNotAllowed": "Impossibile utilizzare la classe creata con NewType con controlli di classe e di istanza",
@@ -738,9 +741,11 @@
         "seeVariableDeclaration": "Vedere la dichiarazione di variabile",
         "tupleAssignmentMismatch": "Il tipo \"{type}\" non è compatibile con la tupla di destinazione",
         "tupleEntryTypeMismatch": "Il tipo della voce di tupla {entry} non è corretto",
-        "tupleSizeIndeterminate": "Dimensioni tupla non corrispondenti; previsto {expected} ma ricevuto indeterminato",
+        "tupleSizeIndeterminateSrc": "Dimensioni tupla non corrispondenti; previsto {expected} ma ricevuto indeterminato",
+        "tupleSizeIndeterminateSrcDest": "Dimensioni della tupla non corrispondenti; previsto {expected} o più, ma ricevuto indeterminato",
         "tupleSizeMismatch": "Dimensioni tupla non corrispondenti; previsto {expected} ma ricevuto {received}",
-        "typeAliasInstanceCheck": "Type alias created with \"type\" statement cannot be used with instance and class checks",
+        "tupleSizeMismatchIndeterminateDest": "Dimensioni della tupla non corrispondenti; previsto {expected} o più ma ricevuto {received}",
+        "typeAliasInstanceCheck": "Non è possibile usare l'alias di tipo creato con l'istruzione \"type\" con controlli di classe e istanza",
         "typeAssignmentMismatch": "impossibile assegnare il tipo \"{sourceType}\" al tipo \"{destType}\"",
         "typeBound": "Il tipo \"{sourceType}\" non è compatibile con il tipo associato \"{destType}\" per la variabile di tipo \"{name}\"",
         "typeConstrainedTypeVar": "Il tipo \"{type}\" non è compatibile con la variabile di tipo vincolato \"{name}\"",
@@ -768,12 +773,13 @@
         "typedDictFieldTypeMismatch": "Il tipo \"{type}\" non può essere assegnato al campo \"{name}\"",
         "typedDictFieldUndefined": "\"{name}\" è un campo non definito nel tipo \"{type}\"",
         "typedDictFinalMismatch": "\"{sourceType}\" non è compatibile con \"{destType}\" a causa di una @final mancata corrispondenza",
+        "typedDictNotAllowed": "Non è possibile usare TypedDict per i controlli di istanze o classi",
         "unhashableType": "Il tipo \"{type}\" non è hashable",
         "uninitializedAbstractVariable": "La variabile di istanza \"{name}\" è definita nella classe di base astratta \"{classType}\" ma non è inizializzata",
         "unreachableExcept": "\"{exceptionType}\" è una sottoclasse di \"{parentType}\"",
         "useDictInstead": "Usare Dict[T1, T2] per indicare un tipo di dizionario",
         "useListInstead": "Usare List[T] per indicare un tipo di elenco o Union[T1, T2] per indicare un tipo di unione",
-        "useTupleInstead": "Usare Tuple[T1, ..., Tn] per indicare un tipo di tupla o Union[T1, T2] per indicare un tipo di unione",
+        "useTupleInstead": "Usare tuple[T1, ..., Tn] per indicare un tipo di tupla o Union[T1, T2] per indicare un tipo di unione",
         "useTypeInstead": "In alternativa, usare Type[T]",
         "varianceMismatchForClass": "La varianza dell'argomento tipo \"{typeVarName}\" non è compatibile con la classe di base \"{className}\"",
         "varianceMismatchForTypeAlias": "La varianza dell'argomento tipo \"{typeVarName}\" non è compatibile con \"{typeAliasParam}\""