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

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

@@ -17,10 +17,10 @@
         "abstractMethodInvocation": "Metodu „{method}“ nelze volat, protože je abstraktní a neimplementovaná.",
         "annotatedParamCountMismatch": "Počet poznámek parametrů se neshoduje: očekával(o/y) se {expected}, ale přijal(o/y) se {received}.",
         "annotatedTypeArgMissing": "Byl očekáván jeden argument typu a jedna nebo více poznámek pro Annotated",
-        "annotationBytesString": "Type annotations cannot use bytes string literals",
+        "annotationBytesString": "Poznámky typu nemůžou používat řetězcové literály bajtů.",
         "annotationFormatString": "Poznámky typu nemůžou používat formátovací řetězcové literály (f-strings)",
         "annotationNotSupported": "Poznámka typu není pro tento příkaz podporována",
-        "annotationRawString": "Type annotations cannot use raw string literals",
+        "annotationRawString": "Poznámky typu nemůžou používat literály nezpracovaného řetězce.",
         "annotationSpansStrings": "Poznámky typu nemůžou zahrnovat více řetězcových literálů",
         "annotationStringEscape": "Poznámky typu nemůžou obsahovat řídicí znaky",
         "argAssignment": "Argument typu {argType} není možné přiřadit k parametru typu {paramType}",
@@ -103,6 +103,7 @@
         "dataClassBaseClassNotFrozen": "Zablokovaná třída nemůže dědit z třídy, která není zablokovaná",
         "dataClassConverterFunction": "Argument typu {argType} není platný převaděč pro pole {fieldName} typu {fieldType}",
         "dataClassConverterOverloads": "Žádná přetížení {funcName} nejsou platné převaděče pro pole {fieldName} typu {fieldType}",
+        "dataClassFieldInheritedDefault": "{fieldName} přepíše pole se stejným názvem, ale chybí mu výchozí hodnota.",
         "dataClassFieldWithDefault": "Pole bez výchozích hodnot se nemůžou zobrazit po polích s výchozími hodnotami",
         "dataClassFieldWithPrivateName": "Pole datové třídy nemůže používat privátní název",
         "dataClassFieldWithoutAnnotation": "Pole dataclass bez poznámky typu způsobí výjimku modulu runtime",
@@ -188,7 +189,7 @@
         "expectedIn": "Očekávalo se in",
         "expectedInExpr": "Za in byl očekáván výraz",
         "expectedIndentedBlock": "Očekával se odsazený blok",
-        "expectedMemberName": "Za znakem . byl očekáván název člena",
+        "expectedMemberName": "Za tečkou (.) byl očekáván název atributu.",
         "expectedModuleName": "Očekávaný název modulu",
         "expectedNameAfterAs": "Za „as“ se očekával název symbolu",
         "expectedNamedParameter": "Parametr klíčového slova musí následovat za znakem *",
@@ -251,6 +252,7 @@
         "incompatibleMethodOverride": "Metoda {name} přepisuje třídu {className} nekompatibilním způsobem",
         "inconsistentIndent": "Množství zrušeného odsazení neodpovídá předchozímu odsazení",
         "inconsistentTabs": "Nekonzistentní použití tabulátorů a mezer v odsazení",
+        "initMethodSelfParamTypeVar": "Anotace typu pro parametr self metody __init__ nemůže obsahovat proměnné typu s oborem třídy.",
         "initMustReturnNone": "Návratový typ __init__ musí být None",
         "initSubclassCallFailed": "Nesprávné argumenty klíčového slova pro metodu __init_subclass__",
         "initSubclassClsParam": "Přepsání __init_subclass__ by mělo mít parametr cls",
@@ -277,16 +279,16 @@
         "listAssignmentMismatch": "Výraz s typem {type} se nedá přiřadit k cílovému seznamu",
         "listInAnnotation": "Výraz seznamu není v poznámce typu povolený",
         "literalEmptyArgs": "Za literálem se očekával jeden nebo více argumentů typu",
-        "literalNamedUnicodeEscape": "Named unicode escape sequences are not supported in \"Literal\" string annotations",
+        "literalNamedUnicodeEscape": "Pojmenované řídicí sekvence Unicode nejsou v řetězcových poznámkách literálů podporovány.",
         "literalNotAllowed": "„Literal“ nejde v tomto kontextu použít bez argumentu typu.",
         "literalNotCallable": "Není možné vytvořit instanci typu literálu",
         "literalUnsupportedType": "Argumenty typu pro Literal musí být None, hodnota literálu (int, bool, str nebo bytes) nebo hodnota výčtu",
         "matchIncompatible": "Příkazy match vyžadují Python 3.10 nebo novější",
         "matchIsNotExhaustive": "Případy v rámci příkazu match nezpracovávají kompletně všechny hodnoty",
         "maxParseDepthExceeded": "Byla překročena maximální hloubka analýzy; rozdělte výraz na dílčí výrazy",
-        "memberAccess": "Není možné získat přístup ke členu {name} pro typ {type}",
-        "memberDelete": "Není možné odstranit člena {name} pro typ {type}",
-        "memberSet": "Nelze přiřadit člena „{name}“ pro typ „{type}“",
+        "memberAccess": "Nelze získat přístup k atributu {name} pro třídu {type}.",
+        "memberDelete": "Nelze odstranit atribut {name} pro třídu {type}.",
+        "memberSet": "Nelze přiřadit k atributu {name} pro třídu {type}.",
         "metaclassConflict": "Metatřída odvozené třídy musí být podtřídou metatříd všech jejích základních tříd",
         "metaclassDuplicate": "Je možné zadat pouze jednu metatřídu",
         "metaclassIsGeneric": "Metatřída nemůže být obecná",
@@ -298,7 +300,7 @@
         "missingSuperCall": "Metoda {methodName} nevolá metodu se stejným názvem v nadřazené třídě",
         "moduleAsType": "Modul nejde použít jako typ",
         "moduleNotCallable": "Modul není volatelný",
-        "moduleUnknownMember": "Člen „{memberName}“ není známým členem modulu „{moduleName}“",
+        "moduleUnknownMember": "{memberName} není známý atribut modulu {moduleName}.",
         "namedExceptAfterCatchAll": "Za klauzulí catch-all except se nemůže objevit pojmenovaná klauzule except",
         "namedParamAfterParamSpecArgs": "Parametr klíčového slova {name} se nemůže objevit v signatuře za parametrem argumentů ParamSpec",
         "namedTupleEmptyName": "Názvy v pojmenované řazené kolekci členů nemůžou být prázdné.",
@@ -332,7 +334,7 @@
         "noneNotSubscriptable": "Objekt typu “None“ nelze zadat jako dolní index",
         "noneNotUsableWith": "Objekt typu None není možné použít s with",
         "noneOperator": "Operátor {operator} se pro None nepodporuje",
-        "noneUnknownMember": "{name} není známým členem None",
+        "noneUnknownMember": "{name} není známý atribut None.",
         "notRequiredArgCount": "Za NotRequired byl očekáván jeden argument typu",
         "notRequiredNotInTypedDict": "NotRequired není v tomto kontextu povolené",
         "objectNotCallable": "Objekt typu {type} není možné volat",
@@ -363,18 +365,18 @@
         "paramAnnotationMissing": "Chybí poznámka typu pro parametr „{name}“",
         "paramAssignmentMismatch": "Výraz typu „{sourceType}“ nelze přiřadit k parametru typu „{paramType}“",
         "paramNameMissing": "Žádný parametr s názvem {name}",
-        "paramSpecArgsKwargsUsage": "Členy argumentů args a kwargs parametru ParamSpec se musí vyskytovat v signatuře funkce",
+        "paramSpecArgsKwargsUsage": "Atributy args a kwargs ParamSpec se musí vyskytovat v signatuře funkce.",
         "paramSpecArgsMissing": "Chybí argumenty pro parametr ParamSpec {type}",
-        "paramSpecArgsUsage": "Člen „args“ parametru ParamSpec je platný jenom v případě, že se používá s parametrem *args",
+        "paramSpecArgsUsage": "Atribut args ParamSpec je platný jenom v případě, že se používá s parametrem *args.",
         "paramSpecAssignedName": "Parametr ParamSpec musí být přiřazen proměnné s názvem {name}",
         "paramSpecContext": "ParamSpec se v tomto kontextu nepovoluje",
         "paramSpecDefaultNotTuple": "Očekávaly se tři tečky, výraz řazené kolekce členů nebo Parametr ParamSpec pro výchozí hodnotu ParamSpec",
         "paramSpecFirstArg": "Očekával se název parametru ParamSpec jako první argument",
-        "paramSpecKwargsUsage": "Člen kwargs parametru ParamSpec je platný jenom v případě, že se používá s parametrem **kwargs",
+        "paramSpecKwargsUsage": "Atribut kwargs ParamSpec je platný jenom v případě, že se používá s parametrem **kwargs.",
         "paramSpecNotUsedByOuterScope": "Parametr ParamSpec {name} nemá v tomto kontextu žádný význam",
         "paramSpecScopedToReturnType": "Parametr ParamSpec {name} je vymezený na volatelnou proměnnou v rámci návratového typu a nedá se na něj odkazovat v těle funkce jazyka",
         "paramSpecUnknownArg": "Parametr ParamSpec nepodporuje více než jeden argument",
-        "paramSpecUnknownMember": "{name} není známý člen ParamSpec",
+        "paramSpecUnknownMember": "{name} není známý atribut ParamSpec.",
         "paramSpecUnknownParam": "„{name}“ je neznámý parametr parametru ParamSpec",
         "paramTypeCovariant": "Proměnnou kovariantní typu není možné použít v typu parametru",
         "paramTypePartiallyUnknown": "Typ parametru {paramName} je částečně neznámý",
@@ -418,7 +420,7 @@
         "returnMissing": "Funkce s deklarovaným návratovým typem „{returnType}“ musí vracet hodnotu na všech cestách kódu",
         "returnOutsideFunction": "„return“ se dá použít jenom v rámci funkce",
         "returnTypeContravariant": "Kontravariantní proměnnou typu nejde použít v návratovém typu",
-        "returnTypeMismatch": "Výraz typu {exprType} není možné přiřadit k návratového typu {returnType}",
+        "returnTypeMismatch": "Výraz typu {exprType} není kompatibilní s návratovým typem {returnType}.",
         "returnTypePartiallyUnknown": "Návratový typ {returnType} je částečně neznámý",
         "returnTypeUnknown": "Návratový typ je neznámý",
         "revealLocalsArgs": "Pro volání reveal_locals se neočekávaly žádné argumenty",
@@ -484,8 +486,8 @@
         "typeArgsMissingForClass": "Očekávané argumenty typu pro obecnou třídu „{name}“",
         "typeArgsTooFew": "Pro {name} se zadalo příliš málo argumentů typu. Očekávalo se {expected}, ale přijalo se {received}",
         "typeArgsTooMany": "Pro „{name}“ se zadalo příliš mnoho argumentů typu. Očekával(o/y) se {expected}, ale přijal(o/y) se {received}",
-        "typeAssignmentMismatch": "Výraz typu {sourceType} není možné přiřadit deklarovanému typu {destType}",
-        "typeAssignmentMismatchWildcard": "Symbol importu {name} má typ {sourceType}, který nejde přiřadit deklarovanému typu {destType}.",
+        "typeAssignmentMismatch": "Výraz typu {sourceType} není kompatibilní s deklarovaným typem {destType}.",
+        "typeAssignmentMismatchWildcard": "Symbol importu {name} má typ {sourceType}, který není kompatibilní s deklarovaným typem {destType}.",
         "typeCallNotAllowed": "Volání type() by se nemělo používat v poznámce typu",
         "typeCheckOnly": "Název {name} je označený jako @type_check_only a dá se použít jenom v poznámkách typu",
         "typeCommentDeprecated": "Použití komentářů typu je zastaralé místo toho použít anotaci typu",
@@ -520,7 +522,7 @@
         "typeVarDefaultIllegal": "Výchozí typy proměnných typů vyžadují Python 3.13 nebo novější",
         "typeVarDefaultInvalidTypeVar": "Parametr typu {name} má výchozí typ, který odkazuje na jednu nebo více proměnných typu, které jsou mimo obor",
         "typeVarFirstArg": "Očekával se název TypeVar jako první argument",
-        "typeVarNoMember": "TypeVar {type} nemá žádného člena {name}",
+        "typeVarNoMember": "TypeVar {type} nemá žádný atribut {name}.",
         "typeVarNotSubscriptable": "TypeVar {type} není možné zadat jako dolní index",
         "typeVarNotUsedByOuterScope": "Proměnná typu {name} nemá v tomto kontextu žádný význam",
         "typeVarPossiblyUnsolvable": "Proměnná typu „{name}“ může být nevyřešená, pokud volající nezadá žádný argument pro parametr „{param}“",
@@ -634,7 +636,7 @@
         "argsPositionOnly": "Neshoda parametrů pouze s pozicí; Očekával(o/y) se {expected}, ale přijal(o/y) se {received}",
         "argumentType": "Typ argumentu je {type}",
         "argumentTypes": "Typy argumentů: ({types})",
-        "assignToNone": "Typ není možné přiřadit typu None",
+        "assignToNone": "Typ není kompatibilní s None.",
         "asyncHelp": "Měli jste na mysli „async s“?",
         "baseClassIncompatible": "Základní třída {baseClass} není kompatibilní s typem {type}",
         "baseClassIncompatibleSubclass": "Základní třída {baseClass} je odvozená od třídy {subclass}, která není kompatibilní s typem {type}",
@@ -670,30 +672,30 @@
         "keyUndefined": "{name} není definovaný klíč v typu {type}",
         "kwargsParamMissing": "Parametr „**{paramName}“ nemá žádný odpovídající parametr",
         "listAssignmentMismatch": "Typ {type} není kompatibilní s cílovým seznamem",
-        "literalAssignmentMismatch": "{sourceType} se nedá přiřadit k typu {destType}",
+        "literalAssignmentMismatch": "{sourceType} není kompatibilní s typem {destType}.",
         "matchIsNotExhaustiveHint": "Pokud není zamýšleno vyčerpávající zpracování, přidejte case _: pass",
         "matchIsNotExhaustiveType": "Nezpracovaný typ: {type}",
-        "memberAssignment": "Výraz typu „{type}“ nelze přiřadit členu „{name}“ třídy „{classType}“",
+        "memberAssignment": "Výraz typu {type} nelze přiřadit k atributu {name} třídy {classType}.",
         "memberIsAbstract": "„{type}.{name}“ není implementováno.",
         "memberIsAbstractMore": "a tento počet dalších: {count}...",
         "memberIsClassVarInProtocol": "„{name}“ je v protokolu definován jako ClassVar.",
         "memberIsFinalInProtocol": "{name} je v protokolu označený jako Final",
-        "memberIsInitVar": "Člen {name} je pole jen pro inicializaci",
+        "memberIsInitVar": "{name} je pole jen pro inicializaci.",
         "memberIsInvariant": "{name} je invariantní, protože je proměnlivé",
         "memberIsNotClassVarInClass": "„{name}“ musí být definováno jako ClassVar, aby bylo kompatibilní s protokolem.",
         "memberIsNotClassVarInProtocol": "„{name}“ není v protokolu definován jako ClassVar.",
         "memberIsNotFinalInProtocol": "„{name}“ není v protokolu označeno jako Final",
         "memberIsWritableInProtocol": "{name} se dá zapisovat do protokolu.",
-        "memberSetClassVar": "Člen „{name}“ nelze přiřadit prostřednictvím instance třídy, protože se jedná o třídu ClassVar",
+        "memberSetClassVar": "Atribut {name} nelze přiřadit prostřednictvím instance třídy, protože jde o ClassVar.",
         "memberTypeMismatch": "{name} je nekompatibilní typ",
-        "memberUnknown": "Člen {name} je neznámý",
+        "memberUnknown": "Atribut {name} je neznámý.",
         "metaclassConflict": "Metatřída {metaclass1} je v konfliktu s metatřídou {metaclass2}.",
         "missingDeleter": "Chybí metoda odstranění vlastnosti",
         "missingGetter": "Chybí metoda getter vlastnosti",
         "missingSetter": "Chybí metoda nastavovacího kódu vlastnosti",
         "namedParamMissingInDest": "V cíli chybí parametr klíčového slova {name}",
         "namedParamMissingInSource": "Ve zdroji chybí parametr klíčového slova „{name}“",
-        "namedParamTypeMismatch": "Parametr klíčového slova {name} typu {sourceType} není možné přiřadit typu {destType}",
+        "namedParamTypeMismatch": "Parametr klíčového slova {name} typu {sourceType} není kompatibilní s typem {destType}.",
         "namedTupleNotAllowed": "NamedTuple se nedá použít pro kontroly instancí nebo tříd.",
         "newMethodLocation": "Metoda __new__ je definována ve třídě {type}",
         "newMethodSignature": "Podpis __new__ je {type}",
@@ -725,7 +727,7 @@
         "overridePositionalParamCount": "Neshoda počtu pozičních parametrů; Základní metoda má „{baseCount}“, ale přepsání má {overrideCount}",
         "overrideReturnType": "Neshoda návratového typu: Základní metoda vrací typ {baseType}, přepsání vrací typ {overrideType}",
         "overrideType": "Základní třída definuje typ jako {type}",
-        "paramAssignment": "Parametr {index}: Typ {sourceType} není možné přiřadit typu {destType}",
+        "paramAssignment": "Parametr {index}: typ {sourceType} není kompatibilní s typem {destType}.",
         "paramSpecMissingInOverride": "V metodě přepsání chybí parametry ParamSpec",
         "paramType": "Typ parametru je {paramType}",
         "privateImportFromPyTypedSource": "Místo toho importovat z modulu {module}",
@@ -755,7 +757,7 @@
         "tupleSizeMismatch": "Neshoda velikosti řazené kolekce členů; Očekávalo se {expected}, ale přijalo se {received}.",
         "tupleSizeMismatchIndeterminateDest": "Neshoda velikosti řazené kolekce členů; Očekávalo se min. {expected}, ale přijalo se {received}.",
         "typeAliasInstanceCheck": "Alias typu vytvořený pomocí příkazu „typ“ se nedá použít s kontrolami instancí a tříd",
-        "typeAssignmentMismatch": "Typ {sourceType} se nedá přiřadit k typu {destType}",
+        "typeAssignmentMismatch": "Typ {sourceType} není kompatibilní s typem {destType}.",
         "typeBound": "Typ {sourceType} je nekompatibilní s vázaným typem {destType} pro proměnnou typu {name}",
         "typeConstrainedTypeVar": "Typ {type} není kompatibilní s proměnnou omezeného typu {name}",
         "typeIncompatible": "{sourceType} není kompatibilní s typem {destType}",

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

@@ -17,10 +17,10 @@
         "abstractMethodInvocation": "Die Methode „{method}“ kann nicht aufgerufen werden, da sie abstrakt und nicht implementiert ist.",
         "annotatedParamCountMismatch": "Nicht übereinstimmende Parameteranmerkungsanzahl: {expected} erwartet, aber {received} empfangen",
         "annotatedTypeArgMissing": "Es wurde ein Typargument und mindestens eine Anmerkung für \"Annotated\" erwartet.",
-        "annotationBytesString": "Type annotations cannot use bytes string literals",
+        "annotationBytesString": "Typanmerkungen dürfen keine Bytes-Zeichenfolgenliterale verwenden.",
         "annotationFormatString": "Typanmerkungen können keine Formatzeichenfolgenliterale (f-strings) verwenden.",
         "annotationNotSupported": "Typanmerkung wird für diese Anweisung nicht unterstützt.",
-        "annotationRawString": "Type annotations cannot use raw string literals",
+        "annotationRawString": "Typanmerkungen dürfen keine unformatierten Zeichenfolgenliterale verwenden.",
         "annotationSpansStrings": "Typanmerkungen dürfen nicht mehrere Zeichenfolgenliterale umfassen.",
         "annotationStringEscape": "Typanmerkungen dürfen keine Escapezeichen enthalten.",
         "argAssignment": "Ein Argument vom Typ \"{argType}\" kann dem Parameter vom Typ \"{paramType}\" nicht zugewiesen werden.",
@@ -103,6 +103,7 @@
         "dataClassBaseClassNotFrozen": "Eine fixierte Klasse kann nicht von einer nicht fixierten Klasse erben.",
         "dataClassConverterFunction": "Das Argument vom Typ \"{argType}\" ist kein gültiger Konverter für das Feld \"{fieldName}\" vom Typ \"{fieldType}\"",
         "dataClassConverterOverloads": "Keine Überladungen von \"{funcName}\" sind gültige Konverter für das Feld \"{fieldName}\" vom Typ \"{fieldType}\"",
+        "dataClassFieldInheritedDefault": "„{fieldName}“ überschreibt ein Feld mit demselben Namen, aber es fehlt ein Standardwert",
         "dataClassFieldWithDefault": "Felder ohne Standardwerte dürfen nicht nach Feldern mit Standardwerten angezeigt werden.",
         "dataClassFieldWithPrivateName": "Das Feld \"Dataclass\" kann keinen privaten Namen verwenden.",
         "dataClassFieldWithoutAnnotation": "Datenklassenfeld ohne Typanmerkung verursacht eine Laufzeitausnahme",
@@ -188,7 +189,7 @@
         "expectedIn": "\"in\" wurde erwartet.",
         "expectedInExpr": "Ausdruck nach \"in\" erwartet",
         "expectedIndentedBlock": "Eingerückter Block erwartet",
-        "expectedMemberName": "Membername nach \".\" erwartet",
+        "expectedMemberName": "Attributname nach „.“ erwartet",
         "expectedModuleName": "Modulname erwartet",
         "expectedNameAfterAs": "Symbolname nach \"as\" erwartet",
         "expectedNamedParameter": "Der Schlüsselwortparameter muss auf \"*\" folgen.",
@@ -251,6 +252,7 @@
         "incompatibleMethodOverride": "Die Methode \"{name}\" überschreibt die Klasse \"{className}\" auf inkompatible Weise.",
         "inconsistentIndent": "Der Betrag für Nichteinzug stimmt nicht mit dem vorherigen Einzug überein.",
         "inconsistentTabs": "Inkonsistente Verwendung von Tabulatoren und Leerzeichen im Einzug.",
+        "initMethodSelfParamTypeVar": "Die Typanmerkung für den Parameter „self“ der Methode „__init__“ darf keine klassenbezogenen Typvariablen enthalten",
         "initMustReturnNone": "Der Rückgabetyp von \"__init__\" muss \"None\" sein.",
         "initSubclassCallFailed": "Falsche Schlüsselwortargumente für __init_subclass__ Methode.",
         "initSubclassClsParam": "__init_subclass__ Außerkraftsetzung sollte einen \"cls\"-Parameter annehmen.",
@@ -277,16 +279,16 @@
         "listAssignmentMismatch": "Ein Ausdruck vom Typ \"{type}\" kann der Zielliste nicht zugewiesen werden.",
         "listInAnnotation": "Ein Listenausdruck ist in der Typanmerkung nicht zulässig.",
         "literalEmptyArgs": "Nach \"Literal\" wurde mindestens ein Typargument erwartet.",
-        "literalNamedUnicodeEscape": "Named unicode escape sequences are not supported in \"Literal\" string annotations",
+        "literalNamedUnicodeEscape": "Benannte Escapesequenz für Unicodezeichen werden in Zeichenfolgenanmerkungen vom Typ „Literal“ nicht unterstützt.",
         "literalNotAllowed": "\"Literal\" kann in diesem Kontext nicht ohne Typargument verwendet werden.",
         "literalNotCallable": "Der Literaltyp kann nicht instanziiert werden.",
         "literalUnsupportedType": "Typargumente für \"Literal\" müssen None, ein Literalwert (int, bool, str oder bytes) oder ein Enumerationswert sein.",
         "matchIncompatible": "Übereinstimmungsanweisungen erfordern Python 3.10 oder höher",
         "matchIsNotExhaustive": "Fälle innerhalb der match-Anweisung behandeln nicht umfassend alle Werte.",
         "maxParseDepthExceeded": "Maximale Analysetiefe überschritten; brechen Sie den Ausdruck in kleinere Unterausdrücke um",
-        "memberAccess": "Auf Member \"{name}\" für Typ \"{type}\" kann nicht zugegriffen werden.",
-        "memberDelete": "Member \"{name}\" für Typ \"{type}\" kann nicht gelöscht werden.",
-        "memberSet": "Member \"{name}\" für Typ \"{type}\" kann nicht zugewiesen werden.",
+        "memberAccess": "Auf das Attribut „{name}“ für die Klasse „{type}“ kann nicht zugegriffen werden",
+        "memberDelete": "Das Attribut „{name}“ für die Klasse „{type}“ kann nicht gelöscht werden",
+        "memberSet": "Zum Attribut „{name}“ für die Klasse „{type}“ kann nicht zugewiesen werden",
         "metaclassConflict": "Die Metaklasse einer abgeleiteten Klasse muss eine Unterklasse der Metaklassen aller ihrer Basisklassen sein.",
         "metaclassDuplicate": "Es kann nur eine Metaklasse angegeben werden.",
         "metaclassIsGeneric": "Metaklasse kann nicht generisch sein.",
@@ -298,7 +300,7 @@
         "missingSuperCall": "Die Methode \"{methodName}\" ruft nicht die Methode mit demselben Namen in der übergeordneten Klasse auf.",
         "moduleAsType": "Das Modul kann nicht als Typ verwendet werden.",
         "moduleNotCallable": "Das Modul kann nicht aufgerufen werden.",
-        "moduleUnknownMember": "\"{memberName}\" ist kein bekanntes Mitglied des Moduls \"{moduleName}\"",
+        "moduleUnknownMember": "„{memberName}“ ist kein bekanntes Attribut des Moduls „{moduleName}“",
         "namedExceptAfterCatchAll": "Eine benannte except-Klausel darf nicht nach catch-all except-Klausel auftreten.",
         "namedParamAfterParamSpecArgs": "Der Schlüsselwortparameter \"{name}\" kann nicht in der Signatur nach dem Parameter \"ParamSpec args\" verwendet werden.",
         "namedTupleEmptyName": "Namen innerhalb eines benannten Tupels dürfen nicht leer sein.",
@@ -332,7 +334,7 @@
         "noneNotSubscriptable": "Das Objekt vom Typ \"None\" kann nicht tiefgestellt werden.",
         "noneNotUsableWith": "Ein Objekt vom Typ \"None\" kann nicht mit \"with\" verwendet werden.",
         "noneOperator": "Der Operator \"{operator}\" wird für den \"{None}\" nicht unterstützt.",
-        "noneUnknownMember": "\"{name}\" ist kein bekanntes Element von \"None\".",
+        "noneUnknownMember": "„{name}“ ist kein bekanntes Attribut von „None“",
         "notRequiredArgCount": "Nach \"NotRequired\" wurde ein einzelnes Typargument erwartet.",
         "notRequiredNotInTypedDict": "\"NotRequired\" ist in diesem Kontext nicht zulässig.",
         "objectNotCallable": "Das Objekt vom Typ \"{type}\" kann nicht aufgerufen werden.",
@@ -363,18 +365,18 @@
         "paramAnnotationMissing": "Typanmerkung fehlt für Parameter \"{name}\"",
         "paramAssignmentMismatch": "Ein Ausdruck vom Typ \"{sourceType}\" kann keinem Parameter vom Typ \"{paramType}\" zugewiesen werden.",
         "paramNameMissing": "Kein Parameter mit dem Namen \"{name}\"",
-        "paramSpecArgsKwargsUsage": "Die Member \"args\" und \"kwargs\" von ParamSpec müssen beide innerhalb einer Funktionssignatur auftreten.",
+        "paramSpecArgsKwargsUsage": "Die Attribute „args“ und „kwargs“ von ParamSpec müssen beide innerhalb einer Funktionssignatur auftreten",
         "paramSpecArgsMissing": "Argumente für ParamSpec \"{type}\" fehlen.",
-        "paramSpecArgsUsage": "Das \"args\"-Element von ParamSpec ist nur gültig, wenn es mit dem Parameter \"*args\" verwendet wird.",
+        "paramSpecArgsUsage": "Das Attribut „args“ von ParamSpec ist nur gültig, wenn es mit dem Parameter „*args“ verwendet wird",
         "paramSpecAssignedName": "ParamSpec muss einer Variablen mit dem Namen \"{name}\" zugewiesen werden.",
         "paramSpecContext": "ParamSpec ist in diesem Kontext nicht zulässig.",
         "paramSpecDefaultNotTuple": "Es wurde ein Auslassungszeichen, ein Tupelausdruck oder ParamSpec für den Standardwert von ParamSpec erwartet.",
         "paramSpecFirstArg": "Der Name von ParamSpec wurde als erstes Argument erwartet.",
-        "paramSpecKwargsUsage": "Das \"kwargs\"-Element von ParamSpec ist nur gültig, wenn es mit dem Parameter **kwargs verwendet wird.",
+        "paramSpecKwargsUsage": "Das Attribut „kwargs“ von ParamSpec ist nur gültig, wenn es mit dem Parameter „*kwargs“ verwendet wird",
         "paramSpecNotUsedByOuterScope": "ParamSpec \"{name}\" hat in diesem Kontext keine Bedeutung.",
         "paramSpecScopedToReturnType": "ParamSpec \"{name}\" ist auf einen Aufruf innerhalb des Rückgabetyps beschränkt und kann im Funktionstext nicht referenziert werden.",
         "paramSpecUnknownArg": "ParamSpec unterstützt nur ein Argument.",
-        "paramSpecUnknownMember": "\"{name}\" ist kein bekanntes Element von ParamSpec.",
+        "paramSpecUnknownMember": "„{name}“ ist kein bekanntes Attribut von ParamSpec",
         "paramSpecUnknownParam": "\"{name}\" ist ein unbekannter Parameter für ParamSpec.",
         "paramTypeCovariant": "Eine Variable vom Typ \"Covariant\" kann nicht im Parametertyp verwendet werden.",
         "paramTypePartiallyUnknown": "Der Typ des Parameters \"{paramName}\" ist teilweise unbekannt.",
@@ -418,7 +420,7 @@
         "returnMissing": "Die Funktion mit dem deklarierten Rückgabetyp \"{returnType}\" muss einen Wert für alle Codepfade zurückgeben.",
         "returnOutsideFunction": "\"return\" kann nur innerhalb einer Funktion verwendet werden.",
         "returnTypeContravariant": "Die Variable vom Typ \"contravariant\" kann nicht im Rückgabetyp verwendet werden.",
-        "returnTypeMismatch": "Ein Ausdruck vom Typ \"{exprType}\" kann dem Rückgabetyp \"{returnType}\" nicht zugewiesen werden.",
+        "returnTypeMismatch": "Der Ausdruck vom Typ „{exprType}“ ist nicht mit dem Rückgabetyp „{returnType}“ kompatibel",
         "returnTypePartiallyUnknown": "Der Rückgabetyp \"{returnType}\" ist teilweise unbekannt.",
         "returnTypeUnknown": "Unbekannter Rückgabetyp",
         "revealLocalsArgs": "Es wurden keine Argumente für den Aufruf \"reveal_locals\" erwartet.",
@@ -484,8 +486,8 @@
         "typeArgsMissingForClass": "Für die generische Klasse \"{name}\" werden Typargumente erwartet.",
         "typeArgsTooFew": "Für \"{name}\" wurden zu wenige Typargumente angegeben; {expected} erwartet, aber {received} empfangen",
         "typeArgsTooMany": "Für \"{name}\" wurden zu viele Typargumente angegeben; {expected} erwartet, aber {received} empfangen",
-        "typeAssignmentMismatch": "Ein Ausdruck vom Typ \"{sourceType}\" kann nicht dem deklarierten Typ \"{destType}\" zugewiesen werden.",
-        "typeAssignmentMismatchWildcard": "Das Importsymbol \"{name}\" weist den Typ \"{sourceType}\" auf, der dem deklarierten Typ \"{destType}\" nicht zugewiesen werden kann.",
+        "typeAssignmentMismatch": "Der Ausdruck vom Typ „{sourceType}“ ist nicht mit dem deklarierten Typ „{destType}“ kompatibel",
+        "typeAssignmentMismatchWildcard": "Das Importsymbol „{name}“ weist den Typ „{sourceType}“ auf, der nicht mit dem deklarierten Typ „{destType}“ kompatibel ist",
         "typeCallNotAllowed": "Der type()-Aufruf darf nicht in der Typanmerkung verwendet werden.",
         "typeCheckOnly": "\"{name}\" ist als @type_check_only markiert und kann nur in Typanmerkungen verwendet werden.",
         "typeCommentDeprecated": "Die Verwendung von Typkommentaren ist veraltet; verwenden Sie stattdessen Typanmerkung",
@@ -520,7 +522,7 @@
         "typeVarDefaultIllegal": "Für Standardtypen von Typvariablen ist Python 3.13 oder höher erforderlich.",
         "typeVarDefaultInvalidTypeVar": "Der Typparameter \"{name}\" weist einen Standardtyp auf, der auf eine oder mehrere Typvariablen verweist, die außerhalb des Gültigkeitsbereichs liegen.",
         "typeVarFirstArg": "Der Name von TypeVar wurde als erstes Argument erwartet.",
-        "typeVarNoMember": "TypeVar \"{type}\" hat kein Member \"{name}\"",
+        "typeVarNoMember": "TypeVar „{type}“ weist kein Attribut „{name}“ auf",
         "typeVarNotSubscriptable": "TypeVar \"{type}\" kann nicht tiefgestellt werden.",
         "typeVarNotUsedByOuterScope": "Die Typvariable \"{name}\" hat in diesem Kontext keine Bedeutung.",
         "typeVarPossiblyUnsolvable": "Die Typvariable \"{name}\" wird möglicherweise nicht aufgelöst, wenn der Aufrufer kein Argument für Parameter \"{param}\" bereitstellt",
@@ -634,7 +636,7 @@
         "argsPositionOnly": "Nicht übereinstimmende Parameteranmerkungsanzahl: {expected} erwartet, aber {received} empfangen",
         "argumentType": "Argumenttyp ist \"{type}\"",
         "argumentTypes": "Argumenttypen: ({types})",
-        "assignToNone": "Der Typ kann nicht dem Typ \"None\" zugewiesen werden.",
+        "assignToNone": "Der Typ ist nicht mit „None“ kompatibel",
         "asyncHelp": "Meinten Sie \"asynchron mit\"?",
         "baseClassIncompatible": "Die Basisklasse \"{baseClass}\" ist nicht mit dem Typ \"{type}\" kompatibel.",
         "baseClassIncompatibleSubclass": "Die Basisklasse \"{baseClass}\" wird von \"{subclass}\" abgeleitet, die mit dem Typ \"{type}\" nicht kompatibel ist.",
@@ -670,30 +672,30 @@
         "keyUndefined": "\"{name}\" ist kein definierter Schlüssel in \"{type}\"",
         "kwargsParamMissing": "Der Parameter \"**{paramName}\" weist keinen entsprechenden Parameter auf.",
         "listAssignmentMismatch": "Der Typ \"{type}\" ist nicht mit der Zielliste kompatibel.",
-        "literalAssignmentMismatch": "\"{sourceType}\" kann dem Typ \"{destType}\" nicht zugewiesen werden.",
+        "literalAssignmentMismatch": "„{sourceType}“ist nicht mit dem Typ „{destType}“ kompatibel",
         "matchIsNotExhaustiveHint": "Wenn keine ausführliche Behandlung beabsichtigt ist, fügen Sie \"case _: pass\" hinzu.",
         "matchIsNotExhaustiveType": "Unbehandelter Typ: \"{type}\"",
-        "memberAssignment": "Ein Ausdruck vom Typ \"{type}\" kann dem Member \"{name}\" der Klasse \"{classType}\" nicht zugewiesen werden.",
+        "memberAssignment": "Ein Ausdruck vom Typ „{type}“ kann dem Attribut „{name}“ der Klasse „{classType}“ nicht zugewiesen werden",
         "memberIsAbstract": "„{type}. {name}“ ist nicht implementiert.",
         "memberIsAbstractMore": "und {count} weitere...",
         "memberIsClassVarInProtocol": "„{name}“ ist als ClassVar im Protokoll definiert.",
         "memberIsFinalInProtocol": "\"{name}\" ist im Protokoll als \"Final\" gekennzeichnet.",
-        "memberIsInitVar": "Das Element \"{name}\" ist ein init-only-Feld.",
+        "memberIsInitVar": "„{name}“ ist ein init-only-Feld.",
         "memberIsInvariant": "\"{name}\" ist invariant, da es änderbar ist.",
         "memberIsNotClassVarInClass": "„{name}“ muss als ClassVar definiert sein, um mit dem Protokoll kompatibel zu sein.",
         "memberIsNotClassVarInProtocol": "„{name}“ ist nicht als ClassVar im Protokoll definiert.",
         "memberIsNotFinalInProtocol": "\"{name}\" ist im Protokoll nicht als \"Final\" gekennzeichnet.",
         "memberIsWritableInProtocol": "\"{name}\" ist im Protokoll beschreibbar.",
-        "memberSetClassVar": "Der Member \"{name}\" kann nicht über eine Klasseninstanz zugewiesen werden, da es sich um eine ClassVar handelt.",
+        "memberSetClassVar": "Attribut „{name}“ kann nicht über eine Klasseninstanz zugewiesen werden, da es sich um eine ClassVar handelt",
         "memberTypeMismatch": "\"{name}\" ist ein inkompatibler Typ.",
-        "memberUnknown": "Das Member \"{name}\" ist unbekannt.",
+        "memberUnknown": "Das Attribut „{name}“ ist unbekannt",
         "metaclassConflict": "Die Metaklasse \"{metaclass1}\" verursacht einen Konflikt mit \"{metaclass2}\"",
         "missingDeleter": "Die Eigenschaft-Deleter-Methode fehlt.",
         "missingGetter": "Die Eigenschaft-Getter-Methode fehlt.",
         "missingSetter": "Die Eigenschaft-Setter-Methode fehlt.",
         "namedParamMissingInDest": "Der Schlüsselwortparameter \"{name}\" fehlt im Ziel.",
         "namedParamMissingInSource": "Der Schlüsselwortparameter \"{name}\" fehlt in der Quelle.",
-        "namedParamTypeMismatch": "Der Stichwortparameter \"{name}\" vom Typ \"{sourceType}\" kann dem Typ \"{destType}\" nicht zugewiesen werden.",
+        "namedParamTypeMismatch": "Der Schlüsselwortparameter „{name}“ vom Typ „{sourceType}“ ist nicht mit dem Typ „{destType}“ kompatibel",
         "namedTupleNotAllowed": "NamedTuple kann nicht für Instanzen- oder Klassenüberprüfungen verwendet werden.",
         "newMethodLocation": "Die __new__ Methode ist in der Klasse \"{type}\" definiert.",
         "newMethodSignature": "Signatur von __new__ ist \"{type}\"",
@@ -725,7 +727,7 @@
         "overridePositionalParamCount": "Anzahl der Positionsparameter stimmt nicht überein; die Basismethode hat {baseCount}, aber die Überschreibung hat {overrideCount}",
         "overrideReturnType": "Rückgabetypkonflikt: Basismethode gibt Typ \"{baseType}\" zurück, Überschreibung gibt Typ \"{overrideType}\" zurück",
         "overrideType": "Die Basisklasse definiert den Typ als \"{type}\"",
-        "paramAssignment": "Parameter {index}: Der Typ \"{sourceType}\" kann dem Typ \"{destType}\" nicht zugewiesen werden.",
+        "paramAssignment": "Parameter „{index}“: Typ „{sourceType}“ ist nicht mit dem Typ „{destType}“ kompatibel",
         "paramSpecMissingInOverride": "Parameter \"ParamSpec\" fehlen in der Überschreibungsmethode.",
         "paramType": "Parametertyp ist \"{paramType}\"",
         "privateImportFromPyTypedSource": "Stattdessen aus \"{module}\" importieren",
@@ -755,7 +757,7 @@
         "tupleSizeMismatch": "Nicht übereinstimmende Tupelgröße; {expected} erwartet, aber {received} empfangen",
         "tupleSizeMismatchIndeterminateDest": "Nicht übereinstimmende Tupelgröße; {expected} oder mehr erwartet, aber {received} empfangen",
         "typeAliasInstanceCheck": "Der mit der „type“-Anweisung erstellte Typalias kann nicht mit Instanz- und Klassenüberprüfungen verwendet werden.",
-        "typeAssignmentMismatch": "Der Typ \"{sourceType}\" kann dem Typ \"{destType}\" nicht zugewiesen werden.",
+        "typeAssignmentMismatch": "Der Typ „{sourceType}“ist nicht mit dem Typ „{destType}“ kompatibel",
         "typeBound": "Der Typ \"{sourceType}\" ist nicht mit dem gebundenen Typ \"{destType}\" für die Typvariablen \"{name}\" kompatibel.",
         "typeConstrainedTypeVar": "Der Typ \"{type}\" ist mit der eingeschränkten Typvariablen nicht kompatibel \"{name}\"",
         "typeIncompatible": "\"{sourceType}\" ist nicht mit \"{destType}\" kompatibel.",

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

@@ -574,7 +574,7 @@
         "unnecessaryPyrightIgnoreRule": "Unnecessary \"# pyright: ignore\" rule: \"{name}\"",
         "unnecessaryTypeIgnore": "Unnecessary \"# type: ignore\" comment",
         "unpackArgCount": "Expected a single type argument after \"Unpack\"",
-        "unpackedArgInTypeArgument": "Unpacked arguments cannot be used in type argument lists",
+        "unpackedArgInTypeArgument": "Unpacked arguments cannot be used in this context",
         "unpackedArgWithVariadicParam": "Unpacked argument cannot be used for TypeVarTuple parameter",
         "unpackedDictArgumentNotMapping": "Argument expression after ** must be a mapping with a \"str\" key type",
         "unpackedDictSubscriptIllegal": "Dictionary unpack operator in subscript is not allowed",