@zzzen/pyright-internal 1.2.0-dev.20240421 → 1.2.0-dev.20240505

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

@@ -17,10 +17,10 @@
         "abstractMethodInvocation": "메서드 \"{method}\"은(는) 추상적이고 구현되지 않았으므로 호출할 수 없습니다.",
         "annotatedParamCountMismatch": "매개 변수 주석 개수가 일치하지 않습니다. {expected}이)(가) 필요하지만 {received}을(를) 받았습니다.",
         "annotatedTypeArgMissing": "\"Annotated\"에 대해 하나의 형식 인수와 하나 이상의 주석이 필요합니다.",
-        "annotationBytesString": "Type annotations cannot use bytes string literals",
+        "annotationBytesString": "형식 주석은 바이트 문자열 리터럴을 사용할 수 없습니다.",
         "annotationFormatString": "형식 주석은 형식 문자열 리터럴(f-문자열)을 사용할 수 없습니다.",
         "annotationNotSupported": "이 문에는 형식 주석이 지원되지 않습니다.",
-        "annotationRawString": "Type annotations cannot use raw string literals",
+        "annotationRawString": "형식 주석은 원시 문자열 리터럴을 사용할 수 없습니다.",
         "annotationSpansStrings": "형식 주석은 여러 문자열 리터럴에 걸쳐 있을 수 없습니다.",
         "annotationStringEscape": "형식 주석에는 이스케이프 문자를 사용할 수 없습니다.",
         "argAssignment": "\"{argType}\" 형식의 인수를 \"{paramType}\" 형식의 매개 변수에 할당할 수 없습니다.",
@@ -103,6 +103,7 @@
         "dataClassBaseClassNotFrozen": "고정 클래스는 고정되지 않은 클래스에서 상속할 수 없습니다.",
         "dataClassConverterFunction": "\"{argType}\" 형식의 인수는 \"{fieldType}\" 형식의 \"{fieldName}\" 필드에 유효한 변환기가 아닙니다.",
         "dataClassConverterOverloads": "\"{funcName}\"의 오버로드는 \"{fieldType}\" 형식의 \"{fieldName}\" 필드에 유효한 변환기가 아닙니다.",
+        "dataClassFieldInheritedDefault": "\"{fieldName}\"이(가) 같은 이름의 필드를 재정의하지만 기본값이 없음",
         "dataClassFieldWithDefault": "기본값이 없는 필드는 기본값이 있는 필드 뒤에 나타날 수 없습니다.",
         "dataClassFieldWithPrivateName": "데이터 클래스 필드는 프라이빗 이름을 사용할 수 없습니다.",
         "dataClassFieldWithoutAnnotation": "형식 주석이 없는 데이터 클래스 필드를 사용하면 런타임 예외가 발생합니다.",
@@ -188,7 +189,7 @@
         "expectedIn": "\"in\"이 필요합니다.",
         "expectedInExpr": "\"in\" 뒤에 식이 필요합니다.",
         "expectedIndentedBlock": "들여쓰기 블록이 필요합니다.",
-        "expectedMemberName": "\".\" 뒤에 멤버 이름이 필요합니다.",
+        "expectedMemberName": "\".\" 뒤에 특성 이름 필요",
         "expectedModuleName": "필요한 모듈 이름",
         "expectedNameAfterAs": "‘as’ 뒤에는 기호 이름이 와야 합니다.",
         "expectedNamedParameter": "키워드 매개 변수는 \"*\"를 따라야 합니다.",
@@ -251,6 +252,7 @@
         "incompatibleMethodOverride": "\"{name}\" 메서드가 호환되지 않는 방식으로 \"{className}\" 클래스를 재정의합니다.",
         "inconsistentIndent": "들여쓰기하지 않은 양이 이전 들여쓰기와 일치하지 않습니다.",
         "inconsistentTabs": "들여쓰기에서 탭 및 공백의 일관성 없는 사용",
+        "initMethodSelfParamTypeVar": "\"__init__\" 메서드의 \"self\" 매개 변수의 형식 주석에는 클래스 범위 형식 varaiable을 포함할 수 없음",
         "initMustReturnNone": "\"__init__\"의 반환 형식은 None이어야 합니다.",
         "initSubclassCallFailed": "__init_subclass__ 메서드의 키워드 인수가 잘못됨",
         "initSubclassClsParam": "__init_subclass__ 재정의는 \"cls\" 매개 변수를 사용해야 합니다.",
@@ -277,16 +279,16 @@
         "listAssignmentMismatch": "형식이 \"{type}\"인 식을 대상 목록에 할당할 수 없습니다.",
         "listInAnnotation": "형식 주석에는 목록 식을 사용할 수 없습니다.",
         "literalEmptyArgs": "‘Literal’ 뒤에 하나 이상의 형식 인수가 필요합니다.",
-        "literalNamedUnicodeEscape": "Named unicode escape sequences are not supported in \"Literal\" string annotations",
+        "literalNamedUnicodeEscape": "명명된 유니코드 이스케이프 시퀀스는 \"Literal\" 문자열 주석에서 지원되지 않습니다.",
         "literalNotAllowed": "형식 인수가 없으면 이 컨텍스트에서 \"Literal\"을 사용할 수 없습니다.",
         "literalNotCallable": "리터럴 형식은 인스턴스화할 수 없습니다.",
         "literalUnsupportedType": "\"Literal\"의 형식 인수는 None, 리터럴 값(int, bool, str 또는 bytes) 또는 열거형 값이어야 합니다.",
         "matchIncompatible": "Match 문에는 Python 3.10 이상이 필요합니다.",
         "matchIsNotExhaustive": "match 문 내의 사례는 모든 값을 완전히 처리하지 않습니다.",
         "maxParseDepthExceeded": "최대 구문 분석 깊이를 초과했습니다. 식을 더 작은 하위 식으로 나누기",
-        "memberAccess": "\"{type}\" 형식의 멤버 \"{name}\"에 액세스할 수 없습니다.",
-        "memberDelete": "\"{type}\" 형식의 멤버 \"{name}\"을(를) 삭제할 수 없습니다.",
-        "memberSet": "‘{type}’ 형식의 ‘{name}’ 멤버에 액세스할 수 없습니다.",
+        "memberAccess": "\"{type}\" 클래스의 \"{name}\" 특성에 액세스할 수 없음",
+        "memberDelete": "\"{type}\" 클래스의 \"{name}\" 특성을 삭제할 수 없음",
+        "memberSet": "\"{type}\" 클래스의 \"{name}\" 특성에 할당할 수 없음",
         "metaclassConflict": "파생 클래스의 메타클래스는 모든 기본 클래스의 메타클래스의 서브클래스여야 합니다.",
         "metaclassDuplicate": "메타클래스를 하나만 제공할 수 있습니다.",
         "metaclassIsGeneric": "메타클래스는 제네릭일 수 없습니다.",
@@ -298,7 +300,7 @@
         "missingSuperCall": "\"{methodName}\" 메서드가 부모 클래스에서 같은 이름의 메서드를 호출하지 않습니다.",
         "moduleAsType": "모듈은 형식으로 사용할 수 없습니다.",
         "moduleNotCallable": "모듈을 호출할 수 없습니다.",
-        "moduleUnknownMember": "‘{memberName}’은(는) ‘{moduleName}’ 모듈의 알려진 멤버가 아닙니다.",
+        "moduleUnknownMember": "‘{memberName}’은(는) ‘{moduleName}’ 모듈의 알려진 특성이 아님",
         "namedExceptAfterCatchAll": "명명된 except 절은 catch-all except 절 뒤에 나타날 수 없습니다.",
         "namedParamAfterParamSpecArgs": "ParamSpec args 매개 변수 뒤에 키워드 매개 변수 \"{name}\"을(를) 시그니처에 표시할 수 없습니다.",
         "namedTupleEmptyName": "명명된 튜플 내의 이름은 비워 둘 수 없습니다.",
@@ -332,7 +334,7 @@
         "noneNotSubscriptable": "’None’ 유형의 개체는 아래 첨자를 사용할 수 없습니다.",
         "noneNotUsableWith": "\"None\" 형식의 개체는 \"with\"와 함께 사용할 수 없습니다.",
         "noneOperator": "\"None\"에 대해 연산자 \"{operator}\"이(가) 지원되지 않습니다.",
-        "noneUnknownMember": "\"{name}\"은(는) \"None\"의 알려진 멤버가 아닙니다.",
+        "noneUnknownMember": "\"{name}\"은(는) \"None\"의 알려진 특성이 아님",
         "notRequiredArgCount": "\"NotRequired\" 뒤에 단일 형식 인수가 필요합니다.",
         "notRequiredNotInTypedDict": "이 컨텍스트에서는 \"NotRequired\"를 사용할 수 없습니다.",
         "objectNotCallable": "\"{type}\" 형식의 개체를 호출할 수 없습니다.",
@@ -363,18 +365,18 @@
         "paramAnnotationMissing": "‘{name}’ 매개 변수에 대한 형식 주석이 없습니다.",
         "paramAssignmentMismatch": "‘{sourceType}’ 형식의 식을 ‘{paramType}’ 형식의 매개 변수에 할당할 수 없습니다.",
         "paramNameMissing": "이름이 \"{name}\"인 매개 변수가 없습니다.",
-        "paramSpecArgsKwargsUsage": "ParamSpec의 \"args\" 및 \"kwargs\" 멤버는 모두 함수 서명 내에 나타나야 합니다.",
+        "paramSpecArgsKwargsUsage": "ParamSpec의 \"args\" 및 \"kwargs\" 특성은 모두 함수 서명 내에 나타나야 함",
         "paramSpecArgsMissing": "ParamSpec \"{type}\"에 대한 인수가 없습니다.",
-        "paramSpecArgsUsage": "ParamSpec의 ‘args’ 멤버는 *args 매개 변수와 함께 사용할 경우에만 유효합니다.",
+        "paramSpecArgsUsage": "ParamSpec의 \"args\" 특성은 *args 매개 변수와 함께 사용할 경우에만 유효함",
         "paramSpecAssignedName": "ParamSpec을 \"{name}\"이라는 변수에 할당해야 합니다.",
         "paramSpecContext": "ParamSpec은 이 컨텍스트에서 허용되지 않습니다.",
         "paramSpecDefaultNotTuple": "ParamSpec의 기본값에는 줄임표, 튜플 식 또는 ParamSpec이 필요합니다.",
         "paramSpecFirstArg": "첫 번째 인수로 ParamSpec의 이름이 필요합니다.",
-        "paramSpecKwargsUsage": "ParamSpec의 \"kwargs\" 멤버는 **kwargs 매개 변수와 함께 사용할 때만 유효합니다.",
+        "paramSpecKwargsUsage": "ParamSpec의 \"kwargs\" 특성은 *kwargs 매개 변수와 함께 사용할 경우에만 유효함",
         "paramSpecNotUsedByOuterScope": "ParamSpec \"{name}\"은(는) 이 컨텍스트에서 의미가 없습니다.",
         "paramSpecScopedToReturnType": "ParamSpec ‘{name}’은 반환 형식 내에서 호출 가능으로 범위가 지정되며 함수 본문에서 참조할 수 없습니다.",
         "paramSpecUnknownArg": "ParamSpec은 한 개 이상의 인수를 지원하지 않습니다.",
-        "paramSpecUnknownMember": "\"{name}\"은(는) ParamSpec의 알려진 멤버가 아닙니다.",
+        "paramSpecUnknownMember": "\"{name}\"은(는) ParamSpec의 알려진 특성이 아님",
         "paramSpecUnknownParam": "‘{name}’은(는) ParamSpec에 대한 알 수 없는 매개 변수입니다.",
         "paramTypeCovariant": "공변(Covariant) 형식 변수는 매개 변수 형식에 사용할 수 없습니다.",
         "paramTypePartiallyUnknown": "매개 변수 \"{paramName}\"의 형식을 부분적으로 알 수 없습니다.",
@@ -418,7 +420,7 @@
         "returnMissing": "선언된 반환 형식이 \"{returnType}\"인 함수는 모든 코드 경로에서 값을 반환해야 합니다.",
         "returnOutsideFunction": "‘return’은 함수 내에서만 사용할 수 있습니다.",
         "returnTypeContravariant": "반공변 유형 변수는 반환 형식에 사용할 수 없습니다.",
-        "returnTypeMismatch": "\"{exprType}\" 형식의 식을 반환 형식 \"{returnType}\"에 할당할 수 없습니다.",
+        "returnTypeMismatch": "\"{exprType}\" 형식의 식을 반환 형식 \"{returnType}\"과(와) 호환되지 않음",
         "returnTypePartiallyUnknown": "반환 형식 \"{returnType}\"을(를) 부분적으로 알 수 없습니다.",
         "returnTypeUnknown": "반환 유형을 알 수 없습니다.",
         "revealLocalsArgs": "‘reveal_locals’ 호출은 인수가 필요하지 않습니다.",
@@ -484,8 +486,8 @@
         "typeArgsMissingForClass": "‘{name}’ 제네릭 클래스에 대한 형식 인수가 필요합니다.",
         "typeArgsTooFew": "\"{name}\"에 대해 제공된 형식 인수가 너무 적습니다. {expected}이(가) 필요하지만 {received}을(를) 받았습니다.",
         "typeArgsTooMany": "‘{name}’에 대한 형식 인수가 너무 많습니다. {expected}이(가) 필요하지만 {received}을(를) 받았습니다.",
-        "typeAssignmentMismatch": "\"{sourceType}\" 형식의 식을 선언된 형식 \"{destType}\"에 할당할 수 없습니다.",
-        "typeAssignmentMismatchWildcard": "가져오기 기호 \"{name}\"에 선언된 형식 \"{destType}\"에 할당할 수 없는 \"{sourceType}\" 형식이 있습니다.",
+        "typeAssignmentMismatch": "\"{sourceType}\" 형식의 식이 선언된 형식 \"{destType}\"과(와) 호환되지 않음",
+        "typeAssignmentMismatchWildcard": "가져오기 기호 \"{name}\"에 선언된 형식 \"{destType}\"과(와) 호환되지 않는 \"{sourceType}\" 형식이 있음",
         "typeCallNotAllowed": "type() 호출은 형식 주석에 사용하면 안 됩니다.",
         "typeCheckOnly": "\"{name}\"이(가) @type_check_only로 표시되어 있으므로 형식 주석에서만 사용할 수 있습니다.",
         "typeCommentDeprecated": "형식 주석의 사용은 더 이상 사용되지 않습니다. 대신 형식 주석 사용",
@@ -520,7 +522,7 @@
         "typeVarDefaultIllegal": "형식 변수 기본 형식은 Python 3.13 이상이 필요합니다.",
         "typeVarDefaultInvalidTypeVar": "형식 매개 변수 \"{name}\"에 범위를 벗어난 하나 이상의 형식 변수를 참조하는 기본 형식이 있습니다.",
         "typeVarFirstArg": "TypeVar의 이름이 첫 번째 인수로 필요합니다.",
-        "typeVarNoMember": "TypeVar \"{type}\"에 멤버 \"{name}\"이(가) 없습니다.",
+        "typeVarNoMember": "TypeVar \"{type}\"에 특성 \"{name}\"이(가) 없음",
         "typeVarNotSubscriptable": "TypeVar \"{type}\"을(를) 첨자할 수 없습니다.",
         "typeVarNotUsedByOuterScope": "형식 변수 \"{name}\"은(는) 이 컨텍스트에서 의미가 없습니다.",
         "typeVarPossiblyUnsolvable": "호출자가 ‘{param}’ 매개 변수에 대한 인수를 제공하지 않으면 ‘{name}’ 형식 변수가 확인되지 않을 수 있습니다.",
@@ -634,7 +636,7 @@
         "argsPositionOnly": "위치 전용 매개 변수가 일치하지 않습니다. {expected}이)(가) 필요하지만 {received}을(를) 받았습니다.",
         "argumentType": "인수 형식이 \"{type}\"입니다.",
         "argumentTypes": "인수 형식: ({types})",
-        "assignToNone": "\"None\" 형식에는 형식을 할당할 수 없습니다.",
+        "assignToNone": "형식이 \"None\"과 호환되지 않음",
         "asyncHelp": "‘async with’를 사용하시겠습니까?",
         "baseClassIncompatible": "기본 클래스 \"{baseClass}\"은(는) \"{type}\" 유형과 호환되지 않습니다.",
         "baseClassIncompatibleSubclass": "기본 클래스 \"{baseClass}\"은(는) \"{type}\" 유형과 호환되지 않는 \"{subclass}\"에서 파생됩니다.",
@@ -670,30 +672,30 @@
         "keyUndefined": "\"{name}\"이 \"{type}\"에 정의된 키가 아닙니다.",
         "kwargsParamMissing": "‘**{paramName}’ 매개 변수에 해당하는 매개 변수가 없습니다.",
         "listAssignmentMismatch": "\"{type}\" 형식이 대상 목록과 호환되지 않습니다.",
-        "literalAssignmentMismatch": "\"{sourceType}\"을(를) \"{destType}\" 형식에 할당할 수 없습니다.",
+        "literalAssignmentMismatch": "\"{sourceType}\"이(가) \"{destType}\" 형식과 호환되지 않음",
         "matchIsNotExhaustiveHint": "전체 처리가 의도되지 않은 경우 \"case _: pass\"를 추가합니다.",
         "matchIsNotExhaustiveType": "처리되지 않은 형식: \"{type}\"",
-        "memberAssignment": "‘{type}’ 형식의 식을 ‘{classType}’ 클래스의 ‘{name}’ 멤버에 할당할 수 없습니다.",
+        "memberAssignment": "\"{type}\" 형식의 식을 \"{classType}\" 클래스의 \"{name}\" 특성에 할당할 수 없음",
         "memberIsAbstract": "\"{type}.{name}\"이(가) 구현되지 않았습니다.",
         "memberIsAbstractMore": "{count}개 더...",
         "memberIsClassVarInProtocol": "\"{name}\"은(는) 프로토콜에서 ClassVar로 정의됩니다.",
         "memberIsFinalInProtocol": "\"{name}\"이(가) 프로토콜에서 Final로 표시됨",
-        "memberIsInitVar": "멤버 \"{name}\"은(는) 초기화 전용 필드입니다.",
+        "memberIsInitVar": "\"{name}\"은(는) 초기화 전용 필드임",
         "memberIsInvariant": "\"{name}\"은(는) 변경 가능하므로 고정되지 않습니다.",
         "memberIsNotClassVarInClass": "\"{name}\"은(는) 프로토콜과 호환되려면 ClassVar로 정의해야 합니다.",
         "memberIsNotClassVarInProtocol": "\"{name}\"이(가) 프로토콜에서 ClassVar로 정의되지 않았습니다.",
         "memberIsNotFinalInProtocol": "‘{name}’이(가) 프로토콜에서 최종으로 표시되지 않았습니다.",
         "memberIsWritableInProtocol": "\"{name}\"은(는) 프로토콜에서 쓸 수 있습니다.",
-        "memberSetClassVar": "‘{name}’ 멤버는 ClassVar이므로 클래스 인스턴스를 통해 할당할 수 없습니다.",
+        "memberSetClassVar": "\"{name}\" 특성은 ClassVar이므로 클래스 인스턴스를 통해 할당할 수 없음",
         "memberTypeMismatch": "\"{name}\"은(는) 호환되지 않는 형식입니다.",
-        "memberUnknown": "멤버 \"{name}\"을(를) 알 수 없습니다.",
+        "memberUnknown": "특성 \"{name}\" 알 수 없음",
         "metaclassConflict": "메타클래스 \"{metaclass1}\"이(가) \"{metaclass2}\"과(와) 충돌합니다.",
         "missingDeleter": "속성 삭제자 메서드가 없습니다.",
         "missingGetter": "속성 getter 메서드가 없습니다.",
         "missingSetter": "속성 setter 메서드가 없습니다.",
         "namedParamMissingInDest": "키워드 매개 변수 ‘{name}’이(가) 대상에 없습니다.",
         "namedParamMissingInSource": "키워드 매개 변수 ‘{name}’이(가) 소스에 없습니다.",
-        "namedParamTypeMismatch": "\"{sourceType}\" 형식의 키워드 매개 변수 \"{name}\"을(를) \"{destType}\" 형식에 할당할 수 없습니다.",
+        "namedParamTypeMismatch": "\"{sourceType}\" 형식의 키워드 매개 변수 \"{name}\"이(가) \"{destType}\" 형식과 호환되지 않음",
         "namedTupleNotAllowed": "인스턴스 또는 클래스 검사에는 NamedTuple을 사용할 수 없습니다.",
         "newMethodLocation": "__new__ 메서드가 \"{type}\" 클래스에 정의되어 있습니다.",
         "newMethodSignature": "__new__ 의 서명은 \"{type}\"입니다.",
@@ -725,7 +727,7 @@
         "overridePositionalParamCount": "위치 매개 변수 개수가 일치하지 않습니다. 기본 메서드에 {baseCount}개가 있지만 재정의에는 {overrideCount}개가 있습니다.",
         "overrideReturnType": "반환 형식 불일치: 기본 메서드는 \"{baseType}\" 형식을 반환하고 재정의는 \"{overrideType}\" 형식을 반환합니다.",
         "overrideType": "기본 클래스는 형식을 \"{type}\"으로 정의합니다.",
-        "paramAssignment": "매개 변수 {index}: \"{sourceType}\" 형식을 \"{destType}\" 형식에 할당할 수 없습니다.",
+        "paramAssignment": "매개 변수 {index}: \"{sourceType}\" 형식이 \"{destType}\" 형식과 호환되지 않음",
         "paramSpecMissingInOverride": "재정의 메서드에 ParamSpec 매개 변수가 없습니다.",
         "paramType": "매개 변수 형식은 \"{paramType}\"입니다.",
         "privateImportFromPyTypedSource": "대신 \"{module}\"에서 가져오기",
@@ -755,7 +757,7 @@
         "tupleSizeMismatch": "튜플 크기 불일치: {expected}이(가) 필요하지만 {received}을(를) 받았습니다.",
         "tupleSizeMismatchIndeterminateDest": "튜플 크기 불일치: {expected} 이상이 필요하지만 {received}을(를) 받았습니다.",
         "typeAliasInstanceCheck": "\"type\" 문을 사용해 만든 형식 별칭은 인스턴스 및 클래스 검사에 사용할 수 없습니다.",
-        "typeAssignmentMismatch": "\"{sourceType}\" 형식은 \"{destType}\" 형식에 할당할 수 없습니다.",
+        "typeAssignmentMismatch": "\"{sourceType}\" 형식이 \"{destType}\" 형식과 호환되지 않음",
         "typeBound": "형식 변수 \"{name}\"에 대해 형식 \"{sourceType}\"이(가) 바인딩된 형식 \"{destType}\"과(와) 호환되지 않습니다.",
         "typeConstrainedTypeVar": "\"{type}\" 형식이 제한된 형식 변수 \"{name}\"과(와) 호환되지 않습니다.",
         "typeIncompatible": "\"{sourceType}\"이(가) \"{destType}\"과(와) 호환되지 않습니다.",

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

@@ -17,10 +17,10 @@
         "abstractMethodInvocation": "Nie można wywołać metody „{method}”, ponieważ jest abstrakcyjna i niezaimplementowana",
         "annotatedParamCountMismatch": "Niezgodność liczby adnotacji parametru; oczekiwano {expected}, a uzyskano {received}",
         "annotatedTypeArgMissing": "Oczekiwano jednego argumentu typu i co najmniej jednej adnotacji dla wartości „Annotated”",
-        "annotationBytesString": "Type annotations cannot use bytes string literals",
+        "annotationBytesString": "Adnotacje typu nie mogą używać literałów ciągu bajtów",
         "annotationFormatString": "Adnotacje typu nie mogą używać literałów ciągów formatu (f-strings)",
         "annotationNotSupported": "Adnotacja typu nie jest obsługiwana dla tej instrukcji",
-        "annotationRawString": "Type annotations cannot use raw string literals",
+        "annotationRawString": "Adnotacje typu nie mogą używać nieprzetworzonych literałów ciągów",
         "annotationSpansStrings": "Adnotacje typu nie mogą obejmować wielu literałów ciągów",
         "annotationStringEscape": "Adnotacje typu nie mogą zawierać znaków ucieczki",
         "argAssignment": "Argumentu typu „{argType}” nie można przypisać do parametru typu „{paramType}”",
@@ -103,6 +103,7 @@
         "dataClassBaseClassNotFrozen": "Zamrożona klasa nie może dziedziczyć po klasie niezamrożonej",
         "dataClassConverterFunction": "Argument typu „{argType}” nie jest prawidłowym konwerterem pola „{fieldName}” typu „{fieldType}”",
         "dataClassConverterOverloads": "Żadne przeciążenia „{funcName}” nie są prawidłowymi konwerterami dla pola „{fieldName}” typu „{fieldType}”",
+        "dataClassFieldInheritedDefault": "Pole „{fieldName}” zastępuje pole o tej samej nazwie, ale brakuje wartości domyślnej",
         "dataClassFieldWithDefault": "Pola bez wartości domyślnych nie mogą występować po polach z wartościami domyślnymi",
         "dataClassFieldWithPrivateName": "Pole klasy danych nie może używać nazwy prywatnej",
         "dataClassFieldWithoutAnnotation": "Pole klasy danych bez adnotacji typu spowoduje wyjątek środowiska uruchomieniowego",
@@ -188,7 +189,7 @@
         "expectedIn": "Oczekiwano parametru „in”",
         "expectedInExpr": "Oczekiwano wyrażenia po „in”",
         "expectedIndentedBlock": "Oczekiwano wciętego bloku",
-        "expectedMemberName": "Oczekiwano nazwy składowej po znaku „.”",
+        "expectedMemberName": "Oczekiwano nazwy atrybutu po „.”",
         "expectedModuleName": "Oczekiwana nazwa modułu",
         "expectedNameAfterAs": "Oczekiwano nazwy symbolu po „jako”",
         "expectedNamedParameter": "Parametr słowa kluczowego musi następować po znaku „*”",
@@ -251,6 +252,7 @@
         "incompatibleMethodOverride": "Metoda „{name}” przesłania klasę „{className}” w niezgodny sposób",
         "inconsistentIndent": "Wartość zmniejszenia wcięcia jest niezgodna z poprzednim wcięciem",
         "inconsistentTabs": "Niespójne użycie tabulatorów i spacji we wcięciach",
+        "initMethodSelfParamTypeVar": "Adnotacja typu dla parametru „self” metody „__init__” nie może zawierać zmiennych typu o zakresie klasy",
         "initMustReturnNone": "Zwracany typ „__init__” musi mieć wartość Brak",
         "initSubclassCallFailed": "Nieprawidłowe argumenty słów kluczowych dla metody __init_subclass__",
         "initSubclassClsParam": "Przesłonięcie __init_subclass__ powinno przyjmować parametr „cls”.",
@@ -277,16 +279,16 @@
         "listAssignmentMismatch": "Wyrażenia typu „{type}” nie można przypisać do listy docelowej",
         "listInAnnotation": "Wyrażenie listy jest niedozwolone w adnotacji typu",
         "literalEmptyArgs": "Oczekiwano co najmniej jednego argumentu typu po wartości „Literal”",
-        "literalNamedUnicodeEscape": "Named unicode escape sequences are not supported in \"Literal\" string annotations",
+        "literalNamedUnicodeEscape": "Nazwane sekwencje ucieczki Unicode nie są obsługiwane w adnotacjach ciągów „Literal”",
         "literalNotAllowed": "„Literał” nie może być używany w tym kontekście bez argumentu typu",
         "literalNotCallable": "Nie można utworzyć wystąpienia typu literału",
         "literalUnsupportedType": "Argumenty typu dla elementu „Literal” muszą mieć wartość Brak, wartość literału (int, bool, str lub bytes) lub wartość wyliczenia",
         "matchIncompatible": "Instrukcje dopasowania wymagają języka Python w wersji 3.10 lub nowszej",
         "matchIsNotExhaustive": "Przypadki w instrukcji dopasowania nie obsługują wyczerpująco wszystkich wartości",
         "maxParseDepthExceeded": "Przekroczono maksymalną głębokość analizy; podziel wyrażenie na mniejsze wyrażenia podrzędne",
-        "memberAccess": "Nie można uzyskać dostępu do składowej „{name}” dla typu „{type}”",
-        "memberDelete": "Nie można usunąć składowej „{name}” dla typu „{type}”",
-        "memberSet": "Nie można uzyskać przypisać składowej „{name}” dla typu „{type}”",
+        "memberAccess": "Nie można uzyskać dostępu do atrybutu „{name}” dla klasy „{type}”",
+        "memberDelete": "Nie można usunąć atrybutu „{name}” dla klasy „{type}”",
+        "memberSet": "Nie można przypisać atrybutu „{name}” dla klasy „{type}”",
         "metaclassConflict": "Metaklasa klasy pochodnej musi być podklasą metaklas wszystkich jej klas bazowych",
         "metaclassDuplicate": "Można podać tylko jedną metaklasę",
         "metaclassIsGeneric": "Metaklasa nie może być ogólna",
@@ -298,7 +300,7 @@
         "missingSuperCall": "Metoda „{methodName}” nie wywołuje metody o tej samej nazwie w klasie nadrzędnej",
         "moduleAsType": "Nie można użyć modułu jako typu",
         "moduleNotCallable": "Moduł nie jest wywoływalny",
-        "moduleUnknownMember": "„{memberName}” nie jest znaną składową modułu „{moduleName}”",
+        "moduleUnknownMember": "„{memberName}” nie jest znanym atrybutem modułu „{moduleName}”",
         "namedExceptAfterCatchAll": "Nazwana klauzula „except” nie może występować po klauzuli „catch-all except”",
         "namedParamAfterParamSpecArgs": "Parametr słowa kluczowego \"{name}\" nie może występować w sygnaturze po parametrze argumentów ParamSpec",
         "namedTupleEmptyName": "Nazwy w nazwanej krotce nie mogą być puste",
@@ -332,7 +334,7 @@
         "noneNotSubscriptable": "Obiekt typu „None” nie może być użyty w indeksie dolnym",
         "noneNotUsableWith": "Obiekt typu „Brak” nie może być używany z parametrem „with”",
         "noneOperator": "Operator „{operator}” nie jest obsługiwany dla wartości „Brak”",
-        "noneUnknownMember": "Nazwa „{name}” nie jest znaną składową elementu „None”",
+        "noneUnknownMember": "„{name}” nie jest znanym atrybutem „Brak”",
         "notRequiredArgCount": "Oczekiwano jednego argumentu typu po wartości „NotRequired”",
         "notRequiredNotInTypedDict": "Element „NotRequired” jest niedozwolony w tym kontekście",
         "objectNotCallable": "Obiekt typu „{type}” nie jest wywoływalny",
@@ -363,18 +365,18 @@
         "paramAnnotationMissing": "Brak adnotacji typu dla parametru „{name}”",
         "paramAssignmentMismatch": "Wyrażenia typu „{sourceType}” nie można przypisać do parametru typu „{paramType}”",
         "paramNameMissing": "Brak parametru o nazwie „{name}”",
-        "paramSpecArgsKwargsUsage": "Składowe „args” i „kwargs” specyfikacji ParamSpec muszą znajdować się w sygnaturze funkcji",
+        "paramSpecArgsKwargsUsage": "Atrybuty „args” i „kwargs” specyfikacji ParamSpec muszą znajdować się w sygnaturze funkcji",
         "paramSpecArgsMissing": "Brak argumentów dla parametru ParamSpec „{type}”.",
-        "paramSpecArgsUsage": "Składowa „args” parametru ParamSpec jest ważna tylko wtedy, gdy jest używana z parametrem *args",
+        "paramSpecArgsUsage": "Atrybut „args” parametru ParamSpec jest ważna tylko wtedy, gdy jest używana z parametrem *args",
         "paramSpecAssignedName": "Parametr ParamSpec musi być przypisany do zmiennej o nazwie „{name}”",
         "paramSpecContext": "Wartość ParamSpec jest niedozwolona w tym kontekście",
         "paramSpecDefaultNotTuple": "Oczekiwano wielokropka, wyrażenia krotki lub parametru ParamSpec dla domyślnej wartości ParamSpec",
         "paramSpecFirstArg": "Oczekiwano nazwy parametru ParamSpec jako pierwszego argumentu",
-        "paramSpecKwargsUsage": "Składowa „kwargs” parametru ParamSpec jest ważna tylko wtedy, gdy jest używana z parametrem **kwargs",
+        "paramSpecKwargsUsage": "Atrybut „kwargs” parametru ParamSpec jest ważna tylko wtedy, gdy jest używana z parametrem **kwargs",
         "paramSpecNotUsedByOuterScope": "Element ParamSpec „{name}” nie ma znaczenia w tym kontekście",
         "paramSpecScopedToReturnType": "Parametr ParamSpec „{name}” jest objęty zakresem możliwości wywołania w ramach zwracanego typu i nie można odwoływać się do niego w treści funkcji",
         "paramSpecUnknownArg": "Parametr ParamSpec nie obsługuje więcej niż jednego argumentu",
-        "paramSpecUnknownMember": "Nazwa „{name}” nie jest znaną składową parametru ParamSpec",
+        "paramSpecUnknownMember": "„{name}” nie jest znanym atrybutem parametru ParamSpec",
         "paramSpecUnknownParam": "„{name}” jest nieznanym parametrem dla parametru ParamSpec",
         "paramTypeCovariant": "Zmienna typu kowariantnego nie może być używana w typie parametru",
         "paramTypePartiallyUnknown": "Typ parametru „{paramName}” jest częściowo nieznany",
@@ -418,7 +420,7 @@
         "returnMissing": "Funkcja z zadeklarowanym typem zwracanym „{returnType}” musi zwracać wartość we wszystkich ścieżkach kodu",
         "returnOutsideFunction": "Instrukcja „return” może być używana tylko w ramach funkcji",
         "returnTypeContravariant": "Kontrawariantna zmienna typu nie może być używana w zwracanym typie",
-        "returnTypeMismatch": "Wyrażenia typu „{exprType}” nie można przypisać do zwracanego typu „{returnType}”",
+        "returnTypeMismatch": "Wyrażenie typu „{exprType}” jest niezgodne z typem zwracania „{returnType}”",
         "returnTypePartiallyUnknown": "Zwracany typ „{returnType}” jest częściowo nieznany",
         "returnTypeUnknown": "Zwracany typ jest nieznany",
         "revealLocalsArgs": "Oczekiwano braku argumentów dla wywołania „reveal_locals”",
@@ -484,8 +486,8 @@
         "typeArgsMissingForClass": "Oczekiwano argumentów typu dla ogólnej klasy „{name}”",
         "typeArgsTooFew": "Podano zbyt mało argumentów typu dla „{name}”; oczekiwano wartości {expected}, ale otrzymano {received}",
         "typeArgsTooMany": "Podano zbyt wiele argumentów typu dla nazwy „{name}”; oczekiwano {expected}, a uzyskano {received}",
-        "typeAssignmentMismatch": "Wyrażenie typu „{sourceType}” nie może być przypisane do zadeklarowanego typu „{destType}”",
-        "typeAssignmentMismatchWildcard": "Symbol importu „{name}” ma typ „{sourceType}”, którego nie można przypisać do zadeklarowanego typu „{destType}”",
+        "typeAssignmentMismatch": "Wyrażenie typu „{sourceType}” jest niezgodne z zadeklarowanym typem „{destType}”",
+        "typeAssignmentMismatchWildcard": "Symbol importu „{name}” ma typ „{sourceType}”, który jest niezgodny z zadeklarowanym typem „{destType}”",
         "typeCallNotAllowed": "Wywołanie type() nie powinno być używane w adnotacji typu",
         "typeCheckOnly": "Nazwa „{name}” jest oznaczona jako @type_check_only i może być używana tylko w adnotacjach typu",
         "typeCommentDeprecated": "Używanie komentarzy typu jest przestarzałe; zamiast tego użyj adnotacji typu",
@@ -520,7 +522,7 @@
         "typeVarDefaultIllegal": "Typy domyślne zmiennych typów wymagają wersji języka Python 3.13 lub nowszej",
         "typeVarDefaultInvalidTypeVar": "Parametr typu „{name}” ma typ domyślny, który odnosi się do co najmniej jednej zmiennej typu, która jest poza zakresem",
         "typeVarFirstArg": "Oczekiwano nazwy TypeVar jako pierwszego argumentu",
-        "typeVarNoMember": "Typ TypeVar „{type}” nie ma składowej „{name}”",
+        "typeVarNoMember": "Typ atrybutu TypeVar „{type}” nie ma atrybutu „{name}”",
         "typeVarNotSubscriptable": "Typ TypeVar „{type}” nie może być subskrybowany",
         "typeVarNotUsedByOuterScope": "Zmienna typu „{name}” nie ma w tym kontekście żadnego znaczenia",
         "typeVarPossiblyUnsolvable": "Zmienna typu „{name}” może zostać nierozwiązana, jeśli obiekt wywołujący nie poda argumentu dla parametru „{param}”",
@@ -634,7 +636,7 @@
         "argsPositionOnly": "Niezgodność parametrów tylko dla pozycji; oczekiwano wartości „{expected}”, a uzyskano „{received}”",
         "argumentType": "Typ argumentu to „{type}”",
         "argumentTypes": "Typy argumentów: ({types})",
-        "assignToNone": "Nie można przypisać typu do typu „Brak”",
+        "assignToNone": "Typ jest niezgodny z wartością „Brak”",
         "asyncHelp": "Czy chodziło o wartość „async with”?",
         "baseClassIncompatible": "Klasa bazowa „{baseClass}” jest niezgodna z typem „{type}”",
         "baseClassIncompatibleSubclass": "Klasa bazowa „{baseClass}” pochodzi od klasy podrzędnej „{subclass}”, która jest niezgodna z typem „{type}”",
@@ -670,10 +672,10 @@
         "keyUndefined": "Nazwa „{name}” nie jest zdefiniowanym kluczem w typie „{type}”",
         "kwargsParamMissing": "Parametr „**{paramName}” nie ma odpowiadającego mu parametru",
         "listAssignmentMismatch": "Typ „{type}” jest niezgodny z listą docelową",
-        "literalAssignmentMismatch": "Nie można przypisać typu „{sourceType}” do typu „{destType}”",
+        "literalAssignmentMismatch": "„{sourceType}” jest niezgodny z typem „{destType}”",
         "matchIsNotExhaustiveHint": "Jeśli kompleksowa obsługa nie jest zamierzona, dodaj „case _: pass”",
         "matchIsNotExhaustiveType": "Nieobsługiwany typ: „{type}”",
-        "memberAssignment": "Wyrażenia typu „{type}” nie można przypisać do składowej „{name}” klasy „{classType}”",
+        "memberAssignment": "Wyrażenia typu „{type}” nie można przypisać do atrybutu „{name}” klasy „{classType}”",
         "memberIsAbstract": "„{type}.{name}” nie zostało zaimplementowane",
         "memberIsAbstractMore": "i jeszcze {count}...",
         "memberIsClassVarInProtocol": "Element „{name}” jest zdefiniowany jako element ClassVar w protokole",
@@ -684,16 +686,16 @@
         "memberIsNotClassVarInProtocol": "Element „{name}” nie jest zdefiniowany jako ClassVar w protokole",
         "memberIsNotFinalInProtocol": "Element „{name}” nie jest oznaczony jako wersja ostateczna w protokole",
         "memberIsWritableInProtocol": "Nazwa „{name}” jest zapisywalna w protokole",
-        "memberSetClassVar": "Nie można przypisać składowej „{name}” przez wystąpienie klasy, ponieważ jest to element ClassVar",
+        "memberSetClassVar": "Atrybut „{name}” nie może zostać przypisany przez wystąpienie klasy, ponieważ jest to element ClassVar",
         "memberTypeMismatch": "Nazwa „{name}” jest niezgodnym typem",
-        "memberUnknown": "Składowa „{name}” jest nieznana",
+        "memberUnknown": "Atrybut „{name}” jest nieznany",
         "metaclassConflict": "Metaklasa „{metaclass1}” powoduje konflikt z „{metaclass2}”",
         "missingDeleter": "Brak metody usuwania właściwości",
         "missingGetter": "Brak metody pobierającej właściwości",
         "missingSetter": "Brak metody zestawu właściwości",
         "namedParamMissingInDest": "W lokalizacji docelowej brakuje parametru słowa kluczowego „{name}”.",
         "namedParamMissingInSource": "W źródle brakuje parametru słowa kluczowego „{name}”.",
-        "namedParamTypeMismatch": "Parametru słowa kluczowego „{name}” typu „{sourceType}” nie można przypisać do typu „{destType}”",
+        "namedParamTypeMismatch": "Parametr słowa kluczowego „{name}” typu „{sourceType}” jest niezgodny z typem „{destType}”",
         "namedTupleNotAllowed": "Funkcja NamedTuple nie może być używana do sprawdzania wystąpień lub klas",
         "newMethodLocation": "Metoda __new__ jest zdefiniowana w klasie „{type}”",
         "newMethodSignature": "Sygnatura __new__ to typ „{type}”",
@@ -725,7 +727,7 @@
         "overridePositionalParamCount": "Niezgodność liczby parametrów pozycyjnych; metoda podstawowa ma {baseCount}, a zastąpienie {overrideCount}",
         "overrideReturnType": "Niezgodność zwracanego typu: metoda podstawowa zwraca typ „{baseType}”, przesłonięcie zwraca typ „{overrideType}”",
         "overrideType": "Klasa bazowa definiuje typ jako „{type}”",
-        "paramAssignment": "Parametr {index}: typu „{sourceType}” nie można przypisać do typu „{destType}”",
+        "paramAssignment": "Parametr {index}: typ „{sourceType}” jest niezgodny z typem „{destType}”",
         "paramSpecMissingInOverride": "Brak parametrów ParamSpec w metodzie zastąpienia",
         "paramType": "Typ parametru to „{paramType}”",
         "privateImportFromPyTypedSource": "Zamiast tego importuj z modułu „{module}”.",
@@ -755,7 +757,7 @@
         "tupleSizeMismatch": "Niezgodność rozmiaru krotki; oczekiwano {expected}, ale otrzymano {received}",
         "tupleSizeMismatchIndeterminateDest": "Niezgodność rozmiaru krotki; oczekiwano {expected}, a otrzymano {received}",
         "typeAliasInstanceCheck": "Alias typu utworzony za pomocą instrukcji „{type}” nie może być użyty do sprawdzania wystąpień i klas",
-        "typeAssignmentMismatch": "Nie można przypisać typu „{sourceType}” do typu „{destType}”",
+        "typeAssignmentMismatch": "Typ „{sourceType}” jest niezgodny z typem „{destType}”",
         "typeBound": "Typ „{sourceType}” jest niezgodny z typem powiązanym „{destType}” dla zmiennej typu „{name}”",
         "typeConstrainedTypeVar": "Typ „{type}” jest niezgodny ze zmienną typu ograniczonego „{name}”",
         "typeIncompatible": "Typ „{sourceType}” jest niezgodny z „{destType}”",