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

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

@@ -1,7 +1,7 @@
 {
     "CodeAction": {
-        "createTypeStub": "Создать заглушку типа",
-        "createTypeStubFor": "Создать заглушку типа для \"{moduleName}\"",
+        "createTypeStub": "Создать Stub типа",
+        "createTypeStubFor": "Создать Stub типа для \"{moduleName}\"",
         "executingCommand": "Производится выполнение команды",
         "filesToAnalyzeCount": "{count} файлов для анализа",
         "filesToAnalyzeOne": "1 файл для анализа",
@@ -18,12 +18,12 @@
         "annotatedMetadataInconsistent": "Тип аннотированных метаданных \"{metadataType}\" несовместим с типом \"{type}\"",
         "annotatedParamCountMismatch": "Несоответствие числа аннотаций параметра: ожидается {expected}, но получено {received}",
         "annotatedTypeArgMissing": "Для \"Annotated\" ожидается один аргумент типа и одна или несколько заметок типа",
-        "annotationBytesString": "Заметки с типом не могут использовать строковые литералы байтов",
-        "annotationFormatString": "В заметках типа не могут использоваться строковые литералы формата (f-строки)",
+        "annotationBytesString": "Выражения типа не могут использовать строковые литералы байтов",
+        "annotationFormatString": "В выражениях типа не могут использоваться строковые литералы формата (f-строки)",
         "annotationNotSupported": "Заметка типа не поддерживается для этой инструкции",
-        "annotationRawString": "Заметки с типом не могут использовать необработанные строковые литералы",
-        "annotationSpansStrings": "Заметки с типом не могут охватывать несколько строковых литералов",
-        "annotationStringEscape": "Заметки с типом не могут содержать escape-символы",
+        "annotationRawString": "Выражения типа не могут использовать необработанные строковые литералы",
+        "annotationSpansStrings": "Выражения типа не могут охватывать несколько строковых литералов",
+        "annotationStringEscape": "Выражения типа не могут содержать escape-символы",
         "argAssignment": "Аргумент типа \"{argType}\" нельзя присвоить параметру типа \"{paramType}\"",
         "argAssignmentFunction": "Аргумент типа \"{argType}\" нельзя присвоить параметру типа \"{paramType}\" в функции \"{functionName}\"",
         "argAssignmentParam": "Аргумент типа \"{argType}\" нельзя присвоить параметру \"{paramName}\" типа \"{paramType}\"",
@@ -45,19 +45,19 @@
         "assignmentExprInSubscript": "Выражения назначения внутри оператора получения подстроки можно использовать в Python версии не ниже 3.10",
         "assignmentInProtocol": "Переменные экземпляра или класса в классе Protocol должны быть явно объявлены в тексте класса",
         "assignmentTargetExpr": "Выражение не может быть целевым объектом присваивания",
-        "asyncNotInAsyncFunction": "Использование \"async\" не разрешено вне асинхронной функции",
+        "asyncNotInAsyncFunction": "Использование \"async\" не разрешено вне async функции",
         "awaitIllegal": "Инструкцию \"await\" можно использовать в Python версии не ранее 3.5",
-        "awaitNotAllowed": "Заметки типов не могут использовать \"await\"",
-        "awaitNotInAsync": "Ключевое слово \"await\" допускается только в асинхронной функции",
+        "awaitNotAllowed": "Выражения типа не могут использовать \"await\"",
+        "awaitNotInAsync": "Ключевое слово \"await\" допускается только в async функции",
         "backticksIllegal": "Выражения, окруженные одиночными обратными кавычками, не поддерживаются в Python 3.x; используйте вместо этого функцию repr",
         "baseClassCircular": "Класс не может быть производным от себя",
-        "baseClassFinal": "Базовый класс \"{type}\" помечен как окончательный, и от него нельзя создать производный класс",
+        "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}\" нельзя использовать в шаблоне класса, поскольку это псевдоним специализированного типа",
@@ -84,18 +84,18 @@
         "clsSelfParamTypeMismatch": "Тип параметра \"{name}\" должен быть супертипом своего класса \"{classType}\"",
         "codeTooComplexToAnalyze": "Код слишком сложен для анализа; уменьшите сложность, разбив его на фрагменты (вложенные процедуры) или сократите количество условных конструкций",
         "collectionAliasInstantiation": "Тип \"{type}\" не может быть создан, вместо этого используйте \"{alias}\"",
-        "comparisonAlwaysFalse": "Условие всегда будет оцениваться как ЛОЖЬ, поскольку типы \"{leftType}\" и \"{rightType}\" не перекрываются",
+        "comparisonAlwaysFalse": "Условие всегда будет оцениваться как False, поскольку типы \"{leftType}\" и \"{rightType}\" не перекрываются",
         "comparisonAlwaysTrue": "Выражение всегда будет возвращать значение True, поскольку типы \"{leftType}\" и \"{rightType}\" не перекрываются",
         "comprehensionInDict": "Понимание не может использоваться с другими записями словаря",
-        "comprehensionInSet": "Понимание не может использоваться с другими записями набора",
+        "comprehensionInSet": "Понимание не может использоваться с другими записями set",
         "concatenateContext": "\"Concatenate\" не допускается в этом контексте",
         "concatenateParamSpecMissing": "Последний аргумент типа для \"Concatenate\" должен быть ParamSpec или \"...\"",
         "concatenateTypeArgsMissing": "Для \"Concatenate\" требуется по крайней мере два аргумента типа",
         "conditionalOperandInvalid": "Недопустимый условный операнд типа \"{type}\"",
         "constantRedefinition": "\"{name}\" является константой (поскольку оно в верхнем регистре) и не может быть переопределено.",
         "constructorParametersMismatch": "Несоответствие подписи __new__ и __init__ в классе \"{classType}\"",
-        "containmentAlwaysFalse": "Выражение всегда будет оцениваться как ЛОЖЬ, так как типы \"{leftType}\" и \"{rightType}\" не перекрываются",
-        "containmentAlwaysTrue": "Выражение всегда будет оцениваться как ИСТИНА, так как типы \"{leftType}\" и \"{rightType}\" не перекрываются",
+        "containmentAlwaysFalse": "Выражение всегда будет оцениваться как False, так как типы \"{leftType}\" и \"{rightType}\" не перекрываются",
+        "containmentAlwaysTrue": "Выражение всегда будет оцениваться как True, так как типы \"{leftType}\" и \"{rightType}\" не перекрываются",
         "continueInFinally": "Невозможно использовать \"continue\" в предложении finally",
         "continueOutsideLoop": "Ключевое слово \"continue\" можно использовать только внутри цикла",
         "coroutineInConditionalExpression": "Условное выражение ссылается на сопрограмму, которая всегда возвращает значение True",
@@ -110,8 +110,8 @@
         "dataClassPostInitParamCount": "Неверное число параметров в методе __post_init__ класса данных; ожидается число, соответствующее числу полей InitVar {expected}",
         "dataClassPostInitType": "Тип параметра метода __post_init__ в классе данных не соответствует типу поля \"{fieldName}\"",
         "dataClassSlotsOverwrite": "__slots__ уже определен в классе",
-        "dataClassTransformExpectedBoolLiteral": "Ожидается выражение, статически оцениваемое как ИСТИНА или ЛОЖЬ",
-        "dataClassTransformFieldSpecifier": "Ожидается кортеж классов или функций, но получен тип \"{type}\"",
+        "dataClassTransformExpectedBoolLiteral": "Ожидается выражение, статически оцениваемое как True или False",
+        "dataClassTransformFieldSpecifier": "Ожидается tuple классов или функций, но получен тип \"{type}\"",
         "dataClassTransformPositionalParam": "Все аргументы \"dataclass_transform\" должны быть аргументами типа \"ключевое слово\"",
         "dataClassTransformUnknownArgument": "Аргумент \"{name}\" не поддерживается в dataclass_transform",
         "dataProtocolInSubclassCheck": "Протоколы данных (включающие атрибуты, не связанные с методами) запрещены в вызовах issubclass",
@@ -127,12 +127,12 @@
         "deprecatedDescriptorSetter": "Метод \"__set__\" для дескриптора \"{name}\" не рекомендуется",
         "deprecatedFunction": "Функция \"{name}\" больше не рекомендуется к использованию",
         "deprecatedMethod": "Метод \"{name}\" в классе \"{className}\" не рекомендуется к использованию",
-        "deprecatedPropertyDeleter": "Метод удаления для свойства \"{name}\" не рекомендуется",
-        "deprecatedPropertyGetter": "Метод получения для свойства \"{name}\" не рекомендуется",
-        "deprecatedPropertySetter": "Метод задания для свойства \"{name}\" не рекомендуется",
+        "deprecatedPropertyDeleter": "Метод deleter для property \"{name}\" не рекомендуется",
+        "deprecatedPropertyGetter": "Метод getter для property \"{name}\" не рекомендуется",
+        "deprecatedPropertySetter": "Метод setter для property \"{name}\" не рекомендуется",
         "deprecatedType": "Этот тип больше не рекомендуется к использованию начиная с версии Python {version}; используйте вместо него \"{replacement}\"",
         "dictExpandIllegalInComprehension": "Расширение словаря в понимании не допускается",
-        "dictInAnnotation": "Словарные выражения не разрешены в заметках типа",
+        "dictInAnnotation": "Словарное выражение не разрешено в выражении типа",
         "dictKeyValuePairs": "Записи словаря должны содержать пары \"ключ-значение\"",
         "dictUnpackIsNotMapping": "Ожидается сопоставление для оператора распаковки словаря",
         "dunderAllSymbolNotPresent": "\"{name}\" указано в методе __all__, но отсутствует в модуле",
@@ -140,7 +140,7 @@
         "duplicateBaseClass": "Дублирование базового класса не допускается",
         "duplicateCapturePatternTarget": "Целевой объект захвата \"{name}\" не может появляться более одного раза в одном шаблоне",
         "duplicateCatchAll": "В блоке except допускается только одно предложение catch-all",
-        "duplicateEnumMember": "Элемент перечислимого типа \"{name}\" уже объявлен",
+        "duplicateEnumMember": "Элемент Enum типа \"{name}\" уже объявлен",
         "duplicateGenericAndProtocolBase": "Допускается только один базовый класс Generic[...] или Protocol[...]",
         "duplicateImport": "\"{importName}\" импортируется несколько раз",
         "duplicateKeywordOnly": "Разрешен только один разделитель \"*\"",
@@ -149,14 +149,14 @@
         "duplicatePositionOnly": "Разрешен только один параметр \"/\"",
         "duplicateStarPattern": "В последовательности шаблонов допускается только один шаблон \"*\"",
         "duplicateStarStarPattern": "Допускается только одна запись \"**\"",
-        "duplicateUnpack": "В списке разрешена только одна операция распаковки",
-        "ellipsisAfterUnpacked": "\"...\" не может использоваться с распакованным элементом TypeVarTuple или кортежем",
+        "duplicateUnpack": "В list разрешена только одна операция распаковки",
+        "ellipsisAfterUnpacked": "\"...\" не может использоваться с распакованным элементом TypeVarTuple или tuple",
         "ellipsisContext": "\"...\" не допускается в данном контексте",
         "ellipsisSecondArg": "\"...\" разрешается только в качестве второго из двух аргументов",
-        "enumClassOverride": "Перечислимый класс \"{name}\" является окончательным и не может иметь производных классов",
-        "enumMemberDelete": "Не удается удалить элемент перечисления \"{name}\"",
-        "enumMemberSet": "Не удается назначить элемент перечисления \"{name}\"",
-        "enumMemberTypeAnnotation": "Аннотации типов не разрешены для элементов перечисления",
+        "enumClassOverride": "Enum класс \"{name}\" является final и не может иметь производных классов",
+        "enumMemberDelete": "Не удается удалить элемент Enum \"{name}\"",
+        "enumMemberSet": "Не удается назначить элемент Enum \"{name}\"",
+        "enumMemberTypeAnnotation": "Аннотации типов не разрешены для элементов enum",
         "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": "Ожидается блок с отступом",
@@ -212,11 +212,11 @@
         "finalClassIsAbstract": "Класс \"{type}\" помечен как final (окончательный) и должен реализовать все абстрактные символы.",
         "finalContext": "\"Final\" не допускается в данном контексте",
         "finalInLoop": "Переменная \"Final\" не может быть назначена внутри цикла",
-        "finalMethodOverride": "Метод \"{name}\" не может переопределять окончательный метод, определенный в классе \"{className}\"",
-        "finalNonMethod": "Функцию \"{name}\" нельзя пометить как @окончательную, так как она не является методом",
-        "finalReassigned": "\"{name}\" объявляется окончательным и не может быть переназначено",
+        "finalMethodOverride": "Метод \"{name}\" не может переопределять final метод, определенный в классе \"{className}\"",
+        "finalNonMethod": "Функцию \"{name}\" нельзя пометить как @final, так как она не является методом",
+        "finalReassigned": "\"{name}\" объявляется Final и не может быть переназначено",
         "finalRedeclaration": "\"{name}\" ранее объявлено как Final",
-        "finalRedeclarationBySubclass": "\"{name}\" невозможно повторно объявить, поскольку в родительском классе \"{className}\" он объявлен как final",
+        "finalRedeclarationBySubclass": "\"{name}\" невозможно повторно объявить, поскольку в родительском классе \"{className}\" он объявлен как Final",
         "finalTooManyArgs": "После \"Final\" ожидается один аргумент типа",
         "finalUnassigned": "\"{name}\" объявлен как Final, но ему не присвоено значение",
         "formatStringBrace": "Одиночная закрывающая скобка не допускается в литерале f-строки. Используйте двойную закрывающую скобку",
@@ -234,7 +234,7 @@
         "functionInConditionalExpression": "Условное выражение ссылается на функцию, которая всегда возвращает значение True",
         "functionTypeParametersIllegal": "Для синтаксиса параметра типа функции требуется версия Python 3.12 или более новая",
         "futureImportLocationNotAllowed": "Операторы импорта из __future__ должны находиться в начале файла",
-        "generatorAsyncReturnType": "Возвращаемый тип функции асинхронного генератора должен быть совместим с \"AsyncGenerator[{yieldType}, Any]\"",
+        "generatorAsyncReturnType": "Тип возвращаемого значения функции генератора async должен быть совместим с \"AsyncGenerator[{yieldType}, Any]\"",
         "generatorNotParenthesized": "Выражения генератора следует взять в скобки, если аргументов больше одного",
         "generatorSyncReturnType": "Возвращаемый тип функции генератора должен быть совместим с \"Generator[{yieldType}, Any, Any]\"",
         "genericBaseClassNotAllowed": "Базовый класс \"Generic\" нельзя использовать с синтаксисом параметра типа",
@@ -246,8 +246,8 @@
         "genericTypeArgMissing": "Для \"Generic\" требуется по крайней мере один аргумент типа",
         "genericTypeArgTypeVar": "Аргумент типа для \"Generic\" должен быть переменной типа",
         "genericTypeArgUnique": "Аргументы типа для \"Generic\" должны быть уникальными",
-        "globalReassignment": "Присвоение \"{name}\" происходит раньше глобального объявления",
-        "globalRedefinition": "Имя \"{name}\" уже объявлено ранее как глобальное",
+        "globalReassignment": "Присвоение \"{name}\" происходит раньше global объявления",
+        "globalRedefinition": "Имя \"{name}\" уже объявлено ранее как global",
         "implicitStringConcat": "Неявное объединение строк не разрешено",
         "importCycleDetected": "Обнаружен цикл в цепочке импорта",
         "importDepthExceeded": "Глубина цепочки импорта превысила {depth}",
@@ -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\" должен быть классом или кортежем классов",
-        "keyValueInSet": "Пары \"ключ-значение\" не допускаются в наборе",
+        "isInstanceInvalidType": "Второй аргумент \"isinstance\" должен быть классом или tuple классов",
+        "isSubclassInvalidType": "Второй аргумент в \"issubclass\" должен быть классом или tuple классов",
+        "keyValueInSet": "Пары \"ключ-значение\" не допускаются в set",
         "keywordArgInTypeArgument": "Аргументы ключевых слов нельзя использовать в списках аргументов типа",
         "keywordArgShortcutIllegal": "Ярлык аргумента ключевого слова требует Python 3.14 или более поздней версии",
         "keywordOnlyAfterArgs": "Разделитель аргументов типа \"только ключевое слово\" не разрешен после параметра \"*\"",
@@ -283,13 +283,13 @@
         "lambdaReturnTypePartiallyUnknown": "Тип возвращаемого лямбдой значения \"{returnType}\" частично неизвестен",
         "lambdaReturnTypeUnknown": "Тип значения, возвращаемого лямбдой, неизвестен",
         "listAssignmentMismatch": "Выражение с типом \"{type}\" нельзя присвоить целевому списку",
-        "listInAnnotation": "Списочное выражение не разрешено в заметке типа",
+        "listInAnnotation": "List выражение не разрешено в выражении типа",
         "literalEmptyArgs": "Ожидается один или несколько аргументов типа после \"Literal\"",
-        "literalNamedUnicodeEscape": "Именованные escape-последовательности Юникода не поддерживаются в аннотациях строк литералов",
+        "literalNamedUnicodeEscape": "Именованные escape-последовательности Юникода не поддерживаются в аннотациях строк Literal",
         "literalNotAllowed": "Невозможно использовать \"Literal\" в этом контексте без аргумента типа",
-        "literalNotCallable": "Не удается создать экземпляр типа литерала",
-        "literalUnsupportedType": "Аргументы типа для \"Literal\" должны иметь значение None, литеральное значение (int, bool, str или bytes) или значение перечислимого типа",
-        "matchIncompatible": "Операторы соответствия могут использоваться в Python версии не ниже 3.10",
+        "literalNotCallable": "Не удается создать экземпляр типа Literal",
+        "literalUnsupportedType": "Аргументы типа для \"Literal\" должны иметь значение None, литеральное значение (int, bool, str или bytes) или значение enum типа",
+        "matchIncompatible": "Операторы Match могут использоваться в Python версии не ниже 3.10",
         "matchIsNotExhaustive": "Блоки case в операторе match обрабатывают не все множество возможных значений",
         "maxParseDepthExceeded": "Превышена максимальная глубина разбора; разбейте выражение на составляющие выражения меньшего размера",
         "memberAccess": "Не удается получить доступ к атрибуту \"{name}\" для класса \"{type}\"",
@@ -304,41 +304,42 @@
         "methodOverridden": "\"{name}\" переопределяет метод с тем же именем в классе \"{className}\" с несовместимым типом \"{type}\"",
         "methodReturnsNonObject": "Метод \"{name}\" не возвращает объект",
         "missingSuperCall": "Метод \"{methodName}\" не вызывает метод с тем же именем в родительском классе",
+        "mixingBytesAndStr": "Невозможно объединить bytes и str значения",
         "moduleAsType": "Модуль не может использоваться в качестве типа",
         "moduleNotCallable": "Модуль не является вызываемым",
         "moduleUnknownMember": "\"{memberName}\" не является известным атрибутом модуля \"{moduleName}\"",
-        "namedExceptAfterCatchAll": "Именованное предложение исключения не может стоять после предложения catch-all except",
-        "namedParamAfterParamSpecArgs": "Параметр ключевого слова \"{name}\" не может размещаться в сигнатуре после параметра аргументов ParamSpec",
-        "namedTupleEmptyName": "Имена в именованном кортеже не могут быть пустыми",
-        "namedTupleEntryRedeclared": "Не удается переопределить \"{name}\", так как родительский класс \"{className}\" является именованным кортежем",
-        "namedTupleFirstArg": "В качестве первого аргумента ожидалось имя именованного класса кортежа",
+        "namedExceptAfterCatchAll": "Именованное предложение except не может стоять после предложения catch-all except",
+        "namedParamAfterParamSpecArgs": "Параметр ключевого слова \"{name}\" не может размещаться в сигнатуре после параметра ParamSpec args",
+        "namedTupleEmptyName": "Имена в именованном tuple не могут быть пустыми",
+        "namedTupleEntryRedeclared": "Не удается переопределить \"{name}\", так как родительский класс \"{className}\" является именованным tuple",
+        "namedTupleFirstArg": "В качестве первого аргумента ожидалось имя именованного класса tuple",
         "namedTupleMultipleInheritance": "Множественное наследование для NamedTuple не поддерживается",
         "namedTupleNameKeyword": "Имена полей не могут быть ключевыми словами",
-        "namedTupleNameType": "Ожидается двухфакторный кортеж с указанием имени и типа записи",
-        "namedTupleNameUnique": "Имена внутри именованного кортежа должны быть уникальными",
+        "namedTupleNameType": "Ожидается двухфакторный tuple с указанием имени и типа записи",
+        "namedTupleNameUnique": "Имена внутри именованного tuple должны быть уникальными",
         "namedTupleNoTypes": "\"namedtuple\" не предоставляет типов для записей кортежа; используйте вместо него \"NamedTuple\"",
-        "namedTupleSecondArg": "В качестве второго аргумента ожидается список записей именованного кортежа",
+        "namedTupleSecondArg": "В качестве второго аргумента ожидается именованный list записей tuple",
         "newClsParam": "Переопределение метода __new__ должно принимать параметр \"cls\"",
-        "newTypeAnyOrUnknown": "Второй аргумент для NewType должен быть известным классом, а не вариантом \"Любой\" или \"Неизвестный\"",
+        "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": "Аргумент, отличный от аргумента по умолчанию, следует за аргументом по умолчанию",
-        "nonLocalInModule": "Нелокальные объявления на уровне модулей не разрешены",
-        "nonLocalNoBinding": "Привязка для нелокального элемента \"{name}\" не найдена",
-        "nonLocalReassignment": "Назначение \"{name}\" происходит раньше нелокального объявления",
-        "nonLocalRedefinition": "\"{name}\" уже объявлено ранее как нелокальное",
+        "nonLocalInModule": "Nonlocal объявления на уровне модулей не разрешены",
+        "nonLocalNoBinding": "Привязка для nonlocal элемента \"{name}\" не найдена",
+        "nonLocalReassignment": "Назначение \"{name}\" происходит раньше nonlocal объявления",
+        "nonLocalRedefinition": "\"{name}\" уже объявлено ранее как nonlocal",
         "noneNotCallable": "Объект типа \"None\" не может быть вызван",
         "noneNotIterable": "Объект типа \"None\" не может использоваться в качестве итерируемого значения",
         "noneNotSubscriptable": "Объект типа \"None\" не подлежит подписке",
-        "noneNotUsableWith": "Объект типа \"None\" нельзя использовать с ключевым словом \"with\"",
+        "noneNotUsableWith": "Object of type \"None\" cannot be used with \"with\"",
         "noneOperator": "Оператор \"{operator}\" не поддерживается для \"None\"",
         "noneUnknownMember": "\"{name}\" не является известным атрибутом \"None\"",
         "notRequiredArgCount": "После \"NotRequired\" ожидается один аргумент типа",
@@ -359,14 +360,14 @@
         "overloadAbstractImplMismatch": "Перегрузки должны соответствовать абстрактному статусу реализации",
         "overloadAbstractMismatch": "Все перегрузки должны быть абстрактными или не абстрактными",
         "overloadClassMethodInconsistent": "Перегрузки для \"{name}\" используют @classmethod несогласованно",
-        "overloadFinalInconsistencyImpl": "Перегрузка для \"{name}\" помечена как @окончательная, но реализация — нет",
-        "overloadFinalInconsistencyNoImpl": "Перегрузка {index} для \"{name}\" помечена как @окончательная, но перегрузка 1 — нет",
+        "overloadFinalInconsistencyImpl": "Перегрузка для \"{name}\" помечена как @final, но реализация — нет",
+        "overloadFinalInconsistencyNoImpl": "Перегрузка {index} для \"{name}\" помечена как @final, но перегрузка 1 — нет",
         "overloadImplementationMismatch": "Перегруженная реализация не согласована с сигнатурой перегрузки {index}",
         "overloadReturnTypeMismatch": "Перегрузка {prevIndex} для \"{name}\" перекрывает перегрузку {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,9 +378,9 @@
         "paramSpecArgsUsage": "Атрибут \"args\" ParamSpec допустим только при использовании с параметром *args",
         "paramSpecAssignedName": "ParamSpec необходимо присвоить переменной с именем \"{name}\"",
         "paramSpecContext": "ParamSpec не допускается в этом контексте",
-        "paramSpecDefaultNotTuple": "Для значения ParamSpec по умолчанию ожидается многоточие, выражение кортежа или ParamSpec",
+        "paramSpecDefaultNotTuple": "Для значения ParamSpec по умолчанию ожидается многоточие, выражение tuple или ParamSpec",
         "paramSpecFirstArg": "Ожидается имя ParamSpec в качестве первого аргумента",
-        "paramSpecKwargsUsage": "Атрибут \"kwargs\" ParamSpec допустим только при использовании с параметром *kwargs",
+        "paramSpecKwargsUsage": "Атрибут \"kwargs\" ParamSpec допустим только при использовании с параметром **kwargs",
         "paramSpecNotUsedByOuterScope": "ParamSpec \"{name}\" не имеет смысла в этом контексте",
         "paramSpecUnknownArg": "ParamSpec не поддерживает более одного аргумента",
         "paramSpecUnknownMember": "\"{name}\" не является известным атрибутом ParamSpec",
@@ -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": "Разделитель чисто позиционных параметров после параметра \"*\" не разрешен",
@@ -398,21 +399,21 @@
         "privateImportFromPyTypedModule": "\"{name}\" не экспортируется из модуля \"{module}\"",
         "privateUsedOutsideOfClass": "Элемент \"{name}\" является закрытым, но используется вне класса, в котором объявлен",
         "privateUsedOutsideOfModule": "\"{name}\" является закрытым, но используется вне модуля, в котором объявлен",
-        "propertyOverridden": "\"{name}\" неправильно переопределяет свойство с таким же именем в классе \"{className}\"",
-        "propertyStaticMethod": "Статические методы не разрешены в методах получения, задания и удаления свойств",
+        "propertyOverridden": "\"{name}\" неправильно переопределяет property с таким же именем в классе \"{className}\"",
+        "propertyStaticMethod": "Статические методы не разрешены в методах getter, setter и deleter property",
         "protectedUsedOutsideOfClass": "\"{name}\" защищено и используется вне класса, в котором оно объявлено",
-        "protocolBaseClass": "Класс протокола \"{classType}\" не может быть производным от непротокольного класса \"{baseType}\"",
-        "protocolBaseClassWithTypeArgs": "Аргументы типа не допускаются с классом протокола при использовании синтаксиса параметра типа",
+        "protocolBaseClass": "Класс Protocol \"{classType}\" не может быть производным от класса \"{baseType}\", отличного от Protocol",
+        "protocolBaseClassWithTypeArgs": "Аргументы типа не допускаются с классом Protocol при использовании синтаксиса параметра типа",
         "protocolIllegal": "Ключевое слово \"Protocol\" можно использовать в Python версии не ниже 3.7",
         "protocolNotAllowed": "Невозможно использовать \"Protocol\" в этом контексте",
         "protocolTypeArgMustBeTypeParam": "Аргумент типа для параметра \"Protocol\" должен быть параметром типа",
         "protocolUnsafeOverlap": "Класс небезопасно перекрывает \"{name}\" и может вызвать совпадение во время выполнения",
-        "protocolVarianceContravariant": "Переменная типа \"{variable}\", используемая в универсальном протоколе \"{class}\", должна быть контравариантной.",
-        "protocolVarianceCovariant": "Переменная типа \"{variable}\", используемая в универсальном протоколе \"{class}\", должна быть ковариантной",
-        "protocolVarianceInvariant": "Переменная типа \"{variable}\", используемая в универсальном протоколе \"{class}\", должна быть инвариантной",
+        "protocolVarianceContravariant": "Переменная типа \"{variable}\", используемая в универсальном Protocol \"{class}\", должна быть контравариантной.",
+        "protocolVarianceCovariant": "Переменная типа \"{variable}\", используемая в универсальном Protocol \"{class}\", должна быть ковариантной",
+        "protocolVarianceInvariant": "Переменная типа \"{variable}\", используемая в универсальном Protocol \"{class}\", должна быть инвариантной",
         "pyrightCommentInvalidDiagnosticBoolValue": "За директивой комментария Pyright должно следовать \"=\" и значение true или false",
-        "pyrightCommentInvalidDiagnosticSeverityValue": "За директивой комментария pyright должно следовать \"=\" и одно из следующих значений: true, false, error, warning, information или none",
-        "pyrightCommentMissingDirective": "После комментария pyright должна следовать директива (обычная или строгая) или правило диагностики",
+        "pyrightCommentInvalidDiagnosticSeverityValue": "За директивой комментария Pyright должно следовать \"=\" и одно из следующих значений: true, false, error, warning, information или none",
+        "pyrightCommentMissingDirective": "После комментария Pyright должна следовать директива (basic или strict) или правило диагностики",
         "pyrightCommentNotOnOwnLine": "Комментарии Pyright, используемые для управления параметрами на уровне файлов, должны располагаться в отдельной строке",
         "pyrightCommentUnknownDiagnosticRule": "Правило диагностики \"{rule}\" для комментария pyright неизвестно",
         "pyrightCommentUnknownDiagnosticSeverityValue": "Значение \"{value}\" недопустимо для комментария pyright; ожидается одно из значений true, false, error, warning, information или none",
@@ -423,15 +424,15 @@
         "relativeImportNotAllowed": "Операции импорта с относительным путем нельзя использовать с формой \"import .a\"; используйте вместо этого \"from . import a\"",
         "requiredArgCount": "Ожидается один аргумент типа после \"Required\"",
         "requiredNotInTypedDict": "Использование \"Required\" в этом контексте не допускается",
-        "returnInAsyncGenerator": "Оператор return со значением не допускается в асинхронном генераторе",
+        "returnInAsyncGenerator": "Оператор return со значением не допускается в генераторе async",
         "returnMissing": "Функция с объявленным типом возвращаемого значения \"{returnType}\" должна возвращать значение во всех путях кода",
         "returnOutsideFunction": "\"return\" можно использовать только внутри функции",
         "returnTypeContravariant": "Переменная контравариантного типа не может использоваться в возвращаемом типе",
-        "returnTypeMismatch": "Выражение типа \"{exprType}\" несовместимо с возвращаемым типом \"{returnType}\"",
+        "returnTypeMismatch": "Тип \"{exprType}\" не может быть присвоен для возврата типа \"{returnType}\"",
         "returnTypePartiallyUnknown": "Тип возвращаемого значения \"{returnType}\" частично неизвестен",
         "returnTypeUnknown": "Тип возвращаемого значения неизвестен",
         "revealLocalsArgs": "Не ожидаются аргументы для вызова \"reveal_locals\"",
-        "revealLocalsNone": "В этой области нет локальных элементов",
+        "revealLocalsNone": "В этой области нет locals",
         "revealTypeArgs": "Для вызова \"reveal_type\" ожидается один позиционный аргумент",
         "revealTypeExpectedTextArg": "Аргумент \"expected_text\" для функции \"reveal_type\" должен быть значением литерала str",
         "revealTypeExpectedTextMismatch": "Несоответствие текста в типе; ожидалось \"{expected}\", но получено \"{received}\"",
@@ -439,7 +440,7 @@
         "selfTypeContext": "'В этом контексте ключевое слово \"Self\" недопустимо",
         "selfTypeMetaclass": "\"Self\" нельзя использовать в метаклассе (подкласс \"type\")",
         "selfTypeWithTypedSelfOrCls": "Ключевое слово \"Self\" нельзя использовать в функции с параметром \"self\" или \"cls\" с заметкой типа, отличной от \"Self\".",
-        "setterGetterTypeMismatch": "Тип значения метода задания свойства нельзя присвоить типу возвращаемого значения метода получения",
+        "setterGetterTypeMismatch": "Тип значения setter property нельзя присвоить типу возвращаемого значения getter",
         "singleOverload": "Элемент \"{name}\" помечен как перегруженный, но дополнительные перегрузки отсутствуют",
         "slotsAttributeError": "\"{name}\" не указано в __slots__",
         "slotsClassVarConflict": "\"{name}\" конфликтует с переменной экземпляра, объявленной в __slots__",
@@ -449,12 +450,12 @@
         "staticClsSelfParam": "Статические методы не принимают в качестве параметра \"self\" и \"cls\"",
         "stdlibModuleOverridden": "\"{path}\" переопределяет модуль stdlib \"{name}\"",
         "stringNonAsciiBytes": "Символы, отличные от ASCII, не допускаются в строковом литерале байтов",
-        "stringNotSubscriptable": "От строкового выражения нельзя взять подстроку в заметке типа; заключите всю заметку в кавычки",
+        "stringNotSubscriptable": "От строкового выражения нельзя взять подстроку в выражении типа; заключите все выражение в кавычки",
         "stringUnsupportedEscape": "Неподдерживаемая escape-последовательность в строковом литерале",
         "stringUnterminated": "В строковом литерале отсутствует символ конца строки",
-        "stubFileMissing": "Файл-заглушка для \"{importName}\" не найден",
-        "stubUsesGetAttr": "Файл-заглушка типа неполон; \"__getattr__\" скрывает ошибки типа для модуля",
-        "sublistParamsIncompatible": "Параметры вложенного списка не поддерживаются в Python 3.x",
+        "stubFileMissing": "Файл stub для \"{importName}\" не найден",
+        "stubUsesGetAttr": "Файл stub типа неполон; \"__getattr__\" скрывает ошибки типа для модуля",
+        "sublistParamsIncompatible": "Параметры sublist списка не поддерживаются в Python 3.x",
         "superCallArgCount": "Ожидается не более двух аргументов для вызова \"super\"",
         "superCallFirstArg": "В качестве первого аргумента для вызова \"super\" ожидался тип класса, но получен \"{type}\"",
         "superCallSecondArg": "Второй аргумент для вызова \"super\" должен быть объектом или классом, производным от \"{type}\"",
@@ -464,45 +465,46 @@
         "symbolIsUnbound": "Элемент \"{name}\" не привязан",
         "symbolIsUndefined": "\"{name}\" не определено",
         "symbolOverridden": "\"{name}\" переопределяет символ с тем же именем в классе \"{className}\"",
-        "ternaryNotAllowed": "Тернарное выражение не разрешено в заметке типа",
+        "ternaryNotAllowed": "Тернарное выражение не разрешено в выражении типа",
         "totalOrderingMissingMethod": "Чтобы можно было использовать total_ordering, в классе должен быть определен один из операторов: \"__lt__\", \"__le__\", \"__gt__\" или \"__ge__\"",
         "trailingCommaInFromImport": "Конечные запятые можно использовать только при заключении в скобки",
-        "tryWithoutExcept": "В операторе try должно быть хотя бы одно предложение exclude или finally.",
-        "tupleAssignmentMismatch": "Выражение с типом \"{type}\" не может быть назначено целевому кортежу",
-        "tupleInAnnotation": "Выражение кортежа не разрешено в заметке с типом",
+        "tryWithoutExcept": "В операторе try должно быть хотя бы одно предложение except или finally",
+        "tupleAssignmentMismatch": "Выражение с типом \"{type}\" не может быть назначено целевому tuple",
+        "tupleInAnnotation": "Выражение tuple не разрешено в выражении типа",
         "tupleIndexOutOfRange": "Индекс {index} выходит за пределы допустимого диапазона для типа {type}",
         "typeAliasIllegalExpressionForm": "Недопустимая форма выражения для определения псевдонима типа",
         "typeAliasIsRecursiveDirect": "Псевдоним типа \"{name}\" не может использовать себя в своем определении",
         "typeAliasNotInModuleOrClass": "TypeAlias можно определить только внутри области модуля или класса",
         "typeAliasRedeclared": "\"{name}\" объявлен как TypeAlias и может быть присвоен только один раз",
-        "typeAliasStatementBadScope": "Утверждение типа можно использовать только внутри области модуля или класса",
+        "typeAliasStatementBadScope": "Утверждение type можно использовать только внутри области модуля или класса",
         "typeAliasStatementIllegal": "Оператор псевдонима типа можно использовать в Python версии не ниже 3.12",
         "typeAliasTypeBaseClass": "Псевдоним типа, определяемый в операторе \"type\", не может использоваться в качестве базового класса.",
         "typeAliasTypeMustBeAssigned": "TypeAliasType должен быть назначен переменной с тем же именем, что и псевдоним типа",
         "typeAliasTypeNameArg": "Первый аргумент TypeAliasType должен быть строковым литералом, представляющим имя псевдонима типа",
         "typeAliasTypeNameMismatch": "Имя псевдонима типа должно соответствовать имени переменной, которой оно назначено",
-        "typeAliasTypeParamInvalid": "Список параметров типа должен быть кортежем, содержащим только TypeVar, TypeVarTuple или ParamSpec",
+        "typeAliasTypeParamInvalid": "Список параметров типа должен быть tuple, содержащим только TypeVar, TypeVarTuple или ParamSpec",
         "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,14 +539,14 @@
         "typeVarSingleConstraint": "TypeVar должен иметь не менее двух ограниченных типов",
         "typeVarTupleConstraints": "TypeVarTuple не может использовать ограничения значений",
         "typeVarTupleContext": "TypeVarTuple не допускается в этом контексте",
-        "typeVarTupleDefaultNotUnpacked": "Тип по умолчанию TypeVarTuple должен быть распакованным кортежем или TypeVarTuple.",
+        "typeVarTupleDefaultNotUnpacked": "Тип по умолчанию TypeVarTuple должен быть распакованным tuple или TypeVarTuple",
         "typeVarTupleMustBeUnpacked": "Для значения TypeVarTuple требуется оператор распаковки",
         "typeVarTupleUnknownParam": "\"{name}\" является неизвестным параметром для TypeVarTuple",
         "typeVarUnknownParam": "\"{name}\" является неизвестным параметром для TypeVar",
         "typeVarUsedByOuterScope": "TypeVar \"{name}\" уже используется внешней областью",
         "typeVarUsedOnlyOnce": "TypeVar \"{name}\" появляется в сигнатуре универсальной функции только один раз",
         "typeVarVariance": "TypeVar не может быть одновременно ковариантным и контравариантным",
-        "typeVarWithDefaultFollowsVariadic": "TypeVar \"{typeVarName}\" имеет значение по умолчанию и не может следовать за typeVarTuple \"{variadicName}\"",
+        "typeVarWithDefaultFollowsVariadic": "TypeVar \"{typeVarName}\" имеет значение по умолчанию и не может следовать за TypeVarTuple \"{variadicName}\"",
         "typeVarWithoutDefault": "\"{name}\" не может появиться после \"{other}\" в списке параметров типа, так как у него нет типа по умолчанию",
         "typeVarsNotInGenericOrProtocol": "Generic[] и Protocol[] должны включать все переменные типа",
         "typedDictAccess": "Не удалось получить доступ к элементу в TypedDict",
@@ -552,20 +554,20 @@
         "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": "Для имени записи словаря ожидается строковый литерал",
         "typedDictEntryUnique": "Имена в словаре должны быть уникальными",
         "typedDictExtraArgs": "Дополнительные аргументы TypedDict не поддерживаются",
-        "typedDictFieldNotRequiredRedefinition": "Элемент TypedDict \"{name}\" нельзя переопределить как необязательный",
-        "typedDictFieldReadOnlyRedefinition": "Элемент TypedDict \"{name}\" нельзя переопределить как доступный только для чтения",
-        "typedDictFieldRequiredRedefinition": "Элемент TypedDict \"{name}\" нельзя переопределить как обязательный",
+        "typedDictFieldNotRequiredRedefinition": "Элемент TypedDict \"{name}\" нельзя переопределить как NotRequired",
+        "typedDictFieldReadOnlyRedefinition": "Элемент TypedDict \"{name}\" нельзя переопределить как доступный ReadOnly",
+        "typedDictFieldRequiredRedefinition": "Элемент TypedDict \"{name}\" нельзя переопределить как Required",
         "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": "После \"async\" ожидается \"def\", \"with\" или \"for\"",
         "unexpectedExprToken": "Непредвиденный токен в конце выражения",
         "unexpectedIndent": "Непредвиденный отступ",
         "unexpectedUnindent": "Отступ не ожидается",
         "unhashableDictKey": "Ключ словаря должен быть хэшируемым",
-        "unhashableSetEntry": "Запись набора должна быть хэшируемой",
-        "uninitializedAbstractVariables": "Переменные, определенные в абстрактном базовом классе, не инициализированы в окончательном классе \"{classType}\"",
+        "unhashableSetEntry": "Запись set должна быть хэшируемой",
+        "uninitializedAbstractVariables": "Переменные, определенные в абстрактном базовом классе, не инициализированы в final классе \"{classType}\"",
         "uninitializedInstanceVariable": "Переменная экземпляра \"{name}\" не инициализирована ни в тексте класса, ни в методе __init__",
-        "unionForwardReferenceNotAllowed": "Синтаксис объединения не может использоваться со строковым операндом; заключите всё выражение в кавычки",
+        "unionForwardReferenceNotAllowed": "Синтаксис Union не может использоваться со строковым операндом; заключите всё выражение в кавычки",
         "unionSyntaxIllegal": "Альтернативный синтаксис объединений можно использовать в версии Python не ниже 3.10",
-        "unionTypeArgCount": "Для объединения требуется два или более аргумента типа",
-        "unionUnpackedTuple": "Объединение не может включать распакованный кортеж",
-        "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 или кортеж",
-        "unpackExpectedTypedDict": "Ожидается аргумент типа TypedDict для распаковки",
+        "unpackExpectedTypeVarTuple": "В качестве аргумента типа для Unpack ожидается элемент TypeVarTuple или tuple",
+        "unpackExpectedTypedDict": "Ожидается аргумент типа TypedDict для Unpack",
         "unpackIllegalInComprehension": "Операция распаковки в понимании не разрешена",
-        "unpackInAnnotation": "Оператор распаковки нельзя использовать в заметке типа",
+        "unpackInAnnotation": "Оператор распаковки нельзя использовать в выражении типа",
         "unpackInDict": "Операция распаковки в словарях не разрешена",
-        "unpackInSet": "Оператор распаковки не разрешен в наборе",
-        "unpackNotAllowed": "Распаковка допускается в этом контексте",
+        "unpackInSet": "Оператор распаковки не разрешен в set",
+        "unpackNotAllowed": "Unpack допускается в этом контексте",
         "unpackOperatorNotAllowed": "Операция распаковки допускается в этом контексте",
         "unpackTuplesIllegal": "Операцию распаковки в кортежах можно использовать в Python версии не ниже 3.8",
         "unpackedArgInTypeArgument": "В этом контексте нельзя использовать распакованные аргументы",
@@ -616,48 +620,48 @@
         "unreachableExcept": "Предложение Except недоступно, так как исключение уже обработано",
         "unsupportedDunderAllOperation": "Операция на \"__all__\" не поддерживается, поэтому список экспортируемых символов может быть неправильным",
         "unusedCallResult": "Результат выражения вызова принадлежит к типу \"{type}\" и не используется. Назначьте переменной \"_\", если это сделано намеренно",
-        "unusedCoroutine": "Результат вызова асинхронной функции не используется; добавьте ключевое слово \"await\" или присвойте результат переменной",
+        "unusedCoroutine": "Результат вызова async функции не используется; добавьте ключевое слово \"await\" или присвойте результат переменной",
         "unusedExpression": "Значение выражения не используется",
-        "varAnnotationIllegal": "Заметки типа для переменных можно использовать в Python версии не ниже 3.6. Для совместимости с более ранними версиями используйте комментарий к типу.",
-        "variableFinalOverride": "Переменная \"{name}\" помечена как Final и переопределяет неокончательную переменную с тем же именем в классе \"{className}\"",
-        "variadicTypeArgsTooMany": "Список аргументов типа может содержать не более одного распакованного элемента TypeVarTuple или кортежа",
+        "varAnnotationIllegal": "Заметки type для переменных можно использовать в Python версии не ниже 3.6. Для совместимости с более ранними версиями используйте комментарий к типу.",
+        "variableFinalOverride": "Переменная \"{name}\" помечена как Final и переопределяет non-Final переменную с тем же именем в классе \"{className}\"",
+        "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\" не допускается в асинхронной функции",
+        "yieldFromIllegal": "\"yield from\" можно использовать в Python версии не ниже 3.3",
+        "yieldFromOutsideAsync": "\"yield from\" не допускается в async функции",
         "yieldOutsideFunction": "\"yield\" не допускается за пределами функции или лямбда-выражении",
         "yieldWithinComprehension": "\"yield\" не допускается внутри понимания",
         "zeroCaseStatementsFound": "Операторе match должен включать по крайней мере один оператор case",
-        "zeroLengthTupleNotAllowed": "Кортеж нулевой длины не допускается в этом контексте"
+        "zeroLengthTupleNotAllowed": "tuple нулевой длины не допускается в этом контексте"
     },
     "DiagnosticAddendum": {
-        "annotatedNotAllowed": "Специальную форму \"С заметками\" нельзя использовать с проверками экземпляра и класса",
+        "annotatedNotAllowed": "Специальную форму \"Annotated\" нельзя использовать с проверками экземпляра и класса",
         "argParam": "Аргумент соответствует параметру \"{paramName}\"",
         "argParamFunction": "Аргумент соответствует параметру \"{paramName}\" функции \"{functionName}\"",
         "argsParamMissing": "У параметра \"*{paramName}\" нет соответствующего параметра",
         "argsPositionOnly": "Несоответствие параметров только положения. Ожидается {expected}, но получено {received}",
         "argumentType": "Аргумент принадлежит к типу \"{type}\"",
         "argumentTypes": "Типы аргументов: ({types})",
-        "assignToNone": "Тип несовместим с \"None\"",
+        "assignToNone": "Для типа не может быть назначено значение \"None\"",
         "asyncHelp": "Вы имели в виду \"async with\"?",
         "baseClassIncompatible": "Базовый класс \"{baseClass}\" несовместим с типом \"{type}\"",
         "baseClassIncompatibleSubclass": "Базовый класс \"{baseClass}\" является производным от \"{subclass}\", который несовместим с типом \"{type}\"",
         "baseClassOverriddenType": "Базовый класс \"{baseClass}\" предоставляет тип \"{type}\", который переопределен",
         "baseClassOverridesType": "Базовый класс \"{baseClass}\" переопределяет тип \"{type}\"",
-        "bytesTypePromotions": "Установите для параметра DisableBytesTypePromotions значение ЛОЖЬ, чтобы включить повышение типа для \"bytearray\" и \"memoryview\"",
+        "bytesTypePromotions": "Установите для параметра disableBytesTypePromotions значение false, чтобы включить повышение типа для \"bytearray\" и \"memoryview\"",
         "conditionalRequiresBool": "Метод __bool__ для типа \"{operandType}\" возвращает тип \"{boolReturnType}\", а не \"bool\"",
         "dataClassFieldLocation": "Объявление поля",
         "dataClassFrozen": "Элемент \"{name}\" зафиксирован",
         "dataProtocolUnsupported": "\"{name}\" является протоколом данных",
         "descriptorAccessBindingFailed": "Не удалось привязать метод \"{name}\" для класса дескриптора \"{className}\"",
         "descriptorAccessCallFailed": "Не удалось вызвать метод \"{name}\" для класса дескриптора \"{className}\"",
-        "finalMethod": "Окончательный метод",
+        "finalMethod": "Final метод",
         "functionParamDefaultMissing": "В параметре \"{name}\" отсутствует аргумент по умолчанию.",
         "functionParamName": "Несоответствие имени параметра: \"{destName}\" и \"{srcName}\"",
         "functionParamPositionOnly": "Несоответствие исключительно позиционных параметров; параметр \"{name}\" не является исключительно позиционным",
@@ -665,9 +669,9 @@
         "functionTooFewParams": "Функция принимает слишком мало позиционных параметров; ожидалось {expected}, но получено {received}",
         "functionTooManyParams": "Функция принимает слишком много позиционных параметров; ожидалось {expected}, но получено {received}",
         "genericClassNotAllowed": "Универсальный тип с аргументами типа запрещен для проверок экземпляров или классов",
-        "incompatibleDeleter": "Метод удаления свойства является несовместимым",
-        "incompatibleGetter": "Несовместимый метод получения свойств",
-        "incompatibleSetter": "Метод задания свойства является несовместимым",
+        "incompatibleDeleter": "Метод deleter property является несовместимым",
+        "incompatibleGetter": "Несовместимый метод getter property",
+        "incompatibleSetter": "Метод setter property является несовместимым",
         "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}\" не может быть назначено атрибуту \"{name}\" класса \"{classType}\"",
         "memberIsAbstract": "Отсутствует реализация \"{type}.{name}\".",
-        "memberIsAbstractMore": "и еще {{count}}",
+        "memberIsAbstractMore": "и еще {{count}}...",
         "memberIsClassVarInProtocol": "\"{name}\" определено как класс ClassVar в протоколе",
-        "memberIsInitVar": "\"{name}\" является полем только для инициализации",
+        "memberIsInitVar": "\"{name}\" является полем только для init-only",
         "memberIsInvariant": "Элемент \"{name}\" инвариантен, поскольку помечен как mutable",
         "memberIsNotClassVarInClass": "Необходимо определить \"{name}\" как ClassVar для совместимости с протоколом.",
         "memberIsNotClassVarInProtocol": "\"{name}\" не определено как класс ClassVar в протоколе",
@@ -699,9 +703,9 @@
         "memberTypeMismatch": "\"{name}\" является несовместимым типом",
         "memberUnknown": "Атрибут \"{name}\" неизвестен",
         "metaclassConflict": "Метакласс \"{metaclass1}\" конфликтует с \"{metaclass2}\"",
-        "missingDeleter": "Отсутствует метод удаления свойства",
-        "missingGetter": "Отсутствует метод получения свойства",
-        "missingSetter": "Отсутствует метод установки свойств",
+        "missingDeleter": "Отсутствует метод deleter property",
+        "missingGetter": "Отсутствует метод getter property",
+        "missingSetter": "Отсутствует метод setter property",
         "namedParamMissingInDest": "Дополнительный параметр \"{name}\"",
         "namedParamMissingInSource": "Отсутствует параметр ключевого слова \"{name}\".",
         "namedParamTypeMismatch": "Параметр ключевого слова \"{name}\" типа \"{sourceType}\" несовместим с типом \"{destType}\"",
@@ -710,7 +714,7 @@
         "newMethodSignature": "Сигнатура метода __new__ требует \"{type}\"",
         "newTypeClassNotAllowed": "Класс, созданный с NewType, нельзя использовать с проверками экземпляров и классов",
         "noOverloadAssignable": "Нет перегруженной функции, соответствующей типу \"{type}\"",
-        "noneNotAllowed": "Их невозможно использовать для проверок экземпляров или классов",
+        "noneNotAllowed": "None невозможно использовать для проверок экземпляров или классов",
         "orPatternMissingName": "Отсутствуют имена: {name}",
         "overloadIndex": "Наилучшее совпадение: {index} перегрузки",
         "overloadNotAssignable": "Одна или несколько перегрузок \"{name}\" не подлежат присвоению",
@@ -722,7 +726,7 @@
         "overrideNoOverloadMatches": "В переопределении нет сигнатуры перегрузки, совместимой с базовым методом",
         "overrideNotClassMethod": "Базовый метод объявлен как classmethod, а его переопределение — нет",
         "overrideNotInstanceMethod": "Базовый метод объявлен как метод экземпляра, а его переопределение — нет",
-        "overrideNotStaticMethod": "Базовый метод объявлен как статический, а его переопределение — нет",
+        "overrideNotStaticMethod": "Базовый метод объявлен как staticmethod, а его переопределение — нет",
         "overrideOverloadNoMatch": "Переопределение не обрабатывает все перегрузки базового метода",
         "overrideOverloadOrder": "Перегрузки в методе переопределения должны располагаться в том же порядке, что и в базовом методе",
         "overrideParamKeywordNoDefault": "Несоответствие параметра ключевого слова \"{name}\": базовый параметр содержит значение аргумента по умолчанию, параметр переопределения — нет",
@@ -741,16 +745,16 @@
         "paramType": "Параметр принадлежит к типу \"{paramType}\"",
         "privateImportFromPyTypedSource": "Вместо этого используйте импорт из \"{module}\"",
         "propertyAccessFromProtocolClass": "Свойство, определенное в классе протокола, не может быть доступно как переменная класса.",
-        "propertyMethodIncompatible": "Метод свойства \"{name}\" несовместим",
-        "propertyMethodMissing": "Метод свойства \"{name}\" отсутствует в переопределении",
-        "propertyMissingDeleter": "Для свойства \"{name}\" не определен метод удаления",
-        "propertyMissingSetter": "Для свойства \"{name}\" не определен метод задания",
+        "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[<правила диагностики>]",
+        "pyrightCommentIgnoreTip": "Для подавления диагностики в одной строке используйте конструкцию \"# pyright: ignore[<diagnostic rules>]\"",
         "readOnlyAttribute": "Атрибут \"{name}\" доступен только для чтения",
         "seeClassDeclaration": "См. объявление класса",
         "seeDeclaration": "См. объявление",
@@ -759,17 +763,17 @@
         "seeParameterDeclaration": "Просмотреть объявление параметра",
         "seeTypeAliasDeclaration": "Просмотреть объявление псевдонима типа",
         "seeVariableDeclaration": "Просмотреть объявление переменной",
-        "tupleAssignmentMismatch": "Тип \"{type}\" несовместим с целевым кортежем",
-        "tupleEntryTypeMismatch": "Запись кортежа {entry} имеет неверный тип",
-        "tupleSizeIndeterminateSrc": "Несоответствие размеров кортежа: ожидается \"{expected}\", но получено неопределенное значение",
-        "tupleSizeIndeterminateSrcDest": "Несоответствие размеров кортежа: ожидается {expected} или больше, но получено неопределенное значение",
-        "tupleSizeMismatch": "Несоответствие размеров кортежа: ожидается \"{expected}\", но получено \"{received}\"",
-        "tupleSizeMismatchIndeterminateDest": "Несоответствие размеров кортежа: ожидается {expected} или больше, но получено {received}",
+        "tupleAssignmentMismatch": "Тип \"{type}\" несовместим с целевым tuple",
+        "tupleEntryTypeMismatch": "Запись tuple {entry} имеет неверный тип",
+        "tupleSizeIndeterminateSrc": "Несоответствие размеров tuple: ожидается \"{expected}\", но получено неопределенное значение",
+        "tupleSizeIndeterminateSrcDest": "Несоответствие размеров tuple: ожидается {expected} или больше, но получено неопределенное значение",
+        "tupleSizeMismatch": "Несоответствие размеров tuple: ожидается \"{expected}\", но получено \"{received}\"",
+        "tupleSizeMismatchIndeterminateDest": "Несоответствие размеров tuple: ожидается {expected} или больше, но получено {received}",
         "typeAliasInstanceCheck": "Псевдоним типа, создаваемый оператором \"type\", не может использоваться с проверками экземпляра и класса.",
-        "typeAssignmentMismatch": "Тип \"{sourceType}\" несовместим с типом \"{destType}\"",
-        "typeBound": "Тип \"{sourceType}\" несовместим с привязанным типом \"{destType}\" для переменной типа \"{name}\"",
-        "typeConstrainedTypeVar": "Тип \"{type}\" несовместим с переменной ограниченного типа \"{name}\"",
-        "typeIncompatible": "\"{sourceType}\" несовместим с \"{destType}\"",
+        "typeAssignmentMismatch": "\"{sourceType}\" типа невозможно назначить тип \"{destType}\"",
+        "typeBound": "Тип \"{sourceType}\" не может быть назначен верхней границе \"{destType}\" для переменной типа \"{name}\"",
+        "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}",
@@ -788,7 +792,7 @@
         "typedDictClassNotAllowed": "Класс TypedDict не допускается для проверок экземпляров или классов",
         "typedDictClosedExtraNotAllowed": "Не удается добавить элемент \"{name}\"",
         "typedDictClosedExtraTypeMismatch": "Не удается добавить элемент \"{name}\" типа \"{type}\"",
-        "typedDictClosedFieldNotRequired": "Не удается добавить элемент \"{name}\", так как он должен быть помечен как необязательный",
+        "typedDictClosedFieldNotRequired": "Не удается добавить элемент \"{name}\", так как он должен быть помечен как NotRequired",
         "typedDictExtraFieldNotAllowed": "Элемент \"{name}\" отсутствует в типе \"{type}\"",
         "typedDictExtraFieldTypeMismatch": "Тип элемента \"{name}\" несовместим с типом \"__extra_items__\" в \"{type}\"",
         "typedDictFieldMissing": "\"{name}\" отсутствует в \"{type}\"",
@@ -797,15 +801,15 @@
         "typedDictFieldRequired": "\"{name}\" является обязательным в \"{type}\"",
         "typedDictFieldTypeMismatch": "Тип \"{type}\" нельзя присвоить полю \"{name}\"",
         "typedDictFieldUndefined": "Элемент \"{name}\" не определен в типе \"{type}\"",
-        "typedDictFinalMismatch": "\"{sourceType}\" несовместим с \"{destType}\" из-за несоответствия окончательности",
+        "typedDictFinalMismatch": "\"{sourceType}\" несовместим с \"{destType}\" из-за несоответствия @final",
         "typedDictKeyAccess": "Использовать [\"{name}\"] для ссылки на элемент в TypedDict",
         "typedDictNotAllowed": "TypedDict не может использоваться для проверок экземпляров или классов",
         "unhashableType": "Тип \"{type}\" не является хэшируемым",
         "uninitializedAbstractVariable": "Переменная экземпляра \"{name}\" определена в абстрактном базовом классе \"{classType}\", но не инициализирована",
         "unreachableExcept": "\"{exceptionType}\" является подклассом \"{parentType}\"",
         "useDictInstead": "Используйте Dict[T1, T2] для указания типа словаря",
-        "useListInstead": "Используйте List[T] для указания типа списка или Union[T1, T2] для указания типа объединения",
-        "useTupleInstead": "Используйте конструкцию tuple[T1, ..., Tn], чтобы указать тип кортежа, или Union[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}\""