From 0d92942a42bf6ec1ed29bfe9a66485737cc208d0 Mon Sep 17 00:00:00 2001 From: Eric Traut Date: Wed, 11 Sep 2024 14:30:16 -0700 Subject: [PATCH 01/27] Fixed bug that results in incorrect type narrowing for sequence patterns in the negative (fall-through) case when the subject is a tuple with an unbounded entry. This addresses #8967. (#8968) --- .../src/analyzer/patternMatching.ts | 5 ++++- .../src/tests/samples/matchSequence1.py | 18 ++++++++++++++++++ 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/packages/pyright-internal/src/analyzer/patternMatching.ts b/packages/pyright-internal/src/analyzer/patternMatching.ts index c86f7cd71..55ae16160 100644 --- a/packages/pyright-internal/src/analyzer/patternMatching.ts +++ b/packages/pyright-internal/src/analyzer/patternMatching.ts @@ -109,6 +109,7 @@ interface SequencePatternInfo { entryTypes: Type[]; isIndeterminateLength?: boolean; isTuple?: boolean; + isUnboundedTuple?: boolean; } interface MappingPatternInfo { @@ -225,7 +226,7 @@ function narrowTypeBasedOnSequencePattern( // contains indeterminate-length entries or the tuple is of indeterminate // length. if (!isPositiveTest) { - if (entry.isIndeterminateLength) { + if (entry.isIndeterminateLength || entry.isUnboundedTuple) { canNarrowTuple = false; } @@ -1436,6 +1437,7 @@ function getSequencePatternInfo( entryTypes: isDefiniteNoMatch ? [] : typeArgs.map((t) => t.type), isIndeterminateLength: false, isTuple: true, + isUnboundedTuple: tupleIndeterminateIndex >= 0, isDefiniteNoMatch, isPotentialNoMatch, }); @@ -1488,6 +1490,7 @@ function getSequencePatternInfo( entryTypes: isDefiniteNoMatch ? [] : typeArgs.map((t) => t.type), isIndeterminateLength: false, isTuple: true, + isUnboundedTuple: tupleIndeterminateIndex >= 0, isDefiniteNoMatch, }); return; diff --git a/packages/pyright-internal/src/tests/samples/matchSequence1.py b/packages/pyright-internal/src/tests/samples/matchSequence1.py index 13ebdcc2b..6a2d3b572 100644 --- a/packages/pyright-internal/src/tests/samples/matchSequence1.py +++ b/packages/pyright-internal/src/tests/samples/matchSequence1.py @@ -608,6 +608,24 @@ def test_unbounded_tuple_5(subj: tuple[int, Unpack[tuple[str, ...]]]): reveal_type(x, expected_text="Never") +def test_unbounded_tuple_6(subj: tuple[str, ...]): + match subj: + case ("a", b, _, _): + reveal_type(b, expected_text="str") + + case ("a", b, _, _, _): + reveal_type(b, expected_text="str") + + case (_, b, _, _): + reveal_type(b, expected_text="str") + + case (_, b, _, _, _): + reveal_type(b, expected_text="str") + + case r: + reveal_type(r, expected_text="tuple[str, ...]") + + def test_variadic_tuple(subj: tuple[int, Unpack[Ts]]) -> tuple[Unpack[Ts]]: match subj: case _, *rest: From a0ecfe25d6be37311a69f8c12c0235677f708f55 Mon Sep 17 00:00:00 2001 From: Stella <100439259+StellaHuang95@users.noreply.github.com> Date: Wed, 11 Sep 2024 16:36:53 -0700 Subject: [PATCH 02/27] Pull Pylance with Pyright 1.1.380 (#8969) * Push pylance changes to pyright * Update typeForm4.py --- .../pyright-internal/src/analyzer/analysis.ts | 3 + .../src/analyzer/backgroundAnalysisProgram.ts | 5 +- .../src/analyzer/cacheManager.ts | 4 +- .../src/analyzer/pythonPathUtils.ts | 2 +- .../pyright-internal/src/analyzer/service.ts | 109 +- .../src/backgroundAnalysisBase.ts | 149 +- .../src/backgroundThreadBase.ts | 14 +- .../src/common/languageServerInterface.ts | 2 +- .../src/common/uri/uriUtils.ts | 8 +- .../src/languageServerBase.ts | 18 +- .../analyzerServiceExecutor.ts | 31 +- .../fileWatcherDynamicFeature.ts | 20 +- .../src/localization/package.nls.cs.json | 308 +-- .../src/localization/package.nls.de.json | 254 ++- .../src/localization/package.nls.en-us.json | 2030 +++++++++++++---- .../src/localization/package.nls.es.json | 300 +-- .../src/localization/package.nls.fr.json | 256 +-- .../src/localization/package.nls.it.json | 284 +-- .../src/localization/package.nls.ja.json | 282 +-- .../src/localization/package.nls.ko.json | 308 +-- .../src/localization/package.nls.pl.json | 354 +-- .../src/localization/package.nls.pt-br.json | 276 +-- .../localization/package.nls.qps-ploc.json | 782 +++---- .../src/localization/package.nls.ru.json | 338 +-- .../src/localization/package.nls.tr.json | 304 +-- .../src/localization/package.nls.zh-cn.json | 296 +-- .../src/localization/package.nls.zh-tw.json | 264 +-- .../src/tests/envVarUtils.test.ts | 5 +- .../harness/fourslash/testLanguageService.ts | 10 +- .../src/tests/harness/fourslash/testState.ts | 23 +- .../tests/harness/fourslash/testStateUtils.ts | 5 + .../src/tests/harness/vfs/filesystem.ts | 8 +- .../src/tests/service.test.ts | 44 +- .../pyright-internal/src/workspaceFactory.ts | 99 +- 34 files changed, 4241 insertions(+), 2954 deletions(-) diff --git a/packages/pyright-internal/src/analyzer/analysis.ts b/packages/pyright-internal/src/analyzer/analysis.ts index 21be06fe5..7a6774203 100644 --- a/packages/pyright-internal/src/analyzer/analysis.ts +++ b/packages/pyright-internal/src/analyzer/analysis.ts @@ -29,6 +29,7 @@ export interface AnalysisResults { configParseErrorOccurred: boolean; elapsedTime: number; error?: Error | undefined; + reason: 'analysis' | 'tracking'; } export interface RequiringAnalysisCount { @@ -76,6 +77,7 @@ export function analyzeProgram( fatalErrorOccurred: false, configParseErrorOccurred: false, elapsedTime, + reason: 'analysis', }); } } catch (e: any) { @@ -95,6 +97,7 @@ export function analyzeProgram( configParseErrorOccurred: false, elapsedTime: 0, error: debug.getSerializableError(e), + reason: 'analysis', }); } diff --git a/packages/pyright-internal/src/analyzer/backgroundAnalysisProgram.ts b/packages/pyright-internal/src/analyzer/backgroundAnalysisProgram.ts index 3d1f8f2f0..6774a7eb9 100644 --- a/packages/pyright-internal/src/analyzer/backgroundAnalysisProgram.ts +++ b/packages/pyright-internal/src/analyzer/backgroundAnalysisProgram.ts @@ -51,6 +51,7 @@ export class BackgroundAnalysisProgram { this._disableChecker, serviceId ); + this._backgroundAnalysis?.setProgramView(this._program); } get configOptions() { @@ -150,7 +151,7 @@ export class BackgroundAnalysisProgram { startAnalysis(token: CancellationToken): boolean { if (this._backgroundAnalysis) { - this._backgroundAnalysis.startAnalysis(this, token); + this._backgroundAnalysis.startAnalysis(token); return false; } @@ -228,6 +229,7 @@ export class BackgroundAnalysisProgram { this._disposed = true; this._program.dispose(); this._backgroundAnalysis?.shutdown(); + this._backgroundAnalysis?.dispose(); } enterEditMode() { @@ -267,6 +269,7 @@ export class BackgroundAnalysisProgram { fatalErrorOccurred: false, configParseErrorOccurred: false, elapsedTime: 0, + reason: 'tracking', }); } } diff --git a/packages/pyright-internal/src/analyzer/cacheManager.ts b/packages/pyright-internal/src/analyzer/cacheManager.ts index 364506b0c..6513fdcf8 100644 --- a/packages/pyright-internal/src/analyzer/cacheManager.ts +++ b/packages/pyright-internal/src/analyzer/cacheManager.ts @@ -10,7 +10,7 @@ import type { HeapInfo } from 'v8'; import { Worker } from 'worker_threads'; -import { AnalysisRequest } from '../backgroundAnalysisBase'; +import { BackgroundRequest } from '../backgroundAnalysisBase'; import { ConsoleInterface } from '../common/console'; import { fail } from '../common/debug'; import { getHeapStatistics, getSystemMemoryInfo } from '../common/memUtils'; @@ -51,7 +51,7 @@ export class CacheManager { } } - handleCachedUsageBufferMessage(msg: AnalysisRequest) { + handleCachedUsageBufferMessage(msg: BackgroundRequest) { if (msg.requestType === 'cacheUsageBuffer') { const index = parseInt(msg.data || '0'); const buffer = msg.sharedUsageBuffer; diff --git a/packages/pyright-internal/src/analyzer/pythonPathUtils.ts b/packages/pyright-internal/src/analyzer/pythonPathUtils.ts index 65871da8b..ae09a3e1f 100644 --- a/packages/pyright-internal/src/analyzer/pythonPathUtils.ts +++ b/packages/pyright-internal/src/analyzer/pythonPathUtils.ts @@ -56,7 +56,7 @@ export function findPythonSearchPaths( importFailureInfo: string[], includeWatchPathsOnly?: boolean | undefined, workspaceRoot?: Uri | undefined -): Uri[] | undefined { +): Uri[] { importFailureInfo.push('Finding python search paths'); if (configOptions.venvPath !== undefined && configOptions.venv) { diff --git a/packages/pyright-internal/src/analyzer/service.ts b/packages/pyright-internal/src/analyzer/service.ts index 4a83d35a5..295596e3b 100644 --- a/packages/pyright-internal/src/analyzer/service.ts +++ b/packages/pyright-internal/src/analyzer/service.ts @@ -36,6 +36,7 @@ import { Range } from '../common/textRange'; import { timingStats } from '../common/timing'; import { Uri } from '../common/uri/uri'; import { + deduplicateFolders, FileSpec, getFileSpec, getFileSystemEntries, @@ -105,7 +106,7 @@ export function getNextServiceId(name: string) { } export class AnalyzerService { - private readonly _options: AnalyzerServiceOptions; + protected readonly options: AnalyzerServiceOptions; private readonly _backgroundAnalysisProgram: BackgroundAnalysisProgram; private readonly _serviceProvider: ServiceProvider; @@ -135,51 +136,51 @@ export class AnalyzerService { this._instanceName = instanceName; this._executionRootUri = Uri.empty(); - this._options = options; + this.options = options; - this._options.serviceId = this._options.serviceId ?? getNextServiceId(instanceName); - this._options.console = options.console || new StandardConsole(); + this.options.serviceId = this.options.serviceId ?? getNextServiceId(instanceName); + this.options.console = options.console || new StandardConsole(); // Create local copy of the given service provider. this._serviceProvider = serviceProvider.clone(); // Override the console and the file system if they were explicitly provided. - if (this._options.console) { - this._serviceProvider.add(ServiceKeys.console, this._options.console); + if (this.options.console) { + this._serviceProvider.add(ServiceKeys.console, this.options.console); } - if (this._options.fileSystem) { - this._serviceProvider.add(ServiceKeys.fs, this._options.fileSystem); + if (this.options.fileSystem) { + this._serviceProvider.add(ServiceKeys.fs, this.options.fileSystem); } - this._options.importResolverFactory = options.importResolverFactory ?? AnalyzerService.createImportResolver; - this._options.cancellationProvider = options.cancellationProvider ?? new DefaultCancellationProvider(); - this._options.hostFactory = options.hostFactory ?? (() => new NoAccessHost()); + this.options.importResolverFactory = options.importResolverFactory ?? AnalyzerService.createImportResolver; + this.options.cancellationProvider = options.cancellationProvider ?? new DefaultCancellationProvider(); + this.options.hostFactory = options.hostFactory ?? (() => new NoAccessHost()); - this._options.configOptions = + this.options.configOptions = options.configOptions ?? new ConfigOptions(Uri.file(process.cwd(), this._serviceProvider)); - const importResolver = this._options.importResolverFactory( + const importResolver = this.options.importResolverFactory( this._serviceProvider, - this._options.configOptions, - this._options.hostFactory() + this.options.configOptions, + this.options.hostFactory() ); this._backgroundAnalysisProgram = - this._options.backgroundAnalysisProgramFactory !== undefined - ? this._options.backgroundAnalysisProgramFactory( - this._options.serviceId, + this.options.backgroundAnalysisProgramFactory !== undefined + ? this.options.backgroundAnalysisProgramFactory( + this.options.serviceId, this._serviceProvider, - this._options.configOptions, + this.options.configOptions, importResolver, - this._options.backgroundAnalysis, - this._options.maxAnalysisTime + this.options.backgroundAnalysis, + this.options.maxAnalysisTime ) : new BackgroundAnalysisProgram( - this._options.serviceId, + this.options.serviceId, this._serviceProvider, - this._options.configOptions, + this.options.configOptions, importResolver, - this._options.backgroundAnalysis, - this._options.maxAnalysisTime, + this.options.backgroundAnalysis, + this.options.maxAnalysisTime, /* disableChecker */ undefined ); } @@ -193,7 +194,7 @@ export class AnalyzerService { } get cancellationProvider() { - return this._options.cancellationProvider!; + return this.options.cancellationProvider!; } get librarySearchUrisToWatch() { @@ -209,7 +210,7 @@ export class AnalyzerService { } get id() { - return this._options.serviceId!; + return this.options.serviceId!; } setServiceName(instanceName: string) { @@ -223,7 +224,7 @@ export class AnalyzerService { fileSystem?: FileSystem ): AnalyzerService { const service = new AnalyzerService(instanceName, this._serviceProvider, { - ...this._options, + ...this.options, serviceId, backgroundAnalysis, skipScanningUserFiles: true, @@ -477,6 +478,21 @@ export class AnalyzerService { this._backgroundAnalysisProgram.restart(); } + protected getCancellationToken() { + if (!this._backgroundAnalysisCancellationSource) { + this._backgroundAnalysisCancellationSource = this.cancellationProvider.createCancellationTokenSource(); + } + return this._backgroundAnalysisCancellationSource.token; + } + + protected runAnalysis() { + // This creates a cancellation source only if it actually gets used. + const moreToAnalyze = this._backgroundAnalysisProgram.startAnalysis(this.getCancellationToken()); + if (moreToAnalyze) { + this._scheduleReanalysis(/* requireTrackedFileUpdate */ false); + } + } + protected applyConfigOptions(host: Host) { // Allocate a new import resolver because the old one has information // cached based on the previous config options. @@ -508,15 +524,15 @@ export class AnalyzerService { } private get _console() { - return this._options.console!; + return this.options.console!; } private get _hostFactory() { - return this._options.hostFactory!; + return this.options.hostFactory!; } private get _importResolverFactory() { - return this._options.importResolverFactory!; + return this.options.importResolverFactory!; } private get _program() { @@ -534,7 +550,7 @@ export class AnalyzerService { private get _watchForLibraryChanges() { return ( !!this._commandLineOptions?.languageServerSettings.watchForLibraryChanges && - !!this._options.libraryReanalysisTimeProvider + !!this.options.libraryReanalysisTimeProvider ); } @@ -1264,7 +1280,7 @@ export class AnalyzerService { } else { this._console.error(`Import '${this._typeStubTargetImportName}' not found`); } - } else if (!this._options.skipScanningUserFiles) { + } else if (!this.options.skipScanningUserFiles) { let fileList: Uri[] = []; this._console.log(`Searching for source files`); fileList = this._getFileNamesFromFileSpecs(); @@ -1617,8 +1633,15 @@ export class AnalyzerService { this._executionRootUri ); - const watchList = this._librarySearchUrisToWatch; - if (watchList && watchList.length > 0) { + // Make sure the watch list includes extra paths that are not part of user files. + // Sometimes, nested folders of the workspace are added as extra paths to import modules as top-level modules. + const extraPaths = this._configOptions + .getExecutionEnvironments() + .map((e) => e.extraPaths.filter((p) => !matchFileSpecs(this._configOptions, p, /* isFile */ false))) + .flat(); + + const watchList = deduplicateFolders([this._librarySearchUrisToWatch, extraPaths]); + if (watchList.length > 0) { try { if (this._verboseOutput) { this._console.info(`Adding fs watcher for library directories:\n ${watchList.join('\n')}`); @@ -1695,7 +1718,7 @@ export class AnalyzerService { this._libraryReanalysisTimer = undefined; const handled = this._backgroundAnalysisProgram?.libraryUpdated(); - this._options.libraryReanalysisTimeProvider?.libraryUpdated?.(handled); + this.options.libraryReanalysisTimeProvider?.libraryUpdated?.(handled); } } @@ -1707,7 +1730,7 @@ export class AnalyzerService { this._clearLibraryReanalysisTimer(); - const reanalysisTimeProvider = this._options.libraryReanalysisTimeProvider; + const reanalysisTimeProvider = this.options.libraryReanalysisTimeProvider; const backOffTimeInMS = reanalysisTimeProvider?.(); if (!backOffTimeInMS) { // We don't support library reanalysis. @@ -1863,14 +1886,9 @@ export class AnalyzerService { this._updateTrackedFileList(/* markFilesDirtyUnconditionally */ false); } - // This creates a cancellation source only if it actually gets used. - this._backgroundAnalysisCancellationSource = this.cancellationProvider.createCancellationTokenSource(); - const moreToAnalyze = this._backgroundAnalysisProgram.startAnalysis( - this._backgroundAnalysisCancellationSource.token - ); - if (moreToAnalyze) { - this._scheduleReanalysis(/* requireTrackedFileUpdate */ false); - } + // Now that the timer has fired, actually send the message to the BG thread to + // start the analysis. + this.runAnalysis(); }, timeUntilNextAnalysisInMs); } @@ -1884,6 +1902,7 @@ export class AnalyzerService { fatalErrorOccurred: false, configParseErrorOccurred: true, elapsedTime: 0, + reason: 'analysis', }); } } diff --git a/packages/pyright-internal/src/backgroundAnalysisBase.ts b/packages/pyright-internal/src/backgroundAnalysisBase.ts index 9bd3d49fb..a2631d124 100644 --- a/packages/pyright-internal/src/backgroundAnalysisBase.ts +++ b/packages/pyright-internal/src/backgroundAnalysisBase.ts @@ -16,7 +16,7 @@ import { analyzeProgram, nullCallback, } from './analyzer/analysis'; -import { BackgroundAnalysisProgram, InvalidatedReason } from './analyzer/backgroundAnalysisProgram'; +import { InvalidatedReason } from './analyzer/backgroundAnalysisProgram'; import { ImportResolver } from './analyzer/importResolver'; import { OpenFileOptions, Program } from './analyzer/program'; import { @@ -44,13 +44,36 @@ import { LogTracker } from './common/logTracker'; import { ServiceProvider } from './common/serviceProvider'; import { Range } from './common/textRange'; import { Uri } from './common/uri/uri'; +import { ProgramView } from './common/extensibility'; export class BackgroundAnalysisBase { private _worker: Worker | undefined; private _onAnalysisCompletion: AnalysisCompleteCallback = nullCallback; + private _analysisCancellationToken: CancellationToken | undefined = undefined; + private _messageChannel: MessageChannel; + protected program: ProgramView | undefined; protected constructor(protected console: ConsoleInterface) { // Don't allow instantiation of this type directly. + + // Create a message channel for handling 'analysis' or 'background' type results. + // The other side of this channel will be sent to the BG thread for sending responses. + this._messageChannel = new MessageChannel(); + this._messageChannel.port1.on('message', (msg: BackgroundResponse) => this.handleBackgroundResponse(msg)); + } + + dispose() { + if (this._messageChannel) { + this._messageChannel.port1.close(); + this._messageChannel.port2.close(); + } + if (this._worker) { + this._worker.terminate(); + } + } + + setProgramView(programView: Program) { + this.program = programView; } setCompletionCallback(callback?: AnalysisCompleteCallback) { @@ -110,8 +133,12 @@ export class BackgroundAnalysisBase { }); } - startAnalysis(program: BackgroundAnalysisProgram, token: CancellationToken) { - this._startOrResumeAnalysis('analyze', program, token); + startAnalysis(token: CancellationToken) { + this._analysisCancellationToken = token; + this.enqueueRequest({ + requestType: 'analyze', + data: serialize(token), + }); } async analyzeFile(fileUri: Uri, token: CancellationToken): Promise { @@ -194,23 +221,29 @@ export class BackgroundAnalysisBase { } shutdown(): void { - this.enqueueRequest({ requestType: 'shutdown', data: null }); + if (this._worker) { + this.enqueueRequest({ requestType: 'shutdown', data: null }); + } } protected setup(worker: Worker) { this._worker = worker; // global channel to communicate from BG channel to main thread. - worker.on('message', (msg: AnalysisResponse) => this.onMessage(msg)); + worker.on('message', (msg: BackgroundResponse) => this.onMessage(msg)); // this will catch any exception thrown from background thread, // print log and ignore exception worker.on('error', (msg) => { this.log(LogLevel.Error, `Error occurred on background thread: ${JSON.stringify(msg)}`); }); + + // Send the port to the other side for use in sending responses. It can only be sent once cause after it's transferred + // it's not usable anymore. + this.enqueueRequest({ requestType: 'start', data: '', port: this._messageChannel.port2 }); } - protected onMessage(msg: AnalysisResponse) { + protected onMessage(msg: BackgroundResponse) { switch (msg.requestType) { case 'log': { const logData = deserialize(msg.data); @@ -230,7 +263,7 @@ export class BackgroundAnalysisBase { } } - protected enqueueRequest(request: AnalysisRequest) { + protected enqueueRequest(request: BackgroundRequest) { if (this._worker) { this._worker.postMessage(request, request.port ? [request.port] : undefined); } @@ -240,13 +273,7 @@ export class BackgroundAnalysisBase { log(this.console, level, msg); } - protected handleAnalysisResponse( - msg: AnalysisResponse, - program: BackgroundAnalysisProgram, - port1: MessagePort, - port2: MessagePort, - token: CancellationToken - ) { + protected handleBackgroundResponse(msg: BackgroundResponse) { switch (msg.requestType) { case 'analysisResult': { this._onAnalysisCompletion(convertAnalysisResults(deserialize(msg.data))); @@ -254,19 +281,20 @@ export class BackgroundAnalysisBase { } case 'analysisPaused': { - port2.close(); - port1.close(); - // Analysis request has completed, but there is more to // analyze, so queue another message to resume later. - this._startOrResumeAnalysis('resumeAnalysis', program, token); + this.enqueueRequest({ + requestType: 'resumeAnalysis', + data: serialize(this._analysisCancellationToken), + }); break; } case 'analysisDone': { - disposeCancellationToken(token); - port2.close(); - port1.close(); + if (this._analysisCancellationToken) { + disposeCancellationToken(this._analysisCancellationToken); + } + this._analysisCancellationToken = undefined; break; } @@ -274,26 +302,12 @@ export class BackgroundAnalysisBase { debug.fail(`${msg.requestType} is not expected. Message structure: ${JSON.stringify(msg)}`); } } - - private _startOrResumeAnalysis( - requestType: 'analyze' | 'resumeAnalysis', - program: BackgroundAnalysisProgram, - token: CancellationToken - ) { - const { port1, port2 } = new MessageChannel(); - - // Handle response from background thread to main thread. - port1.on('message', (msg: AnalysisResponse) => this.handleAnalysisResponse(msg, program, port1, port2, token)); - - const cancellationId = getCancellationTokenId(token); - this.enqueueRequest({ requestType, data: serialize(cancellationId), port: port2 }); - } } export abstract class BackgroundAnalysisRunnerBase extends BackgroundThreadBase { private _configOptions: ConfigOptions; private _program: Program; - + private _responsePort: MessagePort | undefined; protected importResolver: ImportResolver; protected logTracker: LogTracker; protected isCaseSensitive = true; @@ -324,6 +338,11 @@ export abstract class BackgroundAnalysisRunnerBase extends BackgroundThreadBase return this._program; } + get responsePort(): MessagePort { + debug.assert(this._responsePort !== undefined, 'BG thread was not started properly. No response port'); + return this._responsePort!; + } + start() { this.log(LogLevel.Info, `Background analysis(${threadId}) started`); @@ -337,27 +356,28 @@ export abstract class BackgroundAnalysisRunnerBase extends BackgroundThreadBase }); } - protected onMessage(msg: AnalysisRequest) { + protected onMessage(msg: BackgroundRequest) { switch (msg.requestType) { + case 'start': { + // Take ownership of the port for sending responses. This should + // have been provided in the 'start' message. + this._responsePort = msg.port!; + break; + } case 'cacheUsageBuffer': { this.serviceProvider.cacheManager()?.handleCachedUsageBufferMessage(msg); break; } - case 'analyze': { - const port = msg.port!; - const data = deserialize(msg.data); - const token = getCancellationTokenFromId(data); - this.handleAnalyze(port, data, token); + case 'analyze': { + const token = deserialize(msg.data); + this.handleAnalyze(this.responsePort, token); break; } case 'resumeAnalysis': { - const port = msg.port!; - const data = deserialize(msg.data); - const token = getCancellationTokenFromId(data); - - this.handleResumeAnalysis(port, data, token); + const token = deserialize(msg.data); + this.handleResumeAnalysis(this.responsePort, token); break; } @@ -484,7 +504,7 @@ export abstract class BackgroundAnalysisRunnerBase extends BackgroundThreadBase host: Host ): ImportResolver; - protected handleAnalyze(port: MessagePort, cancellationId: string, token: CancellationToken) { + protected handleAnalyze(port: MessagePort, token: CancellationToken) { // Report files to analyze first. const requiringAnalysisCount = this.program.getFilesToAnalyzeCount(); @@ -496,12 +516,13 @@ export abstract class BackgroundAnalysisRunnerBase extends BackgroundThreadBase fatalErrorOccurred: false, configParseErrorOccurred: false, elapsedTime: 0, + reason: 'analysis', }); - this.handleResumeAnalysis(port, cancellationId, token); + this.handleResumeAnalysis(port, token); } - protected handleResumeAnalysis(port: MessagePort, cancellationId: string, token: CancellationToken) { + protected handleResumeAnalysis(port: MessagePort, token: CancellationToken) { // Report results at the interval of the max analysis time. const maxTime = { openFilesTimeInMs: 50, noOpenFilesTimeInMs: 200 }; const moreToAnalyze = analyzeProgram( @@ -517,9 +538,9 @@ export abstract class BackgroundAnalysisRunnerBase extends BackgroundThreadBase // There's more to analyze after we exceeded max time, // so report that we are paused. The foreground thread will // then queue up a message to resume the analysis. - this._analysisPaused(port, cancellationId); + this._analysisPaused(port, token); } else { - this.analysisDone(port, cancellationId); + this.analysisDone(port, token); } } @@ -653,8 +674,8 @@ export abstract class BackgroundAnalysisRunnerBase extends BackgroundThreadBase super.handleShutdown(); } - protected analysisDone(port: MessagePort, cancellationId: string) { - port.postMessage({ requestType: 'analysisDone', data: cancellationId }); + protected analysisDone(port: MessagePort, token: CancellationToken) { + port.postMessage({ requestType: 'analysisDone', data: serialize(token) }); } protected onAnalysisCompletion(port: MessagePort, result: AnalysisResults) { @@ -665,7 +686,7 @@ export abstract class BackgroundAnalysisRunnerBase extends BackgroundThreadBase port.postMessage({ requestType: 'analysisResult', data: serialize(result) }); } - private _onMessageWrapper(msg: AnalysisRequest) { + private _onMessageWrapper(msg: BackgroundRequest) { try { return this.onMessage(msg); } catch (e: any) { @@ -698,12 +719,13 @@ export abstract class BackgroundAnalysisRunnerBase extends BackgroundThreadBase fatalErrorOccurred: false, configParseErrorOccurred: false, elapsedTime, + reason: 'tracking', }); } } - private _analysisPaused(port: MessagePort, cancellationId: string) { - port.postMessage({ requestType: 'analysisPaused', data: cancellationId }); + private _analysisPaused(port: MessagePort, token: CancellationToken) { + port.postMessage({ requestType: 'analysisPaused', data: serialize(token) }); } } @@ -744,7 +766,8 @@ function convertDiagnostics(diagnostics: Diagnostic[]) { }); } -export type AnalysisRequestKind = +export type BackgroundRequestKind = + | 'start' | 'analyze' | 'resumeAnalysis' | 'setConfigOptions' @@ -766,17 +789,17 @@ export type AnalysisRequestKind = | 'analyzeFile' | 'cacheUsageBuffer'; -export interface AnalysisRequest { - requestType: AnalysisRequestKind; +export interface BackgroundRequest { + requestType: BackgroundRequestKind; data: string | null; port?: MessagePort | undefined; sharedUsageBuffer?: SharedArrayBuffer; } -export type AnalysisResponseKind = 'log' | 'analysisResult' | 'analysisPaused' | 'analysisDone'; +export type BackgroundResponseKind = 'log' | 'analysisResult' | 'analysisPaused' | 'analysisDone'; -export interface AnalysisResponse { - requestType: AnalysisResponseKind; +export interface BackgroundResponse { + requestType: BackgroundResponseKind; data: string | null; } diff --git a/packages/pyright-internal/src/backgroundThreadBase.ts b/packages/pyright-internal/src/backgroundThreadBase.ts index 5246031d3..814c5f158 100644 --- a/packages/pyright-internal/src/backgroundThreadBase.ts +++ b/packages/pyright-internal/src/backgroundThreadBase.ts @@ -9,7 +9,11 @@ import { MessagePort, parentPort, TransferListItem } from 'worker_threads'; import { CacheManager } from './analyzer/cacheManager'; -import { OperationCanceledException, setCancellationFolderName } from './common/cancellationUtils'; +import { + getCancellationTokenId, + OperationCanceledException, + setCancellationFolderName, +} from './common/cancellationUtils'; import { ConfigOptions } from './common/configOptions'; import { ConsoleInterface, LogLevel } from './common/console'; import { Disposable, isThenable } from './common/core'; @@ -19,6 +23,8 @@ import { ServiceKeys } from './common/serviceKeys'; import { ServiceProvider } from './common/serviceProvider'; import './common/serviceProviderExtensions'; import { Uri } from './common/uri/uri'; +import { CancellationToken } from 'vscode-jsonrpc'; +import { getCancellationTokenFromId } from './common/fileBasedCancellationUtils'; export class BackgroundConsole implements ConsoleInterface { private _level = LogLevel.Log; @@ -136,6 +142,9 @@ export function serializeReplacer(value: any) { const entries = Object.entries(value); return { __serialized_config_options: entries.reduce((obj, e, i) => ({ ...obj, [e[0]]: e[1] }), {}) }; } + if (CancellationToken.is(value)) { + return { cancellation_token_val: getCancellationTokenId(value) ?? null }; + } return value; } @@ -164,6 +173,9 @@ export function deserializeReviver(value: any) { Object.assign(configOptions, value.__serialized_config_options); return configOptions; } + if (Object.keys(value).includes('cancellation_token_val')) { + return getCancellationTokenFromId(value.cancellation_token_val); + } } return value; } diff --git a/packages/pyright-internal/src/common/languageServerInterface.ts b/packages/pyright-internal/src/common/languageServerInterface.ts index 705175991..24937d810 100644 --- a/packages/pyright-internal/src/common/languageServerInterface.ts +++ b/packages/pyright-internal/src/common/languageServerInterface.ts @@ -135,7 +135,7 @@ export interface LanguageServerBaseInterface { } export interface LanguageServerInterface extends LanguageServerBaseInterface { - getWorkspaceForFile(fileUri: Uri): Promise; + getWorkspaceForFile(fileUri: Uri, pythonPath?: Uri): Promise; } export interface WindowService extends WindowInterface { diff --git a/packages/pyright-internal/src/common/uri/uriUtils.ts b/packages/pyright-internal/src/common/uri/uriUtils.ts index 4588e8103..e92382825 100644 --- a/packages/pyright-internal/src/common/uri/uriUtils.ts +++ b/packages/pyright-internal/src/common/uri/uriUtils.ts @@ -335,7 +335,7 @@ export function getDirectoryChangeKind( return 'Moved'; } -export function deduplicateFolders(listOfFolders: Uri[][]): Uri[] { +export function deduplicateFolders(listOfFolders: Uri[][], excludes: Uri[] = []): Uri[] { const foldersToWatch = new Map(); listOfFolders.forEach((folders) => { @@ -345,6 +345,12 @@ export function deduplicateFolders(listOfFolders: Uri[][]): Uri[] { return; } + for (const exclude of excludes) { + if (p.startsWith(exclude)) { + return; + } + } + for (const existing of foldersToWatch) { // ex) p: "/user/test" existing: "/user" if (p.startsWith(existing[1])) { diff --git a/packages/pyright-internal/src/languageServerBase.ts b/packages/pyright-internal/src/languageServerBase.ts index 8b8609f84..1de47a412 100644 --- a/packages/pyright-internal/src/languageServerBase.ts +++ b/packages/pyright-internal/src/languageServerBase.ts @@ -122,13 +122,7 @@ import { SignatureHelpProvider } from './languageService/signatureHelpProvider'; import { WorkspaceSymbolProvider } from './languageService/workspaceSymbolProvider'; import { Localizer, setLocaleOverride } from './localization/localize'; import { ParseFileResults } from './parser/parser'; -import { - InitStatus, - IWorkspaceFactory, - WellKnownWorkspaceKinds, - Workspace, - WorkspaceFactory, -} from './workspaceFactory'; +import { InitStatus, WellKnownWorkspaceKinds, Workspace, WorkspaceFactory } from './workspaceFactory'; export abstract class LanguageServerBase implements LanguageServerInterface, Disposable { // We support running only one "find all reference" at a time. @@ -170,7 +164,7 @@ export abstract class LanguageServerBase implements LanguageServerInterface, Dis protected defaultClientConfig: any; - protected readonly workspaceFactory: IWorkspaceFactory; + protected readonly workspaceFactory: WorkspaceFactory; protected readonly openFileMap = new Map(); protected readonly fs: FileSystem; protected readonly caseSensitiveDetector: CaseSensitivityDetector; @@ -334,12 +328,6 @@ export abstract class LanguageServerBase implements LanguageServerInterface, Dis // Set logging level first. (this.console as ConsoleWithLogLevel).level = serverSettings.logLevel ?? LogLevel.Info; - // Apply the new path to the workspace (before restarting the service). - serverSettings.pythonPath = this.workspaceFactory.applyPythonPath( - workspace, - serverSettings.pythonPath ? serverSettings.pythonPath : undefined - ); - this.dynamicFeatures.update(serverSettings); // Then use the updated settings to restart the service. @@ -361,7 +349,7 @@ export abstract class LanguageServerBase implements LanguageServerInterface, Dis serverSettings: ServerSettings, typeStubTargetImportName?: string ) { - AnalyzerServiceExecutor.runWithOptions(workspace, serverSettings, typeStubTargetImportName); + AnalyzerServiceExecutor.runWithOptions(workspace, serverSettings, { typeStubTargetImportName }); workspace.searchPathsToWatch = workspace.service.librarySearchUrisToWatch ?? []; } diff --git a/packages/pyright-internal/src/languageService/analyzerServiceExecutor.ts b/packages/pyright-internal/src/languageService/analyzerServiceExecutor.ts index aaad5f895..0bd96b706 100644 --- a/packages/pyright-internal/src/languageService/analyzerServiceExecutor.ts +++ b/packages/pyright-internal/src/languageService/analyzerServiceExecutor.ts @@ -24,19 +24,20 @@ export interface CloneOptions { fileSystem?: FileSystem; } +export interface RunOptions { + typeStubTargetImportName?: string; + trackFiles?: boolean; + pythonEnvironmentName?: string; +} + export class AnalyzerServiceExecutor { - static runWithOptions( - workspace: Workspace, - serverSettings: ServerSettings, - typeStubTargetImportName?: string, - trackFiles = true - ): void { + static runWithOptions(workspace: Workspace, serverSettings: ServerSettings, options?: RunOptions): void { const commandLineOptions = getEffectiveCommandLineOptions( workspace.rootUri, serverSettings, - trackFiles, - typeStubTargetImportName, - workspace.pythonEnvironmentName + options?.trackFiles ?? true, + options?.typeStubTargetImportName, + options?.pythonEnvironmentName ); // Setting options causes the analyzer service to re-analyze everything. @@ -58,8 +59,6 @@ export class AnalyzerServiceExecutor { ...workspace, workspaceName: `temp workspace for cloned service`, rootUri: workspace.rootUri, - pythonPath: workspace.pythonPath, - pythonPathKind: workspace.pythonPathKind, kinds: [...workspace.kinds, WellKnownWorkspaceKinds.Cloned], service: workspace.service.clone( instanceName, @@ -76,12 +75,10 @@ export class AnalyzerServiceExecutor { }; const serverSettings = await ls.getSettings(workspace); - AnalyzerServiceExecutor.runWithOptions( - tempWorkspace, - serverSettings, - options.typeStubTargetImportName, - /* trackFiles */ false - ); + AnalyzerServiceExecutor.runWithOptions(tempWorkspace, serverSettings, { + typeStubTargetImportName: options.typeStubTargetImportName, + trackFiles: false, + }); return tempWorkspace.service; } diff --git a/packages/pyright-internal/src/languageService/fileWatcherDynamicFeature.ts b/packages/pyright-internal/src/languageService/fileWatcherDynamicFeature.ts index 443d05da5..46ea339d7 100644 --- a/packages/pyright-internal/src/languageService/fileWatcherDynamicFeature.ts +++ b/packages/pyright-internal/src/languageService/fileWatcherDynamicFeature.ts @@ -14,9 +14,10 @@ import { } from 'vscode-languageserver'; import { FileSystem } from '../common/fileSystem'; import { deduplicateFolders, isFile } from '../common/uri/uriUtils'; -import { IWorkspaceFactory } from '../workspaceFactory'; import { DynamicFeature } from './dynamicFeature'; import { configFileName } from '../analyzer/serviceUtils'; +import { Workspace } from '../workspaceFactory'; +import { isDefined } from '../common/core'; export class FileWatcherDynamicFeature extends DynamicFeature { constructor( @@ -42,10 +43,21 @@ export class FileWatcherDynamicFeature extends DynamicFeature { // Dedup search paths from all workspaces. // Get rid of any search path under workspace root since it is already watched by // "**" above. + const searchPaths = this._workspaceFactory.getNonDefaultWorkspaces().map((w) => [ + ...w.searchPathsToWatch, + ...w.service + .getConfigOptions() + .getExecutionEnvironments() + .map((e) => e.extraPaths) + .flat(), + ]); + const foldersToWatch = deduplicateFolders( + searchPaths, this._workspaceFactory .getNonDefaultWorkspaces() - .map((w) => w.searchPathsToWatch.filter((p) => !p.startsWith(w.rootUri))) + .map((w) => w.rootUri) + .filter(isDefined) ); foldersToWatch.forEach((p) => { @@ -60,3 +72,7 @@ export class FileWatcherDynamicFeature extends DynamicFeature { return this._connection.client.register(DidChangeWatchedFilesNotification.type, { watchers }); } } + +interface IWorkspaceFactory { + getNonDefaultWorkspaces(kind?: string): Workspace[]; +} diff --git a/packages/pyright-internal/src/localization/package.nls.cs.json b/packages/pyright-internal/src/localization/package.nls.cs.json index 10400bd2e..260ce5a6b 100644 --- a/packages/pyright-internal/src/localization/package.nls.cs.json +++ b/packages/pyright-internal/src/localization/package.nls.cs.json @@ -1,7 +1,7 @@ { "CodeAction": { - "createTypeStub": "Vytvořit zástupná procedura typu", - "createTypeStubFor": "Vytvořit zástupnou proceduru typu pro modul {moduleName}", + "createTypeStub": "Vytvořit zástupnou proceduru (Stub) typu", + "createTypeStubFor": "Vytvořit zástupnou proceduru typu (Stub) pro modul {moduleName}", "executingCommand": "Spouští se příkaz", "filesToAnalyzeCount": "Počet souborů k analýze: {count}", "filesToAnalyzeOne": "1 soubor k analýze", @@ -18,12 +18,12 @@ "annotatedMetadataInconsistent": "Typ metadat s poznámkami „{metadataType}“ není kompatibilní s typem „{type}“.", "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": "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)", + "annotationBytesString": "Výrazy typu nemůžou používat řetězcové literály bajtů.", + "annotationFormatString": "Výrazy 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": "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", + "annotationRawString": "Výrazy typu nemůžou používat literály nezpracovaného řetězce.", + "annotationSpansStrings": "Výrazy typu nemůžou zahrnovat více řetězcových literálů.", + "annotationStringEscape": "Výrazy typu nemůžou obsahovat řídicí znaky.", "argAssignment": "Argument typu {argType} není možné přiřadit k parametru typu {paramType}", "argAssignmentFunction": "Argument typu {argType} není možné přiřadit k parametru typu {paramType} ve funkci {functionName}", "argAssignmentParam": "Argument typu {argType} není možné přiřadit k parametru {paramName} typu {paramType}", @@ -47,7 +47,7 @@ "assignmentTargetExpr": "Výraz nemůže být cílem přiřazení", "asyncNotInAsyncFunction": "Použití „async“ není povolené mimo funkci async", "awaitIllegal": "Použití operátoru await vyžaduje Python 3.5 nebo novější", - "awaitNotAllowed": "Poznámky typu nemůžou používat „await“.", + "awaitNotAllowed": "Výrazy typu nemůžou používat výraz await.", "awaitNotInAsync": "Operátor await je povolený jenom v rámci asynchronní funkce", "backticksIllegal": "V Pythonu 3.x nejsou podporovány výrazy obklopené zpětnými tečkami; místo toho použijte repr", "baseClassCircular": "Třída se nemůže odvozovat od sebe sama", @@ -57,7 +57,7 @@ "baseClassMethodTypeIncompatible": "Základní třídy pro třídu {classType} definují metodu {name} nekompatibilním způsobem", "baseClassUnknown": "Typ základní třídy je neznámý, co zakrývá typ odvozené třídy", "baseClassVariableTypeIncompatible": "Základní třídy pro třídu {classType} definují proměnnou {name} nekompatibilním způsobem", - "binaryOperationNotAllowed": "Binární operátor není v poznámce typu povolený", + "binaryOperationNotAllowed": "Ve výrazu typu není povolený binární operátor.", "bindTypeMismatch": "Nepovedlo se vytvořit vazbu metody „{methodName}“, protože „{type}“ nejde přiřadit k parametru „{paramName}“", "breakOutsideLoop": "„break“ se dá použít jenom ve smyčce", "callableExtraArgs": "Pro Callable se očekávaly pouze dva argumenty typu", @@ -70,7 +70,7 @@ "classDefinitionCycle": "Definice třídy pro „{name}“ závisí sama na sobě", "classGetItemClsParam": "Přepsání __class_getitem__ by mělo mít parametr cls", "classMethodClsParam": "Metody třídy by měly mít parametr „cls“", - "classNotRuntimeSubscriptable": "Dolní index pro třídu {name} vygeneruje výjimku modulu runtime; anotaci typu uzavřete do uvozovek", + "classNotRuntimeSubscriptable": "Dolní index pro třídu {name} vygeneruje výjimku modulu runtime; výraz typu uzavřete do uvozovek.", "classPatternBuiltInArgPositional": "Vzor třídy přijímá pouze poziční dílčí vzor", "classPatternPositionalArgCount": "Příliš mnoho pozičních vzorů pro třídu \"{type}\"; očekávalo se {expected}, ale přijalo se {received}", "classPatternTypeAlias": "Typ „{type}“ nelze použít ve vzorci třídy, protože se jedná o specializovaný alias typu", @@ -87,7 +87,7 @@ "comparisonAlwaysFalse": "Podmínka se vždy vyhodnotí jako False, protože typy {leftType} a {rightType} se nepřekrývají", "comparisonAlwaysTrue": "Podmínka se vždy vyhodnotí jako True, protože typy {leftType} a {rightType} se nepřekrývají", "comprehensionInDict": "Porozumění není možné použít s jinými položkami slovníku", - "comprehensionInSet": "Porozumění nelze použít s jinými položkami sady", + "comprehensionInSet": "Porozumění nelze použít s jinými položkami sady (set).", "concatenateContext": "Možnost „Concatenate“ není v tomto kontextu povolená.", "concatenateParamSpecMissing": "Poslední argument typu pro „Concatenate“ musí být „ParamSpec“ nebo „...“", "concatenateTypeArgsMissing": "Možnost „Concatenate“ vyžaduje alespoň dva argumenty typu", @@ -111,7 +111,7 @@ "dataClassPostInitType": "Neshoda typu parametru metody __post_init__ datové třídy pro pole {fieldName}", "dataClassSlotsOverwrite": "__slots__ je už ve třídě definovaný", "dataClassTransformExpectedBoolLiteral": "Očekával se výraz, který se staticky vyhodnotí jako True nebo False", - "dataClassTransformFieldSpecifier": "Očekávala se řazená kolekce členů tříd nebo funkcí, ale přijatý typ „{type}“", + "dataClassTransformFieldSpecifier": "Očekávala se řazená kolekce členů (tuple) tříd nebo funkcí, ale byl přijat typ „{type}“.", "dataClassTransformPositionalParam": "Všechny argumenty dataclass_transform musí být argumenty klíčových slov", "dataClassTransformUnknownArgument": "Argument {name} není v dataclass_transform podporován", "dataProtocolInSubclassCheck": "Datové protokoly (které zahrnují atributy bez metody) nejsou ve voláních issubclass povolené.", @@ -127,12 +127,12 @@ "deprecatedDescriptorSetter": "Metoda „__set__“ pro popisovač „{name}“ je zastaralá", "deprecatedFunction": "Funkce {name} je zastaralá.", "deprecatedMethod": "Metoda {name} ve třídě {className} je zastaralá.", - "deprecatedPropertyDeleter": "Odstraňovač pro vlastnost „{name}“ je zastaralý", - "deprecatedPropertyGetter": "Metoda getter pro vlastnost „{name}“ je zastaralá", - "deprecatedPropertySetter": "Metoda setter pro vlastnost „{name}“ je zastaralá", + "deprecatedPropertyDeleter": "Metoda deleter pro property „{name}“ je zastaralá.", + "deprecatedPropertyGetter": "Metoda getter pro property „{name}“ je zastaralá.", + "deprecatedPropertySetter": "Metoda setter pro property „{name}“ je zastaralá.", "deprecatedType": "Tento typ je zastaralý jako Python {version}; místo toho použijte {replacement}", "dictExpandIllegalInComprehension": "Rozšíření slovníku není v porozumění povoleno", - "dictInAnnotation": "Výraz slovníku není v poznámce typu povolený", + "dictInAnnotation": "Výraz slovníku není ve výrazu typu povolený.", "dictKeyValuePairs": "Položky slovníku musí obsahovat páry klíč/hodnota", "dictUnpackIsNotMapping": "Očekávalo se mapování pro operátor rozbalení slovníku", "dunderAllSymbolNotPresent": "{name} je zadáno v __all__, ale v modulu se nenachází", @@ -140,8 +140,8 @@ "duplicateBaseClass": "Duplicitní základní třída není povolena", "duplicateCapturePatternTarget": "Cíl zachytávání {name} se v rámci stejného vzoru nemůže vyskytovat více než jednou", "duplicateCatchAll": "Je povolena pouze jedna klauzule catch-all except", - "duplicateEnumMember": "Člen výčtu {name} je už deklarovaný", - "duplicateGenericAndProtocolBase": "Je povolena pouze jedna základní třída Generic nebo Protocol**", + "duplicateEnumMember": "Člen Enum {name} je už deklarovaný.", + "duplicateGenericAndProtocolBase": "Je povolena pouze jedna základní třída Generic[...] nebo Protocol[...].", "duplicateImport": "Import {importName} je importován více než jednou", "duplicateKeywordOnly": "Je povolený jenom jeden oddělovač *", "duplicateKwargsParam": "Je povolený jenom jeden parametr **", @@ -149,14 +149,14 @@ "duplicatePositionOnly": "Je povolený jenom jeden parametr „/“", "duplicateStarPattern": "V sekvenci vzorů je povolený jenom jeden vzor „*“", "duplicateStarStarPattern": "Je povolena pouze jedna položka „**“", - "duplicateUnpack": "V seznamu je povolena pouze jedna operace rozbalení", - "ellipsisAfterUnpacked": "„…“ nelze použít s rozbalenou kolekcí TypeVarTuple nebo řazenou kolekcí členů.", + "duplicateUnpack": "V seznamu (list) je povolena pouze jedna operace rozbalení.", + "ellipsisAfterUnpacked": "„…“ nelze použít s rozbalenou kolekcí TypeVarTuple nebo tuple.", "ellipsisContext": "„...“ se v tomto kontextu nepovoluje", "ellipsisSecondArg": "„...“ je povoleno pouze jako druhý ze dvou argumentů", - "enumClassOverride": "Třída výčtu {name} je konečná a nemůže být podtřídou", - "enumMemberDelete": "Člen výčtu {name} se nedá odstranit.", - "enumMemberSet": "Člen výčtu {name} se nedá přiřadit.", - "enumMemberTypeAnnotation": "Poznámky typu nejsou pro členy výčtu povolené", + "enumClassOverride": "Třída Enum {name} je final a nemůže být podtřídou.", + "enumMemberDelete": "Člen Enum {name} se nedá odstranit.", + "enumMemberSet": "Člen Enum {name} se nedá přiřadit.", + "enumMemberTypeAnnotation": "Poznámky typu nejsou pro členy enum povolené.", "exceptionGroupIncompatible": "Syntaxe skupiny výjimek (\"except*\") vyžaduje Python 3.11 nebo novější", "exceptionGroupTypeIncorrect": "Typ výjimky v except* se nedá odvodit z BaseGroupException.", "exceptionTypeIncorrect": "„{type}“ se neodvozuje od BaseException", @@ -189,7 +189,7 @@ "expectedIdentifier": "Očekávaný identifikátor", "expectedImport": "Očekával se import", "expectedImportAlias": "Za as byl očekáván symbol", - "expectedImportSymbols": "Po importu se očekával jeden nebo více názvů symbolů", + "expectedImportSymbols": "Po možnosti import se očekával jeden nebo více názvů symbolů.", "expectedIn": "Očekávalo se in", "expectedInExpr": "Za in byl očekáván výraz", "expectedIndentedBlock": "Očekával se odsazený blok", @@ -209,16 +209,16 @@ "expectedTypeNotString": "Očekával se typ, ale přijal se řetězcový literál", "expectedTypeParameterName": "Očekávaný název parametru typu", "expectedYieldExpr": "Očekávaný výraz v příkazu yield", - "finalClassIsAbstract": "Třída „{type}“ je označená jako konečná a musí implementovat všechny abstraktní symboly", + "finalClassIsAbstract": "Třída „{type}“ je označena jako final a musí implementovat všechny abstraktní symboly.", "finalContext": "Final se v tomto kontextu nepovoluje", "finalInLoop": "Proměnnou Final nelze přiřadit ve smyčce.", - "finalMethodOverride": "Metoda {name} nemůže přepsat konečnou metodu definovanou ve třídě {className}", + "finalMethodOverride": "Metoda {name} nemůže přepsat metodu final definovanou ve třídě {className}.", "finalNonMethod": "Funkci „{name}“ nelze označit @final, protože se nejedná o metodu.", "finalReassigned": "„{name}“ se deklaruje jako Final a nedá se znovu přiřadit", "finalRedeclaration": "{name} se dříve deklarovalo jako Final", - "finalRedeclarationBySubclass": "{name} se nedá deklarovat znovu, protože nadřazená třída {className} ji deklaruje jako final", + "finalRedeclarationBySubclass": "{name} se nedá deklarovat znovu, protože nadřazená třída {className} ji deklaruje jako Final.", "finalTooManyArgs": "Za Final byl očekáván jeden argument typu", - "finalUnassigned": "{name} se deklaruje jako final, ale hodnota není přiřazená", + "finalUnassigned": "{name} se deklaruje jako Final, ale hodnota není přiřazená.", "formatStringBrace": "Jednoduchá pravá složená závorka není v literálu f-string povolena. použijte dvojitou pravou složenou závorku", "formatStringBytes": "Formátovací řetězcové literály (f-strings) nemůžou být binární", "formatStringDebuggingIllegal": "Specifikátor ladění F-string „=“ vyžaduje Python 3.8 nebo novější", @@ -246,8 +246,8 @@ "genericTypeArgMissing": "Generic vyžaduje alespoň jeden argument typu", "genericTypeArgTypeVar": "Argument typu pro Generic musí být proměnná typu", "genericTypeArgUnique": "Argumenty typu pro Generic musí být jedinečné", - "globalReassignment": "{name} je přiřazen před globální deklarací", - "globalRedefinition": "Název {name} už je deklarován jako globální", + "globalReassignment": "{name} je přiřazen před deklarací global.", + "globalRedefinition": "Název {name} už je deklarován jako global.", "implicitStringConcat": "Implicitní zřetězení řetězců není povolené", "importCycleDetected": "V řetězci importu byl zjištěn cyklus", "importDepthExceeded": "Hloubka řetězu importu překročila {depth}", @@ -265,16 +265,16 @@ "instanceMethodSelfParam": "Metody instance by měly mít parametr self", "instanceVarOverridesClassVar": "Proměnná instance „{name}“ přepíše proměnnou třídy se stejným názvem ve třídě „{className}“", "instantiateAbstract": "Nelze vytvořit instanci abstraktní třídy „{type}“", - "instantiateProtocol": "Nelze vytvořit instanci třídy protokolu „{type}“", + "instantiateProtocol": "Nelze vytvořit instanci třídy Protocol „{type}“.", "internalBindError": "Při vytváření vazby souboru {file} došlo k vnitřní chybě: {message}", "internalParseError": "Při analýze souboru {file} došlo k vnitřní chybě: {message}", "internalTypeCheckingError": "Při kontrole typu souboru {file} došlo k vnitřní chybě: {message}", "invalidIdentifierChar": "Neplatný znak v identifikátoru", - "invalidStubStatement": "Příkaz je v souboru zástupné procedury typu bezvýznamný", + "invalidStubStatement": "Příkaz je v souboru zástupné procedury (stub) typu bezvýznamný.", "invalidTokenChars": "Neplatný znak „{text}“ v tokenu", - "isInstanceInvalidType": "Druhý argument pro „isinstance“ musí být třída nebo řazená kolekce členů tříd", - "isSubclassInvalidType": "Druhý argument pro issubclass musí být třída nebo řazená kolekce členů tříd", - "keyValueInSet": "Páry klíč-hodnota nejsou v rámci sady povoleny", + "isInstanceInvalidType": "Druhý argument pro „isinstance“ musí být třída nebo řazená kolekce členů (tuple) tříd.", + "isSubclassInvalidType": "Druhý argument pro issubclass musí být třída nebo řazená kolekce členů (tuple) tříd.", + "keyValueInSet": "Páry klíč-hodnota nejsou v rámci sady (set) povoleny.", "keywordArgInTypeArgument": "Argumenty klíčových slov nelze použít v seznamech argumentů typu", "keywordArgShortcutIllegal": "Zástupce argumentu klíčového slova vyžaduje Python 3.14 nebo novější.", "keywordOnlyAfterArgs": "Oddělovač argumentů jen pro klíčová slova není povolený za parametrem *", @@ -283,12 +283,12 @@ "lambdaReturnTypePartiallyUnknown": "Návratový typ lambda {returnType} je částečně neznámý", "lambdaReturnTypeUnknown": "Návratový typ výrazu lambda je neznámý", "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": "Pojmenované řídicí sekvence Unicode nejsou v řetězcových poznámkách literálů podporovány.", + "listInAnnotation": "Výraz List není ve výrazu typu povolený.", + "literalEmptyArgs": "Za literálem (Literal) se očekával jeden nebo více argumentů typu.", + "literalNamedUnicodeEscape": "Pojmenované řídicí sekvence Unicode nejsou v poznámkách řetězců Literal 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", + "literalNotCallable": "Není možné vytvořit instanci typu Literal.", + "literalUnsupportedType": "Argumenty typu pro Literal musí být None, hodnota literálu (int, bool, str nebo bytes) nebo hodnota enum.", "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", @@ -304,20 +304,21 @@ "methodOverridden": "„{name}“ přepisuje metodu se stejným názvem ve třídě „{className}“ s nekompatibilním typem {type}", "methodReturnsNonObject": "Metoda {name} nevrací objekt", "missingSuperCall": "Metoda {methodName} nevolá metodu se stejným názvem v nadřazené třídě", + "mixingBytesAndStr": "Hodnoty bytes a str nelze zřetězit.", "moduleAsType": "Modul nejde použít jako typ", "moduleNotCallable": "Modul není volatelný", "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é.", - "namedTupleEntryRedeclared": "{name} nejde přepsat, protože nadřazená třída {className} je pojmenovaná řazená kolekce členů.", - "namedTupleFirstArg": "Jako první argument byl očekáván název pojmenované třídy řazené kolekce členů", + "namedParamAfterParamSpecArgs": "Parametr klíčového slova {name} se nemůže objevit v signatuře za parametrem ParamSpec args.", + "namedTupleEmptyName": "Názvy v pojmenované řazené kolekci členů (tuple) nemůžou být prázdné.", + "namedTupleEntryRedeclared": "{name} nejde přepsat, protože nadřazená třída {className} je pojmenovaná řazená kolekce členů (tuple).", + "namedTupleFirstArg": "Jako první argument byl očekáván název pojmenované třídy řazené kolekce členů (tuple).", "namedTupleMultipleInheritance": "Vícenásobná dědičnost s NamedTuple se nepodporuje", "namedTupleNameKeyword": "Názvy polí nemůžou být klíčové slovo.", - "namedTupleNameType": "Očekávala se řazená kolekce členů se dvěma položkami určující název a typ položky", - "namedTupleNameUnique": "Názvy v pojmenované řazené kolekci členů musí být jedinečné", + "namedTupleNameType": "Očekávala se řazená kolekce členů (tuple) se dvěma položkami určující název a typ položky.", + "namedTupleNameUnique": "Názvy v pojmenované řazené kolekci členů (tuple) musí být jedinečné.", "namedTupleNoTypes": "namedtuple neposkytuje žádné typy pro položky řazené kolekce členů; místo toho použijte NamedTuple", - "namedTupleSecondArg": "Jako druhý argument byl očekáván pojmenovaný seznam řazené kolekce členů", + "namedTupleSecondArg": "Jako druhý argument byl očekáván pojmenovaný seznam (list) řazené kolekce členů (tuple).", "newClsParam": "Přepsání __new__ by mělo mít parametr cls", "newTypeAnyOrUnknown": "Druhý argument pro NewType musí být známá třída, nikoli Any nebo Unknown.", "newTypeBadName": "Prvním argumentem pro NewType musí být řetězcový literál", @@ -325,20 +326,20 @@ "newTypeNameMismatch": "Typ NewType musí být přiřazen proměnné se stejným názvem.", "newTypeNotAClass": "Očekávaná třída jako druhý argument pro NewType", "newTypeParamCount": "NewType vyžaduje dva poziční argumenty", - "newTypeProtocolClass": "NewType nelze použít se strukturálním typem (protokol nebo třída TypedDict).", + "newTypeProtocolClass": "NewType nelze použít se strukturálním typem (třída Protocol nebo TypedDict).", "noOverload": "Zadaným argumentům neodpovídají žádná přetížení pro {name}", - "noReturnContainsReturn": "Funkce s deklarovaným návratovým typem NoReturn nemůže obsahovat příkaz return", + "noReturnContainsReturn": "Funkce s deklarovaným návratovým typem return type NoReturn nemůže obsahovat příkaz return.", "noReturnContainsYield": "Funkce s deklarovaným návratovým typem NoReturn nemůže obsahovat příkaz yield", "noReturnReturnsNone": "Funkce s deklarovaným návratovým typem „NoReturn“ nemůže vrátit „None“.", "nonDefaultAfterDefault": "Nevýchozí argument následuje za výchozím argumentem", - "nonLocalInModule": "Nemístní deklarace není povolená na úrovni modulu", - "nonLocalNoBinding": "Nenašla se žádná vazba pro nemístní {name}", - "nonLocalReassignment": "{name} je přiřazeno před nemístní deklarací", - "nonLocalRedefinition": "{name} již bylo deklarováno jako nemístní", + "nonLocalInModule": "Deklarace Nonlocal není povolená na úrovni modulu.", + "nonLocalNoBinding": "Nenašla se žádná vazba pro nonlocal {name}.", + "nonLocalReassignment": "{name} je přiřazeno před deklarací nonlocal.", + "nonLocalRedefinition": "{name} již bylo deklarováno jako nonlocal.", "noneNotCallable": "Objekt typu „None“ nelze volat.", "noneNotIterable": "Objekt typu None není možné použít jako iterovatelnou hodnotu", "noneNotSubscriptable": "Objekt typu “None“ nelze zadat jako dolní index", - "noneNotUsableWith": "Objekt typu None není možné použít s with", + "noneNotUsableWith": "Object of type \"None\" cannot be used with \"with\"", "noneOperator": "Operátor {operator} se pro None nepodporuje", "noneUnknownMember": "{name} není známý atribut None.", "notRequiredArgCount": "Za NotRequired byl očekáván jeden argument typu", @@ -351,7 +352,7 @@ "obscuredTypeAliasDeclaration": "Deklarace aliasu typu {name} je zakrytá deklarací stejného názvu", "obscuredVariableDeclaration": "Deklarace {name} je zakrytá deklarací stejného názvu", "operatorLessOrGreaterDeprecated": "Operátor <> se v Pythonu 3 nepodporuje; místo toho použijte !=", - "optionalExtraArgs": "Za nepovinnou hodnotou se očekával jeden argument typu", + "optionalExtraArgs": "Za nepovinnou hodnotou (Optional) se očekával jeden argument typu.", "orPatternIrrefutable": "Nevratný vzor je povolený jenom jako poslední dílčí vzorec ve vzorci „or“", "orPatternMissingName": "Všechny dílčí vzory v rámci vzoru or musí cílit na stejné názvy", "overlappingKeywordArgs": "Slovník silného typu se překrývá s parametrem klíčového slova: {names}", @@ -364,9 +365,9 @@ "overloadImplementationMismatch": "Přetížená implementace není konzistentní se signaturou přetížení {index}", "overloadReturnTypeMismatch": "Přetížení {prevIndex} pro {name} se překrývá s přetížením {newIndex} a vrací nekompatibilní typ", "overloadStaticMethodInconsistent": "Přetížení pro {name} používají @staticmethod nekonzistentně.", - "overloadWithoutImplementation": "„{name}“ je označen(é/o) jako přetížení, ale není zadaná žádná implementace", - "overriddenMethodNotFound": "Metoda „{name}“ je označená jako přepsání, ale neexistuje žádná základní metoda se stejným názvem", - "overrideDecoratorMissing": "Metoda „{name}“ není označená jako přepsání, ale přepisuje metodu ve třídě „{className}“", + "overloadWithoutImplementation": "„{name}“ je označené jako přetížení (overload), ale není zadaná žádná implementace.", + "overriddenMethodNotFound": "Metoda „{name}“ je označená jako přepsání (override), ale neexistuje žádná základní metoda se stejným názvem.", + "overrideDecoratorMissing": "Metoda „{name}“ není označená jako přepsání (override), ale přepisuje metodu ve třídě „{className}“.", "paramAfterKwargsParam": "Parametr nemůže následovat za parametrem „**“", "paramAlreadyAssigned": "Parametr {name} je už přiřazený", "paramAnnotationMissing": "Chybí poznámka typu pro parametr „{name}“", @@ -377,7 +378,7 @@ "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", + "paramSpecDefaultNotTuple": "Očekávaly se tři tečky, výraz řazené kolekce členů (tuple) nebo ParamSpec pro výchozí hodnotu ParamSpec.", "paramSpecFirstArg": "Očekával se název parametru ParamSpec jako první argument", "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", @@ -387,7 +388,7 @@ "paramTypeCovariant": "Proměnnou kovariantní typu není možné použít v typu parametru", "paramTypePartiallyUnknown": "Typ parametru {paramName} je částečně neznámý", "paramTypeUnknown": "Typ parametru {paramName} je neznámý", - "parenthesizedContextManagerIllegal": "Závorky v příkazu with vyžadují Python 3.9 nebo novější", + "parenthesizedContextManagerIllegal": "Parentheses within \"with\" statement requires Python 3.9 or newer", "patternNeverMatches": "Vzor se nikdy nebude shodovat s typem předmětu {type}", "positionArgAfterNamedArg": "Poziční argument se nemůže objevit za argumenty klíčového slova", "positionOnlyAfterArgs": "Oddělovač parametrů jen pro pozici není povolený za parametrem *.", @@ -398,21 +399,21 @@ "privateImportFromPyTypedModule": "{name} se neexportuje z modulu {module}", "privateUsedOutsideOfClass": "{name} je privátní a používá se mimo třídu, ve které je deklarovaná", "privateUsedOutsideOfModule": "{name} je privátní a používá se mimo modul, ve kterém je deklarován", - "propertyOverridden": "„{name}“ nesprávně přepíše vlastnost se stejným názvem ve třídě {className}", - "propertyStaticMethod": "Statické metody nejsou povoleny pro metodu getter, setter nebo deleter vlastnosti", + "propertyOverridden": "„{name}“ nesprávně přepíše vlastnost (property) se stejným názvem ve třídě „{className}“.", + "propertyStaticMethod": "Statické metody nejsou povoleny pro metodu getter, setter nebo deleter vlastnosti (property).", "protectedUsedOutsideOfClass": "„{name}“ je chráněn(ý/o/é) a používá se mimo třídu, ve které je deklarovaná", - "protocolBaseClass": "Třída protokolu „{classType}“ se nemůže odvozovat od třídy,která není protokolem „{baseType}“", + "protocolBaseClass": "Třída Protocol {classType} se nemůže odvozovat od třídy, která není třídou Protocol {baseType}.", "protocolBaseClassWithTypeArgs": "Argumenty typu nejsou u třídy Protocol povoleny při použití syntaxe parametru typu", - "protocolIllegal": "Použití protokolu vyžaduje Python 3.7 nebo novější", + "protocolIllegal": "Použití třídy Protocol vyžaduje Python 3.7 nebo novější.", "protocolNotAllowed": "„Protocol“ nejde v tomto kontextu použít.", - "protocolTypeArgMustBeTypeParam": "Argument typu pro „protokol“ musí být parametr typu", + "protocolTypeArgMustBeTypeParam": "Argument typu pro „Protocol“ musí být parametr typu.", "protocolUnsafeOverlap": "Třída se nebezpečně překrývá s názvem „{name}“ a může vytvořit shodu při spuštění.", - "protocolVarianceContravariant": "Proměnná typu „{variable}“ použitá v obecném protokolu „{class}“ by měla být kontravariantní", - "protocolVarianceCovariant": "Proměnná typu „{variable}“ použitá v obecném protokolu „{class}“ by měla být kovariantní", - "protocolVarianceInvariant": "Proměnná typu „{variable}“ použitá v obecném protokolu „{class}“ by měla být invariantní", + "protocolVarianceContravariant": "Proměnná typu {variable} použitá v obecné třídě Protocol {class} by měla být kontravariantní.", + "protocolVarianceCovariant": "Proměnná typu {variable} použitá v obecné třídě Protocol {class} by měla být kovariantní.", + "protocolVarianceInvariant": "Proměnná typu {variable} použitá v obecné třídě Protocol {class} by měla být invariantní.", "pyrightCommentInvalidDiagnosticBoolValue": "Za direktivou komentářů Pyright musí následovat znak =a hodnota true nebo false", "pyrightCommentInvalidDiagnosticSeverityValue": "Za direktivou komentářů Pyright musí následovat = a hodnota true, false, error, warning, information nebo none", - "pyrightCommentMissingDirective": "Za komentářem Pyright musí následovat direktiva (základní nebo striktní) nebo diagnostické pravidlo", + "pyrightCommentMissingDirective": "Za komentářem Pyright musí následovat direktiva (basic nebo strict) nebo diagnostické pravidlo.", "pyrightCommentNotOnOwnLine": "Komentáře Pyright používané k řízení nastavení na úrovni souborů se musí zobrazovat na vlastním řádku", "pyrightCommentUnknownDiagnosticRule": "{rule} je neznámé diagnostické pravidlo pro komentář pyright", "pyrightCommentUnknownDiagnosticSeverityValue": "{value} je neplatná hodnota pro komentář pyright; očekávalo se true, false, error, warning, information nebo none", @@ -420,18 +421,18 @@ "readOnlyArgCount": "Za „ReadOnly“ se očekával jeden argument typu", "readOnlyNotInTypedDict": "ReadOnly není v tomto kontextu povolené", "recursiveDefinition": "Typ „{name}“ nelze určit, protože odkazuje sám na sebe", - "relativeImportNotAllowed": "Relativní importy se nedají použít s formulářem importu .a; místo toho použijte from . import a", - "requiredArgCount": "Za povinným argumentem se očekával jeden argument typu", + "relativeImportNotAllowed": "Relativní importy se nedají použít s formulářem „import .a“; místo toho použijte „from . import a“.", + "requiredArgCount": "Za povinným argumentem (Required) se očekával jeden argument typu.", "requiredNotInTypedDict": "Required není v tomto kontextu povoleno", "returnInAsyncGenerator": "Příkaz Return s hodnotou není v asynchronním generátoru povolený", "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í kompatibilní s návratovým typem {returnType}.", + "returnTypeMismatch": "Typ {exprType} se nedá přiřadit k návratovému typu {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", - "revealLocalsNone": "V tomto oboru nejsou žádné místní hodnoty", + "revealLocalsNone": "V tomto oboru nejsou žádné místní hodnoty (locals).", "revealTypeArgs": "Pro volání reveal_type byl očekáván jeden poziční argument", "revealTypeExpectedTextArg": "Argument „expected_text“ pro funkci „reveal_type“ musí být hodnota literálu str", "revealTypeExpectedTextMismatch": "Neshoda typu textu; očekávaný počet: {expected}, počet, který byl přijat: {received}", @@ -439,7 +440,7 @@ "selfTypeContext": "Self není v tomto kontextu platné", "selfTypeMetaclass": "„Self“ nelze použít v rámci metatřídy (podtřídy „type“).", "selfTypeWithTypedSelfOrCls": "Self není možné použít ve funkci s parametrem self nebo cls, která má jinou poznámku typu než Self", - "setterGetterTypeMismatch": "Typ hodnoty metody setter vlastnosti není možné přiřadit návratového typu getter", + "setterGetterTypeMismatch": "Typ hodnoty metody setter vlastnosti (property) není možné přiřadit návratovému typu getter.", "singleOverload": "{name} je označené jako přetížení, ale chybí další přetížení", "slotsAttributeError": "„{name}“ není zadaný v __slots__", "slotsClassVarConflict": "{name} je v konfliktu s proměnnou instance deklarovanou v __slots__", @@ -449,12 +450,12 @@ "staticClsSelfParam": "Statické metody by neměly přijímat parametr self nebo cls", "stdlibModuleOverridden": "„{path}“ přepisuje modul stdlib „{name}“", "stringNonAsciiBytes": "Znak jiný než ASCII není povolený v bajtech řetězcového literálu", - "stringNotSubscriptable": "Řetězcový výraz není možné v poznámce typu zadat jako dolní index uzavření celé poznámky do uvozovek", + "stringNotSubscriptable": "Řetězcový výraz není možné ve výrazu typu zadat jako dolní index. Uzavřete celý výraz do uvozovek.", "stringUnsupportedEscape": "Nepodporovaná řídicí sekvence v řetězcovém literálu", "stringUnterminated": "Řetězcový literál je neukončený", - "stubFileMissing": "Soubor zástupné procedury pro {importName} se nenašel", - "stubUsesGetAttr": "Soubor zástupné procedury typu je neúplný; __getattr__ zakrývá typové chyby pro modul", - "sublistParamsIncompatible": "Parametry podsestavy nejsou v Python 3.x podporované", + "stubFileMissing": "Soubor zástupné procedury (stub) pro „{importName}“ se nenašel.", + "stubUsesGetAttr": "Soubor zástupné procedury (stub) typu je neúplný; __getattr__ zakrývá typové chyby pro modul.", + "sublistParamsIncompatible": "Parametry sublist nejsou v Pythonu 3.x podporované.", "superCallArgCount": "Pro volání „super“ se očekávaly maximálně dva argumenty", "superCallFirstArg": "Jako první argument pro volání super se očekával typ třídy, ale přijal se {type}", "superCallSecondArg": "Druhý argument volání super musí být objekt nebo třída odvozená z typu {type}", @@ -464,45 +465,46 @@ "symbolIsUnbound": "Název {name} je nevázaný", "symbolIsUndefined": "{name} není definované", "symbolOverridden": "{name} přepíše symbol stejného názvu ve třídě {className}", - "ternaryNotAllowed": "Výraz ternary není v poznámce typu povolený.", + "ternaryNotAllowed": "Výraz ternary není ve výrazu typu povolený.", "totalOrderingMissingMethod": "Třída musí definovat jednu z __lt__, __le__, __gt__ nebo __ge__, aby bylo možné používat total_ordering", "trailingCommaInFromImport": "Koncová čárka není povolena bez okolních závorek", "tryWithoutExcept": "Příkaz Try musí mít alespoň jednu klauzuli except nebo finally", - "tupleAssignmentMismatch": "Výraz s typem „{type}“ se nedá přiřadit cílové řazené kolekci členů", - "tupleInAnnotation": "Výraz řazené kolekce členů není v poznámce typu povolený", + "tupleAssignmentMismatch": "Výraz s typem „{type}“ se nedá přiřadit cílové řazené kolekci členů (tuple).", + "tupleInAnnotation": "Výraz řazené kolekce členů (tuple) není ve výrazu typu povolený.", "tupleIndexOutOfRange": "Index {index} je pro typ {type} mimo rozsah", "typeAliasIllegalExpressionForm": "Neplatný formulář výrazu pro definici aliasu typu", "typeAliasIsRecursiveDirect": "Alias typu „{name}“ nemůže ve své definici používat sám sebe", "typeAliasNotInModuleOrClass": "Typ TypeAlias je možné definovat pouze v rámci oboru modulu nebo třídy", - "typeAliasRedeclared": "{name} se deklaruje jako TypAlias a dá se přiřadit jenom jednou", + "typeAliasRedeclared": "„{name}“ se deklaruje jako TypeAlias a dá se přiřadit jenom jednou.", "typeAliasStatementBadScope": "Příkaz type se dá použít jenom v rámci oboru modulu nebo třídy.", "typeAliasStatementIllegal": "Příkaz alias typu vyžaduje Python 3.12 nebo novější", - "typeAliasTypeBaseClass": "Alias typu definovaný v příkazu „typ“ nejde použít jako základní třídu", + "typeAliasTypeBaseClass": "Alias typu definovaný v příkazu \"type\" nejde použít jako základní třídu.", "typeAliasTypeMustBeAssigned": "Typ TypeAliasType musí být přiřazen proměnné se stejným názvem jako alias typu", - "typeAliasTypeNameArg": "První argument typeAliasType musí být řetězcový literál představující název aliasu typu", + "typeAliasTypeNameArg": "První argument TypeAliasType musí být řetězcový literál představující název aliasu typu.", "typeAliasTypeNameMismatch": "Název aliasu typu se musí shodovat s názvem proměnné, ke které je přiřazená", - "typeAliasTypeParamInvalid": "Seznam parametrů typu musí být řazená kolekce členů obsahující pouze typeVar, TypeVarTuple nebo ParamSpec", + "typeAliasTypeParamInvalid": "Seznam parametrů typu musí být řazená kolekce členů (tuple) obsahující pouze TypeVar, TypeVarTuple nebo ParamSpec.", "typeAnnotationCall": "Výraz volání není ve výrazu typu povolený", "typeAnnotationVariable": "Proměnná není ve výrazu typu povolená", "typeAnnotationWithCallable": "Argument typu pro „type“ musí být třída; volatelné objekty se nepodporují.", - "typeArgListExpected": "Očekával se parametr ParamSpec, tři tečky nebo seznam typů", - "typeArgListNotAllowed": "Výraz seznamu není pro tento argument typu povolený", + "typeArgListExpected": "Očekával se parametr ParamSpec, tři tečky nebo seznam (list) typů.", + "typeArgListNotAllowed": "Výraz seznamu (list) není pro tento argument typu povolený.", "typeArgsExpectingNone": "Pro třídu {name} se neočekávaly žádné argumenty typu", "typeArgsMismatchOne": "Očekával se jeden argument typu, ale bylo přijato {received}", "typeArgsMissingForAlias": "Pro alias obecného typu {name} se očekávaly argumenty typu", "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í 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", + "typeAssignmentMismatch": "Typ {sourceType} se nedá přiřadit k deklarovanému typu {destType}.", + "typeAssignmentMismatchWildcard": "Symbol importu {name} má typ {sourceType}, který se nedá přiřadit k deklarovanému typu {destType}.", + "typeCallNotAllowed": "Volání type() by se nemělo používat ve výrazu 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", + "typeCommentDeprecated": "Použití komentářů type je zastaralé místo toho použít anotaci type.", "typeExpectedClass": "Očekávala se třída, ale byl přijat typ {type}.", + "typeFormArgs": "TypeForm přijímá jeden poziční argument.", "typeGuardArgCount": "Za TypeGuard nebo TypeIs byl očekáván jeden argument typu.", "typeGuardParamCount": "Funkce a metody ochrany typů definované uživatelem musí mít alespoň jeden vstupní parametr", "typeIsReturnType": "Návratový typ TypeIs ({returnType}) není konzistentní s typem parametru hodnoty ({type}).", - "typeNotAwaitable": "„{type}“ se nedá očekávat.", + "typeNotAwaitable": "„{type}“ není awaitable.", "typeNotIntantiable": "Není možné vytvořit instanci {type}", "typeNotIterable": "{type} není možné iterovat", "typeNotSpecializable": "Nepovedlo se specializovat typ „{type}“", @@ -537,14 +539,14 @@ "typeVarSingleConstraint": "TypeVar musí mít alespoň dva omezené typy", "typeVarTupleConstraints": "TypeVarTuple nemůže mít omezení hodnoty", "typeVarTupleContext": "TypeVarTuple se v tomto kontextu nepovoluje", - "typeVarTupleDefaultNotUnpacked": "Výchozí typ TypeVarTuple musí být rozbalený řazená kolekce členů nebo TypeVarTuple", + "typeVarTupleDefaultNotUnpacked": "Výchozí typ TypeVarTuple musí být rozbalená řazená kolekce členů (tuple) nebo TypeVarTuple.", "typeVarTupleMustBeUnpacked": "Pro hodnotu TypeVarTuple se vyžaduje operátor rozbalení", "typeVarTupleUnknownParam": "{name} je neznámý parametr pro TypeVarTuple", "typeVarUnknownParam": "„{name}“ je neznámý parametr pro TypeVar", "typeVarUsedByOuterScope": "TypeVar „{name}“ se už používá ve vnějším oboru", "typeVarUsedOnlyOnce": "TypeVar {name} se v signatuře obecné funkce zobrazuje jenom jednou", "typeVarVariance": "TypeVar nemůže být kovariantní i kontravariantní", - "typeVarWithDefaultFollowsVariadic": "TypeVar {typeVarName} má výchozí hodnotu a nemůže následovat po typeVarTuple {variadicName}.", + "typeVarWithDefaultFollowsVariadic": "TypeVar {typeVarName} má výchozí hodnotu a nemůže následovat po TypeVarTuple {variadicName}.", "typeVarWithoutDefault": "„{name}“ se v seznamu parametrů typu nemůže zobrazit za „{other}“ , protože nemá žádný výchozí typ", "typeVarsNotInGenericOrProtocol": "Generic[] nebo Protocol[] musí obsahovat všechny proměnné typu", "typedDictAccess": "Nepovedlo se získat přístup k položce v TypedDict", @@ -552,8 +554,8 @@ "typedDictBadVar": "Třídy TypedDict můžou obsahovat jenom poznámky typu", "typedDictBaseClass": "Všechny základní třídy pro třídy TypedDict musí být také třídami TypedDict", "typedDictBoolParam": "Očekávalo se, že parametr {name} bude mít hodnotu True nebo False", - "typedDictClosedExtras": "Základní třída {name} je uzavřená třída TypedDict; Další položky musí být typu {type}.", - "typedDictClosedNoExtras": "Základní třída {name} je uzavřená hodnota TypedDict; Položky navíc nejsou povolené.", + "typedDictClosedExtras": "Základní třída {name} je closed TypedDict; další položky musí být typu {type}.", + "typedDictClosedNoExtras": "Základní třída {name} je closed TypedDict; položky navíc nejsou povolené.", "typedDictDelete": "Nepovedlo se odstranit položku v TypedDict", "typedDictEmptyName": "Názvy v rámci TypedDict nemůžou být prázdné", "typedDictEntryName": "Očekával se řetězcový literál pro název položky slovníku", @@ -565,7 +567,7 @@ "typedDictFirstArg": "Jako první argument byl očekáván název třídy TypedDict", "typedDictInitsubclassParameter": "TypedDict nepodporuje parametr __init_subclass__ „{name}“.", "typedDictNotAllowed": "„TypedDict“ se v tomto kontextu nedá použít.", - "typedDictSecondArgDict": "Jako druhý parametr se očekával parametr diktování nebo klíčového slova", + "typedDictSecondArgDict": "Jako druhý parametr se očekával parametr dict nebo keyword.", "typedDictSecondArgDictEntry": "Očekávaná jednoduchá položka slovníku", "typedDictSet": "Nelze přiřadit položku v TypedDict", "unaccessedClass": "Třída „{name}“ není přístupná", @@ -574,34 +576,34 @@ "unaccessedSymbol": "{name} není přístupné", "unaccessedVariable": "Proměnná {name} není přístupná", "unannotatedFunctionSkipped": "Analýza funkce „{name}“ se přeskočila, protože není označená", - "unaryOperationNotAllowed": "Unární operátor není v poznámce typu povolený.", + "unaryOperationNotAllowed": "Ve výrazu typu není povolený unární operátor.", "unexpectedAsyncToken": "Očekávalo se, že za async bude následovat def, with nebo for", "unexpectedExprToken": "Neočekávaný token na konci výrazu", "unexpectedIndent": "Neočekávané odsazení", "unexpectedUnindent": "Neočekává se unindent", "unhashableDictKey": "Klíč slovníku musí být hashovatelný", - "unhashableSetEntry": "Položka sady musí být hashovatelná", - "uninitializedAbstractVariables": "Proměnné definované v abstraktní základní třídě nejsou inicializovány v konečné třídě {classType}", + "unhashableSetEntry": "Položka set musí být hashovatelná.", + "uninitializedAbstractVariables": "Proměnné definované v abstraktní základní třídě nejsou inicializovány ve třídě final {classType}.", "uninitializedInstanceVariable": "Proměnná instance {name} není inicializována v těle třídy nebo v metodě __init__", - "unionForwardReferenceNotAllowed": "Syntaxi sjednocení není možné použít s operandem řetězce; použijte uvozovky kolem celého výrazu", + "unionForwardReferenceNotAllowed": "Syntaxi Union není možné použít s operandem řetězce; použijte uvozovky kolem celého výrazu.", "unionSyntaxIllegal": "Alternativní syntaxe pro sjednocení vyžaduje Python 3.10 nebo novější", - "unionTypeArgCount": "Sjednocení vyžaduje dva nebo více argumentů typu", - "unionUnpackedTuple": "Sjednocení nemůže obsahovat rozbalenou řazenou kolekci členů.", - "unionUnpackedTypeVarTuple": "Sjednocení nemůže obsahovat rozbalený typ TypeVarTuple.", - "unnecessaryCast": "Nepotřebné volání„přetypování“; Typ už je „{type}“.", + "unionTypeArgCount": "Union vyžaduje dva nebo více argumentů typu.", + "unionUnpackedTuple": "Union nemůže obsahovat rozbalenou řazenou kolekci členů (tuple).", + "unionUnpackedTypeVarTuple": "Union nemůže obsahovat rozbalený typ TypeVarTuple.", + "unnecessaryCast": "Nepotřebné volání „cast“; typ už je „{type}“.", "unnecessaryIsInstanceAlways": "Zbytečné volání isinstance; {testType} je vždy instancí třídy {classType}", "unnecessaryIsSubclassAlways": "Nepotřebné volání issubclass; „{testType}“ je vždy podtřídou třídy „{classType}“", "unnecessaryPyrightIgnore": "Nepotřebný komentář „# pyright: ignore“", "unnecessaryPyrightIgnoreRule": "Nepotřebné pravidlo # pyright: ignore: {name}", "unnecessaryTypeIgnore": "Nepotřebný komentář „# type: ignore“", "unpackArgCount": "Po rozbalení „Unpack“ se očekával jeden argument typu", - "unpackExpectedTypeVarTuple": "Jako argument typu pro rozbalení byl očekáván typ TypeVarTuple nebo řazená kolekce členů", + "unpackExpectedTypeVarTuple": "Jako argument typu pro Unpack byl očekáván typ TypeVarTuple nebo tuple.", "unpackExpectedTypedDict": "Byl očekáván argument typu TypedDict pro rozbalení Unpack", "unpackIllegalInComprehension": "Operace rozbalení není v porozumění povolená", - "unpackInAnnotation": "V poznámce typu není povolený operátor rozbalení", + "unpackInAnnotation": "Ve výrazu typu není povolený operátor rozbalení.", "unpackInDict": "Operace rozbalení není ve slovnících povolena", - "unpackInSet": "Operátor rozbalení není v sadě povolený", - "unpackNotAllowed": "Rozbalení se v tomto kontextu nepovoluje", + "unpackInSet": "Operátor rozbalení není v sadě (set) povolený.", + "unpackNotAllowed": "Unpack se v tomto kontextu nepovoluje.", "unpackOperatorNotAllowed": "Operace rozbalení není v tomto kontextu povolená", "unpackTuplesIllegal": "Operace rozbalení není povolená v řazených kolekcích členů před Pythonem 3.8", "unpackedArgInTypeArgument": "V tomto kontextu nelze použít rozbalené argumenty.", @@ -618,34 +620,34 @@ "unusedCallResult": "Výsledek výrazu volání je typu „{type}“ a nepoužívá se. přiřadit proměnné „_“, pokud je to záměrné", "unusedCoroutine": "Výsledek volání asynchronní funkce se nepoužívá; použijte operátor await nebo přiřaďte výsledek proměnné", "unusedExpression": "Hodnota výrazu se nepoužívá", - "varAnnotationIllegal": "Poznámky typu pro proměnné vyžadují Python 3.6 nebo novější; pro kompatibilitu s předchozími verzemi použijte komentáře typu", - "variableFinalOverride": "Proměnná {name} je označená jako final a přepíše proměnnou non-Final se stejným názvem ve třídě {className}", - "variadicTypeArgsTooMany": "Seznam argumentů typů může mít maximálně jeden rozbalený typ TypeVarTuple nebo řazenou kolekci členů", + "varAnnotationIllegal": "Poznámky type pro proměnné vyžadují Python 3.6 nebo novější; pro kompatibilitu s předchozími verzemi použijte komentáře type.", + "variableFinalOverride": "Proměnná {name} je označená jako Final a přepíše proměnnou non-Final se stejným názvem ve třídě {className}.", + "variadicTypeArgsTooMany": "Seznam argumentů typů může mít maximálně jeden rozbalený typ TypeVarTuple nebo tuple.", "variadicTypeParamTooManyAlias": "Alias typu může mít maximálně jeden parametr typu TypeVarTuple, ale přijal několik ({names})", "variadicTypeParamTooManyClass": "Obecná třída může mít maximálně jeden parametr typu TypeVarTuple, ale přijala více ({names})", "walrusIllegal": "Operátor := vyžaduje Python 3.8 nebo novější", "walrusNotAllowed": "Operátor := není v tomto kontextu povolen bez okolních závorek", - "wildcardInFunction": "Import se zástupnými znaky není v rámci třídy nebo funkce povolen", - "wildcardLibraryImport": "Import se zástupnými znaky z knihovny není povolený", + "wildcardInFunction": "V rámci třídy nebo funkce není povolen import se zástupnými znaky.", + "wildcardLibraryImport": "Není povolený import se zástupnými znaky z knihovny.", "wildcardPatternTypePartiallyUnknown": "Typ zachycený vzorem se zástupnými znaky je částečně neznámý", "wildcardPatternTypeUnknown": "Typ zachycený vzorem se zástupnými znaky je neznámý", "yieldFromIllegal": "Použití příkazu yield from vyžaduje Python 3.3 nebo novější", "yieldFromOutsideAsync": "yield from není v asynchronní funkci povoleno", "yieldOutsideFunction": "„yield“ není povoleno mimo funkci nebo lambdu", "yieldWithinComprehension": "„yield“ není povolené uvnitř porozumění", - "zeroCaseStatementsFound": "Výraz shody obsahovat alespoň jeden výraz velikosti písmen", - "zeroLengthTupleNotAllowed": "Řazená kolekce členů s nulovou délkou není v tomto kontextu povolená" + "zeroCaseStatementsFound": "Výraz shody (match) obsahovat alespoň jeden výraz velikosti písmen (case).", + "zeroLengthTupleNotAllowed": "Řazená kolekce členů (tuple) s nulovou délkou není v tomto kontextu povolená." }, "DiagnosticAddendum": { - "annotatedNotAllowed": "Speciální formulář s poznámkami nejde použít s kontrolami instancí a tříd.", + "annotatedNotAllowed": "Speciální formulář Annotated nejde použít s kontrolami instancí a tříd.", "argParam": "Argument odpovídá parametru {paramName}", "argParamFunction": "Argument odpovídá parametru {paramName} ve funkci {functionName}", "argsParamMissing": "Parametr „*{paramName}“ nemá žádný odpovídající parametr", "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í kompatibilní s None.", - "asyncHelp": "Měli jste na mysli „async s“?", + "assignToNone": "Typ se nedá přiřadit k None.", + "asyncHelp": "Měli jste na mysli „async with“?", "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}", "baseClassOverriddenType": "Základní třída {baseClass} poskytuje typ {type}, který je přepsán", @@ -657,7 +659,7 @@ "dataProtocolUnsupported": "„{name}“ je datový protokol.", "descriptorAccessBindingFailed": "Nepovedlo se vytvořit vazbu metody {name} pro třídu popisovače {className}.", "descriptorAccessCallFailed": "Nepovedlo se volat metodu {name} pro třídu popisovače {className}.", - "finalMethod": "Konečná metoda", + "finalMethod": "Metoda Final", "functionParamDefaultMissing": "V parametru „{name}“ chybí výchozí argument", "functionParamName": "Neshoda názvu parametru: {destName} a {srcName}", "functionParamPositionOnly": "Neshoda parametrů pouze s pozicí; Parametr „{name}“ není jen pro pozici.", @@ -665,15 +667,15 @@ "functionTooFewParams": "Funkce přijímá příliš málo pozičních parametrů; očekávaný počet: {expected}, počet, který byl přijat: {received}", "functionTooManyParams": "Funkce přijímá příliš mnoho pozičních parametrů; očekávaný počet: {expected}, počet, který byl přijat: {received}", "genericClassNotAllowed": "Obecný typ s argumenty obecného typu se pro kontroly instancí nebo tříd nepovoluje.", - "incompatibleDeleter": "Metoda odstranění vlastnosti je nekompatibilní", - "incompatibleGetter": "Metoda getter vlastnosti je nekompatibilní", - "incompatibleSetter": "Metoda setter vlastnosti je nekompatibilní", + "incompatibleDeleter": "Metoda deleter vlastnosti (property) je nekompatibilní.", + "incompatibleGetter": "Metoda getter vlastnosti (property) je nekompatibilní.", + "incompatibleSetter": "Metoda setter vlastnosti (property) je nekompatibilní.", "initMethodLocation": "Metoda __init__ je definována ve třídě {type}", "initMethodSignature": "Podpis __init__ je {type}", "initSubclassLocation": "Metoda __init_subclass__ je definována ve třídě {name}.", - "invariantSuggestionDict": "Zvažte přepnutí z „diktování“ na „mapování“, které je v typu hodnoty kovariantní", - "invariantSuggestionList": "Zvažte přepnutí ze „seznamu“ na „sekvenci“, která je kovavariantní", - "invariantSuggestionSet": "Zvažte přepnutí ze „seznamu“ na „sekvenci“, která je kovavariantní", + "invariantSuggestionDict": "Zvažte přepnutí z možnosti „dict“ na možnost „Mapping“, která je v typu hodnoty kovariantní.", + "invariantSuggestionList": "Zvažte přepnutí z možnosti „list“ na možnost „Sequence“, která je kovariantní.", + "invariantSuggestionSet": "Zvažte přepnutí z možnosti „set“ na možnost „Container“, která je kovariantní.", "isinstanceClassNotSupported": "{type} se pro kontroly instancí a tříd nepodporuje.", "keyNotRequired": "„{name}! není v typu „{type}“ povinný klíč, takže přístup může vést k výjimce modulu runtime", "keyReadOnly": "{name} je klíč jen pro čtení v {type}", @@ -681,14 +683,14 @@ "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} není kompatibilní s typem {destType}.", + "literalAssignmentMismatch": "{sourceType} se nedá přiřadit k typu {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 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.", - "memberIsInitVar": "{name} je pole jen pro inicializaci.", + "memberIsInitVar": "{name} je pole init-only.", "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.", @@ -699,18 +701,18 @@ "memberTypeMismatch": "{name} je nekompatibilní typ", "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", + "missingDeleter": "Chybí metoda deleter vlastnosti (property).", + "missingGetter": "Chybí metoda getter vlastnosti (property).", + "missingSetter": "Chybí metoda setter vlastnosti (property).", "namedParamMissingInDest": "Další parametr „{name}“", "namedParamMissingInSource": "Chybí parametr klíčového slova „{name}“.", "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}", - "newTypeClassNotAllowed": "Třídu vytvořenou pomocí newType nelze použít s kontrolami instancí a tříd.", + "newTypeClassNotAllowed": "Třídu vytvořenou pomocí NewType nelze použít s kontrolami instancí a tříd.", "noOverloadAssignable": "Typ {type} neodpovídá žádné přetížené funkci", - "noneNotAllowed": "Žádné se nedají použít pro kontroly instancí nebo tříd.", + "noneNotAllowed": "Možnost None se nedá použít pro kontroly instancí nebo tříd.", "orPatternMissingName": "Chybějící názvy: {name}", "overloadIndex": "Přetížení {index} je nejbližší shoda.", "overloadNotAssignable": "Nejméně jedno přetížení {name} není možné přiřadit", @@ -741,13 +743,13 @@ "paramType": "Typ parametru je {paramType}", "privateImportFromPyTypedSource": "Místo toho importovat z modulu {module}", "propertyAccessFromProtocolClass": "Vlastnost definovaná v rámci třídy protokolu není přístupná jako proměnná třídy", - "propertyMethodIncompatible": "Metoda vlastnosti {name} není kompatibilní", - "propertyMethodMissing": "V přepsání chybí metoda vlastnosti „{name}“", - "propertyMissingDeleter": "Vlastnost {name} nemá definovaný odstraňovač", - "propertyMissingSetter": "Vlastnost {name} nemá definovanou metodu setter", + "propertyMethodIncompatible": "Metoda vlastnosti (property) {name} není kompatibilní.", + "propertyMethodMissing": "V přepsání (override) chybí metoda vlastnosti (property) „{name}“.", + "propertyMissingDeleter": "Vlastnost (property) {name} nemá definovanou metodu deleter.", + "propertyMissingSetter": "Vlastnost (property) {name} nemá definovanou metodu setter.", "protocolIncompatible": "{sourceType} není kompatibilní s protokolem {destType}", "protocolMemberMissing": "{name} není k dispozici", - "protocolRequiresRuntimeCheckable": "Třída protokolu musí být @runtime_checkable, aby se použila při kontrolách instancí a tříd.", + "protocolRequiresRuntimeCheckable": "Třída Protocol musí být @runtime_checkable, aby se použila při kontrolách instancí a tříd.", "protocolSourceIsNotConcrete": "„{sourceType}“ není konkrétní typ třídy a nedá se přiřadit k typu „{destType}“", "protocolUnsafeOverlap": "Atributy „{name}“ mají stejné názvy jako protokol.", "pyrightCommentIgnoreTip": "Pokud chcete potlačit diagnostiku pro jeden řádek, použijte # pyright: ignore[]", @@ -759,17 +761,17 @@ "seeParameterDeclaration": "Viz deklarace parametru", "seeTypeAliasDeclaration": "Zobrazit deklaraci aliasu typu", "seeVariableDeclaration": "Zobrazit deklaraci proměnné", - "tupleAssignmentMismatch": "Typ „{type}“ není kompatibilní s cílovou řazenou kolekcí členů", - "tupleEntryTypeMismatch": "Položka řazené kolekce členů {entry} je nesprávného typu", - "tupleSizeIndeterminateSrc": "Neshoda velikosti řazené kolekce členů; Očekávalo se {expected}, ale přijalo se neurčité.", - "tupleSizeIndeterminateSrcDest": "Neshoda velikosti řazené kolekce členů; Očekávalo se min. {expected}, ale přijalo se neurčité.", - "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} 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}", + "tupleAssignmentMismatch": "Typ „{type}“ není kompatibilní s cílovou řazenou kolekcí členů (tuple).", + "tupleEntryTypeMismatch": "Položka řazené kolekce členů (tuple) {entry} je nesprávného typu.", + "tupleSizeIndeterminateSrc": "Neshoda velikosti řazené kolekce členů (tuple); očekávalo se {expected}, ale přijalo se neurčité.", + "tupleSizeIndeterminateSrcDest": "Neshoda velikosti řazené kolekce členů (tuple); očekávalo se min. {expected}, ale přijalo se neurčité.", + "tupleSizeMismatch": "Neshoda velikosti řazené kolekce členů (tuple); očekávalo se {expected}, ale přijalo se {received}.", + "tupleSizeMismatchIndeterminateDest": "Neshoda velikosti řazené kolekce členů (tuple); Očekávalo se {expected}, ale přijalo se {received}.", + "typeAliasInstanceCheck": "Alias typu vytvořený pomocí příkazu „type“ se nedá použít s kontrolami instancí a tříd.", + "typeAssignmentMismatch": "Typ {sourceType} se nedá přiřadit k typu {destType}.", + "typeBound": "Typ {sourceType} se nedá přiřadit k horní hranici {destType} pro proměnnou typu {name}.", + "typeConstrainedTypeVar": "Typ {type} se nedá přiřadit k proměnné omezeného typu {name}.", + "typeIncompatible": "{sourceType} se nedá přiřadit k {destType}.", "typeNotClass": "{type} není třída", "typeNotStringLiteral": "„{type}“ není řetězcový literál", "typeOfSymbol": "Typ „{name}“ je „{type}“", @@ -780,7 +782,7 @@ "typeVarIsCovariant": "Parametr typu „{name}“ je kovariantní, ale „{sourceType}“ není podtyp „{destType}“.", "typeVarIsInvariant": "Parametr typu „{name}“ je invariantní, ale „{sourceType}“ není stejný jako „{destType}“.", "typeVarNotAllowed": "TypeVar se pro kontroly instancí nebo tříd nepovoluje.", - "typeVarTupleRequiresKnownLength": "Typ TypeVarTuple nemůže být vázaný na řazenou kolekci členů neznámé délky", + "typeVarTupleRequiresKnownLength": "Typ TypeVarTuple nemůže být vázaný na řazenou kolekci členů (tuple) neznámé délky.", "typeVarUnnecessarySuggestion": "Místo toho použijte {type}.", "typeVarUnsolvableRemedy": "Zadejte přetížení, které určuje návratový typ, pokud argument není zadán", "typeVarsMissing": "Chybějící proměnné typu: {names}", @@ -804,8 +806,8 @@ "uninitializedAbstractVariable": "Proměnná instance {name} je definovaná v abstraktní základní třídě {classType}, ale neinicializovala se", "unreachableExcept": "{exceptionType} je podtřídou {parentType}", "useDictInstead": "Označte typ slovníku pomocí Dict[T1, T2]", - "useListInstead": "Použijte List[T] k označení typu seznamu nebo Union[T1, T2] k označení typu sjednocení", - "useTupleInstead": "Použijte tuple[T1, ..., Tn] k označení typu řazené kolekce členů nebo Union[T1, T2] k označení typu sjednocení", + "useListInstead": "Použijte List[T] k označení typu seznamu (list) nebo Union[T1, T2] k označení typu sjednocení (union).", + "useTupleInstead": "Použijte tuple[T1, ..., Tn] k označení typu řazené kolekce členů (tuple) nebo Union[T1, T2] k označení typu sjednocení (union).", "useTypeInstead": "Místo toho použít Type[T]", "varianceMismatchForClass": "Odchylka argumentu typu „{typeVarName}“ není kompatibilní se základní třídou „{className}“", "varianceMismatchForTypeAlias": "Rozptyl argumentu typu „{typeVarName}“ není kompatibilní s typem „{typeAliasParam}“" diff --git a/packages/pyright-internal/src/localization/package.nls.de.json b/packages/pyright-internal/src/localization/package.nls.de.json index 454c3f5ac..d544f33a7 100644 --- a/packages/pyright-internal/src/localization/package.nls.de.json +++ b/packages/pyright-internal/src/localization/package.nls.de.json @@ -1,7 +1,7 @@ { "CodeAction": { - "createTypeStub": "Typstub erstellen", - "createTypeStubFor": "Typstub für \"{moduleName}\" erstellen", + "createTypeStub": "Type Stub erstellen", + "createTypeStubFor": "Type Stub für \"{moduleName}\" erstellen", "executingCommand": "Der Befehl wird ausgeführt.", "filesToAnalyzeCount": "{count} Dateien zu analysieren", "filesToAnalyzeOne": "1 zu analysierende Datei", @@ -18,12 +18,12 @@ "annotatedMetadataInconsistent": "Der mit Anmerkungen versehene Metadatentyp „{metadataType}“ ist nicht mit dem Typ „{type}“ kompatibel.", "annotatedParamCountMismatch": "Nicht übereinstimmende Parameteranmerkungsanzahl: {expected} erwartet, aber {received} empfangen", "annotatedTypeArgMissing": "Es wurde ein Typargument und mindestens eine Anmerkung für \"Annotated\" erwartet.", - "annotationBytesString": "Typanmerkungen dürfen keine Bytes-Zeichenfolgenliterale verwenden.", - "annotationFormatString": "Typanmerkungen können keine Formatzeichenfolgenliterale (f-strings) verwenden.", + "annotationBytesString": "In Typausdrücken dürfen keine Bytes-Zeichenfolgenliterale verwendet werden", + "annotationFormatString": "Typausdrücke dürfen keine Formatzeichenfolgenliterale (f-strings) enthalten", "annotationNotSupported": "Typanmerkung wird für diese Anweisung nicht unterstützt.", - "annotationRawString": "Typanmerkungen dürfen keine unformatierten Zeichenfolgenliterale verwenden.", - "annotationSpansStrings": "Typanmerkungen dürfen nicht mehrere Zeichenfolgenliterale umfassen.", - "annotationStringEscape": "Typanmerkungen dürfen keine Escapezeichen enthalten.", + "annotationRawString": "Typausdrücke dürfen keine unformatierten Zeichenfolgenliterale enthalten", + "annotationSpansStrings": "Typausdrücke dürfen nicht mehrere Zeichenfolgenliterale umfassen.", + "annotationStringEscape": "Typausdrücke dürfen keine Escapezeichen enthalten", "argAssignment": "Ein Argument vom Typ \"{argType}\" kann dem Parameter vom Typ \"{paramType}\" nicht zugewiesen werden.", "argAssignmentFunction": "Ein Argument vom Typ \"{argType}\" kann dem Parameter vom Typ \"{paramType}\" in der Funktion \"{functionName}\" nicht zugewiesen werden.", "argAssignmentParam": "Ein Argument vom Typ \"{argType}\" kann dem Parameter \"{paramName}\" vom Typ \"{paramType}\" nicht zugewiesen werden.", @@ -37,17 +37,17 @@ "argPositionalExpectedOne": "Es wurde 1 Positionsargument erwartet.", "argTypePartiallyUnknown": "Der Argumenttyp ist teilweise unbekannt", "argTypeUnknown": "Argumenttyp ist unbekannt", - "assertAlwaysTrue": "Assertausdruck wird immer als True ausgewertet.", + "assertAlwaysTrue": "Assertausdruck wird immer als „true“ ausgewertet.", "assertTypeArgs": "\"assert_type\" erwartet zwei Positionsargumente.", "assertTypeTypeMismatch": "\"assert_type\" Konflikt: \"{expected}\" erwartet, aber \"{received}\" empfangen", "assignmentExprComprehension": "Ziel des Zuweisungsausdrucks \"{name}\" kann nicht denselben Namen wie das Verständnis für das Ziel verwenden.", "assignmentExprContext": "Der Zuweisungsausdruck muss sich innerhalb des Moduls, der Funktion oder der Lambdafunktion befinden.", "assignmentExprInSubscript": "Zuweisungsausdrücke innerhalb eines Tiefgestellten werden nur in Python 3.10 und höher unterstützt.", - "assignmentInProtocol": "Instanzen- oder Klassenvariablen innerhalb einer Protokollklasse müssen explizit innerhalb des Klassentexts deklariert werden.", + "assignmentInProtocol": "Instanzen- oder Klassenvariablen innerhalb einer Protocol Klasse müssen explizit innerhalb des Klassentexts deklariert werden.", "assignmentTargetExpr": "Der Ausdruck kann kein Zuweisungsziel sein.", "asyncNotInAsyncFunction": "Die Verwendung von \"async\" ist außerhalb einer asynchronen Funktion nicht zulässig.", "awaitIllegal": "Die Verwendung von \"await\" erfordert Python 3.5 oder höher.", - "awaitNotAllowed": "Typanmerkungen können „await“ nicht verwenden.", + "awaitNotAllowed": "In Typausdrücken darf „await“ nicht verwendet werden", "awaitNotInAsync": "\"await\" ist nur innerhalb einer asynchronen Funktion zulässig.", "backticksIllegal": "Ausdrücke, die von Backticks umgeben sind, werden in Python 3.x nicht unterstützt; verwenden Sie stattdessen repr", "baseClassCircular": "Die Klasse kann nicht von sich selbst abgeleitet werden.", @@ -57,7 +57,7 @@ "baseClassMethodTypeIncompatible": "Basisklassen für die Klasse \"{classType}\" definieren die Methode \"{name}\" auf inkompatible Weise.", "baseClassUnknown": "Der Basisklassentyp ist unbekannt, sodass der Typ der abgeleiteten Klasse verdeckt wird.", "baseClassVariableTypeIncompatible": "Basisklassen für die Klasse \"{classType}\" definieren die Variable \"{name}\" auf inkompatible Weise.", - "binaryOperationNotAllowed": "Binärer Operator in Typanmerkung nicht zulässig", + "binaryOperationNotAllowed": "Der binärer Operator ist im Typausdruck nicht zulässig", "bindTypeMismatch": "Die Methode \"{methodName}\" konnte nicht gebunden werden, da \"{type}\" dem Parameter \"{paramName}\" nicht zugewiesen werden kann.", "breakOutsideLoop": "\"break\" kann nur innerhalb einer Schleife verwendet werden.", "callableExtraArgs": "Es wurden nur zwei Typargumente für \"Callable\" erwartet.", @@ -70,7 +70,7 @@ "classDefinitionCycle": "Die Klassendefinition für \"{name}\" hängt von sich selbst ab.", "classGetItemClsParam": "__class_getitem__ Außerkraftsetzung sollte einen \"cls\"-Parameter annehmen.", "classMethodClsParam": "Klassenmethoden sollten einen \"cls\"-Parameter verwenden.", - "classNotRuntimeSubscriptable": "Durch das Tiefstellungsskript für die Klasse \"{name}\" wird eine Laufzeitausnahme generiert; schließen Sie die Typanmerkung in Anführungszeichen ein", + "classNotRuntimeSubscriptable": "Tiefgestellte Zeichen für die Klasse „{name}“ generieren eine Laufzeitausnahme; schließen Sie den Typausdruck in Anführungszeichen ein", "classPatternBuiltInArgPositional": "Das Klassenmuster akzeptiert nur positionsbezogenes Untermuster.", "classPatternPositionalArgCount": "Zu viele Positionsmuster für Klasse \"{type}\". Erwartet: {expected}, empfangen: {received}.", "classPatternTypeAlias": "\"{type}\" kann nicht in einem Klassenmuster verwendet werden, da es sich um einen spezialisierten Typalias handelt.", @@ -87,10 +87,10 @@ "comparisonAlwaysFalse": "Die Bedingung wird immer als False ausgewertet, da die Typen \"{leftType}\" und \"{rightType}\" keine Überlappung aufweisen.", "comparisonAlwaysTrue": "Die Bedingung wird immer als True ausgewertet, da die Typen \"{leftType}\" und \"{rightType}\" keine Überlappung aufweisen.", "comprehensionInDict": "Verständnis kann nicht mit anderen Wörterbucheinträgen verwendet werden.", - "comprehensionInSet": "Verständnis kann nicht mit anderen Satzeinträgen verwendet werden.", - "concatenateContext": "„Verketten“ ist in diesem Kontext nicht zulässig.", + "comprehensionInSet": "Verständnis kann nicht mit anderen „set“ Einträgen verwendet werden.", + "concatenateContext": "„Concatenate“ ist in diesem Kontext nicht zulässig.", "concatenateParamSpecMissing": "Das letzte Typargument für \"Concatenate\" muss ein ParamSpec oder \"...\" sein.", - "concatenateTypeArgsMissing": "\"Verketten\" erfordert mindestens zwei Typargumente.", + "concatenateTypeArgsMissing": "„Concatenate„ erfordert mindestens zwei Typargumente.", "conditionalOperandInvalid": "Ungültiger bedingter Operand vom Typ \"{type}\"", "constantRedefinition": "\"{name}\" ist konstant (da es sich um Großbuchstaben handelt) und kann nicht neu definiert werden.", "constructorParametersMismatch": "Keine Übereinstimmung zwischen der Signatur von __new__ und __init__ in der Klasse \"{classType}\"", @@ -111,7 +111,7 @@ "dataClassPostInitType": "Dataclass __post_init__ Methodenparametertypkonflikt für Feld \"{fieldName}\"", "dataClassSlotsOverwrite": "__slots__ ist bereits in der Klasse definiert.", "dataClassTransformExpectedBoolLiteral": "Es wurde ein Ausdruck erwartet, der statisch als True oder False ausgewertet wird.", - "dataClassTransformFieldSpecifier": "Es wurde ein Tupel von Klassen oder Funktionen erwartet, es wurde jedoch der Typ \"{type}\" empfangen", + "dataClassTransformFieldSpecifier": "Es wurde tuple von Klassen oder Funktionen erwartet, es wurde jedoch der Typ \"{type}\" empfangen", "dataClassTransformPositionalParam": "Alle Argumente für \"dataclass_transform\" müssen Schlüsselwortargumente sein.", "dataClassTransformUnknownArgument": "Argument \"{name}\" wird von dataclass_transform nicht unterstützt.", "dataProtocolInSubclassCheck": "Datenprotokolle (die Nicht-Methodenattribute enthalten) sind in „issubclass“-Aufrufen nicht zulässig.", @@ -127,12 +127,12 @@ "deprecatedDescriptorSetter": "Die Methode \"__set__\" für den Deskriptor \"{name}\" ist veraltet.", "deprecatedFunction": "Die Funktion \"{name}\" ist veraltet.", "deprecatedMethod": "Die Methode \"{name}\" in der Klasse \"{className}\" ist veraltet.", - "deprecatedPropertyDeleter": "Der Deleter für die Eigenschaft \"{name}\" ist veraltet.", - "deprecatedPropertyGetter": "Der Getter für die Eigenschaft \"{name}\" ist veraltet.", - "deprecatedPropertySetter": "Der Setter für die Eigenschaft \"{name}\" ist veraltet.", + "deprecatedPropertyDeleter": "Der deleter für property \"{name}\" ist veraltet.", + "deprecatedPropertyGetter": "Der getter für property \"{name}\" ist veraltet.", + "deprecatedPropertySetter": "Der setter für property \"{name}\" ist veraltet.", "deprecatedType": "Dieser Typ ist ab python-{version} veraltet; verwenden Sie stattdessen \"{replacement}\"", "dictExpandIllegalInComprehension": "Wörterbucherweiterung ist im Verständnis nicht zulässig.", - "dictInAnnotation": "Ein Wörterbuchausdruck ist in der Typanmerkung nicht zulässig.", + "dictInAnnotation": "Der Wörterbuchausdruck ist im Typausdruck nicht zulässig", "dictKeyValuePairs": "Wörterbucheinträge müssen Schlüssel-Wert-Paare enthalten.", "dictUnpackIsNotMapping": "Es wird eine Zuordnung für den Operator zum Entpacken des Wörterbuchs erwartet.", "dunderAllSymbolNotPresent": "\"{name}\" ist in __all__ angegeben, aber nicht im Modul vorhanden.", @@ -149,14 +149,14 @@ "duplicatePositionOnly": "Es ist nur ein \"/\"-Parameter zulässig.", "duplicateStarPattern": "In einer Mustersequenz ist nur ein \"*\"-Muster zulässig.", "duplicateStarStarPattern": "Es ist nur ein \"**\"-Eintrag zulässig.", - "duplicateUnpack": "In der Liste ist nur ein Vorgang zum Entpacken zulässig.", - "ellipsisAfterUnpacked": "„...“ kann nicht mit einem entpackten „TypeVarTuple“ oder „Tupel“ verwendet werden.", + "duplicateUnpack": "In list ist nur ein Vorgang zum Entpacken zulässig.", + "ellipsisAfterUnpacked": "„...“ kann nicht mit einem entpackten „TypeVarTuple“ oder „tuple“ verwendet werden.", "ellipsisContext": "\"...\" ist in diesem Kontext nicht zulässig.", "ellipsisSecondArg": "\"...\" ist nur als zweites von zwei Argumenten zulässig.", "enumClassOverride": "Die Enumerationsklasse \"{name}\" ist final und kann nicht in eine Unterklasse aufgenommen werden.", "enumMemberDelete": "Das Enumerationselement \"{name}\" kann nicht gelöscht werden.", "enumMemberSet": "Das Enumerationselement \"{name}\" kann nicht zugewiesen werden.", - "enumMemberTypeAnnotation": "Typanmerkungen sind für Enumerationsmember nicht zulässig", + "enumMemberTypeAnnotation": "Typanmerkungen sind für enum Member nicht zulässig", "exceptionGroupIncompatible": "Die Ausnahmegruppensyntax (\"except*\") erfordert Python 3.11 oder höher.", "exceptionGroupTypeIncorrect": "Der Ausnahmetyp in except* kann nicht von BaseGroupException abgeleitet werden.", "exceptionTypeIncorrect": "\"{type}\" ist nicht von BaseException abgeleitet.", @@ -189,7 +189,7 @@ "expectedIdentifier": "Bezeichner erwartet", "expectedImport": "\"import\" erwartet", "expectedImportAlias": "Symbol nach \"as\" erwartet", - "expectedImportSymbols": "Nach dem Import wurde mindestens ein Symbolname erwartet.", + "expectedImportSymbols": "Nach dem \"import\" wurde mindestens ein Symbolname erwartet.", "expectedIn": "\"in\" wurde erwartet.", "expectedInExpr": "Ausdruck nach \"in\" erwartet", "expectedIndentedBlock": "Eingerückter Block erwartet", @@ -209,10 +209,10 @@ "expectedTypeNotString": "Typ erwartet, aber Zeichenfolgenliteral empfangen", "expectedTypeParameterName": "Name für Typparameter erwartet", "expectedYieldExpr": "Ausdruck in yield-Anweisung erwartet", - "finalClassIsAbstract": "Die Klasse „{type}“ ist als abgeschlossen markiert und muss alle abstrakten Symbole implementieren.", + "finalClassIsAbstract": "Die Klasse „{type}“ ist als final markiert und muss alle abstrakten Symbole implementieren.", "finalContext": "\"Final\" ist in diesem Kontext nicht zulässig.", "finalInLoop": "Eine \"Final\"-Variable kann nicht innerhalb einer Schleife zugewiesen werden.", - "finalMethodOverride": "Die Methode \"{name}\" kann die in der Klasse definierte endgültige Methode \"{className}\" nicht überschreiben.", + "finalMethodOverride": "Die Methode \"{name}\" kann die in der Klasse definierte final Methode \"{className}\" nicht überschreiben.", "finalNonMethod": "Die Funktion „{name}“ kann nicht @final markiert werden, da sie keine Methode ist.", "finalReassigned": "\"{name}\" ist als \"Final\" deklariert und kann nicht neu zugewiesen werden.", "finalRedeclaration": "\"{name}\" wurde zuvor als \"Final\" deklariert.", @@ -261,20 +261,20 @@ "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.", - "initVarNotAllowed": "„ClassVar“ ist in diesem Kontext nicht zulässig.", + "initVarNotAllowed": "„InitVar“ ist in diesem Kontext nicht zulässig.", "instanceMethodSelfParam": "Instanzmethoden sollten einen \"self\"-Parameter verwenden.", "instanceVarOverridesClassVar": "Die Instanzvariable \"{name}\" überschreibt die Klassenvariable desselben Namens in der Klasse \"{className}\"", "instantiateAbstract": "Abstrakte Klasse \"{type}\" kann nicht erstellt werden.", - "instantiateProtocol": "Die Protokollklasse \"{type}\" kann nicht instanziiert werden.", + "instantiateProtocol": "Die Protocol-Klasse \"{type}\" kann nicht instanziiert werden.", "internalBindError": "Interner Fehler beim Binden der Datei \"{file}\": {message}", "internalParseError": "Interner Fehler beim Parsen der Datei \"{file}\": {message}", "internalTypeCheckingError": "Interner Fehler bei der Typüberprüfung der Datei \"{file}\": {message}", "invalidIdentifierChar": "Ungültiges Zeichen in Bezeichner", "invalidStubStatement": "Die Anweisung ist innerhalb einer Typstubdatei bedeutungslos.", "invalidTokenChars": "Ungültiges Zeichen \"{text}\" im Token", - "isInstanceInvalidType": "Das zweite Argument für \"isinstance\" muss eine Klasse oder ein Tupel von Klassen sein.", - "isSubclassInvalidType": "Das zweite Argument für \"issubclass\" muss eine Klasse oder ein Tupel von Klassen sein.", - "keyValueInSet": "Schlüssel-Wert-Paare sind innerhalb einer Menge nicht zulässig.", + "isInstanceInvalidType": "Das zweite Argument für \"isinstance\" muss eine Klasse oder tuple von Klassen sein.", + "isSubclassInvalidType": "Das zweite Argument für \"issubclass\" muss eine Klasse oder tuple von Klassen sein.", + "keyValueInSet": "Schlüssel-Wert-Paare sind innerhalb einer Menge „set“ nicht zulässig.", "keywordArgInTypeArgument": "Schlüsselwortargumente können nicht in Typargumentlisten verwendet werden.", "keywordArgShortcutIllegal": "Die Tastenkombination für Schlüsselwortargumente erfordert Python 3.14 oder höher.", "keywordOnlyAfterArgs": "Schlüsselworttrennzeichen ist nach dem Parameter \"*\" nicht zulässig.", @@ -283,13 +283,13 @@ "lambdaReturnTypePartiallyUnknown": "Der Rückgabetyp des Lambdaausdrucks \"{returnType}\" ist teilweise unbekannt.", "lambdaReturnTypeUnknown": "Der Rückgabetyp der Lambdafunktion ist unbekannt.", "listAssignmentMismatch": "Ein Ausdruck vom Typ \"{type}\" kann der Zielliste nicht zugewiesen werden.", - "listInAnnotation": "Ein Listenausdruck ist in der Typanmerkung nicht zulässig.", + "listInAnnotation": "Der Listenausdruck ist im Typausdruck nicht zulässig", "literalEmptyArgs": "Nach \"Literal\" wurde mindestens ein Typargument erwartet.", "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", + "literalUnsupportedType": "Typargumente für \"Literal\" müssen None, ein Literalwert (int, bool, str oder bytes) oder ein enum Wert sein.", + "matchIncompatible": "Match Anweisungen 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 das Attribut „{name}“ für die Klasse „{type}“ kann nicht zugegriffen werden", @@ -304,20 +304,21 @@ "methodOverridden": "\"{name}\" überschreibt die Methode mit demselben Namen in der Klasse \"{className}\" mit inkompatiblem Typ \"{type}\"", "methodReturnsNonObject": "Die Methode \"{name}\" gibt kein Objekt zurück.", "missingSuperCall": "Die Methode \"{methodName}\" ruft nicht die Methode mit demselben Namen in der übergeordneten Klasse auf.", + "mixingBytesAndStr": "Bytes- und str-Werte können nicht verkettet werden", "moduleAsType": "Das Modul kann nicht als Typ verwendet werden.", "moduleNotCallable": "Das Modul kann nicht aufgerufen werden.", "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.", - "namedTupleEntryRedeclared": "\"{name}\" kann nicht überschrieben werden, da die übergeordnete Klasse \"{className}\" ein benanntes Tupel ist.", - "namedTupleFirstArg": "Es wird ein benannter Tupelklassenname als erstes Argument erwartet.", + "namedTupleEmptyName": "Namen innerhalb benannten tuple dürfen nicht leer sein.", + "namedTupleEntryRedeclared": "\"{name}\" kann nicht überschrieben werden, da die übergeordnete benannte tuple Klasse \"{className}\" ist.", + "namedTupleFirstArg": "Es wird ein benannter tuple Klassenname als erstes Argument erwartet.", "namedTupleMultipleInheritance": "Mehrfachvererbung mit NamedTuple wird nicht unterstützt.", "namedTupleNameKeyword": "Feldnamen dürfen kein Schlüsselwort sein.", - "namedTupleNameType": "Es wurde ein Tupel mit zwei Einträgen unter Angabe von Eintragsname und -typ erwartet.", - "namedTupleNameUnique": "Namen innerhalb eines benannten Tupels müssen eindeutig sein.", + "namedTupleNameType": "Es wurde tuple mit zwei Einträgen unter Angabe von Eintragsname und -typ erwartet.", + "namedTupleNameUnique": "Namen innerhalb benannten tuple müssen eindeutig sein.", "namedTupleNoTypes": "\"namedtuple\" stellt keine Typen für Tupeleinträge bereit; verwenden Sie stattdessen \"NamedTuple\".", - "namedTupleSecondArg": "Benannte Tupeleintragsliste als zweites Argument erwartet", + "namedTupleSecondArg": "Benannte tuple Eintragsliste als zweites Argument erwartet", "newClsParam": "__new__ Außerkraftsetzung sollte einen \"cls\"-Parameter annehmen.", "newTypeAnyOrUnknown": "Das zweite Argument für NewType muss eine bekannte Klasse sein, nicht „Any“ oder „Unknown“.", "newTypeBadName": "Das erste Argument für NewType muss ein Zeichenfolgenliteral sein.", @@ -325,20 +326,20 @@ "newTypeNameMismatch": "NewType muss einer Variablen mit demselben Namen zugewiesen werden.", "newTypeNotAClass": "Klasse als zweites Argument für NewType erwartet", "newTypeParamCount": "NewType erfordert zwei Positionsargumente.", - "newTypeProtocolClass": "NewType kann nicht mit strukturellem Typ (Protokoll- oder TypedDict-Klasse) verwendet werden.", + "newTypeProtocolClass": "NewType kann nicht mit strukturellem Typ (Protocol- oder TypedDict-Klasse) verwendet werden.", "noOverload": "Keine Überladungen für \"{name}\" stimmen mit den angegebenen Argumenten überein.", - "noReturnContainsReturn": "Eine Funktion mit dem deklarierten Rückgabetyp \"NoReturn\" kann keine return-Anweisung enthalten.", + "noReturnContainsReturn": "Eine Funktion mit dem deklarierten return Typ \"NoReturn\" kann keine return-Anweisung enthalten.", "noReturnContainsYield": "Eine Funktion mit dem deklarierten Rückgabetyp \"NoReturn\" kann keine yield-Anweisung enthalten.", "noReturnReturnsNone": "Eine Funktion mit dem deklarierten Rückgabetyp \"NoReturn\" kann nicht \"None\" zurückgeben.", "nonDefaultAfterDefault": "Das nicht standardmäßige Argument folgt dem Standardargument.", - "nonLocalInModule": "Nichtlokale Deklaration auf Modulebene nicht zulässig", - "nonLocalNoBinding": "Es wurde keine Bindung für nichtlokale \"{name}\" gefunden.", - "nonLocalReassignment": "\"{name}\" wird vor einer nichtlokalen Deklaration zugewiesen.", - "nonLocalRedefinition": "\"{name}\" wurde bereits als nichtlokal deklariert.", + "nonLocalInModule": "Nonlocal Deklaration auf Modulebene nicht zulässig", + "nonLocalNoBinding": "Es wurde keine Bindung für nonlocal \"{name}\" gefunden.", + "nonLocalReassignment": "\"{name}\" wird vor einer nonlocal Deklaration zugewiesen.", + "nonLocalRedefinition": "\"{name}\" wurde bereits als nonlocal deklariert.", "noneNotCallable": "Ein Objekt vom Typ \"None\" kann nicht aufgerufen werden.", "noneNotIterable": "Ein Objekt vom Typ \"None\" kann nicht als iterierbarer Wert verwendet werden.", "noneNotSubscriptable": "Das Objekt vom Typ \"None\" kann nicht tiefgestellt werden.", - "noneNotUsableWith": "Ein Objekt vom Typ \"None\" kann nicht mit \"with\" verwendet werden.", + "noneNotUsableWith": "Object of type \"None\" cannot be used with \"with\"", "noneOperator": "Der Operator \"{operator}\" wird für den \"{None}\" nicht unterstützt.", "noneUnknownMember": "„{name}“ ist kein bekanntes Attribut von „None“", "notRequiredArgCount": "Nach \"NotRequired\" wurde ein einzelnes Typargument erwartet.", @@ -364,9 +365,9 @@ "overloadImplementationMismatch": "Die überladene Implementierung ist nicht konsistent mit der Signatur der Überladung {index}", "overloadReturnTypeMismatch": "Überladung {prevIndex} für \"{name}\" überlappt {newIndex} und gibt einen inkompatiblen Typ zurück.", "overloadStaticMethodInconsistent": "Überladungen für \"{name}\" verwenden @staticmethod inkonsistent", - "overloadWithoutImplementation": "\"{name}\" ist als Überladen markiert, es wurde jedoch keine Implementierung bereitgestellt.", - "overriddenMethodNotFound": "Die Methode \"{name}\" ist als Überschreibung markiert, aber es ist keine Basismethode mit demselben Namen vorhanden.", - "overrideDecoratorMissing": "Die Methode \"{name}\" ist nicht als Überschreibung markiert, überschreibt jedoch eine Methode in der Klasse \"{className}\"", + "overloadWithoutImplementation": "\"{name}\" ist als overload markiert, es wurde jedoch keine Implementierung bereitgestellt.", + "overriddenMethodNotFound": "Die Methode \"{name}\" ist als override markiert, aber es ist keine Basismethode mit demselben Namen vorhanden.", + "overrideDecoratorMissing": "Die Methode \"{name}\" ist nicht als override markiert, überschreibt jedoch eine Methode in der Klasse \"{className}\"", "paramAfterKwargsParam": "Der Parameter kann nicht auf den Parameter \"**\" folgen.", "paramAlreadyAssigned": "Der Parameter \"{name}\" ist bereits zugewiesen.", "paramAnnotationMissing": "Typanmerkung fehlt für Parameter \"{name}\"", @@ -377,9 +378,9 @@ "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.", + "paramSpecDefaultNotTuple": "Es wurde ein Auslassungszeichen, ein tuple Ausdruck oder ParamSpec für den Standardwert von ParamSpec erwartet.", "paramSpecFirstArg": "Der Name von ParamSpec wurde als erstes Argument erwartet.", - "paramSpecKwargsUsage": "Das Attribut „kwargs“ 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.", "paramSpecUnknownArg": "ParamSpec unterstützt nur ein Argument.", "paramSpecUnknownMember": "„{name}“ ist kein bekanntes Attribut von ParamSpec", @@ -387,7 +388,7 @@ "paramTypeCovariant": "Eine Variable vom Typ \"Covariant\" kann nicht im Parametertyp verwendet werden.", "paramTypePartiallyUnknown": "Der Typ des Parameters \"{paramName}\" ist teilweise unbekannt.", "paramTypeUnknown": "Der Typ des Parameters \"{paramName}\" ist unbekannt.", - "parenthesizedContextManagerIllegal": "Klammern innerhalb der with-Anweisung erfordern Python 3.9 oder höher.", + "parenthesizedContextManagerIllegal": "Parentheses within \"with\" statement requires Python 3.9 or newer", "patternNeverMatches": "Das Muster wird für den Antragstellertyp \"{type}\" nie abgeglichen", "positionArgAfterNamedArg": "Ein Positionsargument darf nicht nach Schlüsselwortargumenten stehen.", "positionOnlyAfterArgs": "Das Parametertrennzeichen \"Nur Position\" ist nach dem Parameter \"*\" nicht zulässig.", @@ -398,18 +399,18 @@ "privateImportFromPyTypedModule": "\"{name}\" wird nicht aus dem Modul \"{module}\" exportiert.", "privateUsedOutsideOfClass": "\"{name}\" ist privat und wird außerhalb der Klasse verwendet, in dem es deklariert ist.", "privateUsedOutsideOfModule": "\"{name}\" ist privat und wird außerhalb des Moduls verwendet, in dem es deklariert ist.", - "propertyOverridden": "\"{name}\" überschreibt die Eigenschaft desselben Namens in der Klasse \"{className}\" nicht ordnungsgemäß", - "propertyStaticMethod": "Statische Methoden sind für Eigenschaften-Getter, -Setter oder -Deleter nicht zulässig.", + "propertyOverridden": "\"{name}\" überschreibt property desselben Namens in der Klasse \"{className}\" nicht ordnungsgemäß", + "propertyStaticMethod": "Statische Methoden sind für property getter, setter oder deleter nicht zulässig.", "protectedUsedOutsideOfClass": "\"{name}\" ist geschützt und wird außerhalb der Klasse verwendet, in der es deklariert ist.", - "protocolBaseClass": "Die Protokollklasse \"{classType}\" kann nicht von einer Nichtprotokollklasse \"{baseType}\" abgeleitet werden", - "protocolBaseClassWithTypeArgs": "Typargumente sind mit der Protokollklasse nicht zulässig, wenn die Typparametersyntax verwendet wird.", + "protocolBaseClass": "Die Protocol-Klasse \"{classType}\" kann nicht von einer non-Protocol-Klasse \"{baseType}\" abgeleitet werden", + "protocolBaseClassWithTypeArgs": "Typargumente sind mit der Protocol Klasse nicht zulässig, wenn die Typparametersyntax verwendet wird.", "protocolIllegal": "Die Verwendung von \"Protocol\" erfordert Python 3.7 oder höher.", "protocolNotAllowed": "\"Protocol\" kann in diesem Kontext nicht verwendet werden.", "protocolTypeArgMustBeTypeParam": "Das Typargument für „Protocol“ muss ein Typparameter sein.", "protocolUnsafeOverlap": "Die Klasse überlappt unsicher mit „{name}“ und könnte zur Laufzeit eine Übereinstimmung erzeugen.", - "protocolVarianceContravariant": "Die Typvariable \"{variable}\", die im generischen Protokoll \"{class}\" verwendet wird, muss \"contravariant\" sein.", - "protocolVarianceCovariant": "Die Typvariable \"{variable}\", die im generischen Protokoll \"{class}\" verwendet wird, muss \"covariant\" sein.", - "protocolVarianceInvariant": "Die Typvariable \"{variable}\", die im generischen Protokoll \"{class}\" verwendet wird, muss \"invariant\" sein.", + "protocolVarianceContravariant": "Die Typvariable \"{variable}\", die im generischen Protocol \"{class}\" verwendet wird, muss \"contravariant\" sein.", + "protocolVarianceCovariant": "Die Typvariable \"{variable}\", die im generischen Protocol \"{class}\" verwendet wird, muss \"covariant\" sein.", + "protocolVarianceInvariant": "Die Typvariable \"{variable}\", die im generischen Protocol \"{class}\" verwendet wird, muss \"invariant\" sein.", "pyrightCommentInvalidDiagnosticBoolValue": "Auf die Pyright-Kommentardirektive muss \"=\" und der Wert \"true\" oder \"false\" folgen.", "pyrightCommentInvalidDiagnosticSeverityValue": "Auf die Pyright-Kommentardirektive muss \"=\" und der Wert \"true\", \"false\", \"error\", \"warning\", \"information\" oder \"none\" folgen.", "pyrightCommentMissingDirective": "Auf einen Pyright-Kommentar muss eine Direktive (basic oder strict) oder eine Diagnoseregel folgen.", @@ -427,11 +428,11 @@ "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": "Der Ausdruck vom Typ „{exprType}“ ist nicht mit dem Rückgabetyp „{returnType}“ kompatibel", + "returnTypeMismatch": "Der Typ „{exprType}“ kann dem Rückgabetyp „{returnType}“ nicht zugewiesen werden", "returnTypePartiallyUnknown": "Der Rückgabetyp \"{returnType}\" ist teilweise unbekannt.", "returnTypeUnknown": "Unbekannter Rückgabetyp", "revealLocalsArgs": "Es wurden keine Argumente für den Aufruf \"reveal_locals\" erwartet.", - "revealLocalsNone": "Keine lokalen Elemente in diesem Bereich", + "revealLocalsNone": "Keine locals Elemente in diesem Bereich", "revealTypeArgs": "Für den Aufruf \"reveal_type\" wurde ein einzelnes Positionsargument erwartet.", "revealTypeExpectedTextArg": "Das Argument \"expected_text\" für die Funktion \"reveal_type\" muss ein str-Literalwert sein.", "revealTypeExpectedTextMismatch": "Typentextkonflikt; \"{expected}\" erwartet, aber \"{received}\" empfangen", @@ -439,7 +440,7 @@ "selfTypeContext": "\"Self\" ist in diesem Kontext ungültig.", "selfTypeMetaclass": "„Self“ kann nicht innerhalb einer Metaklasse (einer Unterklasse von „type“) verwendet werden.", "selfTypeWithTypedSelfOrCls": "\"Self\" kann nicht in einer Funktion mit einem Parameter \"self\" oder \"cls\" verwendet werden, der eine andere Typanmerkung als \"Self\" aufweist.", - "setterGetterTypeMismatch": "Der Werttyp des Eigenschaftensetters kann dem Rückgabetyp des Getters nicht zugewiesen werden.", + "setterGetterTypeMismatch": "Der Property setter Werttyp kann dem getter Rückgabetyp nicht zugewiesen werden.", "singleOverload": "\"{name}\" ist als Überladung markiert, aber es fehlen weitere Überladungen.", "slotsAttributeError": "\"{name}\" ist in __slots__ nicht angegeben.", "slotsClassVarConflict": "\"{name}\" steht in Konflikt mit Instanzvariablen, die in __slots__ deklariert sind.", @@ -449,43 +450,43 @@ "staticClsSelfParam": "Statische Methoden dürfen keinen \"self\"- oder \"cls\"-Parameter annehmen.", "stdlibModuleOverridden": "\"{path}\" überschreibt das stdlib-Modul \"{name}\"", "stringNonAsciiBytes": "Ein Nicht-ASCII-Zeichen ist im Zeichenfolgenliteral in Bytes nicht zulässig.", - "stringNotSubscriptable": "Der Zeichenfolgenausdruck kann nicht in der Typanmerkung tiefgestellt werden; schließen Sie die gesamte Anmerkung in Anführungszeichen ein", + "stringNotSubscriptable": "Der Zeichenfolgenausdruck kann im Typausdruck nicht tiefgestellt werden; schließen Sie den samten Ausdruck in Anführungszeichen ein", "stringUnsupportedEscape": "Nicht unterstützte Escapesequenz im Zeichenfolgenliteral.", "stringUnterminated": "Das Zeichenfolgenliteral ist nicht beendet.", "stubFileMissing": "Die Stubdatei wurde für \"{importName}\" nicht gefunden.", "stubUsesGetAttr": "Die Typ-Stub-Datei ist unvollständig; \"__getattr__\" verdeckt Typfehler für Modul", - "sublistParamsIncompatible": "Unterlistenparameter werden in Python 3.x nicht unterstützt.", - "superCallArgCount": "Es werden nicht mehr als zwei Argumente für den Superaufruf erwartet.", + "sublistParamsIncompatible": "Sublist Parameter werden in Python 3.x nicht unterstützt.", + "superCallArgCount": "Es werden nicht mehr als zwei Argumente für den „super“ Aufruf erwartet.", "superCallFirstArg": "Klassentyp als erstes Argument für super-Aufruf erwartet, aber \"{type}\" empfangen", "superCallSecondArg": "Das zweite Argument für den \"super\"-Aufruf muss ein Objekt oder eine Klasse sein, das bzw. die von \"{type}\" abgeleitet wird.", - "superCallZeroArgForm": "Die Nullargumentform des „Superaufrufs“ ist nur innerhalb einer Methode gültig.", - "superCallZeroArgFormStaticMethod": "Die Nullargumentform des „Superaufrufs“ ist nicht innerhalb einer statischen Methode gültig.", + "superCallZeroArgForm": "Die Nullargumentform des „super“ Aufrufs ist nur innerhalb einer Methode gültig.", + "superCallZeroArgFormStaticMethod": "Die Nullargumentform des „super“ Aufrufs ist nicht innerhalb einer statischen Methode gültig.", "symbolIsPossiblyUnbound": "\"{name}\" ist möglicherweise ungebunden.", "symbolIsUnbound": "\"{name}\" ist ungebunden.", "symbolIsUndefined": "\"{name}\" ist nicht definiert.", "symbolOverridden": "\"{name}\" überschreibt das Symbol desselben Namens in der Klasse \"{className}\"", - "ternaryNotAllowed": "Ternärer Ausdruck in Typanmerkung nicht zulässig", + "ternaryNotAllowed": "Der ternäre Ausdruck ist im Typausdruck nicht zulässig", "totalOrderingMissingMethod": "Die Klasse muss \"__lt__\", \"__le__\", \"__gt__\" oder \"__ge__\" definieren, um total_ordering zu verwenden.", "trailingCommaInFromImport": "Nachgestelltes Komma ist ohne umgebende Klammern nicht zulässig.", "tryWithoutExcept": "Die try-Anweisung muss mindestens eine except- oder finally-Klausel aufweisen.", - "tupleAssignmentMismatch": "Ein Ausdruck vom Typ \"{type}\" kann dem Zieltupel nicht zugewiesen werden.", - "tupleInAnnotation": "Ein Tupelausdruck ist in der Typanmerkung nicht zulässig.", + "tupleAssignmentMismatch": "Ein Ausdruck vom Typ \"{type}\" kann dem Ziel-tuple nicht zugewiesen werden.", + "tupleInAnnotation": "Der Tuple-ausdruck ist im Typausdruck nicht zulässig", "tupleIndexOutOfRange": "Der Index {index} liegt für den Typ {type} außerhalb des gültigen Bereichs.", "typeAliasIllegalExpressionForm": "Ungültiges Ausdrucksformular für Typaliasdefinition", "typeAliasIsRecursiveDirect": "Der Typalias \"{name}\" kann sich nicht selbst in seiner Definition verwenden.", "typeAliasNotInModuleOrClass": "TypeAlias kann nur innerhalb eines Moduls oder Klassenbereichs definiert werden.", "typeAliasRedeclared": "\"{name}\" ist als TypeAlias deklariert und kann nur einmal zugewiesen werden.", - "typeAliasStatementBadScope": "Eine Typanweisung kann nur innerhalb eines Moduls oder Klassenbereichs verwendet werden.", + "typeAliasStatementBadScope": "Eine type Anweisung kann nur innerhalb eines Moduls oder Klassenbereichs verwendet werden.", "typeAliasStatementIllegal": "Die Typaliasanweisung erfordert Python 3.12 oder höher.", - "typeAliasTypeBaseClass": "Ein in einer „type“-Anweisung definierter Typalias kann nicht als Basisklasse verwendet werden.", + "typeAliasTypeBaseClass": "Ein in einer \"type\"-Anweisung definierter type Alias kann nicht als Basisklasse verwendet werden.", "typeAliasTypeMustBeAssigned": "TypeAliasType muss einer Variablen mit dem gleichen Namen wie der Typalias zugewiesen werden.", "typeAliasTypeNameArg": "Das erste Argument für TypeAliasType muss ein Zeichenfolgenliteral sein, das den Namen des Typalias darstellt.", "typeAliasTypeNameMismatch": "Der Name des Typalias muss mit dem Namen der Variablen übereinstimmen, der er zugewiesen ist.", - "typeAliasTypeParamInvalid": "Die Typparameterliste muss ein Tupel sein, das nur TypeVar, TypeVarTuple oder ParamSpec enthält.", + "typeAliasTypeParamInvalid": "Die Typparameterliste muss tuple sein, das nur TypeVar, TypeVarTuple oder ParamSpec enthält.", "typeAnnotationCall": "Der Aufrufausdruck ist im Typausdruck nicht zulässig", "typeAnnotationVariable": "Variable im Typausdruck nicht zulässig", "typeAnnotationWithCallable": "Das Typargument für \"type\" muss eine Klasse sein. Aufrufbare Elemente werden nicht unterstützt.", - "typeArgListExpected": "ParamSpec, Ellipse oder Liste der Typen erwartet", + "typeArgListExpected": "ParamSpec, Ellipse oder list der Typen erwartet", "typeArgListNotAllowed": "Der Listenausdruck ist für dieses Typargument nicht zulässig.", "typeArgsExpectingNone": "Für die Klasse \"{name}\" werden keine Typargumente erwartet.", "typeArgsMismatchOne": "Es wurde ein Typargument erwartet, es wurde jedoch {received} empfangen.", @@ -493,12 +494,13 @@ "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": "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.", + "typeAssignmentMismatch": "Der Typ „{sourceType}“ kann dem deklarierten Typ „{destType}“ nicht zugewiesen werden", + "typeAssignmentMismatchWildcard": "Das Importsymbol „{name}“ weist den Typ „{sourceType}“ auf, der dem deklarierten Typ „{destType}“ nicht zugewiesen werden kann.", + "typeCallNotAllowed": "Der type()-Aufruf darf nicht im Typausdruck 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", + "typeCommentDeprecated": "Die Verwendung von type Kommentaren ist veraltet; verwenden Sie stattdessen type Anmerkung", "typeExpectedClass": "Die Klasse wurde erwartet, aber „{type}“ wurde empfangen.", + "typeFormArgs": "„TypeForm“ akzeptiert ein einzelnes positionelles Argument", "typeGuardArgCount": "Nach \"TypeGuard\" oder \"TypeIs\" wurde ein einzelnes Typargument erwartet.", "typeGuardParamCount": "Benutzerdefinierte Typenschutzfunktionen und -methoden müssen mindestens einen Eingabeparameter aufweisen.", "typeIsReturnType": "Der Rückgabetyp von TypeIs (\"{returnType}\") ist nicht konsistent mit dem Wertparametertyp (\"{type}\").", @@ -537,14 +539,14 @@ "typeVarSingleConstraint": "TypeVar muss mindestens zwei eingeschränkte Typen aufweisen.", "typeVarTupleConstraints": "TypeVarTuple darf keine Werteinschränkungen aufweisen.", "typeVarTupleContext": "TypeVarTuple ist in diesem Kontext nicht zulässig.", - "typeVarTupleDefaultNotUnpacked": "Der Standardtyp \"TypeVarTuple\" muss ein entpacktes Tupel oder ein TypeVarTuple sein.", + "typeVarTupleDefaultNotUnpacked": "Der Standardtyp \"TypeVarTuple\" muss entpacktes tuple oder ein TypeVarTuple sein.", "typeVarTupleMustBeUnpacked": "Der Entpackungsoperator ist für den TypeVarTuple-Wert erforderlich.", - "typeVarTupleUnknownParam": "\"{name}\" ist ein unbekannter Parameter für TypeVar-Tuple.", + "typeVarTupleUnknownParam": "\"{name}\" ist ein unbekannter Parameter für TypeVarTuple.", "typeVarUnknownParam": "\"{name}\" ist ein unbekannter Parameter für TypeVar.", "typeVarUsedByOuterScope": "TypeVar \"{name}\" wird bereits von einem äußeren Bereich verwendet.", "typeVarUsedOnlyOnce": "TypeVar \"{name}\" wird in der generischen Funktionssignatur nur einmal angezeigt.", "typeVarVariance": "TypeVar darf nicht gleichzeitig \"covariant\" und \"contravariant\" sein.", - "typeVarWithDefaultFollowsVariadic": "TypeVar „{typeVarName}“ weist einen Standardwert auf und kann typeVarTuple „{variadicName}“ nicht folgen.", + "typeVarWithDefaultFollowsVariadic": "TypeVar „{typeVarName}“ weist einen Standardwert auf und kann TypeVarTuple „{variadicName}“ nicht folgen.", "typeVarWithoutDefault": "\"{name}\" kann nicht nach \"{other}\" in der Typparameterliste angezeigt werden, da es keinen Standardtyp aufweist.", "typeVarsNotInGenericOrProtocol": "Generic[] oder Protocol[] müssen alle Typvariablen enthalten.", "typedDictAccess": "Auf das Element in TypedDict konnte nicht zugegriffen werden.", @@ -552,8 +554,8 @@ "typedDictBadVar": "TypedDict-Klassen dürfen nur Typanmerkungen enthalten.", "typedDictBaseClass": "Alle Basisklassen für TypedDict-Klassen müssen auch TypedDict-Klassen sein.", "typedDictBoolParam": "Es wird erwartet, dass \"{name}\" Parameter den Wert \"True\" oder \"False\" aufweist.", - "typedDictClosedExtras": "Die Basisklasse „{name}“ ist ein geschlossenes TypedDict; zusätzliche Elemente müssen vom Typ „{type}“ sein.", - "typedDictClosedNoExtras": "Die Basisklasse „{name}“ ist ein geschlossenes TypedDict; zusätzliche Elemente sind nicht zulässig.", + "typedDictClosedExtras": "Die Basisklasse „{name}“ ist ein closed TypedDict; zusätzliche Elemente müssen vom Typ „{type}“ sein.", + "typedDictClosedNoExtras": "Die Basisklasse „{name}“ ist ein closed TypedDict; zusätzliche Elemente sind nicht zulässig.", "typedDictDelete": "Das Element in TypedDict konnte nicht gelöscht werden.", "typedDictEmptyName": "Namen innerhalb eines TypedDict dürfen nicht leer sein.", "typedDictEntryName": "Für den Wörterbucheintragsnamen wurde ein Zeichenfolgenliteral erwartet.", @@ -574,19 +576,19 @@ "unaccessedSymbol": "Auf \"{name}\" kann nicht zugegriffen werden.", "unaccessedVariable": "Auf die Variable \"{name}\" kann nicht zugegriffen werden.", "unannotatedFunctionSkipped": "Die Analyse der Funktion \"{name}\" wird übersprungen, da sie nicht kommentiert wurde.", - "unaryOperationNotAllowed": "Unärer Operator in Typanmerkung nicht zulässig", + "unaryOperationNotAllowed": "Der unäre Operator ist im Typausdruck nicht zulässig", "unexpectedAsyncToken": "Es wurde erwartet, dass \"def\", \"with\" oder \"for\" auf \"async\" folgt.", "unexpectedExprToken": "Unerwartetes Token am Ende des Ausdrucks.", "unexpectedIndent": "Unerwarteter Einzug", "unexpectedUnindent": "\"Unindent\" nicht erwartet.", "unhashableDictKey": "Der Wörterbuchschlüssel muss hashbar sein.", "unhashableSetEntry": "Der Eintrag \"Set\" muss hashbar sein.", - "uninitializedAbstractVariables": "In der abstrakten Basisklasse definierte Variablen sind in der endgültigen Klasse \"{classType}\" nicht initialisiert", + "uninitializedAbstractVariables": "In der abstrakten Basisklasse definierte Variablen sind in der final Klasse \"{classType}\" nicht initialisiert", "uninitializedInstanceVariable": "Die Instanzvariable \"{name}\" ist im Klassentext oder in der __init__ Methode nicht initialisiert.", "unionForwardReferenceNotAllowed": "Die Unionsyntax kann nicht mit einem Zeichenfolgenoperanden verwendet werden; verwenden Sie Anführungszeichen um den gesamten Ausdruck", "unionSyntaxIllegal": "Alternative Syntax für Unions erfordert Python 3.10 oder höher.", "unionTypeArgCount": "Union erfordert mindestens zwei Typargumente.", - "unionUnpackedTuple": "Union kann kein entpacktes Tupel enthalten.", + "unionUnpackedTuple": "Union kann kein entpacktes tuple enthalten.", "unionUnpackedTypeVarTuple": "Die Union kann kein entpacktes TypeVarTuple enthalten.", "unnecessaryCast": "Nicht erforderlicher \"cast\"-Aufruf; der Typ ist bereits \"{type}\".", "unnecessaryIsInstanceAlways": "Nicht erforderlicher isinstance-Aufruf; \"{testType}\" ist immer eine Instanz von \"{classType}\"", @@ -594,13 +596,13 @@ "unnecessaryPyrightIgnore": "Unnötiger \"# pyright: ignore\"-Kommentar", "unnecessaryPyrightIgnoreRule": "Unnötiger \"# pyright: ignore\"-Regel: \"{name}\"", "unnecessaryTypeIgnore": "Nicht erforderlicher \"# type: ignore\"-Kommentar", - "unpackArgCount": "Nach \"Required\" wurde ein einzelnes Typargument erwartet.", - "unpackExpectedTypeVarTuple": "„TypeVarTuple“ oder „Tupel“ als Typargument für „Unpack“ erwartet", + "unpackArgCount": "Nach \"Unpack\" wurde ein einzelnes Typargument erwartet.", + "unpackExpectedTypeVarTuple": "„TypeVarTuple“ oder „tuple“ als Typargument für „Unpack“ erwartet", "unpackExpectedTypedDict": "TypedDict-Typargument für Unpack erwartet", "unpackIllegalInComprehension": "Der Entpackvorgang ist in Verständnis nicht zulässig.", - "unpackInAnnotation": "Der Operator zum Entpacken ist in der Typanmerkung nicht zulässig.", + "unpackInAnnotation": "Der Operator zum Entpacken ist im Typausdruck nicht zulässig", "unpackInDict": "Der Entpackvorgang ist in Wörterbüchern nicht zulässig.", - "unpackInSet": "Der Operator zum Entpacken ist innerhalb einer Menge nicht zulässig.", + "unpackInSet": "Der Operator zum Entpacken ist innerhalb einer Menge „set“ nicht zulässig.", "unpackNotAllowed": "\"Unpack\" ist in diesem Kontext nicht zulässig.", "unpackOperatorNotAllowed": "Der Entpackvorgang ist in diesem Kontext nicht zulässig.", "unpackTuplesIllegal": "Der Entpackvorgang ist in Tupeln vor Python 3.8 nicht zulässig.", @@ -618,9 +620,9 @@ "unusedCallResult": "Das Ergebnis des Aufrufausdrucks ist vom Typ \"{type}\" und wird nicht verwendet; der Variablen \"_\" zuweisen, wenn dies beabsichtigt ist", "unusedCoroutine": "Das Ergebnis eines asynchronen Funktionsaufrufs wird nicht verwendet; verwenden Sie \"await\", oder weisen Sie der Variablen ein Ergebnis zu.", "unusedExpression": "Der Ausdruckswert wird nicht verwendet.", - "varAnnotationIllegal": "Typanmerkungen für Variablen erfordern Python 3.6 oder höher; verwenden Sie den Typkommentar für Kompatibilität mit früheren Versionen", + "varAnnotationIllegal": "Type Anmerkungen für Variablen erfordern Python 3.6 oder höher; verwenden Sie den type Kommentar für Kompatibilität mit früheren Versionen", "variableFinalOverride": "Die Variable \"{name}\" ist als \"Final\" gekennzeichnet und überschreibt die Nicht-Final-Variable desselben Namens in der Klasse \"{className}\"", - "variadicTypeArgsTooMany": "Die Liste der Typargumente darf höchstens ein entpacktes „TypeVarTuple“ oder „Tupel“ enthalten.", + "variadicTypeArgsTooMany": "Die Liste der Typargumente darf höchstens ein entpacktes „TypeVarTuple“ oder „tuple“ enthalten.", "variadicTypeParamTooManyAlias": "Der Typalias darf höchstens einen TypeVarTuple-Typparameter aufweisen, es wurden jedoch mehrere ({names}) empfangen.", "variadicTypeParamTooManyClass": "Die generische Klasse darf höchstens einen TypeVarTuple-Typparameter aufweisen, es wurden jedoch mehrere ({names}) empfangen.", "walrusIllegal": "Der Operator \":=\" erfordert Python 3.8 oder höher.", @@ -634,30 +636,30 @@ "yieldOutsideFunction": "\"yield\" ist außerhalb einer Funktion oder eines Lambdas nicht zulässig.", "yieldWithinComprehension": "„yield“ ist innerhalb eines Verständnisses nicht zulässig", "zeroCaseStatementsFound": "Die match-Anweisung muss mindestens eine case-Anweisung enthalten", - "zeroLengthTupleNotAllowed": "Ein Tupel mit der Länge Null ist in diesem Kontext nicht zulässig." + "zeroLengthTupleNotAllowed": "Zero-length tuple is not allowed in this context" }, "DiagnosticAddendum": { - "annotatedNotAllowed": "Das Sonderformular „Änderungsverlauf eingeblendet“ kann nicht mit Instanz- und Klassenüberprüfungen verwendet werden.", + "annotatedNotAllowed": "Das Sonderformular „Annotated“ kann nicht mit Instanz- und Klassenüberprüfungen verwendet werden.", "argParam": "Argument entspricht Parameter \"{paramName}\"", "argParamFunction": "Argument entspricht Parameter \"{paramName}\" in Funktion \"{functionName}\"", "argsParamMissing": "Der Parameter \"*{paramName}\" weist keinen entsprechenden Parameter auf.", "argsPositionOnly": "Nicht übereinstimmende Parameteranmerkungsanzahl: {expected} erwartet, aber {received} empfangen", "argumentType": "Argumenttyp ist \"{type}\"", "argumentTypes": "Argumenttypen: ({types})", - "assignToNone": "Der Typ ist nicht mit „None“ kompatibel", - "asyncHelp": "Meinten Sie \"asynchron mit\"?", + "assignToNone": "Der Typ kann nicht „None“ zugewiesen werden.", + "asyncHelp": "Meinten Sie \"async with\"?", "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.", "baseClassOverriddenType": "Die Basisklasse \"{baseClass}\" stellt einen Typ \"{type}\" bereit, der überschrieben wird.", "baseClassOverridesType": "Basisklasse \"{baseClass}\" überschreibt mit Typ \"{type}\"", - "bytesTypePromotions": "Legen Sie disableBytesTypePromotions auf FALSE fest, um das Typerweiterungsverhalten für \"bytearray\" und \"memoryview\" zu aktivieren.", + "bytesTypePromotions": "Legen Sie disableBytesTypePromotions auf false fest, um das Typerweiterungsverhalten für \"bytearray\" und \"memoryview\" zu aktivieren.", "conditionalRequiresBool": "Die Methode __bool__ für den Typ \"{operandType}\" gibt den Typ \"{boolReturnType}\" anstelle von \"bool\" zurück", "dataClassFieldLocation": "Felddeklaration", "dataClassFrozen": "\"{name}\" ist fixiert", "dataProtocolUnsupported": "„{name}“ ist ein Datenprotokoll.", "descriptorAccessBindingFailed": "Fehler beim Binden der Methode „{name}“ für die Deskriptorklasse „{className}“", "descriptorAccessCallFailed": "Fehler beim Aufrufen der Methode „{name}“ für die Deskriptorklasse „{className}“", - "finalMethod": "Endgültige Methode", + "finalMethod": "Final Methode", "functionParamDefaultMissing": "Standardargument für Parameter \"{name}\" fehlt.", "functionParamName": "Parameternamen stimmen nicht überein: \"{destName}\" und \"{srcName}\"", "functionParamPositionOnly": "Nicht übereinstimmender Parameter „nur für Position“. Der Parameter „{name}“ ist nicht „nur für Position“.", @@ -665,9 +667,9 @@ "functionTooFewParams": "Die Funktion akzeptiert zu wenige Positionsparameter; {expected} erwartet, aber {received} empfangen", "functionTooManyParams": "Die Funktion akzeptiert zu viele Positionsparameter; {expected} erwartet, aber {received} empfangen", "genericClassNotAllowed": "Ein generischer Typ mit Typargumenten ist für Instanz- oder Klassenprüfungen nicht zulässig.", - "incompatibleDeleter": "Die Deletermethode der Eigenschaft ist nicht kompatibel.", - "incompatibleGetter": "Die Gettermethode der Eigenschaft ist nicht kompatibel.", - "incompatibleSetter": "Die Settermethode der Eigenschaft ist nicht kompatibel.", + "incompatibleDeleter": "Die deleter Methode der Property ist nicht kompatibel.", + "incompatibleGetter": "Die Property getter Methode ist nicht kompatibel.", + "incompatibleSetter": "Die Property setter Methode ist nicht kompatibel.", "initMethodLocation": "Die __init__ Methode ist in der Klasse \"{type}\" definiert.", "initMethodSignature": "Die Signatur von __init__ ist \"{type}\".", "initSubclassLocation": "Die __init_subclass__ Methode ist in der Klasse \"{name}\" definiert.", @@ -681,7 +683,7 @@ "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}“ist nicht mit dem Typ „{destType}“ kompatibel", + "literalAssignmentMismatch": "„{sourceType}“ kann dem Typ „{destType}“ nicht zugewiesen werden.", "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 Attribut „{name}“ der Klasse „{classType}“ nicht zugewiesen werden", @@ -699,9 +701,9 @@ "memberTypeMismatch": "\"{name}\" ist ein inkompatibler Typ.", "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.", + "missingDeleter": "Die Property deleter Methode fehlt.", + "missingGetter": "Die Property getter Methode fehlt.", + "missingSetter": "Die Property setter Methode fehlt.", "namedParamMissingInDest": "Zusätzlicher Parameter \"{name}\"", "namedParamMissingInSource": "Fehlender Schlüsselwortparameter \"{name}\"", "namedParamTypeMismatch": "Der Schlüsselwortparameter „{name}“ vom Typ „{sourceType}“ ist nicht mit dem Typ „{destType}“ kompatibel", @@ -720,7 +722,7 @@ "overrideInvariantMismatch": "Der Überschreibungstyp \"{overrideType}\" ist nicht identisch mit dem Basistyp \"{baseType}\".", "overrideIsInvariant": "Die Variable ist veränderlich, sodass ihr Typ unveränderlich ist.", "overrideNoOverloadMatches": "Keine Überladungssignatur in Überschreibung ist mit der Basismethode kompatibel.", - "overrideNotClassMethod": "Die Basismethode ist als Klassenmethode deklariert, die Überschreibung jedoch nicht", + "overrideNotClassMethod": "Die Basismethode ist als classmethod deklariert, die Überschreibung jedoch nicht", "overrideNotInstanceMethod": "Die Basismethode ist als Instanz deklariert, die Überschreibung jedoch nicht", "overrideNotStaticMethod": "Die Basismethode ist als staticmethod deklariert, die Überschreibung jedoch nicht", "overrideOverloadNoMatch": "Außerkraftsetzung behandelt nicht alle Überladungen der Basismethode.", @@ -741,13 +743,13 @@ "paramType": "Parametertyp ist \"{paramType}\"", "privateImportFromPyTypedSource": "Stattdessen aus \"{module}\" importieren", "propertyAccessFromProtocolClass": "Auf eine in einer Protokollklasse definierte Eigenschaft kann nicht als Klassenvariable zugegriffen werden.", - "propertyMethodIncompatible": "Die Eigenschaftsmethode \"{name}\" ist inkompatibel.", - "propertyMethodMissing": "Die Eigenschaftsmethode \"{name}\" fehlt in der Überschreibung.", - "propertyMissingDeleter": "Die Eigenschaft \"{name}\" hat keinen definierten Deleter.", - "propertyMissingSetter": "Die Eigenschaft \"{name}\" hat keinen definierten Setter.", + "propertyMethodIncompatible": "Die Property-Methode \"{name}\" ist inkompatibel.", + "propertyMethodMissing": "Die Property-Methode \"{name}\" fehlt in der Überschreibung.", + "propertyMissingDeleter": "Property \"{name}\" hat keinen definierten deleter.", + "propertyMissingSetter": "Property \"{name}\" hat keinen definierten setter.", "protocolIncompatible": "\"{sourceType}\" ist nicht mit dem Protokoll \"{destType}\" kompatibel.", "protocolMemberMissing": "\"{name}\" ist nicht vorhanden.", - "protocolRequiresRuntimeCheckable": "Die Protokollklasse muss @runtime_checkable sein, damit sie mit Instanz- und Klassenprüfungen verwendet werden kann.", + "protocolRequiresRuntimeCheckable": "Die Protocol Klasse muss @runtime_checkable sein, damit sie mit Instanz- und Klassenprüfungen verwendet werden kann.", "protocolSourceIsNotConcrete": "\"{sourceType}\" ist kein konkreter Klassentyp und kann dem Typ \"{destType}\" nicht zugewiesen werden.", "protocolUnsafeOverlap": "Attribute von „{name}“ weisen die gleichen Namen wie das Protokoll auf.", "pyrightCommentIgnoreTip": "Verwenden Sie \"# pyright: ignore[]\", um die Diagnose für eine einzelne Zeile zu unterdrücken.", @@ -759,17 +761,17 @@ "seeParameterDeclaration": "Siehe Parameterdeklaration", "seeTypeAliasDeclaration": "Siehe Typaliasdeklaration", "seeVariableDeclaration": "Siehe Variablendeklaration", - "tupleAssignmentMismatch": "Der Typ \"{type}\" ist nicht mit dem Zieltupel kompatibel.", - "tupleEntryTypeMismatch": "Der Tupeleintrag {entry} ist ein falscher Typ.", - "tupleSizeIndeterminateSrc": "Nicht übereinstimmende Tupelgröße; {expected} erwartet, aber unbestimmt empfangen", - "tupleSizeIndeterminateSrcDest": "Nicht übereinstimmende Tupelgröße; {expected} oder mehr erwartet, aber „unbestimmt“ empfangen", - "tupleSizeMismatch": "Nicht übereinstimmende Tupelgröße; {expected} erwartet, aber {received} empfangen", - "tupleSizeMismatchIndeterminateDest": "Nicht übereinstimmende Tupelgröße; {expected} oder mehr erwartet, aber {received} empfangen", + "tupleAssignmentMismatch": "Der Typ \"{type}\" ist nicht mit dem Ziel-tuple kompatibel.", + "tupleEntryTypeMismatch": "Der Tuple-eintrag {entry} ist ein falscher Typ.", + "tupleSizeIndeterminateSrc": "Nicht übereinstimmende Tuple Größe; {expected} erwartet, aber unbestimmt empfangen", + "tupleSizeIndeterminateSrcDest": "Nicht übereinstimmende Tuple Größe; {expected} oder mehr erwartet, aber „unbestimmt“ empfangen", + "tupleSizeMismatch": "Nicht übereinstimmende Tuple Größe; {expected} erwartet, aber {received} empfangen", + "tupleSizeMismatchIndeterminateDest": "Nicht übereinstimmende Tuple Größ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}“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.", + "typeAssignmentMismatch": "Der Typ „{sourceType}“ kann dem Typ „{destType}“ nicht zugewiesen werden.", + "typeBound": "Der Typ „{sourceType}“ kann der oberen Grenze „{destType}“ für die Typvariable „{name}“ nicht zugewiesen werden.", + "typeConstrainedTypeVar": "Der Typ „{type}“ kann der eingeschränkten Typvariablen „{name}“ nicht zugewiesen werden", + "typeIncompatible": "„{sourceType}“ kann „{destType}“ nicht zugewiesen werden.", "typeNotClass": "\"{type}\" ist keine Klasse.", "typeNotStringLiteral": "\"{type}\" ist kein Zeichenfolgenliteral.", "typeOfSymbol": "Der Typ von \"{name}\" ist \"{type}\".", @@ -780,7 +782,7 @@ "typeVarIsCovariant": "Der Typparameter \"{name}\" ist kovariant, aber \"{sourceType}\" ist kein Untertyp von \"{destType}\"", "typeVarIsInvariant": "Der Typparameter \"{name}\" ist invariant, \"{sourceType}\" ist jedoch nicht identisch mit \"{destType}\"", "typeVarNotAllowed": "TypeVar ist für Instanz- oder Klassenprüfungen nicht zulässig.", - "typeVarTupleRequiresKnownLength": "TypeVarTuple kann nicht an ein Tupel unbekannter Länge gebunden werden.", + "typeVarTupleRequiresKnownLength": "TypeVarTuple kann nicht an tuple unbekannter Länge gebunden werden.", "typeVarUnnecessarySuggestion": "Stattdessen {type} verwenden", "typeVarUnsolvableRemedy": "Geben Sie eine Überladung an, die den Rückgabetyp angibt, wenn das Argument nicht angegeben ist.", "typeVarsMissing": "Fehlende Typvariablen: {names}", @@ -804,9 +806,9 @@ "uninitializedAbstractVariable": "Die Instanzvariable \"{name}\" ist in einer abstrakten Basisklasse \"{classType}\" definiert, aber nicht initialisiert.", "unreachableExcept": "\"{exceptionType}\" ist eine Unterklasse von \"{parentType}\"", "useDictInstead": "Verwenden Sie Dict[T1, T2], um einen Wörterbuchtyp anzugeben.", - "useListInstead": "Verwenden Sie List[T], um einen Listentyp anzugeben, oder Union[T1, T2], um einen Vereinigungstyp anzugeben.", - "useTupleInstead": "Verwenden Sie Tupel[T1, ..., Tn], um einen Tupeltyp anzugeben, oder Union[T1, T2], um einen Union-Typ anzugeben.", - "useTypeInstead": "Stattdessen Typ[T] verwenden", + "useListInstead": "Verwenden Sie List[T], um einen list Typ anzugeben, oder Union[T1, T2], um einen union-Typ anzugeben.", + "useTupleInstead": "Verwenden Sie tuple[T1, ..., Tn], um einen tuple-Typ anzugeben, oder Union[T1, T2], um einen union-Typ anzugeben.", + "useTypeInstead": "Stattdessen Type[T] verwenden", "varianceMismatchForClass": "Die Varianz des Typarguments \"{typeVarName}\" ist nicht mit der Basisklasse \"{className}\" kompatibel", "varianceMismatchForTypeAlias": "Die Varianz des Typarguments \"{typeVarName}\" ist nicht mit \"{typeAliasParam}\" kompatibel" }, diff --git a/packages/pyright-internal/src/localization/package.nls.en-us.json b/packages/pyright-internal/src/localization/package.nls.en-us.json index e27391bb8..13cee259b 100644 --- a/packages/pyright-internal/src/localization/package.nls.en-us.json +++ b/packages/pyright-internal/src/localization/package.nls.en-us.json @@ -1,7 +1,13 @@ { "CodeAction": { - "createTypeStub": "Create Type Stub", - "createTypeStubFor": "Create Type Stub For \"{moduleName}\"", + "createTypeStub": { + "message": "Create Type Stub", + "comment": "{Locked='Stub'}" + }, + "createTypeStubFor": { + "message": "Create Type Stub For \"{moduleName}\"", + "comment": "{Locked='Stub'}" + }, "executingCommand": "Executing command", "filesToAnalyzeCount": "{count} files to analyze", "filesToAnalyzeOne": "1 file to analyze", @@ -22,7 +28,10 @@ "comment": "{Locked='Annotated'}" }, "annotationBytesString": "Type expressions cannot use bytes string literals", - "annotationFormatString": "Type expressions cannot use format string literals (f-strings)", + "annotationFormatString": { + "message": "Type expressions cannot use format string literals (f-strings)", + "comment": "'f-string' is the common English slang for a Python format string" + }, "annotationNotSupported": "Type annotation not supported for this statement", "annotationRawString": "Type expressions cannot use raw string literals", "annotationSpansStrings": "Type expressions cannot span multiple string literals", @@ -40,68 +49,170 @@ "argPositionalExpectedOne": "Expected 1 positional argument", "argTypePartiallyUnknown": "Argument type is partially unknown", "argTypeUnknown": "Argument type is unknown", - "assertAlwaysTrue": "Assert expression always evaluates to true", - "assertTypeArgs": "\"assert_type\" expects two positional arguments", - "assertTypeTypeMismatch": "\"assert_type\" mismatch: expected \"{expected}\" but received \"{received}\"", - "assignmentExprComprehension": "Assignment expression target \"{name}\" cannot use same name as comprehension for target", + "assertAlwaysTrue": { + "message": "Assert expression always evaluates to true", + "comment": "{Locked='true'}" + }, + "assertTypeArgs": { + "message": "\"assert_type\" expects two positional arguments", + "comment": "{Locked='assert_type'}" + }, + "assertTypeTypeMismatch": { + "message": "\"assert_type\" mismatch: expected \"{expected}\" but received \"{received}\"", + "comment": "{Locked='assert_type'}" + }, + "assignmentExprComprehension": { + "message": "Assignment expression target \"{name}\" cannot use same name as comprehension for target", + "comment": "A comprehension is a 'set of looping and filtering instructions' applied to a collection to generate a new collection; the word may not be translatable" + }, "assignmentExprContext": "Assignment expression must be within module, function or lambda", "assignmentExprInSubscript": "Assignment expressions within a subscript are supported only in Python 3.10 and newer", - "assignmentInProtocol": "Instance or class variables within a Protocol class must be explicitly declared within the class body", + "assignmentInProtocol": { + "message": "Instance or class variables within a Protocol class must be explicitly declared within the class body", + "comment": "{Locked='Protocol'}" + }, "assignmentTargetExpr": "Expression cannot be assignment target", - "asyncNotInAsyncFunction": "Use of \"async\" not allowed outside of async function", - "awaitIllegal": "Use of \"await\" requires Python 3.5 or newer", - "awaitNotAllowed": "Type expressions cannot use \"await\"", - "awaitNotInAsync": "\"await\" allowed only within async function", - "backticksIllegal": "Expressions surrounded by backticks are not supported in Python 3.x; use repr instead", + "asyncNotInAsyncFunction": { + "message": "Use of \"async\" not allowed outside of async function", + "comment": "{Locked='async'}" + }, + "awaitIllegal": { + "message": "Use of \"await\" requires Python 3.5 or newer", + "comment": "{Locked='await'}" + }, + "awaitNotAllowed": { + "message": "Type expressions cannot use \"await\"", + "comment": "{Locked='await'}" + }, + "awaitNotInAsync": { + "message": "\"await\" allowed only within async function", + "comment": "{Locked='await','async'}" + }, + "backticksIllegal": { + "message": "Expressions surrounded by backticks are not supported in Python 3.x; use repr instead", + "comment": "{Locked='repr'}" + }, "baseClassCircular": "Class cannot derive from itself", - "baseClassFinal": "Base class \"{type}\" is marked final and cannot be subclassed", + "baseClassFinal": { + "message": "Base class \"{type}\" is marked final and cannot be subclassed", + "comment": "{Locked='final'}" + }, "baseClassIncompatible": "Base classes of {type} are mutually incompatible", "baseClassInvalid": "Argument to class must be a base class", "baseClassMethodTypeIncompatible": "Base classes for class \"{classType}\" define method \"{name}\" in incompatible way", "baseClassUnknown": "Base class type is unknown, obscuring type of derived class", "baseClassVariableTypeIncompatible": "Base classes for class \"{classType}\" define variable \"{name}\" in incompatible way", "binaryOperationNotAllowed": "Binary operator not allowed in type expression", - "bindTypeMismatch": "Could not bind method \"{methodName}\" because \"{type}\" is not assignable to parameter \"{paramName}\"", - "breakOutsideLoop": "\"break\" can be used only within a loop", - "callableExtraArgs": "Expected only two type arguments to \"Callable\"", + "bindTypeMismatch": { + "message": "Could not bind method \"{methodName}\" because \"{type}\" is not assignable to parameter \"{paramName}\"", + "comment": "Binding is the process through which Pyright determines what object a name refers to" + }, + "breakOutsideLoop": { + "message": "\"break\" can be used only within a loop", + "comment": "{Locked='break'}" + }, + "callableExtraArgs": { + "message": "Expected only two type arguments to \"Callable\"", + "comment": "{Locked='Callable'}" + }, "callableFirstArg": "Expected parameter type list or \"...\"", "callableNotInstantiable": "Cannot instantiate type \"{type}\"", - "callableSecondArg": "Expected return type as second type argument for \"Callable\"", + "callableSecondArg": { + "message": "Expected return type as second type argument for \"Callable\"", + "comment": "{Locked='Callable'}" + }, "casePatternIsIrrefutable": "Irrefutable pattern is allowed only for the last case statement", "classAlreadySpecialized": "Type \"{type}\" is already specialized", "classDecoratorTypeUnknown": "Untyped class decorator obscures type of class; ignoring decorator", "classDefinitionCycle": "Class definition for \"{name}\" depends on itself", - "classGetItemClsParam": "__class_getitem__ override should take a \"cls\" parameter", - "classMethodClsParam": "Class methods should take a \"cls\" parameter", + "classGetItemClsParam": { + "message": "__class_getitem__ override should take a \"cls\" parameter", + "comment": "{Locked='__class_getitem__','cls'}" + }, + "classMethodClsParam": { + "message": "Class methods should take a \"cls\" parameter", + "comment": "{Locked='cls'}" + }, "classNotRuntimeSubscriptable": "Subscript for class \"{name}\" will generate runtime exception; enclose type expression in quotes", "classPatternBuiltInArgPositional": "Class pattern accepts only positional sub-pattern", "classPatternPositionalArgCount": "Too many positional patterns for class \"{type}\"; expected {expected} but received {received}", "classPatternTypeAlias": "\"{type}\" cannot be used in a class pattern because it is a specialized type alias", "classPropertyDeprecated": "Class properties are deprecated in Python 3.11 and will not be supported in Python 3.13", "classTypeParametersIllegal": "Class type parameter syntax requires Python 3.12 or newer", - "classVarFirstArgMissing": "Expected a type argument after \"ClassVar\"", - "classVarNotAllowed": "\"ClassVar\" is not allowed in this context", + "classVarFirstArgMissing": { + "message": "Expected a type argument after \"ClassVar\"", + "comment": "{Locked='ClassVar'}" + }, + "classVarNotAllowed": { + "message": "\"ClassVar\" is not allowed in this context", + "comment": "{Locked='ClassVar'}" + }, "classVarOverridesInstanceVar": "Class variable \"{name}\" overrides instance variable of same name in class \"{className}\"", - "classVarTooManyArgs": "Expected only one type argument after \"ClassVar\"", - "classVarWithTypeVar": "\"ClassVar\" type cannot include type variables", + "classVarTooManyArgs": { + "message": "Expected only one type argument after \"ClassVar\"", + "comment": "{Locked='ClassVar'}" + }, + "classVarWithTypeVar": { + "message": "\"ClassVar\" type cannot include type variables", + "comment": "{Locked='ClassVar'}" + }, "clsSelfParamTypeMismatch": "Type of parameter \"{name}\" must be a supertype of its class \"{classType}\"", "codeTooComplexToAnalyze": "Code is too complex to analyze; reduce complexity by refactoring into subroutines or reducing conditional code paths", "collectionAliasInstantiation": "Type \"{type}\" cannot be instantiated, use \"{alias}\" instead", - "comparisonAlwaysFalse": "Condition will always evaluate to False since the types \"{leftType}\" and \"{rightType}\" have no overlap", - "comparisonAlwaysTrue": "Condition will always evaluate to True since the types \"{leftType}\" and \"{rightType}\" have no overlap", - "comprehensionInDict": "Comprehension cannot be used with other dictionary entries", - "comprehensionInSet": "Comprehension cannot be used with other set entries", - "concatenateContext": "\"Concatenate\" is not allowed in this context", - "concatenateParamSpecMissing": "Last type argument for \"Concatenate\" must be a ParamSpec or \"...\"", - "concatenateTypeArgsMissing": "\"Concatenate\" requires at least two type arguments", + "comparisonAlwaysFalse": { + "message": "Condition will always evaluate to False since the types \"{leftType}\" and \"{rightType}\" have no overlap", + "comment": "{Locked='False'}" + }, + "comparisonAlwaysTrue": { + "message": "Condition will always evaluate to True since the types \"{leftType}\" and \"{rightType}\" have no overlap", + "comment": "{Locked='True'}" + }, + "comprehensionInDict": { + "message": "Comprehension cannot be used with other dictionary entries", + "comment": "A comprehension is a 'set of looping and filtering instructions' applied to a collection to generate a new collection; the word may not be translatable" + }, + "comprehensionInSet": { + "message": "Comprehension cannot be used with other set entries", + "comment": ["{Locked='set'}", "A comprehension is a 'set of looping and filtering instructions' applied to a collection to generate a new collection; the word may not be translatable"] + }, + "concatenateContext": { + "message": "\"Concatenate\" is not allowed in this context", + "comment": "{Locked='Concatenate'}" + }, + "concatenateParamSpecMissing": { + "message": "Last type argument for \"Concatenate\" must be a ParamSpec or \"...\"", + "comment": "{Locked='Concatenate','ParamSpec','...'}" + }, + "concatenateTypeArgsMissing": { + "message": "\"Concatenate\" requires at least two type arguments", + "comment": "{Locked='Concatenate'}" + }, "conditionalOperandInvalid": "Invalid conditional operand of type \"{type}\"", "constantRedefinition": "\"{name}\" is constant (because it is uppercase) and cannot be redefined", - "constructorParametersMismatch": "Mismatch between signature of __new__ and __init__ in class \"{classType}\"", - "containmentAlwaysFalse": "Expression will always evaluate to False since the types \"{leftType}\" and \"{rightType}\" have no overlap", - "containmentAlwaysTrue": "Expression will always evaluate to True since the types \"{leftType}\" and \"{rightType}\" have no overlap", - "continueInFinally": "\"continue\" cannot be used within a finally clause", - "continueOutsideLoop": "\"continue\" can be used only within a loop", - "coroutineInConditionalExpression": "Conditional expression references coroutine which always evaluates to True", + "constructorParametersMismatch": { + "message": "Mismatch between signature of __new__ and __init__ in class \"{classType}\"", + "comment": "{Locked='__new__','__init__'}" + }, + "containmentAlwaysFalse": { + "message": "Expression will always evaluate to False since the types \"{leftType}\" and \"{rightType}\" have no overlap", + "comment": "{Locked='False'}" + }, + "containmentAlwaysTrue": { + "message": "Expression will always evaluate to True since the types \"{leftType}\" and \"{rightType}\" have no overlap", + "comment": "{Locked='True'}" + }, + "continueInFinally": { + "message": "\"continue\" cannot be used within a finally clause", + "comment": "{Locked='continue','finally'}" + }, + "continueOutsideLoop": { + "message": "\"continue\" can be used only within a loop", + "comment": "{Locked='continue'}" + }, + "coroutineInConditionalExpression": { + "message": "Conditional expression references coroutine which always evaluates to True", + "comment": "{Locked='True'}" + }, "dataClassBaseClassFrozen": "A non-frozen class cannot inherit from a class that is frozen", "dataClassBaseClassNotFrozen": "A frozen class cannot inherit from a class that is not frozen", "dataClassConverterFunction": "Argument of type \"{argType}\" is not a valid converter for field \"{fieldName}\" of type \"{fieldType}\"", @@ -110,14 +221,38 @@ "dataClassFieldWithDefault": "Fields without default values cannot appear after fields with default values", "dataClassFieldWithPrivateName": "Dataclass field cannot use private name", "dataClassFieldWithoutAnnotation": "Dataclass field without type annotation will cause runtime exception", - "dataClassPostInitParamCount": "Dataclass __post_init__ incorrect parameter count; number of InitVar fields is {expected}", - "dataClassPostInitType": "Dataclass __post_init__ method parameter type mismatch for field \"{fieldName}\"", - "dataClassSlotsOverwrite": "__slots__ is already defined in class", - "dataClassTransformExpectedBoolLiteral": "Expected expression that statically evaluates to True or False", - "dataClassTransformFieldSpecifier": "Expected tuple of classes or functions but received type \"{type}\"", - "dataClassTransformPositionalParam": "All arguments to \"dataclass_transform\" must be keyword arguments", - "dataClassTransformUnknownArgument": "Argument \"{name}\" is not supported by dataclass_transform", - "dataProtocolInSubclassCheck": "Data protocols (which include non-method attributes) are not allowed in issubclass calls", + "dataClassPostInitParamCount": { + "message": "Dataclass __post_init__ incorrect parameter count; number of InitVar fields is {expected}", + "comment": "{Locked='__post_init__','InitVar'}" + }, + "dataClassPostInitType": { + "message": "Dataclass __post_init__ method parameter type mismatch for field \"{fieldName}\"", + "comment": "{Locked='__post_init__'}" + }, + "dataClassSlotsOverwrite": { + "message": "__slots__ is already defined in class", + "comment": "{Locked='__slots__'}" + }, + "dataClassTransformExpectedBoolLiteral": { + "message": "Expected expression that statically evaluates to True or False", + "comment": "{Locked='True','False'}" + }, + "dataClassTransformFieldSpecifier": { + "message": "Expected tuple of classes or functions but received type \"{type}\"", + "comment": "{Locked='tuple'}" + }, + "dataClassTransformPositionalParam": { + "message": "All arguments to \"dataclass_transform\" must be keyword arguments", + "comment": "{Locked='dataclass_transform'}" + }, + "dataClassTransformUnknownArgument": { + "message": "Argument \"{name}\" is not supported by dataclass_transform", + "comment": "{Locked='dataclass_transform'}" + }, + "dataProtocolInSubclassCheck": { + "message": "Data protocols (which include non-method attributes) are not allowed in issubclass calls", + "comment": "{Locked='issubclass'}" + }, "declaredReturnTypePartiallyUnknown": "Declared return type, \"{returnType}\", is partially unknown", "declaredReturnTypeUnknown": "Declared return type is unknown", "defaultValueContainsCall": "Function calls and mutable objects not allowed within parameter default value expression", @@ -130,21 +265,45 @@ "deprecatedDescriptorSetter": "The \"__set__\" method for descriptor \"{name}\" is deprecated", "deprecatedFunction": "The function \"{name}\" is deprecated", "deprecatedMethod": "The method \"{name}\" in class \"{className}\" is deprecated", - "deprecatedPropertyDeleter": "The deleter for property \"{name}\" is deprecated", - "deprecatedPropertyGetter": "The getter for property \"{name}\" is deprecated", - "deprecatedPropertySetter": "The setter for property \"{name}\" is deprecated", + "deprecatedPropertyDeleter": { + "message": "The deleter for property \"{name}\" is deprecated", + "comment": "{Locked='deleter','property'}" + }, + "deprecatedPropertyGetter": { + "message": "The getter for property \"{name}\" is deprecated", + "comment": "{Locked='getter','property'}" + }, + "deprecatedPropertySetter": { + "message": "The setter for property \"{name}\" is deprecated", + "comment": "{Locked='setter','property'}" + }, "deprecatedType": "This type is deprecated as of Python {version}; use \"{replacement}\" instead", - "dictExpandIllegalInComprehension": "Dictionary expansion not allowed in comprehension", + "dictExpandIllegalInComprehension": { + "message": "Dictionary expansion not allowed in comprehension", + "comment": "A comprehension is a 'set of looping and filtering instructions' applied to a collection to generate a new collection; the word may not be translatable" + }, "dictInAnnotation": "Dictionary expression not allowed in type expression", "dictKeyValuePairs": "Dictionary entries must contain key/value pairs", "dictUnpackIsNotMapping": "Expected mapping for dictionary unpack operator", - "dunderAllSymbolNotPresent": "\"{name}\" is specified in __all__ but is not present in module", + "dunderAllSymbolNotPresent": { + "message": "\"{name}\" is specified in __all__ but is not present in module", + "comment": "{Locked='__all__'}" + }, "duplicateArgsParam": "Only one \"*\" parameter allowed", "duplicateBaseClass": "Duplicate base class not allowed", "duplicateCapturePatternTarget": "Capture target \"{name}\" cannot appear more than once within the same pattern", - "duplicateCatchAll": "Only one catch-all except clause allowed", - "duplicateEnumMember": "Enum member \"{name}\" is already declared", - "duplicateGenericAndProtocolBase": "Only one Generic[...] or Protocol[...] base class allowed", + "duplicateCatchAll": { + "message": "Only one catch-all except clause allowed", + "comment": "{Locked='except'}" + }, + "duplicateEnumMember": { + "message": "Enum member \"{name}\" is already declared", + "comment": "{Locked='Enum'}" + }, + "duplicateGenericAndProtocolBase": { + "message": "Only one Generic[...] or Protocol[...] base class allowed", + "comment": "{Locked='Generic[...]','Protocol[...]'}" + }, "duplicateImport": "\"{importName}\" is imported more than once", "duplicateKeywordOnly": "Only one \"*\" separator allowed", "duplicateKwargsParam": "Only one \"**\" parameter allowed", @@ -152,14 +311,32 @@ "duplicatePositionOnly": "Only one \"/\" parameter allowed", "duplicateStarPattern": "Only one \"*\" pattern allowed in a pattern sequence", "duplicateStarStarPattern": "Only one \"**\" entry allowed", - "duplicateUnpack": "Only one unpack operation allowed in list", - "ellipsisAfterUnpacked": "\"...\" cannot be used with an unpacked TypeVarTuple or tuple", + "duplicateUnpack": { + "message": "Only one unpack operation allowed in list", + "comment": "{Locked='list'}" + }, + "ellipsisAfterUnpacked": { + "message": "\"...\" cannot be used with an unpacked TypeVarTuple or tuple", + "comment": "{Locked='TypeVarTuple','tuple'}" + }, "ellipsisContext": "\"...\" is not allowed in this context", "ellipsisSecondArg": "\"...\" is allowed only as the second of two arguments", - "enumClassOverride": "Enum class \"{name}\" is final and cannot be subclassed", - "enumMemberDelete": "Enum member \"{name}\" cannot be deleted", - "enumMemberSet": "Enum member \"{name}\" cannot be assigned", - "enumMemberTypeAnnotation": "Type annotations are not allowed for enum members", + "enumClassOverride": { + "message": "Enum class \"{name}\" is final and cannot be subclassed", + "comment": "{Locked='Enum','final'}" + }, + "enumMemberDelete": { + "message": "Enum member \"{name}\" cannot be deleted", + "comment": "{Locked='Enum'}" + }, + "enumMemberSet": { + "message": "Enum member \"{name}\" cannot be assigned", + "comment": "{Locked='Enum'}" + }, + "enumMemberTypeAnnotation": { + "message": "Type annotations are not allowed for enum members", + "comment": "{Locked='enum'}" + }, "exceptionGroupIncompatible": { "message": "Exception group syntax (\"except*\") requires Python 3.11 or newer", "comment": "{Locked='except*'}" @@ -168,46 +345,91 @@ "message": "Exception type in except* cannot derive from BaseGroupException", "comment": "{Locked='except*','BaseGroupException'}" }, - "exceptionTypeIncorrect": "\"{type}\" does not derive from BaseException", + "exceptionTypeIncorrect": { + "message": "\"{type}\" does not derive from BaseException", + "comment": "{Locked='BaseException'}" + }, "exceptionTypeNotClass": "\"{type}\" is not a valid exception class", "exceptionTypeNotInstantiable": "Constructor for exception type \"{type}\" requires one or more arguments", "expectedAfterDecorator": "Expected function or class declaration after decorator", "expectedArrow": "Expected \"->\" followed by return type annotation", - "expectedAsAfterException": "Expected \"as\" after exception type", + "expectedAsAfterException": { + "message": "Expected \"as\" after exception type", + "comment": "{Locked='as'}" + }, "expectedAssignRightHandExpr": "Expected expression to the right of \"=\"", "expectedBinaryRightHandExpr": "Expected expression to the right of operator", "expectedBoolLiteral": { "message": "Expected True or False", "comment": "{Locked='True','False'}" }, - "expectedCase": "Expected \"case\" statement", + "expectedCase": { + "message": "Expected \"case\" statement", + "comment": "{Locked='case'}" + }, "expectedClassName": "Expected class name", "expectedCloseBrace": "\"{\" was not closed", "expectedCloseBracket": "\"[\" was not closed", "expectedCloseParen": "\"(\" was not closed", "expectedColon": "Expected \":\"", - "expectedComplexNumberLiteral": "Expected complex number literal for pattern matching", + "expectedComplexNumberLiteral": { + "message": "Expected complex number literal for pattern matching", + "comment": "Complex numbers are a mathematical concept consisting of a real number and an imaginary number" + }, "expectedDecoratorExpr": "Expression form not supported for decorator prior to Python 3.9", "expectedDecoratorName": "Expected decorator name", "expectedDecoratorNewline": "Expected new line at end of decorator", - "expectedDelExpr": "Expected expression after \"del\"", - "expectedElse": "Expected \"else\"", + "expectedDelExpr": { + "message": "Expected expression after \"del\"", + "comment": "{Locked='del'}" + }, + "expectedElse": { + "message": "Expected \"else\"", + "comment": "{Locked='else'}" + }, "expectedEquals": "Expected \"=\"", "expectedExceptionClass": "Invalid exception class or object", - "expectedExceptionObj": "Expected exception object, exception class or None", + "expectedExceptionObj": { + "message": "Expected exception object, exception class or None", + "comment": "{Locked='None'}" + }, "expectedExpr": "Expected expression", - "expectedFunctionAfterAsync": "Expected function definition after \"async\"", - "expectedFunctionName": "Expected function name after \"def\"", + "expectedFunctionAfterAsync": { + "message": "Expected function definition after \"async\"", + "comment": "{Locked='async'}" + }, + "expectedFunctionName": { + "message": "Expected function name after \"def\"", + "comment": "{Locked='def'}" + }, "expectedIdentifier": "Expected identifier", - "expectedImport": "Expected \"import\"", - "expectedImportAlias": "Expected symbol after \"as\"", - "expectedImportSymbols": "Expected one or more symbol names after import", - "expectedIn": "Expected \"in\"", - "expectedInExpr": "Expected expression after \"in\"", + "expectedImport": { + "message": "Expected \"import\"", + "comment": "{Locked='import'}" + }, + "expectedImportAlias": { + "message": "Expected symbol after \"as\"", + "comment": "{Locked='as'}" + }, + "expectedImportSymbols": { + "message": "Expected one or more symbol names after \"import\"", + "comment": "{Locked='import'}" + }, + "expectedIn": { + "message": "Expected \"in\"", + "comment": "{Locked='in'}" + }, + "expectedInExpr": { + "message": "Expected expression after \"in\"", + "comment": "{Locked='in'}" + }, "expectedIndentedBlock": "Expected indented block", "expectedMemberName": "Expected attribute name after \".\"", "expectedModuleName": "Expected module name", - "expectedNameAfterAs": "Expected symbol name after \"as\"", + "expectedNameAfterAs": { + "message": "Expected symbol name after \"as\"", + "comment": "{Locked='as'}" + }, "expectedNamedParameter": "Keyword parameter must follow \"*\"", "expectedNewline": "Expected newline", "expectedNewlineOrSemicolon": "Statements must be separated by newlines or semicolons", @@ -215,51 +437,162 @@ "expectedParamName": "Expected parameter name", "expectedPatternExpr": "Expected pattern expression", "expectedPatternSubjectExpr": "Expected pattern subject expression", - "expectedPatternValue": "Expected pattern value expression of the form \"a.b\"", - "expectedReturnExpr": "Expected expression after \"return\"", + "expectedPatternValue": { + "message": "Expected pattern value expression of the form \"a.b\"", + "comment": "{Locked='a.b'}" + }, + "expectedReturnExpr": { + "message": "Expected expression after \"return\"", + "comment": "{Locked='return'}" + }, "expectedSliceIndex": "Expected index or slice expression", "expectedTypeNotString": "Expected type but received a string literal", "expectedTypeParameterName": "Expected type parameter name", - "expectedYieldExpr": "Expected expression in yield statement", - "finalClassIsAbstract": "Class \"{type}\" is marked final and must implement all abstract symbols", - "finalContext": "\"Final\" is not allowed in this context", - "finalInLoop": "A \"Final\" variable cannot be assigned within a loop", - "finalMethodOverride": "Method \"{name}\" cannot override final method defined in class \"{className}\"", - "finalNonMethod": "Function \"{name}\" cannot be marked @final because it is not a method", - "finalReassigned": "\"{name}\" is declared as Final and cannot be reassigned", - "finalRedeclaration": "\"{name}\" was previously declared as Final", - "finalRedeclarationBySubclass": "\"{name}\" cannot be redeclared because parent class \"{className}\" declares it as Final", - "finalTooManyArgs": "Expected a single type argument after \"Final\"", - "finalUnassigned": "\"{name}\" is declared Final, but value is not assigned", - "formatStringBrace": "Single close brace not allowed within f-string literal; use double close brace", - "formatStringBytes": "Format string literals (f-strings) cannot be binary", - "formatStringDebuggingIllegal": "F-string debugging specifier \"=\" requires Python 3.8 or newer", - "formatStringEscape": "Escape sequence (backslash) not allowed in expression portion of f-string prior to Python 3.12", - "formatStringExpectedConversion": "Expected a conversion specifier after \"!\" in f-string", - "formatStringIllegal": "Format string literals (f-strings) require Python 3.6 or newer", + "expectedYieldExpr": { + "message": "Expected expression in yield statement", + "comment": "{Locked='yield'}" + }, + "finalClassIsAbstract": { + "message": "Class \"{type}\" is marked final and must implement all abstract symbols", + "comment": "{Locked='final'}" + }, + "finalContext": { + "message": "\"Final\" is not allowed in this context", + "comment": "{Locked='Final'}" + }, + "finalInLoop": { + "message": "A \"Final\" variable cannot be assigned within a loop", + "comment": "{Locked='Final'}" + }, + "finalMethodOverride": { + "message": "Method \"{name}\" cannot override final method defined in class \"{className}\"", + "comment": "{Locked='final'}" + }, + "finalNonMethod": { + "message": "Function \"{name}\" cannot be marked @final because it is not a method", + "comment": "{Locked='@final'}" + }, + "finalReassigned": { + "message": "\"{name}\" is declared as Final and cannot be reassigned", + "comment": "{Locked='Final'}" + }, + "finalRedeclaration": { + "message": "\"{name}\" was previously declared as Final", + "comment": "{Locked='Final'}" + }, + "finalRedeclarationBySubclass": { + "message": "\"{name}\" cannot be redeclared because parent class \"{className}\" declares it as Final", + "comment": "{Locked='Final'}" + }, + "finalTooManyArgs": { + "message": "Expected a single type argument after \"Final\"", + "comment": "{Locked='Final'}" + }, + "finalUnassigned": { + "message": "\"{name}\" is declared Final, but value is not assigned", + "comment": "{Locked='Final'}" + }, + "formatStringBrace": { + "message": "Single close brace not allowed within f-string literal; use double close brace", + "comment": "'f-string' is the common English slang for a Python format string" + }, + "formatStringBytes": { + "message": "Format string literals (f-strings) cannot be binary", + "comment": "'f-string' is the common English slang for a Python format string" + }, + "formatStringDebuggingIllegal": { + "message": "F-string debugging specifier \"=\" requires Python 3.8 or newer", + "comment": "'f-string' is the common English slang for a Python format string" + }, + "formatStringEscape": { + "message": "Escape sequence (backslash) not allowed in expression portion of f-string prior to Python 3.12", + "comment": "'f-string' is the common English slang for a Python format string" + }, + "formatStringExpectedConversion": { + "message": "Expected a conversion specifier after \"!\" in f-string", + "comment": "'f-string' is the common English slang for a Python format string" + }, + "formatStringIllegal": { + "message": "Format string literals (f-strings) require Python 3.6 or newer", + "comment": "'f-string' is the common English slang for a Python format string" + }, "formatStringInPattern": "Format string not allowed in pattern", "formatStringNestedFormatSpecifier": "Expressions nested too deeply within format string specifier", - "formatStringNestedQuote": "Strings nested within an f-string cannot use the same quote character as the f-string prior to Python 3.12", - "formatStringUnicode": "Format string literals (f-strings) cannot be unicode", - "formatStringUnterminated": "Unterminated expression in f-string; expecting \"}\"", + "formatStringNestedQuote": { + "message": "Strings nested within an f-string cannot use the same quote character as the f-string prior to Python 3.12", + "comment": "'f-string' is the common English slang for a Python format string" + }, + "formatStringUnicode": { + "message": "Format string literals (f-strings) cannot be unicode", + "comment": "'f-string' is the common English slang for a Python format string" + }, + "formatStringUnterminated": { + "message": "Unterminated expression in f-string; expecting \"}\"", + "comment": "'f-string' is the common English slang for a Python format string" + }, "functionDecoratorTypeUnknown": "Untyped function decorator obscures type of function; ignoring decorator", - "functionInConditionalExpression": "Conditional expression references function which always evaluates to True", + "functionInConditionalExpression": { + "message": "Conditional expression references function which always evaluates to True", + "comment": "{Locked='True'}" + }, "functionTypeParametersIllegal": "Function type parameter syntax requires Python 3.12 or newer", - "futureImportLocationNotAllowed": "Imports from __future__ must be at the beginning of the file", - "generatorAsyncReturnType": "Return type of async generator function must be compatible with \"AsyncGenerator[{yieldType}, Any]\"", + "futureImportLocationNotAllowed": { + "message": "Imports from __future__ must be at the beginning of the file", + "comment": "{Locked='__future__'}" + }, + "generatorAsyncReturnType": { + "message": "Return type of async generator function must be compatible with \"AsyncGenerator[{yieldType}, Any]\"", + "comment": "{Locked='async','AsyncGenerator[{yieldType}, Any]'}" + }, "generatorNotParenthesized": "Generator expressions must be parenthesized if not sole argument", - "generatorSyncReturnType": "Return type of generator function must be compatible with \"Generator[{yieldType}, Any, Any]\"", - "genericBaseClassNotAllowed": "\"Generic\" base class cannot be used with type parameter syntax", - "genericClassAssigned": "Generic class type cannot be assigned", - "genericClassDeleted": "Generic class type cannot be deleted", - "genericInstanceVariableAccess": "Access to generic instance variable through class is ambiguous", - "genericNotAllowed": "\"Generic\" is not valid in this context", - "genericTypeAliasBoundTypeVar": "Generic type alias within class cannot use bound type variables {names}", - "genericTypeArgMissing": "\"Generic\" requires at least one type argument", - "genericTypeArgTypeVar": "Type argument for \"Generic\" must be a type variable", - "genericTypeArgUnique": "Type arguments for \"Generic\" must be unique", - "globalReassignment": "\"{name}\" is assigned before global declaration", - "globalRedefinition": "\"{name}\" was already declared global", + "generatorSyncReturnType": { + "message": "Return type of generator function must be compatible with \"Generator[{yieldType}, Any, Any]\"", + "comment": "{Locked='Generator[{yieldType}, Any, Any]'}" + }, + "genericBaseClassNotAllowed": { + "message": "\"Generic\" base class cannot be used with type parameter syntax", + "comment": "{Locked='Generic'}" + }, + "genericClassAssigned": { + "message": "Generic class type cannot be assigned", + "comment": "A generic type is a parameterized type, for example a container where the generic type parameter specifies the type of elements in the container" + }, + "genericClassDeleted": { + "message": "Generic class type cannot be deleted", + "comment": "A generic type is a parameterized type, for example a container where the generic type parameter specifies the type of elements in the container" + }, + "genericInstanceVariableAccess": { + "message": "Access to generic instance variable through class is ambiguous", + "comment": "A generic type is a parameterized type, for example a container where the generic type parameter specifies the type of elements in the container" + }, + "genericNotAllowed": { + "message": "\"Generic\" is not valid in this context", + "comment": "{Locked='Generic'}" + }, + "genericTypeAliasBoundTypeVar": { + "message": "Generic type alias within class cannot use bound type variables {names}", + "comment": "A generic type is a parameterized type, for example a container where the generic type parameter specifies the type of elements in the container" + }, + "genericTypeArgMissing": { + "message": "\"Generic\" requires at least one type argument", + "comment": "{Locked='Generic'}" + }, + "genericTypeArgTypeVar": { + "message": "Type argument for \"Generic\" must be a type variable", + "comment": "{Locked='Generic'}" + }, + "genericTypeArgUnique": { + "message": "Type arguments for \"Generic\" must be unique", + "comment": "{Locked='Generic'}" + }, + "globalReassignment": { + "message": "\"{name}\" is assigned before global declaration", + "comment": "{Locked='global'}" + }, + "globalRedefinition": { + "message": "\"{name}\" was already declared global", + "comment": "{Locked='global'}" + }, "implicitStringConcat": "Implicit string concatenation not allowed", "importCycleDetected": "Cycle detected in import chain", "importDepthExceeded": "Import chain depth exceeded {depth}", @@ -269,24 +602,60 @@ "incompatibleMethodOverride": "Method \"{name}\" overrides class \"{className}\" in an incompatible manner", "inconsistentIndent": "Unindent amount does not match previous indent", "inconsistentTabs": "Inconsistent use of tabs and spaces in indentation", - "initMethodSelfParamTypeVar": "Type annotation for \"self\" parameter of \"__init__\" method cannot contain class-scoped type variables", - "initMustReturnNone": "Return type of \"__init__\" must be None", - "initSubclassCallFailed": "Incorrect keyword arguments for __init_subclass__ method", - "initSubclassClsParam": "__init_subclass__ override should take a \"cls\" parameter", - "initVarNotAllowed": "\"InitVar\" is not allowed in this context", - "instanceMethodSelfParam": "Instance methods should take a \"self\" parameter", + "initMethodSelfParamTypeVar": { + "message": "Type annotation for \"self\" parameter of \"__init__\" method cannot contain class-scoped type variables", + "comment": "{Locked='self','__init__'}" + }, + "initMustReturnNone": { + "message": "Return type of \"__init__\" must be None", + "comment": "{Locked='__init__','None'}" + }, + "initSubclassCallFailed": { + "message": "Incorrect keyword arguments for __init_subclass__ method", + "comment": "{Locked='__init_subclass__'}" + }, + "initSubclassClsParam": { + "message": "__init_subclass__ override should take a \"cls\" parameter", + "comment": "{Locked='__init_subclass__','cls'}" + }, + "initVarNotAllowed": { + "message": "\"InitVar\" is not allowed in this context", + "comment": "{Locked='InitVar'}" + }, + "instanceMethodSelfParam": { + "message": "Instance methods should take a \"self\" parameter", + "comment": "{Locked='self'}" + }, "instanceVarOverridesClassVar": "Instance variable \"{name}\" overrides class variable of same name in class \"{className}\"", "instantiateAbstract": "Cannot instantiate abstract class \"{type}\"", - "instantiateProtocol": "Cannot instantiate protocol class \"{type}\"", - "internalBindError": "An internal error occurred while binding file \"{file}\": {message}", + "instantiateProtocol": { + "message": "Cannot instantiate Protocol class \"{type}\"", + "comment": "{Locked='Protocol'}" + }, + "internalBindError": { + "message": "An internal error occurred while binding file \"{file}\": {message}", + "comment": "Binding is the process through which Pyright determines what object a name refers to" + }, "internalParseError": "An internal error occurred while parsing file \"{file}\": {message}", "internalTypeCheckingError": "An internal error occurred while type checking file \"{file}\": {message}", "invalidIdentifierChar": "Invalid character in identifier", - "invalidStubStatement": "Statement is meaningless within a type stub file", + "invalidStubStatement": { + "message": "Statement is meaningless within a type stub file", + "comment": "{StrContains=i'stub'}" + }, "invalidTokenChars": "Invalid character \"{text}\" in token", - "isInstanceInvalidType": "Second argument to \"isinstance\" must be a class or tuple of classes", - "isSubclassInvalidType": "Second argument to \"issubclass\" must be a class or tuple of classes", - "keyValueInSet": "Key/value pairs are not allowed within a set", + "isInstanceInvalidType": { + "message": "Second argument to \"isinstance\" must be a class or tuple of classes", + "comment": "{Locked='isinstance','tuple'}" + }, + "isSubclassInvalidType": { + "message": "Second argument to \"issubclass\" must be a class or tuple of classes", + "comment": "{Locked='issubclass','tuple'}" + }, + "keyValueInSet": { + "message": "Key/value pairs are not allowed within a set", + "comment": "{Locked='set'}" + }, "keywordArgInTypeArgument": "Keyword arguments cannot be used in type argument lists", "keywordArgShortcutIllegal": "Keyword argument shortcut requires Python 3.14 or newer", "keywordOnlyAfterArgs": "Keyword-only argument separator not allowed after \"*\" parameter", @@ -295,67 +664,202 @@ "lambdaReturnTypePartiallyUnknown": "Return type of lambda, \"{returnType}\", is partially unknown", "lambdaReturnTypeUnknown": "Return type of lambda is unknown", "listAssignmentMismatch": "Expression with type \"{type}\" cannot be assigned to target list", - "listInAnnotation": "List expression not allowed in type expression", - "literalEmptyArgs": "Expected one or more type arguments after \"Literal\"", - "literalNamedUnicodeEscape": "Named unicode escape sequences are not supported in \"Literal\" string annotations", - "literalNotAllowed": "\"Literal\" cannot be used in this context without a type argument", - "literalNotCallable": "Literal type cannot be instantiated", - "literalUnsupportedType": "Type arguments for \"Literal\" must be None, a literal value (int, bool, str, or bytes), or an enum value", - "matchIncompatible": "Match statements require Python 3.10 or newer", - "matchIsNotExhaustive": "Cases within match statement do not exhaustively handle all values", + "listInAnnotation": { + "message": "List expression not allowed in type expression", + "comment": "{Locked='List'}" + }, + "literalEmptyArgs": { + "message": "Expected one or more type arguments after \"Literal\"", + "comment": "{Locked='Literal'}" + }, + "literalNamedUnicodeEscape": { + "message": "Named unicode escape sequences are not supported in \"Literal\" string annotations", + "comment": "{Locked='Literal'}" + }, + "literalNotAllowed": { + "message": "\"Literal\" cannot be used in this context without a type argument", + "comment": "{Locked='Literal'}" + }, + "literalNotCallable": { + "message": "Literal type cannot be instantiated", + "comment": "{Locked='Literal'}" + }, + "literalUnsupportedType": { + "message": "Type arguments for \"Literal\" must be None, a literal value (int, bool, str, or bytes), or an enum value", + "comment": "{Locked='Literal','None','int','bool','str','bytes','enum'}" + }, + "matchIncompatible": { + "message": "Match statements require Python 3.10 or newer", + "comment": ["{StrContains=i'match'}", "'match' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, + "matchIsNotExhaustive": { + "message": "Cases within match statement do not exhaustively handle all values", + "comment": ["{Locked='match'}", "Case statements are children of match statements where 'case' is a keyword. It may be best to keep 'case' in English"] + }, "maxParseDepthExceeded": "Maximum parse depth exceeded; break expression into smaller sub-expressions", "memberAccess": "Cannot access attribute \"{name}\" for class \"{type}\"", "memberDelete": "Cannot delete attribute \"{name}\" for class \"{type}\"", "memberSet": "Cannot assign to attribute \"{name}\" for class \"{type}\"", - "metaclassConflict": "The metaclass of a derived class must be a subclass of the metaclasses of all its base classes", - "metaclassDuplicate": "Only one metaclass can be provided", - "metaclassIsGeneric": "Metaclass cannot be generic", + "metaclassConflict": { + "message": "The metaclass of a derived class must be a subclass of the metaclasses of all its base classes", + "comment": "Metaclasses are a complex concept and it may be best to not localize the term" + }, + "metaclassDuplicate": { + "message": "Only one metaclass can be provided", + "comment": "Metaclasses are a complex concept and it may be best to not localize the term" + }, + "metaclassIsGeneric": { + "message": "Metaclass cannot be generic", + "comment": ["Metaclasses are a complex concept and it may be best to not localize the term", "A generic type is a parameterized type, for example a container where the generic type parameter specifies the type of elements in the container"] + }, "methodNotDefined": "\"{name}\" method not defined", "methodNotDefinedOnType": "\"{name}\" method not defined on type \"{type}\"", "methodOrdering": "Cannot create consistent method ordering", "methodOverridden": "\"{name}\" overrides method of same name in class \"{className}\" with incompatible type \"{type}\"", "methodReturnsNonObject": "\"{name}\" method does not return an object", "missingSuperCall": "Method \"{methodName}\" does not call the method of the same name in parent class", - "mixingBytesAndStr": "Bytes and str values cannot be concatenated", + "mixingBytesAndStr": { + "message": "Bytes and str values cannot be concatenated", + "comment": ["{Locked='str'}", "{StrContains=i'bytes'}", "'bytes' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, "moduleAsType": "Module cannot be used as a type", "moduleNotCallable": "Module is not callable", "moduleUnknownMember": "\"{memberName}\" is not a known attribute of module \"{moduleName}\"", - "namedExceptAfterCatchAll": "A named except clause cannot appear after catch-all except clause", - "namedParamAfterParamSpecArgs": "Keyword parameter \"{name}\" cannot appear in signature after ParamSpec args parameter", - "namedTupleEmptyName": "Names within a named tuple cannot be empty", - "namedTupleEntryRedeclared": "Cannot override \"{name}\" because parent class \"{className}\" is a named tuple", - "namedTupleFirstArg": "Expected named tuple class name as first argument", - "namedTupleMultipleInheritance": "Multiple inheritance with NamedTuple is not supported", + "namedExceptAfterCatchAll": { + "message": "A named except clause cannot appear after catch-all except clause", + "comment": "{Locked='except'}" + }, + "namedParamAfterParamSpecArgs": { + "message": "Keyword parameter \"{name}\" cannot appear in signature after ParamSpec args parameter", + "comment": "{Locked='ParamSpec','args'}" + }, + "namedTupleEmptyName": { + "message": "Names within a named tuple cannot be empty", + "comment": "{Locked='tuple'}" + }, + "namedTupleEntryRedeclared": { + "message": "Cannot override \"{name}\" because parent class \"{className}\" is a named tuple", + "comment": "{Locked='tuple'}" + }, + "namedTupleFirstArg": { + "message": "Expected named tuple class name as first argument", + "comment": "{Locked='tuple'}" + }, + "namedTupleMultipleInheritance": { + "message": "Multiple inheritance with NamedTuple is not supported", + "comment": "{Locked='NamedTuple'}" + }, "namedTupleNameKeyword": "Field names cannot be a keyword", - "namedTupleNameType": "Expected two-entry tuple specifying entry name and type", - "namedTupleNameUnique": "Names within a named tuple must be unique", - "namedTupleNoTypes": "\"namedtuple\" provides no types for tuple entries; use \"NamedTuple\" instead", - "namedTupleSecondArg": "Expected named tuple entry list as second argument", - "newClsParam": "__new__ override should take a \"cls\" parameter", - "newTypeAnyOrUnknown": "The second argument to NewType must be a known class, not Any or Unknown", - "newTypeBadName": "The first argument to NewType must be a string literal", - "newTypeLiteral": "NewType cannot be used with Literal type", - "newTypeNameMismatch": "NewType must be assigned to a variable with the same name", - "newTypeNotAClass": "Expected class as second argument to NewType", - "newTypeParamCount": "NewType requires two positional arguments", - "newTypeProtocolClass": "NewType cannot be used with structural type (a protocol or TypedDict class)", + "namedTupleNameType": { + "message": "Expected two-entry tuple specifying entry name and type", + "comment": "{Locked='tuple'}" + }, + "namedTupleNameUnique": { + "message": "Names within a named tuple must be unique", + "comment": "{Locked='tuple'}" + }, + "namedTupleNoTypes": { + "message": "\"namedtuple\" provides no types for tuple entries; use \"NamedTuple\" instead", + "comment": "{Locked='namedtuple\";'tuple','NamedTuple'}" + }, + "namedTupleSecondArg": { + "message": "Expected named tuple entry list as second argument", + "comment": "{Locked='tuple','list'}" + }, + "newClsParam": { + "message": "__new__ override should take a \"cls\" parameter", + "comment": "{Locked='__new__','cls'}" + }, + "newTypeAnyOrUnknown": { + "message": "The second argument to NewType must be a known class, not Any or Unknown", + "comment": "{Locked='NewType','Any','Unknown'}" + }, + "newTypeBadName": { + "message": "The first argument to NewType must be a string literal", + "comment": "{Locked='NewType'}" + }, + "newTypeLiteral": { + "message": "NewType cannot be used with Literal type", + "comment": "{Locked='NewType','Literal'}" + }, + "newTypeNameMismatch": { + "message": "NewType must be assigned to a variable with the same name", + "comment": "{Locked='NewType'}" + }, + "newTypeNotAClass": { + "message": "Expected class as second argument to NewType", + "comment": "{Locked='NewType'}" + }, + "newTypeParamCount": { + "message": "NewType requires two positional arguments", + "comment": "{Locked='NewType'}" + }, + "newTypeProtocolClass": { + "message": "NewType cannot be used with structural type (a Protocol or TypedDict class)", + "comment": "{Locked='NewType','Protocol','TypedDict'}" + }, "noOverload": "No overloads for \"{name}\" match the provided arguments", - "noReturnContainsReturn": "Function with declared return type \"NoReturn\" cannot include a return statement", - "noReturnContainsYield": "Function with declared return type \"NoReturn\" cannot include a yield statement", - "noReturnReturnsNone": "Function with declared return type \"NoReturn\" cannot return \"None\"", + "noReturnContainsReturn": { + "message": "Function with declared return type \"NoReturn\" cannot include a return statement", + "comment": "{Locked='NoReturn','return'}" + }, + "noReturnContainsYield": { + "message": "Function with declared return type \"NoReturn\" cannot include a yield statement", + "comment": "{Locked='NoReturn','yield'}" + }, + "noReturnReturnsNone": { + "message": "Function with declared return type \"NoReturn\" cannot return \"None\"", + "comment": "{Locked='NoReturn','None'}" + }, "nonDefaultAfterDefault": "Non-default argument follows default argument", - "nonLocalInModule": "Nonlocal declaration not allowed at module level", - "nonLocalNoBinding": "No binding for nonlocal \"{name}\" found", - "nonLocalReassignment": "\"{name}\" is assigned before nonlocal declaration", - "nonLocalRedefinition": "\"{name}\" was already declared nonlocal", - "noneNotCallable": "Object of type \"None\" cannot be called", - "noneNotIterable": "Object of type \"None\" cannot be used as iterable value", - "noneNotSubscriptable": "Object of type \"None\" is not subscriptable", - "noneNotUsableWith": "Object of type \"None\" cannot be used with \"with\"", - "noneOperator": "Operator \"{operator}\" not supported for \"None\"", - "noneUnknownMember": "\"{name}\" is not a known attribute of \"None\"", - "notRequiredArgCount": "Expected a single type argument after \"NotRequired\"", - "notRequiredNotInTypedDict": "\"NotRequired\" is not allowed in this context", + "nonLocalInModule": { + "message": "Nonlocal declaration not allowed at module level", + "comment": ["{StrContains=i'nonlocal'}", "'nonlocal' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, + "nonLocalNoBinding": { + "message": "No binding for nonlocal \"{name}\" found", + "comment": ["{Locked='nonlocal'}", "'No binding found' means that Pyright couldn't resolve the variable name to an object"] + }, + "nonLocalReassignment": { + "message": "\"{name}\" is assigned before nonlocal declaration", + "comment": "{Locked='nonlocal'}" + }, + "nonLocalRedefinition": { + "message": "\"{name}\" was already declared nonlocal", + "comment": "{Locked='nonlocal'}" + }, + "noneNotCallable": { + "message": "Object of type \"None\" cannot be called", + "comment": "{Locked='None'}" + }, + "noneNotIterable": { + "message": "Object of type \"None\" cannot be used as iterable value", + "comment": "{Locked='None'}" + }, + "noneNotSubscriptable": { + "message": "Object of type \"None\" is not subscriptable", + "comment": "{Locked='None'}" + }, + "noneNotUsableWith": { + "message": "Object of type \"None\" cannot be used with \"with\"", + "comment": "{Locked='None','with'}" + }, + "noneOperator": { + "message": "Operator \"{operator}\" not supported for \"None\"", + "comment": "{Locked='None'}" + }, + "noneUnknownMember": { + "message": "\"{name}\" is not a known attribute of \"None\"", + "comment": "{Locked='None'}" + }, + "notRequiredArgCount": { + "message": "Expected a single type argument after \"NotRequired\"", + "comment": "{Locked='NotRequired'}" + }, + "notRequiredNotInTypedDict": { + "message": "\"NotRequired\" is not allowed in this context", + "comment": "{Locked='NotRequired'}" + }, "objectNotCallable": "Object of type \"{type}\" is not callable", "obscuredClassDeclaration": "Class declaration \"{name}\" is obscured by a declaration of the same name", "obscuredFunctionDeclaration": "Function declaration \"{name}\" is obscured by a declaration of the same name", @@ -364,43 +868,112 @@ "obscuredTypeAliasDeclaration": "Type alias declaration \"{name}\" is obscured by a declaration of the same name", "obscuredVariableDeclaration": "Declaration \"{name}\" is obscured by a declaration of the same name", "operatorLessOrGreaterDeprecated": "Operator \"<>\" is not supported in Python 3; use \"!=\" instead", - "optionalExtraArgs": "Expected one type argument after \"Optional\"", - "orPatternIrrefutable": "Irrefutable pattern allowed only as the last subpattern in an \"or\" pattern", - "orPatternMissingName": "All subpatterns within an \"or\" pattern must target the same names", + "optionalExtraArgs": { + "message": "Expected one type argument after \"Optional\"", + "comment": "{Locked='Optional'}" + }, + "orPatternIrrefutable": { + "message": "Irrefutable pattern allowed only as the last subpattern in an \"or\" pattern", + "comment": "{Locked='or'}" + }, + "orPatternMissingName": { + "message": "All subpatterns within an \"or\" pattern must target the same names", + "comment": "{Locked='or'}" + }, "overlappingKeywordArgs": "Typed dictionary overlaps with keyword parameter: {names}", "overlappingOverload": "Overload {obscured} for \"{name}\" will never be used because its parameters overlap overload {obscuredBy}", "overloadAbstractImplMismatch": "Overloads must match abstract status of implementation", "overloadAbstractMismatch": "Overloads must all be abstract or not", - "overloadClassMethodInconsistent": "Overloads for \"{name}\" use @classmethod inconsistently", - "overloadFinalInconsistencyImpl": "Overload for \"{name}\" is marked @final but implementation is not", - "overloadFinalInconsistencyNoImpl": "Overload {index} for \"{name}\" is marked @final but overload 1 is not", + "overloadClassMethodInconsistent": { + "message": "Overloads for \"{name}\" use @classmethod inconsistently", + "comment": "{Locked='@classmethod'}" + }, + "overloadFinalInconsistencyImpl": { + "message": "Overload for \"{name}\" is marked @final but implementation is not", + "comment": "{Locked='@final'}" + }, + "overloadFinalInconsistencyNoImpl": { + "message": "Overload {index} for \"{name}\" is marked @final but overload 1 is not", + "comment": "{Locked='@final'}" + }, "overloadImplementationMismatch": "Overloaded implementation is not consistent with signature of overload {index}", "overloadReturnTypeMismatch": "Overload {prevIndex} for \"{name}\" overlaps overload {newIndex} and returns an incompatible type", - "overloadStaticMethodInconsistent": "Overloads for \"{name}\" use @staticmethod inconsistently", - "overloadWithoutImplementation": "\"{name}\" is marked as overload, but no implementation is provided", - "overriddenMethodNotFound": "Method \"{name}\" is marked as override, but no base method of same name is present", - "overrideDecoratorMissing": "Method \"{name}\" is not marked as override but is overriding a method in class \"{className}\"", + "overloadStaticMethodInconsistent": { + "message": "Overloads for \"{name}\" use @staticmethod inconsistently", + "comment": "{Locked='@staticmethod'}" + }, + "overloadWithoutImplementation": { + "message": "\"{name}\" is marked as overload, but no implementation is provided", + "comment": "{Locked='overload'}" + }, + "overriddenMethodNotFound": { + "message": "Method \"{name}\" is marked as override, but no base method of same name is present", + "comment": "{Locked='override'}" + }, + "overrideDecoratorMissing": { + "message": "Method \"{name}\" is not marked as override but is overriding a method in class \"{className}\"", + "comment": "{Locked='override'}" + }, "paramAfterKwargsParam": "Parameter cannot follow \"**\" parameter", "paramAlreadyAssigned": "Parameter \"{name}\" is already assigned", "paramAnnotationMissing": "Type annotation is missing for parameter \"{name}\"", "paramAssignmentMismatch": "Expression of type \"{sourceType}\" cannot be assigned to parameter of type \"{paramType}\"", "paramNameMissing": "No parameter named \"{name}\"", - "paramSpecArgsKwargsUsage": "\"args\" and \"kwargs\" attributes of ParamSpec must both appear within a function signature", - "paramSpecArgsMissing": "Arguments for ParamSpec \"{type}\" are missing", - "paramSpecArgsUsage": "\"args\" attribute of ParamSpec is valid only when used with *args parameter", - "paramSpecAssignedName": "ParamSpec must be assigned to a variable named \"{name}\"", - "paramSpecContext": "ParamSpec is not allowed in this context", - "paramSpecDefaultNotTuple": "Expected ellipsis, a tuple expression, or ParamSpec for default value of ParamSpec", - "paramSpecFirstArg": "Expected name of ParamSpec as first argument", - "paramSpecKwargsUsage": "\"kwargs\" attribute of ParamSpec is valid only when used with **kwargs parameter", - "paramSpecNotUsedByOuterScope": "ParamSpec \"{name}\" has no meaning in this context", - "paramSpecUnknownArg": "ParamSpec does not support more than one argument", - "paramSpecUnknownMember": "\"{name}\" is not a known attribute of ParamSpec", - "paramSpecUnknownParam": "\"{name}\" is unknown parameter to ParamSpec", + "paramSpecArgsKwargsUsage": { + "message": "\"args\" and \"kwargs\" attributes of ParamSpec must both appear within a function signature", + "comment": "{Locked='args','kwargs','ParamSpec'}" + }, + "paramSpecArgsMissing": { + "message": "Arguments for ParamSpec \"{type}\" are missing", + "comment": "{Locked='ParamSpec'}" + }, + "paramSpecArgsUsage": { + "message": "\"args\" attribute of ParamSpec is valid only when used with *args parameter", + "comment": "{Locked='args','ParamSpec','*args'}" + }, + "paramSpecAssignedName": { + "message": "ParamSpec must be assigned to a variable named \"{name}\"", + "comment": "{Locked='ParamSpec'}" + }, + "paramSpecContext": { + "message": "ParamSpec is not allowed in this context", + "comment": "{Locked='ParamSpec'}" + }, + "paramSpecDefaultNotTuple": { + "message": "Expected ellipsis, a tuple expression, or ParamSpec for default value of ParamSpec", + "comment": "{Locked='tuple','ParamSpec'}" + }, + "paramSpecFirstArg": { + "message": "Expected name of ParamSpec as first argument", + "comment": "{Locked='ParamSpec'}" + }, + "paramSpecKwargsUsage": { + "message": "\"kwargs\" attribute of ParamSpec is valid only when used with **kwargs parameter", + "comment": "{Locked='kwargs','ParamSpec','**kwargs'}" + }, + "paramSpecNotUsedByOuterScope": { + "message": "ParamSpec \"{name}\" has no meaning in this context", + "comment": "{Locked='ParamSpec'}" + }, + "paramSpecUnknownArg": { + "message": "ParamSpec does not support more than one argument", + "comment": "{Locked='ParamSpec'}" + }, + "paramSpecUnknownMember": { + "message": "\"{name}\" is not a known attribute of ParamSpec", + "comment": "{Locked='ParamSpec'}" + }, + "paramSpecUnknownParam": { + "message": "\"{name}\" is unknown parameter to ParamSpec", + "comment": "{Locked='ParamSpec'}" + }, "paramTypeCovariant": "Covariant type variable cannot be used in parameter type", "paramTypePartiallyUnknown": "Type of parameter \"{paramName}\" is partially unknown", "paramTypeUnknown": "Type of parameter \"{paramName}\" is unknown", - "parenthesizedContextManagerIllegal": "Parentheses within \"with\" statement requires Python 3.9 or newer", + "parenthesizedContextManagerIllegal": { + "message": "Parentheses within \"with\" statement requires Python 3.9 or newer", + "comment": "{Locked='with'}" + }, "patternNeverMatches": "Pattern will never be matched for subject type \"{type}\"", "positionArgAfterNamedArg": "Positional argument cannot appear after keyword arguments", "positionOnlyAfterArgs": "Position-only parameter separator not allowed after \"*\" parameter", @@ -411,112 +984,322 @@ "privateImportFromPyTypedModule": "\"{name}\" is not exported from module \"{module}\"", "privateUsedOutsideOfClass": "\"{name}\" is private and used outside of the class in which it is declared", "privateUsedOutsideOfModule": "\"{name}\" is private and used outside of the module in which it is declared", - "propertyOverridden": "\"{name}\" incorrectly overrides property of same name in class \"{className}\"", - "propertyStaticMethod": "Static methods not allowed for property getter, setter or deleter", + "propertyOverridden": { + "message": "\"{name}\" incorrectly overrides property of same name in class \"{className}\"", + "comment": "{Locked='property'}" + }, + "propertyStaticMethod": { + "message": "Static methods not allowed for property getter, setter or deleter", + "comment": "{Locked='property','getter','setter','deleter'}" + }, "protectedUsedOutsideOfClass": "\"{name}\" is protected and used outside of the class in which it is declared", - "protocolBaseClass": "Protocol class \"{classType}\" cannot derive from non-protocol class \"{baseType}\"", - "protocolBaseClassWithTypeArgs": "Type arguments are not allowed with Protocol class when using type parameter syntax", - "protocolIllegal": "Use of \"Protocol\" requires Python 3.7 or newer", - "protocolNotAllowed": "\"Protocol\" cannot be used in this context", - "protocolTypeArgMustBeTypeParam": "Type argument for \"Protocol\" must be a type parameter", + "protocolBaseClass": { + "message": "Protocol class \"{classType}\" cannot derive from non-Protocol class \"{baseType}\"", + "comment": "{Locked='Protocol'}" + }, + "protocolBaseClassWithTypeArgs": { + "message": "Type arguments are not allowed with Protocol class when using type parameter syntax", + "comment": "{Locked='Protocol'}" + }, + "protocolIllegal": { + "message": "Use of \"Protocol\" requires Python 3.7 or newer", + "comment": "{Locked='Protocol'}" + }, + "protocolNotAllowed": { + "message": "\"Protocol\" cannot be used in this context", + "comment": "{Locked='Protocol'}" + }, + "protocolTypeArgMustBeTypeParam": { + "message": "Type argument for \"Protocol\" must be a type parameter", + "comment": "{Locked='Protocol'}" + }, "protocolUnsafeOverlap": "Class overlaps \"{name}\" unsafely and could produce a match at runtime", - "protocolVarianceContravariant": "Type variable \"{variable}\" used in generic protocol \"{class}\" should be contravariant", - "protocolVarianceCovariant": "Type variable \"{variable}\" used in generic protocol \"{class}\" should be covariant", - "protocolVarianceInvariant": "Type variable \"{variable}\" used in generic protocol \"{class}\" should be invariant", - "pyrightCommentInvalidDiagnosticBoolValue": "Pyright comment directive must be followed by \"=\" and a value of true or false", - "pyrightCommentInvalidDiagnosticSeverityValue": "Pyright comment directive must be followed by \"=\" and a value of true, false, error, warning, information, or none", - "pyrightCommentMissingDirective": "Pyright comment must be followed by a directive (basic or strict) or a diagnostic rule", - "pyrightCommentNotOnOwnLine": "Pyright comments used to control file-level settings must appear on their own line", - "pyrightCommentUnknownDiagnosticRule": "\"{rule}\" is an unknown diagnostic rule for pyright comment", - "pyrightCommentUnknownDiagnosticSeverityValue": "\"{value}\" is invalid value for pyright comment; expected true, false, error, warning, information, or none", - "pyrightCommentUnknownDirective": "\"{directive}\" is an unknown directive for pyright comment; expected \"strict\" or \"basic\"", - "readOnlyArgCount": "Expected a single type argument after \"ReadOnly\"", - "readOnlyNotInTypedDict": "\"ReadOnly\" is not allowed in this context", + "protocolVarianceContravariant": { + "message": "Type variable \"{variable}\" used in generic Protocol \"{class}\" should be contravariant", + "comment": ["{Locked='Protocol'}", "A generic type is a parameterized type, for example a container where the generic type parameter specifies the type of elements in the container"] + }, + "protocolVarianceCovariant": { + "message": "Type variable \"{variable}\" used in generic Protocol \"{class}\" should be covariant", + "comment": ["{Locked='Protocol'}", "A generic type is a parameterized type, for example a container where the generic type parameter specifies the type of elements in the container"] + }, + "protocolVarianceInvariant": { + "message": "Type variable \"{variable}\" used in generic Protocol \"{class}\" should be invariant", + "comment": ["{Locked='Protocol'}", "A generic type is a parameterized type, for example a container where the generic type parameter specifies the type of elements in the container"] + }, + "pyrightCommentInvalidDiagnosticBoolValue": { + "message": "Pyright comment directive must be followed by \"=\" and a value of true or false", + "comment": "{Locked='Pyright','true','false'}" + }, + "pyrightCommentInvalidDiagnosticSeverityValue": { + "message": "Pyright comment directive must be followed by \"=\" and a value of true, false, error, warning, information, or none", + "comment": "{Locked='Pyright','true','false','error','warning','information','none'}" + }, + "pyrightCommentMissingDirective": { + "message": "Pyright comment must be followed by a directive (basic or strict) or a diagnostic rule", + "comment": "{Locked='Pyright','basic','strict'}" + }, + "pyrightCommentNotOnOwnLine": { + "message": "Pyright comments used to control file-level settings must appear on their own line", + "comment": "{Locked='Pyright'}" + }, + "pyrightCommentUnknownDiagnosticRule": { + "message": "\"{rule}\" is an unknown diagnostic rule for pyright comment", + "comment": "{Locked='pyright'}" + }, + "pyrightCommentUnknownDiagnosticSeverityValue": { + "message": "\"{value}\" is invalid value for pyright comment; expected true, false, error, warning, information, or none", + "comment": "{Locked='pyright','true','false','error','warning','information','none'}" + }, + "pyrightCommentUnknownDirective": { + "message": "\"{directive}\" is an unknown directive for pyright comment; expected \"strict\" or \"basic\"", + "comment": "{Locked='pyright','strict','basic'}" + }, + "readOnlyArgCount": { + "message": "Expected a single type argument after \"ReadOnly\"", + "comment": "{Locked='ReadOnly'}" + }, + "readOnlyNotInTypedDict": { + "message": "\"ReadOnly\" is not allowed in this context", + "comment": "{Locked='ReadOnly'}" + }, "recursiveDefinition": "Type of \"{name}\" could not be determined because it refers to itself", - "relativeImportNotAllowed": "Relative imports cannot be used with \"import .a\" form; use \"from . import a\" instead", - "requiredArgCount": "Expected a single type argument after \"Required\"", - "requiredNotInTypedDict": "\"Required\" is not allowed in this context", - "returnInAsyncGenerator": "Return statement with value is not allowed in async generator", + "relativeImportNotAllowed": { + "message": "Relative imports cannot be used with \"import .a\" form; use \"from . import a\" instead", + "comment": "{Locked='import .a','from . import a'}" + }, + "requiredArgCount": { + "message": "Expected a single type argument after \"Required\"", + "comment": "{Locked='Required'}" + }, + "requiredNotInTypedDict": { + "message": "\"Required\" is not allowed in this context", + "comment": "{Locked='Required'}" + }, + "returnInAsyncGenerator": { + "message": "Return statement with value is not allowed in async generator", + "comment": "{Locked='async'}" + }, "returnMissing": "Function with declared return type \"{returnType}\" must return value on all code paths", - "returnOutsideFunction": "\"return\" can be used only within a function", + "returnOutsideFunction": { + "message": "\"return\" can be used only within a function", + "comment": "{Locked='return'}" + }, "returnTypeContravariant": "Contravariant type variable cannot be used in return type", "returnTypeMismatch": "Type \"{exprType}\" is not assignable to return type \"{returnType}\"", "returnTypePartiallyUnknown": "Return type, \"{returnType}\", is partially unknown", "returnTypeUnknown": "Return type is unknown", - "revealLocalsArgs": "Expected no arguments for \"reveal_locals\" call", - "revealLocalsNone": "No locals in this scope", - "revealTypeArgs": "Expected a single positional argument for \"reveal_type\" call", - "revealTypeExpectedTextArg": "The \"expected_text\" argument for function \"reveal_type\" must be a str literal value", + "revealLocalsArgs": { + "message": "Expected no arguments for \"reveal_locals\" call", + "comment": "{Locked='reveal_locals'}" + }, + "revealLocalsNone": { + "message": "No locals in this scope", + "comment": "{Locked='locals'}" + }, + "revealTypeArgs": { + "message": "Expected a single positional argument for \"reveal_type\" call", + "comment": "{Locked='reveal_type'}" + }, + "revealTypeExpectedTextArg": { + "message": "The \"expected_text\" argument for function \"reveal_type\" must be a str literal value", + "comment": "{Locked='expected_text','reveal_type','str'}" + }, "revealTypeExpectedTextMismatch": "Type text mismatch; expected \"{expected}\" but received \"{received}\"", "revealTypeExpectedTypeMismatch": "Type mismatch; expected \"{expected}\" but received \"{received}\"", - "selfTypeContext": "\"Self\" is not valid in this context", - "selfTypeMetaclass": "\"Self\" cannot be used within a metaclass (a subclass of \"type\")", - "selfTypeWithTypedSelfOrCls": "\"Self\" cannot be used in a function with a `self` or `cls` parameter that has a type annotation other than \"Self\"", - "setterGetterTypeMismatch": "Property setter value type is not assignable to the getter return type", + "selfTypeContext": { + "message": "\"Self\" is not valid in this context", + "comment": "{Locked='Self'}" + }, + "selfTypeMetaclass": { + "message": "\"Self\" cannot be used within a metaclass (a subclass of \"type\")", + "comment": ["{Locked='Self'}", "Metaclasses are a complex concept and it may be best to not localize the term"] + }, + "selfTypeWithTypedSelfOrCls": { + "message": "\"Self\" cannot be used in a function with a `self` or `cls` parameter that has a type annotation other than \"Self\"", + "comment": "{Locked='Self','self','cls'}" + }, + "setterGetterTypeMismatch": { + "message": "Property setter value type is not assignable to the getter return type", + "comment": ["{Locked='setter','getter'}", "{StrContains=i'property'}", "'property' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, "singleOverload": "\"{name}\" is marked as overload, but additional overloads are missing", - "slotsAttributeError": "\"{name}\" is not specified in __slots__", - "slotsClassVarConflict": "\"{name}\" conflicts with instance variable declared in __slots__", - "starPatternInAsPattern": "Star pattern cannot be used with \"as\" target", - "starPatternInOrPattern": "Star pattern cannot be ORed within other patterns", + "slotsAttributeError": { + "message": "\"{name}\" is not specified in __slots__", + "comment": "{Locked='__slots__'}" + }, + "slotsClassVarConflict": { + "message": "\"{name}\" conflicts with instance variable declared in __slots__", + "comment": "{Locked='__slots__'}" + }, + "starPatternInAsPattern": { + "message": "Star pattern cannot be used with \"as\" target", + "comment": ["{Locked='as'}", "Star pattern refers to the use of the * (star) character to represent a variable length pattern match"] + }, + "starPatternInOrPattern": { + "message": "Star pattern cannot be ORed within other patterns", + "comment": ["Star pattern refers to the use of the * (star) character to represent a variable length pattern match", "'ORed' means joined together with a binary 'or' operation"] + }, "starStarWildcardNotAllowed": "** cannot be used with wildcard \"_\"", - "staticClsSelfParam": "Static methods should not take a \"self\" or \"cls\" parameter", - "stdlibModuleOverridden": "\"{path}\" is overriding the stdlib module \"{name}\"", - "stringNonAsciiBytes": "Non-ASCII character not allowed in bytes string literal", + "staticClsSelfParam": { + "message": "Static methods should not take a \"self\" or \"cls\" parameter", + "comment": "{Locked='self','cls'}" + }, + "stdlibModuleOverridden": { + "message": "\"{path}\" is overriding the stdlib module \"{name}\"", + "comment": "{Locked='stdlib'}" + }, + "stringNonAsciiBytes": { + "message": "Non-ASCII character not allowed in bytes string literal", + "comment": "{Locked='ASCII'}" + }, "stringNotSubscriptable": "String expression cannot be subscripted in type expression; enclose entire expression in quotes", "stringUnsupportedEscape": "Unsupported escape sequence in string literal", "stringUnterminated": "String literal is unterminated", - "stubFileMissing": "Stub file not found for \"{importName}\"", - "stubUsesGetAttr": "Type stub file is incomplete; \"__getattr__\" obscures type errors for module", - "sublistParamsIncompatible": "Sublist parameters are not supported in Python 3.x", - "superCallArgCount": "Expected no more than two arguments to \"super\" call", - "superCallFirstArg": "Expected class type as first argument to \"super\" call but received \"{type}\"", - "superCallSecondArg": "Second argument to \"super\" call must be object or class that derives from \"{type}\"", - "superCallZeroArgForm": "Zero-argument form of \"super\" call is valid only within a method", - "superCallZeroArgFormStaticMethod": "Zero-argument form of \"super\" call is not valid within a static method", + "stubFileMissing": { + "message": "Stub file not found for \"{importName}\"", + "comment": "{StrContains=i'stub'}" + }, + "stubUsesGetAttr": { + "message": "Type stub file is incomplete; \"__getattr__\" obscures type errors for module", + "comment": ["{Locked='__getattr__'}", "{StrContains=i'stub'}"] + }, + "sublistParamsIncompatible": { + "message": "Sublist parameters are not supported in Python 3.x", + "comment": "{StrContains=i'sublist'}" + }, + "superCallArgCount": { + "message": "Expected no more than two arguments to \"super\" call", + "comment": "{Locked='super'}" + }, + "superCallFirstArg": { + "message": "Expected class type as first argument to \"super\" call but received \"{type}\"", + "comment": "{Locked='super'}" + }, + "superCallSecondArg": { + "message": "Second argument to \"super\" call must be object or class that derives from \"{type}\"", + "comment": "{Locked='super'}" + }, + "superCallZeroArgForm": { + "message": "Zero-argument form of \"super\" call is valid only within a method", + "comment": "{Locked='super'}" + }, + "superCallZeroArgFormStaticMethod": { + "message": "Zero-argument form of \"super\" call is not valid within a static method", + "comment": "{Locked='super'}" + }, "symbolIsPossiblyUnbound": "\"{name}\" is possibly unbound", "symbolIsUnbound": "\"{name}\" is unbound", "symbolIsUndefined": "\"{name}\" is not defined", "symbolOverridden": "\"{name}\" overrides symbol of same name in class \"{className}\"", "ternaryNotAllowed": "Ternary expression not allowed in type expression", - "totalOrderingMissingMethod": "Class must define one of \"__lt__\", \"__le__\", \"__gt__\", or \"__ge__\" to use total_ordering", + "totalOrderingMissingMethod": { + "message": "Class must define one of \"__lt__\", \"__le__\", \"__gt__\", or \"__ge__\" to use total_ordering", + "comment": "{Locked='__lt__','__le__','__gt__','__ge__','total_ordering'}" + }, "trailingCommaInFromImport": "Trailing comma not allowed without surrounding parentheses", - "tryWithoutExcept": "Try statement must have at least one except or finally clause", - "tupleAssignmentMismatch": "Expression with type \"{type}\" cannot be assigned to target tuple", - "tupleInAnnotation": "Tuple expression not allowed in type expression", + "tryWithoutExcept": { + "message": "Try statement must have at least one except or finally clause", + "comment": ["{Locked='except','finally'}", "{StrContains=i'try'}", "'try' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, + "tupleAssignmentMismatch": { + "message": "Expression with type \"{type}\" cannot be assigned to target tuple", + "comment": "{Locked='tuple'}" + }, + "tupleInAnnotation": { + "message": "Tuple expression not allowed in type expression", + "comment": ["{StrContains=i'tuple'}", "'tuple' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, "tupleIndexOutOfRange": "Index {index} is out of range for type {type}", "typeAliasIllegalExpressionForm": "Invalid expression form for type alias definition", "typeAliasIsRecursiveDirect": "Type alias \"{name}\" cannot use itself in its definition", - "typeAliasNotInModuleOrClass": "A TypeAlias can be defined only within a module or class scope", - "typeAliasRedeclared": "\"{name}\" is declared as a TypeAlias and can be assigned only once", - "typeAliasStatementBadScope": "A type statement can be used only within a module or class scope", + "typeAliasNotInModuleOrClass": { + "message": "A TypeAlias can be defined only within a module or class scope", + "comment": "{Locked='TypeAlias'}" + }, + "typeAliasRedeclared": { + "message": "\"{name}\" is declared as a TypeAlias and can be assigned only once", + "comment": "{Locked='TypeAlias'}" + }, + "typeAliasStatementBadScope": { + "message": "A type statement can be used only within a module or class scope", + "comment": "{Locked='type'}" + }, "typeAliasStatementIllegal": "Type alias statement requires Python 3.12 or newer", - "typeAliasTypeBaseClass": "A type alias defined in a \"type\" statement cannot be used as a base class", - "typeAliasTypeMustBeAssigned": "TypeAliasType must be assigned to a variable with the same name as the type alias", - "typeAliasTypeNameArg": "First argument to TypeAliasType must be a string literal representing the name of the type alias", + "typeAliasTypeBaseClass": { + "message": "A type alias defined in a \"type\" statement cannot be used as a base class", + "comment": "{Locked='\"type\"'}" + }, + "typeAliasTypeMustBeAssigned": { + "message": "TypeAliasType must be assigned to a variable with the same name as the type alias", + "comment": "{Locked='TypeAliasType'}" + }, + "typeAliasTypeNameArg": { + "message": "First argument to TypeAliasType must be a string literal representing the name of the type alias", + "comment": "{Locked='TypeAliasType'}" + }, "typeAliasTypeNameMismatch": "Name of type alias must match the name of the variable to which it is assigned", - "typeAliasTypeParamInvalid": "Type parameter list must be a tuple containing only TypeVar, TypeVarTuple, or ParamSpec", + "typeAliasTypeParamInvalid": { + "message": "Type parameter list must be a tuple containing only TypeVar, TypeVarTuple, or ParamSpec", + "comment": "{Locked='tuple','TypeVar','TypeVarTuple','ParamSpec'}" + }, "typeAnnotationCall": "Call expression not allowed in type expression", "typeAnnotationVariable": "Variable not allowed in type expression", - "typeAnnotationWithCallable": "Type argument for \"type\" must be a class; callables are not supported", - "typeArgListExpected": "Expected ParamSpec, ellipsis, or list of types", - "typeArgListNotAllowed": "List expression not allowed for this type argument", + "typeAnnotationWithCallable": { + "message": "Type argument for \"type\" must be a class; callables are not supported", + "comment": ["{Locked='type'}", "'callables' are objects that can be called like a function"] + }, + "typeArgListExpected": { + "message": "Expected ParamSpec, ellipsis, or list of types", + "comment": "{Locked='ParamSpec','list'}" + }, + "typeArgListNotAllowed": { + "message": "List expression not allowed for this type argument", + "comment": ["{StrContains=i'list'}", "'list' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, "typeArgsExpectingNone": "Expected no type arguments for class \"{name}\"", "typeArgsMismatchOne": "Expected one type argument but received {received}", - "typeArgsMissingForAlias": "Expected type arguments for generic type alias \"{name}\"", - "typeArgsMissingForClass": "Expected type arguments for generic class \"{name}\"", + "typeArgsMissingForAlias": { + "message": "Expected type arguments for generic type alias \"{name}\"", + "comment": "A generic type is a parameterized type, for example a container where the generic type parameter specifies the type of elements in the container" + }, + "typeArgsMissingForClass": { + "message": "Expected type arguments for generic class \"{name}\"", + "comment": "A generic type is a parameterized type, for example a container where the generic type parameter specifies the type of elements in the container" + }, "typeArgsTooFew": "Too few type arguments provided for \"{name}\"; expected {expected} but received {received}", "typeArgsTooMany": "Too many type arguments provided for \"{name}\"; expected {expected} but received {received}", "typeAssignmentMismatch": "Type \"{sourceType}\" is not assignable to declared type \"{destType}\"", "typeAssignmentMismatchWildcard": "Import symbol \"{name}\" has type \"{sourceType}\", which is not assignable to declared type \"{destType}\"", - "typeCallNotAllowed": "type() call should not be used in type expression", - "typeCheckOnly": "\"{name}\" is marked as @type_check_only and can be used only in type annotations", - "typeCommentDeprecated": "Use of type comments is deprecated; use type annotation instead", + "typeCallNotAllowed": { + "message": "type() call should not be used in type expression", + "comment": "{Locked='type()'}" + }, + "typeCheckOnly": { + "message": "\"{name}\" is marked as @type_check_only and can be used only in type annotations", + "comment": "{Locked='@type_check_only'}" + }, + "typeCommentDeprecated": { + "message": "Use of type comments is deprecated; use type annotation instead", + "comment": "{Locked='type'}" + }, "typeExpectedClass": "Expected class but received \"{type}\"", - "typeFormArgs": "\"TypeForm\" accepts a single positional argument", - "typeGuardArgCount": "Expected a single type argument after \"TypeGuard\" or \"TypeIs\"", + "typeFormArgs": { + "message": "\"TypeForm\" accepts a single positional argument", + "comment": "{Locked='TypeForm'}" + }, + "typeGuardArgCount": { + "message": "Expected a single type argument after \"TypeGuard\" or \"TypeIs\"", + "comment": "{Locked='TypeGuard','TypeIs'}" + }, "typeGuardParamCount": "User-defined type guard functions and methods must have at least one input parameter", - "typeIsReturnType": "Return type of TypeIs (\"{returnType}\") is not consistent with value parameter type (\"{type}\")", - "typeNotAwaitable": "\"{type}\" is not awaitable", + "typeIsReturnType": { + "message": "Return type of TypeIs (\"{returnType}\") is not consistent with value parameter type (\"{type}\")", + "comment": "{Locked='TypeIs'}" + }, + "typeNotAwaitable": { + "message": "\"{type}\" is not awaitable", + "comment": "{Locked='awaitable'}" + }, "typeNotIntantiable": "\"{type}\" cannot be instantiated", "typeNotIterable": "\"{type}\" is not iterable", "typeNotSpecializable": "Could not specialize type \"{type}\"", @@ -526,62 +1309,182 @@ "typeNotSupportUnaryOperator": "Operator \"{operator}\" not supported for type \"{type}\"", "typeNotSupportUnaryOperatorBidirectional": "Operator \"{operator}\" not supported for type \"{type}\" when expected type is \"{expectedType}\"", "typeNotUsableWith": "Object of type \"{type}\" cannot be used with \"with\" because it does not implement {method}", - "typeParameterBoundNotAllowed": "Bound or constraint cannot be used with a variadic type parameter or ParamSpec", + "typeParameterBoundNotAllowed": { + "message": "Bound or constraint cannot be used with a variadic type parameter or ParamSpec", + "comment": ["{Locked='ParamSpec'}", "'variadic' means that it accepts a variable number of arguments"] + }, "typeParameterConstraintTuple": "Type parameter constraint must be a tuple of two or more types", "typeParameterExistingTypeParameter": "Type parameter \"{name}\" is already in use", "typeParameterNotDeclared": "Type parameter \"{name}\" is not included in the type parameter list for \"{container}\"", "typeParametersMissing": "At least one type parameter must be specified", "typePartiallyUnknown": "Type of \"{name}\" is partially unknown", "typeUnknown": "Type of \"{name}\" is unknown", - "typeVarAssignedName": "TypeVar must be assigned to a variable named \"{name}\"", + "typeVarAssignedName": { + "message": "TypeVar must be assigned to a variable named \"{name}\"", + "comment": "{Locked='TypeVar'}" + }, "typeVarAssignmentMismatch": "Type \"{type}\" cannot be assigned to type variable \"{name}\"", - "typeVarBoundAndConstrained": "TypeVar cannot be both bound and constrained", - "typeVarBoundGeneric": "TypeVar bound type cannot be generic", - "typeVarConstraintGeneric": "TypeVar constraint type cannot be generic", - "typeVarDefaultBoundMismatch": "TypeVar default type must be a subtype of the bound type", - "typeVarDefaultConstraintMismatch": "TypeVar default type must be one of the constrained types", + "typeVarBoundAndConstrained": { + "message": "TypeVar cannot be both bound and constrained", + "comment": "{Locked='TypeVar'}" + }, + "typeVarBoundGeneric": { + "message": "TypeVar bound type cannot be generic", + "comment": ["{Locked='TypeVar'}", "A generic type is a parameterized type, for example a container where the generic type parameter specifies the type of elements in the container"] + }, + "typeVarConstraintGeneric": { + "message": "TypeVar constraint type cannot be generic", + "comment": ["{Locked='TypeVar'}", "A generic type is a parameterized type, for example a container where the generic type parameter specifies the type of elements in the container"] + }, + "typeVarDefaultBoundMismatch": { + "message": "TypeVar default type must be a subtype of the bound type", + "comment": "{Locked='TypeVar'}" + }, + "typeVarDefaultConstraintMismatch": { + "message": "TypeVar default type must be one of the constrained types", + "comment": "{Locked='TypeVar'}" + }, "typeVarDefaultIllegal": "Type variable default types require Python 3.13 or newer", "typeVarDefaultInvalidTypeVar": "Type parameter \"{name}\" has a default type that refers to one or more type variables that are out of scope", - "typeVarFirstArg": "Expected name of TypeVar as first argument", + "typeVarFirstArg": { + "message": "Expected name of TypeVar as first argument", + "comment": "{Locked='TypeVar'}" + }, "typeVarInvalidForMemberVariable": "Attribute type cannot use type variable \"{name}\" scoped to local method", - "typeVarNoMember": "TypeVar \"{type}\" has no attribute \"{name}\"", - "typeVarNotSubscriptable": "TypeVar \"{type}\" is not subscriptable", + "typeVarNoMember": { + "message": "TypeVar \"{type}\" has no attribute \"{name}\"", + "comment": "{Locked='TypeVar'}" + }, + "typeVarNotSubscriptable": { + "message": "TypeVar \"{type}\" is not subscriptable", + "comment": "{Locked='TypeVar'}" + }, "typeVarNotUsedByOuterScope": "Type variable \"{name}\" has no meaning in this context", "typeVarPossiblyUnsolvable": "Type variable \"{name}\" may go unsolved if caller supplies no argument for parameter \"{param}\"", - "typeVarSingleConstraint": "TypeVar must have at least two constrained types", - "typeVarTupleConstraints": "TypeVarTuple cannot have value constraints", - "typeVarTupleContext": "TypeVarTuple is not allowed in this context", - "typeVarTupleDefaultNotUnpacked": "TypeVarTuple default type must be an unpacked tuple or TypeVarTuple", - "typeVarTupleMustBeUnpacked": "Unpack operator is required for TypeVarTuple value", - "typeVarTupleUnknownParam": "\"{name}\" is unknown parameter to TypeVarTuple", - "typeVarUnknownParam": "\"{name}\" is unknown parameter to TypeVar", - "typeVarUsedByOuterScope": "TypeVar \"{name}\" is already in use by an outer scope", - "typeVarUsedOnlyOnce": "TypeVar \"{name}\" appears only once in generic function signature", - "typeVarVariance": "TypeVar cannot be both covariant and contravariant", - "typeVarWithDefaultFollowsVariadic": "TypeVar \"{typeVarName}\" has a default value and cannot follow TypeVarTuple \"{variadicName}\"", + "typeVarSingleConstraint": { + "message": "TypeVar must have at least two constrained types", + "comment": "{Locked='TypeVar'}" + }, + "typeVarTupleConstraints": { + "message": "TypeVarTuple cannot have value constraints", + "comment": "{Locked='TypeVarTuple'}" + }, + "typeVarTupleContext": { + "message": "TypeVarTuple is not allowed in this context", + "comment": "{Locked='TypeVarTuple'}" + }, + "typeVarTupleDefaultNotUnpacked": { + "message": "TypeVarTuple default type must be an unpacked tuple or TypeVarTuple", + "comment": "{Locked='TypeVarTuple','tuple'}" + }, + "typeVarTupleMustBeUnpacked": { + "message": "Unpack operator is required for TypeVarTuple value", + "comment": "{Locked='TypeVarTuple'}" + }, + "typeVarTupleUnknownParam": { + "message": "\"{name}\" is unknown parameter to TypeVarTuple", + "comment": "{Locked='TypeVarTuple'}" + }, + "typeVarUnknownParam": { + "message": "\"{name}\" is unknown parameter to TypeVar", + "comment": "{Locked='TypeVar'}" + }, + "typeVarUsedByOuterScope": { + "message": "TypeVar \"{name}\" is already in use by an outer scope", + "comment": "{Locked='TypeVar'}" + }, + "typeVarUsedOnlyOnce": { + "message": "TypeVar \"{name}\" appears only once in generic function signature", + "comment": ["{Locked='TypeVar'}", "A generic type is a parameterized type, for example a container where the generic type parameter specifies the type of elements in the container"] + }, + "typeVarVariance": { + "message": "TypeVar cannot be both covariant and contravariant", + "comment": "{Locked='TypeVar'}" + }, + "typeVarWithDefaultFollowsVariadic": { + "message": "TypeVar \"{typeVarName}\" has a default value and cannot follow TypeVarTuple \"{variadicName}\"", + "comment": "{Locked='TypeVar','TypeVarTuple'}" + }, "typeVarWithoutDefault": "\"{name}\" cannot appear after \"{other}\" in type parameter list because it has no default type", - "typeVarsNotInGenericOrProtocol": "Generic[] or Protocol[] must include all type variables", - "typedDictAccess": "Could not access item in TypedDict", - "typedDictAssignedName": "TypedDict must be assigned to a variable named \"{name}\"", - "typedDictBadVar": "TypedDict classes can contain only type annotations", - "typedDictBaseClass": "All base classes for TypedDict classes must also be TypedDict classes", - "typedDictBoolParam": "Expected \"{name}\" parameter to have a value of True or False", - "typedDictClosedExtras": "Base class \"{name}\" is a closed TypedDict; extra items must be type \"{type}\"", - "typedDictClosedNoExtras": "Base class \"{name}\" is a closed TypedDict; extra items are not allowed", - "typedDictDelete": "Could not delete item in TypedDict", - "typedDictEmptyName": "Names within a TypedDict cannot be empty", + "typeVarsNotInGenericOrProtocol": { + "message": "Generic[] or Protocol[] must include all type variables", + "comment": "{Locked='Generic[]','Protocol[]'}" + }, + "typedDictAccess": { + "message": "Could not access item in TypedDict", + "comment": "{Locked='TypedDict'}" + }, + "typedDictAssignedName": { + "message": "TypedDict must be assigned to a variable named \"{name}\"", + "comment": "{Locked='TypedDict'}" + }, + "typedDictBadVar": { + "message": "TypedDict classes can contain only type annotations", + "comment": "{Locked='TypedDict'}" + }, + "typedDictBaseClass": { + "message": "All base classes for TypedDict classes must also be TypedDict classes", + "comment": "{Locked='TypedDict'}" + }, + "typedDictBoolParam": { + "message": "Expected \"{name}\" parameter to have a value of True or False", + "comment": "{Locked='True','False'}" + }, + "typedDictClosedExtras": { + "message": "Base class \"{name}\" is a closed TypedDict; extra items must be type \"{type}\"", + "comment": "{Locked='closed','TypedDict'}" + }, + "typedDictClosedNoExtras": { + "message": "Base class \"{name}\" is a closed TypedDict; extra items are not allowed", + "comment": "{Locked='closed','TypedDict'}" + }, + "typedDictDelete": { + "message": "Could not delete item in TypedDict", + "comment": "{Locked='TypedDict'}" + }, + "typedDictEmptyName": { + "message": "Names within a TypedDict cannot be empty", + "comment": "{Locked='TypedDict'}" + }, "typedDictEntryName": "Expected string literal for dictionary entry name", "typedDictEntryUnique": "Names within a dictionary must be unique", - "typedDictExtraArgs": "Extra TypedDict arguments not supported", - "typedDictFieldNotRequiredRedefinition": "TypedDict item \"{name}\" cannot be redefined as NotRequired", - "typedDictFieldReadOnlyRedefinition": "TypedDict item \"{name}\" cannot be redefined as ReadOnly", - "typedDictFieldRequiredRedefinition": "TypedDict item \"{name}\" cannot be redefined as Required", - "typedDictFirstArg": "Expected TypedDict class name as first argument", - "typedDictInitsubclassParameter": "TypedDict does not support __init_subclass__ parameter \"{name}\"", - "typedDictNotAllowed": "\"TypedDict\" cannot be used in this context", - "typedDictSecondArgDict": "Expected dict or keyword parameter as second parameter", + "typedDictExtraArgs": { + "message": "Extra TypedDict arguments not supported", + "comment": "{Locked='TypedDict'}" + }, + "typedDictFieldNotRequiredRedefinition": { + "message": "TypedDict item \"{name}\" cannot be redefined as NotRequired", + "comment": "{Locked='TypedDict','NotRequired'}" + }, + "typedDictFieldReadOnlyRedefinition": { + "message": "TypedDict item \"{name}\" cannot be redefined as ReadOnly", + "comment": "{Locked='TypedDict','ReadOnly'}" + }, + "typedDictFieldRequiredRedefinition": { + "message": "TypedDict item \"{name}\" cannot be redefined as Required", + "comment": "{Locked='TypedDict','Required'}" + }, + "typedDictFirstArg": { + "message": "Expected TypedDict class name as first argument", + "comment": "{Locked='TypedDict'}" + }, + "typedDictInitsubclassParameter": { + "message": "TypedDict does not support __init_subclass__ parameter \"{name}\"", + "comment": "{Locked='TypedDict','__init_subclass__'}" + }, + "typedDictNotAllowed": { + "message": "\"TypedDict\" cannot be used in this context", + "comment": "{Locked='TypedDict'}" + }, + "typedDictSecondArgDict": { + "message": "Expected dict or keyword parameter as second parameter", + "comment": "{Locked='dict'}" + }, "typedDictSecondArgDictEntry": "Expected simple dictionary entry", - "typedDictSet": "Could not assign item in TypedDict", + "typedDictSet": { + "message": "Could not assign item in TypedDict", + "comment": "{Locked='TypedDict'}" + }, "unaccessedClass": "Class \"{name}\" is not accessed", "unaccessedFunction": "Function \"{name}\" is not accessed", "unaccessedImport": "Import \"{name}\" is not accessed", @@ -589,105 +1492,282 @@ "unaccessedVariable": "Variable \"{name}\" is not accessed", "unannotatedFunctionSkipped": "Analysis of function \"{name}\" is skipped because it is unannotated", "unaryOperationNotAllowed": "Unary operator not allowed in type expression", - "unexpectedAsyncToken": "Expected \"def\", \"with\" or \"for\" to follow \"async\"", + "unexpectedAsyncToken": { + "message": "Expected \"def\", \"with\" or \"for\" to follow \"async\"", + "comment": "{Locked='def','with','for','async'}" + }, "unexpectedExprToken": "Unexpected token at end of expression", "unexpectedIndent": "Unexpected indentation", "unexpectedUnindent": "Unindent not expected", "unhashableDictKey": "Dictionary key must be hashable", - "unhashableSetEntry": "Set entry must be hashable", - "uninitializedAbstractVariables": "Variables defined in abstract base class are not initialized in final class \"{classType}\"", - "uninitializedInstanceVariable": "Instance variable \"{name}\" is not initialized in the class body or __init__ method", - "unionForwardReferenceNotAllowed": "Union syntax cannot be used with string operand; use quotes around entire expression", - "unionSyntaxIllegal": "Alternative syntax for unions requires Python 3.10 or newer", - "unionTypeArgCount": "Union requires two or more type arguments", - "unionUnpackedTuple": "Union cannot include an unpacked tuple", - "unionUnpackedTypeVarTuple": "Union cannot include an unpacked TypeVarTuple", - "unnecessaryCast": "Unnecessary \"cast\" call; type is already \"{type}\"", - "unnecessaryIsInstanceAlways": "Unnecessary isinstance call; \"{testType}\" is always an instance of \"{classType}\"", - "unnecessaryIsSubclassAlways": "Unnecessary issubclass call; \"{testType}\" is always a subclass of \"{classType}\"", - "unnecessaryPyrightIgnore": "Unnecessary \"# pyright: ignore\" comment", - "unnecessaryPyrightIgnoreRule": "Unnecessary \"# pyright: ignore\" rule: \"{name}\"", - "unnecessaryTypeIgnore": "Unnecessary \"# type: ignore\" comment", - "unpackArgCount": "Expected a single type argument after \"Unpack\"", - "unpackExpectedTypeVarTuple": "Expected TypeVarTuple or tuple as type argument for Unpack", - "unpackExpectedTypedDict": "Expected TypedDict type argument for Unpack", - "unpackIllegalInComprehension": "Unpack operation not allowed in comprehension", + "unhashableSetEntry": { + "message": "Set entry must be hashable", + "comment": ["{StrContains=i'set'}", "'set' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, + "uninitializedAbstractVariables": { + "message": "Variables defined in abstract base class are not initialized in final class \"{classType}\"", + "comment": "{Locked='final'}" + }, + "uninitializedInstanceVariable": { + "message": "Instance variable \"{name}\" is not initialized in the class body or __init__ method", + "comment": "{Locked='__init__'}" + }, + "unionForwardReferenceNotAllowed": { + "message": "Union syntax cannot be used with string operand; use quotes around entire expression", + "comment": "{Locked='Union'}" + }, + "unionSyntaxIllegal": { + "message": "Alternative syntax for unions requires Python 3.10 or newer", + "comment": "'unions' as in the mathematical set theory term" + }, + "unionTypeArgCount": { + "message": "Union requires two or more type arguments", + "comment": "{Locked='Union'}" + }, + "unionUnpackedTuple": { + "message": "Union cannot include an unpacked tuple", + "comment": "{Locked='Union','tuple'}" + }, + "unionUnpackedTypeVarTuple": { + "message": "Union cannot include an unpacked TypeVarTuple", + "comment": "{Locked='Union','TypeVarTuple'}" + }, + "unnecessaryCast": { + "message": "Unnecessary \"cast\" call; type is already \"{type}\"", + "comment": "{Locked='cast'}" + }, + "unnecessaryIsInstanceAlways": { + "message": "Unnecessary isinstance call; \"{testType}\" is always an instance of \"{classType}\"", + "comment": "{Locked='isinstance'}" + }, + "unnecessaryIsSubclassAlways": { + "message": "Unnecessary issubclass call; \"{testType}\" is always a subclass of \"{classType}\"", + "comment": "{Locked='issubclass'}" + }, + "unnecessaryPyrightIgnore": { + "message": "Unnecessary \"# pyright: ignore\" comment", + "comment": "{Locked='# pyright: ignore'}" + }, + "unnecessaryPyrightIgnoreRule": { + "message": "Unnecessary \"# pyright: ignore\" rule: \"{name}\"", + "comment": "{Locked='# pyright: ignore'}" + }, + "unnecessaryTypeIgnore": { + "message": "Unnecessary \"# type: ignore\" comment", + "comment": "{Locked='# type: ignore'}" + }, + "unpackArgCount": { + "message": "Expected a single type argument after \"Unpack\"", + "comment": "{Locked='Unpack'}" + }, + "unpackExpectedTypeVarTuple": { + "message": "Expected TypeVarTuple or tuple as type argument for Unpack", + "comment": "{Locked='TypeVarTuple','tuple','Unpack'}" + }, + "unpackExpectedTypedDict": { + "message": "Expected TypedDict type argument for Unpack", + "comment": "{Locked='TypedDict','Unpack'}" + }, + "unpackIllegalInComprehension": { + "message": "Unpack operation not allowed in comprehension", + "comment": "A comprehension is a 'set of looping and filtering instructions' applied to a collection to generate a new collection; the word may not be translatable" + }, "unpackInAnnotation": "Unpack operator not allowed in type expression", "unpackInDict": "Unpack operation not allowed in dictionaries", - "unpackInSet": "Unpack operator not allowed within a set", - "unpackNotAllowed": "Unpack is not allowed in this context", + "unpackInSet": { + "message": "Unpack operator not allowed within a set", + "comment": "{Locked='set'}" + }, + "unpackNotAllowed": { + "message": "Unpack is not allowed in this context", + "comment": "{Locked='Unpack'}" + }, "unpackOperatorNotAllowed": "Unpack operation is not allowed in this context", - "unpackTuplesIllegal": "Unpack operation not allowed in tuples prior to Python 3.8", + "unpackTuplesIllegal": { + "message": "Unpack operation not allowed in tuples prior to Python 3.8", + "comment": "'tuple' is a keyword and should not be localized, but here it is pluralized" + }, "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", + "unpackedArgWithVariadicParam": { + "message": "Unpacked argument cannot be used for TypeVarTuple parameter", + "comment": "{Locked='TypeVarTuple'}" + }, + "unpackedDictArgumentNotMapping": { + "message": "Argument expression after ** must be a mapping with a \"str\" key type", + "comment": "{Locked='str'}" + }, "unpackedDictSubscriptIllegal": "Dictionary unpack operator in subscript is not allowed", "unpackedSubscriptIllegal": "Unpack operator in subscript requires Python 3.11 or newer", - "unpackedTypeVarTupleExpected": "Expected unpacked TypeVarTuple; use Unpack[{name1}] or *{name2}", - "unpackedTypedDictArgument": "Unable to match unpacked TypedDict argument to parameters", + "unpackedTypeVarTupleExpected": { + "message": "Expected unpacked TypeVarTuple; use Unpack[{name1}] or *{name2}", + "comment": "{Locked='TypeVarTuple','Unpack[{name1}]','*{name2}'}" + }, + "unpackedTypedDictArgument": { + "message": "Unable to match unpacked TypedDict argument to parameters", + "comment": "{Locked='TypedDict'}" + }, "unreachableCode": "Code is unreachable", "unreachableCodeType": "Type analysis indicates code is unreachable", - "unreachableExcept": "Except clause is unreachable because exception is already handled", - "unsupportedDunderAllOperation": "Operation on \"__all__\" is not supported, so exported symbol list may be incorrect", + "unreachableExcept": { + "message": "Except clause is unreachable because exception is already handled", + "comment": ["{StrContains=i'except'}", "'except' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, + "unsupportedDunderAllOperation": { + "message": "Operation on \"__all__\" is not supported, so exported symbol list may be incorrect", + "comment": "{Locked='__all__'}" + }, "unusedCallResult": "Result of call expression is of type \"{type}\" and is not used; assign to variable \"_\" if this is intentional", - "unusedCoroutine": "Result of async function call is not used; use \"await\" or assign result to variable", + "unusedCoroutine": { + "message": "Result of async function call is not used; use \"await\" or assign result to variable", + "comment": "{Locked='async'}" + }, "unusedExpression": "Expression value is unused", - "varAnnotationIllegal": "Type annotations for variables requires Python 3.6 or newer; use type comment for compatibility with previous versions", - "variableFinalOverride": "Variable \"{name}\" is marked Final and overrides non-Final variable of same name in class \"{className}\"", - "variadicTypeArgsTooMany": "Type argument list can have at most one unpacked TypeVarTuple or tuple", - "variadicTypeParamTooManyAlias": "Type alias can have at most one TypeVarTuple type parameter but received multiple ({names})", - "variadicTypeParamTooManyClass": "Generic class can have at most one TypeVarTuple type parameter but received multiple ({names})", + "varAnnotationIllegal": { + "message": "Type annotations for variables requires Python 3.6 or newer; use type comment for compatibility with previous versions", + "comment": "{Locked='type'}" + }, + "variableFinalOverride": { + "message": "Variable \"{name}\" is marked Final and overrides non-Final variable of same name in class \"{className}\"", + "comment": "{Locked='Final'}" + }, + "variadicTypeArgsTooMany": { + "message": "Type argument list can have at most one unpacked TypeVarTuple or tuple", + "comment": "{Locked='TypeVarTuple','tuple'}" + }, + "variadicTypeParamTooManyAlias": { + "message": "Type alias can have at most one TypeVarTuple type parameter but received multiple ({names})", + "comment": "{Locked='TypeVarTuple'}" + }, + "variadicTypeParamTooManyClass": { + "message": "Generic class can have at most one TypeVarTuple type parameter but received multiple ({names})", + "comment": ["{Locked='TypeVarTuple'}", "A generic type is a parameterized type, for example a container where the generic type parameter specifies the type of elements in the container"] + }, "walrusIllegal": "Operator \":=\" requires Python 3.8 or newer", "walrusNotAllowed": "Operator \":=\" is not allowed in this context without surrounding parentheses", - "wildcardInFunction": "Wildcard import not allowed within a class or function", - "wildcardLibraryImport": "Wildcard import from a library not allowed", + "wildcardInFunction": { + "message": "Wildcard import not allowed within a class or function", + "comment": "{Locked='import'}" + }, + "wildcardLibraryImport": { + "message": "Wildcard import from a library not allowed", + "comment": "{Locked='import'}" + }, "wildcardPatternTypePartiallyUnknown": "Type captured by wildcard pattern is partially unknown", "wildcardPatternTypeUnknown": "Type captured by wildcard pattern is unknown", - "yieldFromIllegal": "Use of \"yield from\" requires Python 3.3 or newer", - "yieldFromOutsideAsync": "\"yield from\" not allowed in an async function", - "yieldOutsideFunction": "\"yield\" not allowed outside of a function or lambda", - "yieldWithinComprehension": "\"yield\" not allowed inside a comprehension", - "zeroCaseStatementsFound": "Match statement must include at least one case statement", - "zeroLengthTupleNotAllowed": "Zero-length tuple is not allowed in this context" + "yieldFromIllegal": { + "message": "Use of \"yield from\" requires Python 3.3 or newer", + "comment": "{Locked='yield from'}" + }, + "yieldFromOutsideAsync": { + "message": "\"yield from\" not allowed in an async function", + "comment": "{Locked='yield from','async'}" + }, + "yieldOutsideFunction": { + "message": "\"yield\" not allowed outside of a function or lambda", + "comment": "{Locked='yield'}" + }, + "yieldWithinComprehension": { + "message": "\"yield\" not allowed inside a comprehension", + "comment": ["{Locked='yield'}", "A comprehension is a 'set of looping and filtering instructions' applied to a collection to generate a new collection; the word may not be translatable"] + }, + "zeroCaseStatementsFound": { + "message": "Match statement must include at least one case statement", + "comment": ["{Locked='case'}", "{StrContains=i'match'}", "'match' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, + "zeroLengthTupleNotAllowed": { + "message": "Zero-length tuple is not allowed in this context", + "comment": "{Locked='tuple'}" + } }, "DiagnosticAddendum": { - "annotatedNotAllowed": "\"Annotated\" special form cannot be used with instance and class checks", + "annotatedNotAllowed": { + "message": "\"Annotated\" special form cannot be used with instance and class checks", + "comment": "{Locked='Annotated'}" + }, "argParam": "Argument corresponds to parameter \"{paramName}\"", "argParamFunction": "Argument corresponds to parameter \"{paramName}\" in function \"{functionName}\"", "argsParamMissing": "Parameter \"*{paramName}\" has no corresponding parameter", "argsPositionOnly": "Position-only parameter mismatch; expected {expected} but received {received}", "argumentType": "Argument type is \"{type}\"", "argumentTypes": "Argument types: ({types})", - "assignToNone": "Type is not assignable to \"None\"", - "asyncHelp": "Did you mean \"async with\"?", + "assignToNone": { + "message": "Type is not assignable to \"None\"", + "comment": "{Locked='None'}" + }, + "asyncHelp": { + "message": "Did you mean \"async with\"?", + "comment": "{Locked='async with'}" + }, "baseClassIncompatible": "Base class \"{baseClass}\" is incompatible with type \"{type}\"", "baseClassIncompatibleSubclass": "Base class \"{baseClass}\" derives from \"{subclass}\" which is incompatible with type \"{type}\"", "baseClassOverriddenType": "Base class \"{baseClass}\" provides type \"{type}\", which is overridden", "baseClassOverridesType": "Base class \"{baseClass}\" overrides with type \"{type}\"", - "bytesTypePromotions": "Set disableBytesTypePromotions to false to enable type promotion behavior for \"bytearray\" and \"memoryview\"", - "conditionalRequiresBool": "Method __bool__ for type \"{operandType}\" returns type \"{boolReturnType}\" rather than \"bool\"", + "bytesTypePromotions": { + "message": "Set disableBytesTypePromotions to false to enable type promotion behavior for \"bytearray\" and \"memoryview\"", + "comment": "{Locked='disableBytesTypePromotions','false','bytearray','memoryview'}" + }, + "conditionalRequiresBool": { + "message": "Method __bool__ for type \"{operandType}\" returns type \"{boolReturnType}\" rather than \"bool\"", + "comment": "{Locked='__bool__'}" + }, "dataClassFieldLocation": "Field declaration", "dataClassFrozen": "\"{name}\" is frozen", "dataProtocolUnsupported": "\"{name}\" is a data protocol", - "descriptorAccessBindingFailed": "Failed to bind method \"{name}\" for descriptor class \"{className}\"", + "descriptorAccessBindingFailed": { + "message": "Failed to bind method \"{name}\" for descriptor class \"{className}\"", + "comment": "Binding is the process through which Pyright determines what object a name refers to" + }, "descriptorAccessCallFailed": "Failed to call method \"{name}\" for descriptor class \"{className}\"", - "finalMethod": "Final method", + "finalMethod": { + "message": "Final method", + "comment": "{Locked='Final'}" + }, "functionParamDefaultMissing": "Parameter \"{name}\" is missing default argument", "functionParamName": "Parameter name mismatch: \"{destName}\" versus \"{srcName}\"", "functionParamPositionOnly": "Position-only parameter mismatch; parameter \"{name}\" is not position-only", "functionReturnTypeMismatch": "Function return type \"{sourceType}\" is incompatible with type \"{destType}\"", "functionTooFewParams": "Function accepts too few positional parameters; expected {expected} but received {received}", "functionTooManyParams": "Function accepts too many positional parameters; expected {expected} but received {received}", - "genericClassNotAllowed": "Generic type with type arguments not allowed for instance or class checks", - "incompatibleDeleter": "Property deleter method is incompatible", - "incompatibleGetter": "Property getter method is incompatible", - "incompatibleSetter": "Property setter method is incompatible", - "initMethodLocation": "The __init__ method is defined in class \"{type}\"", - "initMethodSignature": "Signature of __init__ is \"{type}\"", - "initSubclassLocation": "The __init_subclass__ method is defined in class \"{name}\"", - "invariantSuggestionDict": "Consider switching from \"dict\" to \"Mapping\" which is covariant in the value type", - "invariantSuggestionList": "Consider switching from \"list\" to \"Sequence\" which is covariant", - "invariantSuggestionSet": "Consider switching from \"set\" to \"Container\" which is covariant", + "genericClassNotAllowed": { + "message": "Generic type with type arguments not allowed for instance or class checks", + "comment": "A generic type is a parameterized type, for example a container where the generic type parameter specifies the type of elements in the container" + }, + "incompatibleDeleter": { + "message": "Property deleter method is incompatible", + "comment": ["{Locked='deleter'}", "{StrContains=i'property'}", "'property' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, + "incompatibleGetter": { + "message": "Property getter method is incompatible", + "comment": ["{Locked='getter'}", "{StrContains=i'property'}", "'property' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, + "incompatibleSetter": { + "message": "Property setter method is incompatible", + "comment": ["{Locked='setter'}", "{StrContains=i'property'}", "'property' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, + "initMethodLocation": { + "message": "The __init__ method is defined in class \"{type}\"", + "comment": "{Locked='__init__'}" + }, + "initMethodSignature": { + "message": "Signature of __init__ is \"{type}\"", + "comment": "{Locked='__init__'}" + }, + "initSubclassLocation": { + "message": "The __init_subclass__ method is defined in class \"{name}\"", + "comment": "{Locked='__init_subclass__'}" + }, + "invariantSuggestionDict": { + "message": "Consider switching from \"dict\" to \"Mapping\" which is covariant in the value type", + "comment": "{Locked='dict','Mapping'}" + }, + "invariantSuggestionList": { + "message": "Consider switching from \"list\" to \"Sequence\" which is covariant", + "comment": "{Locked='list','Sequence'}" + }, + "invariantSuggestionSet": { + "message": "Consider switching from \"set\" to \"Container\" which is covariant", + "comment": "{Locked='set','Container'}" + }, "isinstanceClassNotSupported": "\"{type}\" is not supported for instance and class checks", "keyNotRequired": "\"{name}\" is not a required key in \"{type}\", so access may result in runtime exception", "keyReadOnly": "\"{name}\" is a read-only key in \"{type}\"", @@ -696,35 +1776,83 @@ "kwargsParamMissing": "Parameter \"**{paramName}\" has no corresponding parameter", "listAssignmentMismatch": "Type \"{type}\" is incompatible with target list", "literalAssignmentMismatch": "\"{sourceType}\" is not assignable to type \"{destType}\"", - "matchIsNotExhaustiveHint": "If exhaustive handling is not intended, add \"case _: pass\"", + "matchIsNotExhaustiveHint": { + "message": "If exhaustive handling is not intended, add \"case _: pass\"", + "comment": "{Locked='case _: pass'}" + }, "matchIsNotExhaustiveType": "Unhandled type: \"{type}\"", "memberAssignment": "Expression of type \"{type}\" cannot be assigned to attribute \"{name}\" of class \"{classType}\"", "memberIsAbstract": "\"{type}.{name}\" is not implemented", - "memberIsAbstractMore": "and {count} more...", - "memberIsClassVarInProtocol": "\"{name}\" is defined as a ClassVar in protocol", - "memberIsInitVar": "\"{name}\" is an init-only field", + "memberIsAbstractMore": { + "message": "and {count} more...", + "comment": "{StrEnds='...'}" + }, + "memberIsClassVarInProtocol": { + "message": "\"{name}\" is defined as a ClassVar in protocol", + "comment": "{Locked='ClassVar'}" + }, + "memberIsInitVar": { + "message": "\"{name}\" is an init-only field", + "comment": "{Locked='init-only'}" + }, "memberIsInvariant": "\"{name}\" is invariant because it is mutable", - "memberIsNotClassVarInClass": "\"{name}\" must be defined as a ClassVar to be compatible with protocol", - "memberIsNotClassVarInProtocol": "\"{name}\" is not defined as a ClassVar in protocol", + "memberIsNotClassVarInClass": { + "message": "\"{name}\" must be defined as a ClassVar to be compatible with protocol", + "comment": "{Locked='ClassVar'}" + }, + "memberIsNotClassVarInProtocol": { + "message": "\"{name}\" is not defined as a ClassVar in protocol", + "comment": "{Locked='ClassVar'}" + }, "memberIsNotReadOnlyInProtocol": "\"{name}\" is not read-only in protocol", "memberIsReadOnlyInProtocol": "\"{name}\" is read-only in protocol", "memberIsWritableInProtocol": "\"{name}\" is writable in protocol", - "memberSetClassVar": "Attribute \"{name}\" cannot be assigned through a class instance because it is a ClassVar", + "memberSetClassVar": { + "message": "Attribute \"{name}\" cannot be assigned through a class instance because it is a ClassVar", + "comment": "{Locked='ClassVar'}" + }, "memberTypeMismatch": "\"{name}\" is an incompatible type", "memberUnknown": "Attribute \"{name}\" is unknown", - "metaclassConflict": "Metaclass \"{metaclass1}\" conflicts with \"{metaclass2}\"", - "missingDeleter": "Property deleter method is missing", - "missingGetter": "Property getter method is missing", - "missingSetter": "Property setter method is missing", + "metaclassConflict": { + "message": "Metaclass \"{metaclass1}\" conflicts with \"{metaclass2}\"", + "comment": "Metaclasses are a complex concept and it may be best to not localize the term" + }, + "missingDeleter": { + "message": "Property deleter method is missing", + "comment": ["{Locked='deleter'}", "{StrContains=i'property'}", "'property' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, + "missingGetter": { + "message": "Property getter method is missing", + "comment": ["{Locked='getter'}", "{StrContains=i'property'}", "'property' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, + "missingSetter": { + "message": "Property setter method is missing", + "comment": ["{Locked='setter'}", "{StrContains=i'property'}", "'property' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, "namedParamMissingInDest": "Extra parameter \"{name}\"", "namedParamMissingInSource": "Missing keyword parameter \"{name}\"", "namedParamTypeMismatch": "Keyword parameter \"{name}\" of type \"{sourceType}\" is incompatible with type \"{destType}\"", - "namedTupleNotAllowed": "NamedTuple cannot be used for instance or class checks", - "newMethodLocation": "The __new__ method is defined in class \"{type}\"", - "newMethodSignature": "Signature of __new__ is \"{type}\"", - "newTypeClassNotAllowed": "Class created with NewType cannot be used with instance and class checks", + "namedTupleNotAllowed": { + "message": "NamedTuple cannot be used for instance or class checks", + "comment": "{Locked='NamedTuple'}" + }, + "newMethodLocation": { + "message": "The __new__ method is defined in class \"{type}\"", + "comment": "{Locked='__new__'}" + }, + "newMethodSignature": { + "message": "Signature of __new__ is \"{type}\"", + "comment": "{Locked='__new__'}" + }, + "newTypeClassNotAllowed": { + "message": "Class created with NewType cannot be used with instance and class checks", + "comment": "{Locked='NewType'}" + }, "noOverloadAssignable": "No overloaded function matches type \"{type}\"", - "noneNotAllowed": "None cannot be used for instance or class checks", + "noneNotAllowed": { + "message": "None cannot be used for instance or class checks", + "comment": "{Locked='None'}" + }, "orPatternMissingName": "Missing names: {name}", "overloadIndex": "Overload {index} is the closest match", "overloadNotAssignable": "One or more overloads of \"{name}\" is not assignable", @@ -734,9 +1862,15 @@ "overrideInvariantMismatch": "Override type \"{overrideType}\" is not the same as base type \"{baseType}\"", "overrideIsInvariant": "Variable is mutable so its type is invariant", "overrideNoOverloadMatches": "No overload signature in override is compatible with base method", - "overrideNotClassMethod": "Base method is declared as a classmethod but override is not", + "overrideNotClassMethod": { + "message": "Base method is declared as a classmethod but override is not", + "comment": "{Locked='classmethod'}" + }, "overrideNotInstanceMethod": "Base method is declared as an instance method but override is not", - "overrideNotStaticMethod": "Base method is declared as a staticmethod but override is not", + "overrideNotStaticMethod": { + "message": "Base method is declared as a staticmethod but override is not", + "comment": "{Locked='staticmethod'}" + }, "overrideOverloadNoMatch": "Override does not handle all overloads of base method", "overrideOverloadOrder": "Overloads for override method must be in the same order as the base method", "overrideParamKeywordNoDefault": "Keyword parameter \"{name}\" mismatch: base parameter has default argument value, override parameter does not", @@ -751,20 +1885,41 @@ "overrideReturnType": "Return type mismatch: base method returns type \"{baseType}\", override returns type \"{overrideType}\"", "overrideType": "Base class defines type as \"{type}\"", "paramAssignment": "Parameter {index}: type \"{sourceType}\" is incompatible with type \"{destType}\"", - "paramSpecMissingInOverride": "ParamSpec parameters are missing in override method", + "paramSpecMissingInOverride": { + "message": "ParamSpec parameters are missing in override method", + "comment": "{Locked='ParamSpec'}" + }, "paramType": "Parameter type is \"{paramType}\"", "privateImportFromPyTypedSource": "Import from \"{module}\" instead", "propertyAccessFromProtocolClass": "A property defined within a protocol class cannot be accessed as a class variable", - "propertyMethodIncompatible": "Property method \"{name}\" is incompatible", - "propertyMethodMissing": "Property method \"{name}\" is missing in override", - "propertyMissingDeleter": "Property \"{name}\" has no defined deleter", - "propertyMissingSetter": "Property \"{name}\" has no defined setter", + "propertyMethodIncompatible": { + "message": "Property method \"{name}\" is incompatible", + "comment": ["{StrContains=i'property'}", "'property' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, + "propertyMethodMissing": { + "message": "Property method \"{name}\" is missing in override", + "comment": ["{StrContains=i'property'}", "'property' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, + "propertyMissingDeleter": { + "message": "Property \"{name}\" has no defined deleter", + "comment": ["{Locked='deleter'}", "{StrContains=i'property'}", "'property' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, + "propertyMissingSetter": { + "message": "Property \"{name}\" has no defined setter", + "comment": ["{Locked='setter'}", "{StrContains=i'property'}", "'property' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, "protocolIncompatible": "\"{sourceType}\" is incompatible with protocol \"{destType}\"", "protocolMemberMissing": "\"{name}\" is not present", - "protocolRequiresRuntimeCheckable": "Protocol class must be @runtime_checkable to be used with instance and class checks", + "protocolRequiresRuntimeCheckable": { + "message": "Protocol class must be @runtime_checkable to be used with instance and class checks", + "comment": "{Locked='Protocol','@runtime_checkable'}" + }, "protocolSourceIsNotConcrete": "\"{sourceType}\" is not a concrete class type and cannot be assigned to type \"{destType}\"", "protocolUnsafeOverlap": "Attributes of \"{name}\" have the same names as the protocol", - "pyrightCommentIgnoreTip": "Use \"# pyright: ignore[] to suppress diagnostics for a single line", + "pyrightCommentIgnoreTip": { + "message": "Use \"# pyright: ignore[]\" to suppress diagnostics for a single line", + "comment": "{Locked='# pyright: ignore[]'}" + }, "readOnlyAttribute": "Attribute \"{name}\" is read-only", "seeClassDeclaration": "See class declaration", "seeDeclaration": "See declaration", @@ -773,13 +1928,34 @@ "seeParameterDeclaration": "See parameter declaration", "seeTypeAliasDeclaration": "See type alias declaration", "seeVariableDeclaration": "See variable declaration", - "tupleAssignmentMismatch": "Type \"{type}\" is incompatible with target tuple", - "tupleEntryTypeMismatch": "Tuple entry {entry} is incorrect type", - "tupleSizeIndeterminateSrc": "Tuple size mismatch; expected {expected} but received indeterminate", - "tupleSizeIndeterminateSrcDest": "Tuple size mismatch; expected {expected} or more but received indeterminate", - "tupleSizeMismatch": "Tuple size mismatch; expected {expected} but received {received}", - "tupleSizeMismatchIndeterminateDest": "Tuple size mismatch; expected {expected} or more but received {received}", - "typeAliasInstanceCheck": "Type alias created with \"type\" statement cannot be used with instance and class checks", + "tupleAssignmentMismatch": { + "message": "Type \"{type}\" is incompatible with target tuple", + "comment": "{Locked='tuple'}" + }, + "tupleEntryTypeMismatch": { + "message": "Tuple entry {entry} is incorrect type", + "comment": ["{StrContains=i'tuple'}", "'tuple' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, + "tupleSizeIndeterminateSrc": { + "message": "Tuple size mismatch; expected {expected} but received indeterminate", + "comment": ["{StrContains=i'tuple'}", "'tuple' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, + "tupleSizeIndeterminateSrcDest": { + "message": "Tuple size mismatch; expected {expected} or more but received indeterminate", + "comment": ["{StrContains=i'tuple'}", "'tuple' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, + "tupleSizeMismatch": { + "message": "Tuple size mismatch; expected {expected} but received {received}", + "comment": ["{StrContains=i'tuple'}", "'tuple' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, + "tupleSizeMismatchIndeterminateDest": { + "message": "Tuple size mismatch; expected {expected} or more but received {received}", + "comment": ["{StrContains=i'tuple'}", "'tuple' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"] + }, + "typeAliasInstanceCheck": { + "message": "Type alias created with \"type\" statement cannot be used with instance and class checks", + "comment": "{Locked='type'}" + }, "typeAssignmentMismatch": "Type \"{sourceType}\" is not assignable to type \"{destType}\"", "typeBound": "Type \"{sourceType}\" is not assignable to upper bound \"{destType}\" for type variable \"{name}\"", "typeConstrainedTypeVar": "Type \"{type}\" is not assignable to constrained type variable \"{name}\"", @@ -787,40 +1963,82 @@ "typeNotClass": "\"{type}\" is not a class", "typeNotStringLiteral": "\"{type}\" is not a string literal", "typeOfSymbol": "Type of \"{name}\" is \"{type}\"", - "typeParamSpec": "Type \"{type}\" is incompatible with ParamSpec \"{name}\"", + "typeParamSpec": { + "message": "Type \"{type}\" is incompatible with ParamSpec \"{name}\"", + "comment": "{Locked='ParamSpec'}" + }, "typeUnsupported": "Type \"{type}\" is unsupported", "typeVarDefaultOutOfScope": "Type variable \"{name}\" is not in scope", "typeVarIsContravariant": "Type parameter \"{name}\" is contravariant, but \"{sourceType}\" is not a supertype of \"{destType}\"", "typeVarIsCovariant": "Type parameter \"{name}\" is covariant, but \"{sourceType}\" is not a subtype of \"{destType}\"", "typeVarIsInvariant": "Type parameter \"{name}\" is invariant, but \"{sourceType}\" is not the same as \"{destType}\"", - "typeVarNotAllowed": "TypeVar not allowed for instance or class checks", - "typeVarTupleRequiresKnownLength": "TypeVarTuple cannot be bound to a tuple of unknown length", + "typeVarNotAllowed": { + "message": "TypeVar not allowed for instance or class checks", + "comment": "{Locked='TypeVar'}" + }, + "typeVarTupleRequiresKnownLength": { + "message": "TypeVarTuple cannot be bound to a tuple of unknown length", + "comment": "{Locked='TypeVarTuple','tuple'}" + }, "typeVarUnnecessarySuggestion": "Use {type} instead", "typeVarUnsolvableRemedy": "Provide an overload that specifies the return type when the argument is not supplied", "typeVarsMissing": "Missing type variables: {names}", - "typedDictBaseClass": "Class \"{type}\" is not a TypedDict", - "typedDictClassNotAllowed": "TypedDict class not allowed for instance or class checks", + "typedDictBaseClass": { + "message": "Class \"{type}\" is not a TypedDict", + "comment": "{Locked='TypedDict'}" + }, + "typedDictClassNotAllowed": { + "message": "TypedDict class not allowed for instance or class checks", + "comment": "{Locked='TypedDict'}" + }, "typedDictClosedExtraNotAllowed": "Cannot add item \"{name}\"", "typedDictClosedExtraTypeMismatch": "Cannot add item \"{name}\" with type \"{type}\"", - "typedDictClosedFieldNotRequired": "Cannot add item \"{name}\" because it must be NotRequired", + "typedDictClosedFieldNotRequired": { + "message": "Cannot add item \"{name}\" because it must be NotRequired", + "comment": "{Locked='NotRequired'}" + }, "typedDictExtraFieldNotAllowed": "\"{name}\" is not present in \"{type}\"", - "typedDictExtraFieldTypeMismatch": "Type of \"{name}\" is incompatible with type of \"__extra_items__\" in \"{type}\"", + "typedDictExtraFieldTypeMismatch": { + "message": "Type of \"{name}\" is incompatible with type of \"__extra_items__\" in \"{type}\"", + "comment": "{Locked='__extra_items__'}" + }, "typedDictFieldMissing": "\"{name}\" is missing from \"{type}\"", "typedDictFieldNotReadOnly": "\"{name}\" is not read-only in \"{type}\"", "typedDictFieldNotRequired": "\"{name}\" is not required in \"{type}\"", "typedDictFieldRequired": "\"{name}\" is required in \"{type}\"", "typedDictFieldTypeMismatch": "Type \"{type}\" is not assignable to item \"{name}\"", "typedDictFieldUndefined": "\"{name}\" is an undefined item in type \"{type}\"", - "typedDictFinalMismatch": "\"{sourceType}\" is incompatible with \"{destType}\" because of a @final mismatch", - "typedDictKeyAccess": "Use [\"{name}\"] to reference item in TypedDict", - "typedDictNotAllowed": "TypedDict cannot be used for instance or class checks", + "typedDictFinalMismatch": { + "message": "\"{sourceType}\" is incompatible with \"{destType}\" because of a @final mismatch", + "comment": "{Locked='@final'}" + }, + "typedDictKeyAccess": { + "message": "Use [\"{name}\"] to reference item in TypedDict", + "comment": "{Locked='TypedDict'}" + }, + "typedDictNotAllowed": { + "message": "TypedDict cannot be used for instance or class checks", + "comment": "{Locked='TypedDict'}" + }, "unhashableType": "Type \"{type}\" is not hashable", "uninitializedAbstractVariable": "Instance variable \"{name}\" is defined in abstract base class \"{classType}\" but not initialized", "unreachableExcept": "\"{exceptionType}\" is a subclass of \"{parentType}\"", - "useDictInstead": "Use Dict[T1, T2] to indicate a dictionary type", - "useListInstead": "Use List[T] to indicate a list type or Union[T1, T2] to indicate a union type", - "useTupleInstead": "Use tuple[T1, ..., Tn] to indicate a tuple type or Union[T1, T2] to indicate a union type", - "useTypeInstead": "Use Type[T] instead", + "useDictInstead": { + "message": "Use Dict[T1, T2] to indicate a dictionary type", + "comment": "{Locked='Dict[T1, T2]'}" + }, + "useListInstead": { + "message": "Use List[T] to indicate a list type or Union[T1, T2] to indicate a union type", + "comment": "{Locked='List[T]','list','Union[T1, T2]','union'}" + }, + "useTupleInstead": { + "message": "Use tuple[T1, ..., Tn] to indicate a tuple type or Union[T1, T2] to indicate a union type", + "comment": "{Locked='tuple[T1, ..., Tn]','tuple','Union[T1, T2]','union'}" + }, + "useTypeInstead": { + "message": "Use Type[T] instead", + "comment": "{Locked='Type[T]'}" + }, "varianceMismatchForClass": "Variance of type argument \"{typeVarName}\" is incompatible with base class \"{className}\"", "varianceMismatchForTypeAlias": "Variance of type argument \"{typeVarName}\" is incompatible with \"{typeAliasParam}\"" }, diff --git a/packages/pyright-internal/src/localization/package.nls.es.json b/packages/pyright-internal/src/localization/package.nls.es.json index 9ed8d9a27..f3f340af1 100644 --- a/packages/pyright-internal/src/localization/package.nls.es.json +++ b/packages/pyright-internal/src/localization/package.nls.es.json @@ -18,12 +18,12 @@ "annotatedMetadataInconsistent": "El tipo de metadatos anotados \"{metadataType}\" no es compatible con el tipo \"{type}\"", "annotatedParamCountMismatch": "El recuento de anotaciones del parámetro no coincide: se esperaba {expected}, pero se recibió {received}", "annotatedTypeArgMissing": "Se espera un argumento de tipo y una o más anotaciones para \"Annotated\".", - "annotationBytesString": "Las anotaciones de tipo no pueden utilizar literales de cadena de bytes", - "annotationFormatString": "Las anotaciones de tipo no pueden utilizar literales de cadena de formato (cadenas f)", + "annotationBytesString": "Las expresiones de tipo no pueden usar literales de cadena de bytes", + "annotationFormatString": "Las expresiones de tipo no pueden usar literales de cadena de formato (f-strings)", "annotationNotSupported": "No se admite la anotación de tipo para esta declaración", - "annotationRawString": "Las anotaciones de tipo no pueden utilizar literales de cadena sin formato", - "annotationSpansStrings": "Las anotaciones de tipo no pueden abarcar varios literales de cadena", - "annotationStringEscape": "Las anotaciones de tipo no pueden contener caracteres de escape", + "annotationRawString": "Las expresiones de tipo no pueden usar literales de cadena sin formato", + "annotationSpansStrings": "Las expresiones de tipo no pueden abarcar varios literales de cadena", + "annotationStringEscape": "Las expresiones de tipo no pueden contener caracteres de escape", "argAssignment": "Argumento de tipo \"{argType}\" no puede ser asignado a parámetro de tipo \"{paramType}\"", "argAssignmentFunction": "El argumento de tipo \"{argType}\" no puede ser asignado a parámetro de tipo \"{paramType}\" en función \"{functionName}\"", "argAssignmentParam": "Argumento de tipo \"{argType}\" no puede ser asignado a parámetro \"{paramName}\" de tipo \"{paramType}\"", @@ -37,7 +37,7 @@ "argPositionalExpectedOne": "Se espera 1 argumento posicional", "argTypePartiallyUnknown": "El tipo de argumento es parcialmente desconocido", "argTypeUnknown": "Tipo de argumento desconocido", - "assertAlwaysTrue": "La expresión Assert siempre se evalúa como verdadero", + "assertAlwaysTrue": "La expresión Assert siempre se evalúa como true", "assertTypeArgs": "\"assert_type\" espera dos argumentos posicionales", "assertTypeTypeMismatch": "Error de coincidencia \"assert_type\": se esperaba \"{expected}\" pero se ha recibido \"{received}\"", "assignmentExprComprehension": "El destino de la expresión de asignación \"{name}\" no puede usar el mismo nombre que la comprensión para el destino", @@ -45,9 +45,9 @@ "assignmentExprInSubscript": "Las expresiones de asignación dentro de un subíndice solo se admiten en Python 3.10 y versiones posteriores.", "assignmentInProtocol": "Las variables de instancia o clase dentro de una clase Protocol deben declararse explícitamente en el cuerpo de la clase.", "assignmentTargetExpr": "La expresión no puede ser objetivo de asignación", - "asyncNotInAsyncFunction": "No se permite el uso de \"async\" fuera de la función asincrónica", + "asyncNotInAsyncFunction": "No se permite el uso de \"async\" fuera de la función async", "awaitIllegal": "El uso de \"await\" requiere Python 3.5 o posterior.", - "awaitNotAllowed": "Las anotaciones de tipo no pueden usar \"await\"", + "awaitNotAllowed": "Las expresiones de tipo no pueden usar \"await\"", "awaitNotInAsync": "\"await\" solo se permite dentro de una función async", "backticksIllegal": "En Python 3.x no se admiten expresiones rodeadas de puntos suspensivos; utilice repr en su lugar.", "baseClassCircular": "La clase no se puede derivar de sí misma", @@ -57,20 +57,20 @@ "baseClassMethodTypeIncompatible": "Las clases base para la clase \"{classType}\" definen el método \"{name}\" de forma incompatible", "baseClassUnknown": "Se desconoce el tipo de la clase base, lo que oculta el tipo de la clase derivada.", "baseClassVariableTypeIncompatible": "Las clases base para la clase \"{classType}\" definen la variable \"{name}\" de forma incompatible", - "binaryOperationNotAllowed": "Operador binario no permitido en la anotación de tipo", + "binaryOperationNotAllowed": "Operador binario no permitido en la expresión de tipo", "bindTypeMismatch": "No se pudo enlazar el método \"{methodName}\" porque \"{type}\" no se puede asignar al parámetro \"{paramName}\"", "breakOutsideLoop": "\"break\" solo se puede usar dentro de un bucle", - "callableExtraArgs": "Se esperaban solo dos argumentos de tipo para \"Exigible\".", + "callableExtraArgs": "Se esperaban solo dos argumentos de tipo para \"Callable\".", "callableFirstArg": "Lista de tipos de parámetros esperados o \"...\"", "callableNotInstantiable": "No se puede instanciar el tipo \"{type}\"", - "callableSecondArg": "Tipo de retorno esperado como segundo argumento de tipo para \"Exigible\"", + "callableSecondArg": "Tipo de retorno esperado como segundo argumento de tipo para \"Callable\"", "casePatternIsIrrefutable": "El patrón irrefutable solo se permite para la última instrucción case", "classAlreadySpecialized": "El tipo \"{type}\" ya está especializado", "classDecoratorTypeUnknown": "El decorador de clase sin tipo oculta el tipo de clase; omitiendo el elemento Decorator", "classDefinitionCycle": "La definición de clase para \"{name}\" depende de sí misma.", "classGetItemClsParam": "__class_getitem__ debe tomar un parámetro \"cls\"", "classMethodClsParam": "Los métodos de clase deben tomar un parámetro \"cls\"", - "classNotRuntimeSubscriptable": "El subíndice para la clase \"{name}\" generará una excepción en tiempo de ejecución; encierre la anotación de tipo entre comillas", + "classNotRuntimeSubscriptable": "El subíndice para la clase \"{name}\" generará una excepción en tiempo de ejecución; encierre la expresión de tipo entre comillas", "classPatternBuiltInArgPositional": "El patrón de clase solo acepta subpatrones posicionales", "classPatternPositionalArgCount": "Demasiados patrones posicionales para la clase \"{type}\"; esperado {expected} pero recibido {received}", "classPatternTypeAlias": "\"{type}\" no se puede usar en un patrón de clase porque es un alias de tipo especializado", @@ -84,13 +84,13 @@ "clsSelfParamTypeMismatch": "El tipo de parámetro \"{name}\" debe ser un supertipo de su clase \"{classType}\"", "codeTooComplexToAnalyze": "El código es demasiado complejo para analizarlo; reduzca la complejidad refactorizándolo en subrutinas o reduciendo las rutas de código condicional.", "collectionAliasInstantiation": "No se puede crear una instancia del tipo \"{type}\"; use \"{alias}\" en su lugar.", - "comparisonAlwaysFalse": "La condición siempre se evaluará como Falso, ya que los tipos \"{leftType}\" y \"{rightType}\" no se superponen.", - "comparisonAlwaysTrue": "La condición siempre se evaluará como Verdadero, ya que los tipos \"{leftType}\" y \"{rightType}\" no se superpone.", + "comparisonAlwaysFalse": "La condición siempre se evaluará como False, ya que los tipos \"{leftType}\" y \"{rightType}\" no se superponen.", + "comparisonAlwaysTrue": "La condición siempre se evaluará como True, ya que los tipos \"{leftType}\" y \"{rightType}\" no se superponen.", "comprehensionInDict": "La comprensión no puede utilizarse con otras entradas del diccionario", - "comprehensionInSet": "La comprensión no se puede usar con otras entradas de conjunto", - "concatenateContext": "\"Concatenar\" no se permite en este contexto", - "concatenateParamSpecMissing": "El último argumento de tipo para \"Concatenatar\" debe ser un ParamSpec o \"...\"", - "concatenateTypeArgsMissing": "\"Concatenar\" requiere al menos dos argumentos de tipo", + "comprehensionInSet": "La comprensión no se puede usar con otras entradas de set", + "concatenateContext": "\"Concatenate\" no se permite en este contexto", + "concatenateParamSpecMissing": "El último argumento de tipo para \"Concatenate\" debe ser un ParamSpec o \"...\"", + "concatenateTypeArgsMissing": "\"Concatenate\" requiere al menos dos argumentos de tipo", "conditionalOperandInvalid": "Operando condicional no válido de tipo \"{type}\"", "constantRedefinition": "\"{name}\" es constante (porque está en mayúsculas) y no se puede volver a definir", "constructorParametersMismatch": "Error de coincidencia entre la firma de __new__ y __init__ en la clase \"{classType}\"", @@ -98,7 +98,7 @@ "containmentAlwaysTrue": "La expresión siempre se evaluará como True, ya que los tipos \"{leftType}\" y \"{rightType}\" no tienen superposición", "continueInFinally": "\"continue\" no puede utilizarse dentro de una cláusula finally", "continueOutsideLoop": "\"continue\" solo puede utilizarse dentro de un bucle", - "coroutineInConditionalExpression": "La expresión condicional hace referencia a una corrutina que siempre se evalúa como Verdadero", + "coroutineInConditionalExpression": "La expresión condicional hace referencia a una corrutina que siempre se evalúa como True", "dataClassBaseClassFrozen": "Una clase no inmovilizada no puede heredar de una clase inmovilizada", "dataClassBaseClassNotFrozen": "Una clase congelada no puede heredar de una clase que no esté congelada", "dataClassConverterFunction": "Argumento de tipo \"{argType}\" no es un convertidor válido para el campo \"{fieldName}\" de tipo \"{fieldType}\"", @@ -111,7 +111,7 @@ "dataClassPostInitType": "El tipo de parámetro del método __post_init__ de la clase de datos no coincide con el del campo \"{fieldName}\".", "dataClassSlotsOverwrite": "__slots__ ya está definido en la clase", "dataClassTransformExpectedBoolLiteral": "Expresión esperada que se evalúa estáticamente como True o False", - "dataClassTransformFieldSpecifier": "Se esperaba una tupla de clases o funciones, pero se recibió el tipo \"{type}\"", + "dataClassTransformFieldSpecifier": "Se esperaba una tuple de clases o funciones, pero se recibió el tipo \"{type}\"", "dataClassTransformPositionalParam": "Todos los argumentos de \"dataclass_transform\" deben ser argumentos de palabra clave", "dataClassTransformUnknownArgument": "El argumento \"{name}\" no es compatible con dataclass_transform", "dataProtocolInSubclassCheck": "No se permiten protocolos de datos (que incluyen atributos que no son de método) en llamadas issubclass", @@ -127,21 +127,21 @@ "deprecatedDescriptorSetter": "El método \"__set__\" para el \"{name}\" de descriptor está en desuso", "deprecatedFunction": "La función \"{name}\" está obsoleta", "deprecatedMethod": "El método \"{name}\" en la clase \"{className}\" está en desuso", - "deprecatedPropertyDeleter": "El eliminador de la propiedad \"{name}\" está en desuso", - "deprecatedPropertyGetter": "El captador de la propiedad \"{name}\" está en desuso", - "deprecatedPropertySetter": "El establecedor de la propiedad \"{name}\" está en desuso", + "deprecatedPropertyDeleter": "El deleter de la property \"{name}\" está en desuso", + "deprecatedPropertyGetter": "El getter de la property \"{name}\" está en desuso", + "deprecatedPropertySetter": "El setter de la property \"{name}\" está en desuso", "deprecatedType": "Este tipo está obsoleto a partir de la {version} de Python; utilice en su lugar \"{replacement}\".", "dictExpandIllegalInComprehension": "No se permite la ampliación del diccionario en la comprensión", - "dictInAnnotation": "Expresión de diccionario no permitida en anotación de tipo", + "dictInAnnotation": "Expresión de diccionario no permitida en expresión de tipo", "dictKeyValuePairs": "Las entradas del diccionario deben contener pares clave/valor", "dictUnpackIsNotMapping": "Asignación esperada para el operador de desempaquetado del diccionario", "dunderAllSymbolNotPresent": "\"{name}\" se especifica en __all__ pero no está presente en el módulo", "duplicateArgsParam": "Solo se permite un parámetro \"*\".", "duplicateBaseClass": "Clase base duplicada no permitida", "duplicateCapturePatternTarget": "El destino de captura \"{name}\" no puede aparecer más de una vez dentro del mismo patrón", - "duplicateCatchAll": "Solo se permite una cláusula de excepción", + "duplicateCatchAll": "Solo se permite una cláusula de except", "duplicateEnumMember": "El miembro Enum \"{name}\" ya está declarado", - "duplicateGenericAndProtocolBase": "Solo se permite una clase base Genérica[...] o Protocolar[...].", + "duplicateGenericAndProtocolBase": "Solo se permite una clase base Generic[...] o Protocol[...].", "duplicateImport": "\"{importName}\" se importa más de una vez", "duplicateKeywordOnly": "Solo se permite un separador \"*\".", "duplicateKwargsParam": "Solo se permite un parámetro \"**\".", @@ -150,12 +150,12 @@ "duplicateStarPattern": "Solo se permite un patrón \"*\" en una secuencia de patrones", "duplicateStarStarPattern": "Solo se permite una entrada \"**\"", "duplicateUnpack": "Solo se permite una operación de desempaquetado en la lista", - "ellipsisAfterUnpacked": "\"...\" no se puede usar con una TypeVarTuple o tupla sin empaquetar", + "ellipsisAfterUnpacked": "\"...\" no se puede usar con una TypeVarTuple o tuple sin empaquetar", "ellipsisContext": "\"...\" no está permitido en este contexto", "ellipsisSecondArg": "\"...\" está permitido sólo como el segundo de dos argumentos", "enumClassOverride": "La clase Enum \"{name}\" es final y no puede ser subclasificada", - "enumMemberDelete": "No se puede eliminar el miembro de enumeración \"{name}\"", - "enumMemberSet": "No se puede asignar el miembro de enumeración \"{name}\"", + "enumMemberDelete": "No se puede eliminar el miembro de Enum \"{name}\"", + "enumMemberSet": "No se puede asignar el miembro de Enum \"{name}\"", "enumMemberTypeAnnotation": "No se permiten anotaciones de tipo para miembros de enumeración", "exceptionGroupIncompatible": "La sintaxis de grupo de excepciones (\"except*\") requiere Python 3.11 o posterior.", "exceptionGroupTypeIncorrect": "El tipo de excepción en except* no puede derivarse de BaseGroupException", @@ -182,13 +182,13 @@ "expectedElse": "Se espera \"else\"", "expectedEquals": "Se esperaba \"=\"", "expectedExceptionClass": "Clase o objeto de excepción no válido", - "expectedExceptionObj": "Objeto de excepción esperado, clase de excepción o Ninguno", + "expectedExceptionObj": "Objeto de excepción esperado, clase de excepción o None", "expectedExpr": "Se esperaba una expresión", "expectedFunctionAfterAsync": "Definición de función esperada después de \"async\"", "expectedFunctionName": "Se esperaba nombre de la función luego de \"def\"", "expectedIdentifier": "Identificador esperado", "expectedImport": "Se espera \"import\"", - "expectedImportAlias": "Símbolo esperado después de \"como\"", + "expectedImportAlias": "Símbolo esperado después de \"as\"", "expectedImportSymbols": "Se esperan uno o más nombres de símbolos tras la importación", "expectedIn": "Se esperaba \"in\"", "expectedInExpr": "Expresión esperada después de \"in\"", @@ -231,10 +231,10 @@ "formatStringUnicode": "Los literales de cadena de formato (cadenas f) no pueden ser unicode", "formatStringUnterminated": "Expresión sin terminar en f-string; se esperaba \"}\"", "functionDecoratorTypeUnknown": "Un decorator de función no tipificado oculta el tipo de función; ignorar el decorator", - "functionInConditionalExpression": "La expresión condicional hace referencia a una función que siempre se evalúa como Verdadero", + "functionInConditionalExpression": "La expresión condicional hace referencia a una función que siempre se evalúa como True", "functionTypeParametersIllegal": "La sintaxis del parámetro de tipo de función requiere Python 3.12 o posterior", "futureImportLocationNotAllowed": "Las importaciones desde __future__ deben estar al principio del fichero", - "generatorAsyncReturnType": "El tipo de retorno de la función generadora asíncrona debe ser compatible con \"AsyncGenerator[{yieldType}, Any]\"", + "generatorAsyncReturnType": "El tipo de retorno de la función generadora async debe ser compatible con \"AsyncGenerator[{yieldType}, Any]\"", "generatorNotParenthesized": "Las expresiones del generador deben ir entre paréntesis si no son el único argumento", "generatorSyncReturnType": "El tipo de retorno de la función generadora debe ser compatible con \"Generator[{yieldType}, Any, Any]\"", "genericBaseClassNotAllowed": "La clase base \"Generic\" no se puede usar con la sintaxis de parámetro de tipo", @@ -262,19 +262,19 @@ "initSubclassCallFailed": "Argumentos de palabra clave incorrectos para el método __init_subclass__", "initSubclassClsParam": "__init_subclass__ debe tomar un parámetro \"cls\"", "initVarNotAllowed": "\"InitVar\" no se permite en este contexto", - "instanceMethodSelfParam": "Los métodos de instancia deben tomar un parámetro \"auto\"", + "instanceMethodSelfParam": "Los métodos de instancia deben tomar un parámetro \"self\"", "instanceVarOverridesClassVar": "La variable de instancia \"{name}\" invalida la variable de clase del mismo nombre en la clase \"{className}\"", "instantiateAbstract": "No se puede instanciar la clase abstracta \"{type}\"", - "instantiateProtocol": "No se puede crear una instancia de la clase de protocolo \"{type}\"", + "instantiateProtocol": "No se puede crear una instancia de la clase Protocol \"{type}\"", "internalBindError": "Se ha producido un error interno al vincular el archivo \"{file}\": {message}", "internalParseError": "Se ha producido un error interno al procesar el archivo \"{file}\": {message}", "internalTypeCheckingError": "Se ha producido un error interno al comprobar el tipo de archivo \"{file}\":{message}", "invalidIdentifierChar": "Carácter no válido en el identificador", "invalidStubStatement": "La declaración no tiene sentido dentro de un archivo de tipo stub", "invalidTokenChars": "Carácter \"{text}\" no válido en el token", - "isInstanceInvalidType": "El segundo argumento de \"isinstance\" debe ser una clase o tupla de clases", - "isSubclassInvalidType": "El segundo argumento de \"issubclass\" debe ser una clase o tupla de clases", - "keyValueInSet": "No se permiten pares de clave/valor dentro de un conjunto", + "isInstanceInvalidType": "El segundo argumento de \"isinstance\" debe ser una clase o tuple de clases", + "isSubclassInvalidType": "El segundo argumento de \"issubclass\" debe ser una clase o tuple de clases", + "keyValueInSet": "No se permiten pares de clave/valor dentro de un set", "keywordArgInTypeArgument": "No se pueden usar argumentos de palabra clave en listas de argumentos de tipo", "keywordArgShortcutIllegal": "El acceso directo del argumento de palabra clave requiere Python 3.14 o posterior", "keywordOnlyAfterArgs": "No se permite el separador de argumentos por palabra clave después del parámetro \"*\".", @@ -283,14 +283,14 @@ "lambdaReturnTypePartiallyUnknown": "El tipo de retorno de la lambda \"{returnType}\" es parcialmente desconocido.", "lambdaReturnTypeUnknown": "Se desconoce el tipo de retorno de la lambda", "listAssignmentMismatch": "La expresión con el tipo \"{type}\" no puede asignarse a la lista de destino", - "listInAnnotation": "Expresión de lista no permitida en anotación de tipo", + "listInAnnotation": "No se permite la expresión de List en la expresión de tipo", "literalEmptyArgs": "Se esperaban uno o varios argumentos de tipo después de \"Literal\"", "literalNamedUnicodeEscape": "No se admiten secuencias de escape Unicode con nombre en las anotaciones de cadena de \"Literales\".", "literalNotAllowed": "\"Literal\" no se puede usar en este contexto sin un argumento de tipo", - "literalNotCallable": "El tipo literal no puede instanciarse", + "literalNotCallable": "El tipo Literal no puede instanciarse", "literalUnsupportedType": "Los argumentos de tipo para \"Literal\" deben ser None, un valor literal (int, bool, str, o bytes), o un valor enum", - "matchIncompatible": "Las declaraciones de coincidencia requieren Python 3.10 o posterior", - "matchIsNotExhaustive": "Los casos dentro de la declaración de coincidencia no tratan exhaustivamente todos los valores", + "matchIncompatible": "Las declaraciones de Match requieren Python 3.10 o posterior", + "matchIsNotExhaustive": "Los casos dentro de la declaración de match no tratan exhaustivamente todos los valores", "maxParseDepthExceeded": "Se ha superado la profundidad máxima de análisis; divida la expresión en subexpresiones más pequeñas.", "memberAccess": "No se puede tener acceso al atributo \"{name}\" para la clase \"{type}\"", "memberDelete": "No se puede eliminar el atributo \"{name}\" de la clase \"{type}\"", @@ -304,41 +304,42 @@ "methodOverridden": "\"{name}\" invalida el método del mismo nombre en la clase \"{className}\" con el tipo incompatible \"{type}\"", "methodReturnsNonObject": "El método \"{name}\" no devuelve un objeto", "missingSuperCall": "El método \"{methodName}\" no llama al método del mismo nombre en la clase principal.", + "mixingBytesAndStr": "No se pueden concatenar los valores de bytes y str", "moduleAsType": "El módulo no se puede usar como tipo.", "moduleNotCallable": "No se puede llamar al módulo", "moduleUnknownMember": "\"{memberName}\" no es un atributo conocido del módulo \"{moduleName}\"", "namedExceptAfterCatchAll": "Una cláusula except con nombre no puede aparecer después de la cláusula catch-all except", "namedParamAfterParamSpecArgs": "El parámetro de palabra clave \"{name}\" no puede aparecer en la firma después del parámetro ParamSpec args", - "namedTupleEmptyName": "Los nombres de una tupla con nombre no pueden estar vacíos", - "namedTupleEntryRedeclared": "No se puede invalidar \"{name}\" porque la clase primaria \"{className}\" es una tupla con nombre", - "namedTupleFirstArg": "Nombre de clase de tupla como primer argumento", + "namedTupleEmptyName": "Los nombres de una tuple con nombre no pueden estar vacíos", + "namedTupleEntryRedeclared": "No se puede invalidar \"{name}\" porque la clase primaria \"{className}\" es una tuple con nombre", + "namedTupleFirstArg": "Nombre de clase de tuple como primer argumento", "namedTupleMultipleInheritance": "No se admite la herencia múltiple con NamedTuple", "namedTupleNameKeyword": "Los nombres de campo no pueden ser una palabra clave", - "namedTupleNameType": "Tupla de dos entradas esperada que especifica el nombre y el tipo de entrada", - "namedTupleNameUnique": "Los nombres dentro de una tupla con nombre deben ser únicos", + "namedTupleNameType": "tuple de dos entradas esperada que especifica el nombre y el tipo de entrada", + "namedTupleNameUnique": "Los nombres dentro de una tuple con nombre deben ser únicos", "namedTupleNoTypes": "\"namedtuple\" no proporciona tipos para las entradas de tupla; utilice en su lugar \"NamedTuple\".", - "namedTupleSecondArg": "Lista de entradas de tupla con nombre esperada como segundo argumento", + "namedTupleSecondArg": "list de entradas de tuple con nombre esperada como segundo argumento", "newClsParam": "__new__ debe tomar un parámetro \"cls\"", - "newTypeAnyOrUnknown": "El segundo argumento de NewType debe ser una clase conocida, no Cualquiera ni Desconocido", + "newTypeAnyOrUnknown": "El segundo argumento de NewType debe ser una clase conocida, no Any ni Unknown", "newTypeBadName": "El primer argumento de NewType debe ser una cadena literal", "newTypeLiteral": "NewType no se puede usar con el tipo Literal", "newTypeNameMismatch": "NewType debe asignarse a una variable con el mismo nombre", "newTypeNotAClass": "Clase esperada como segundo argumento de NewType", "newTypeParamCount": "NewType requiere dos argumentos posicionales", - "newTypeProtocolClass": "NewType no se puede usar con un tipo estructural (un protocolo o una clase TypedDict)", + "newTypeProtocolClass": "NewType no se puede usar con un tipo estructural (Protocol o clase TypedDict)", "noOverload": "Ninguna sobrecarga para \"{name}\" coincide con los argumentos proporcionados", - "noReturnContainsReturn": "La función con tipo de retorno declarado \"NoReturn\" no puede incluir una sentencia volver", + "noReturnContainsReturn": "La función con tipo de return declarado \"NoReturn\" no puede incluir una sentencia return", "noReturnContainsYield": "La función con tipo de retorno declarado \"NoReturn\" no puede incluir una instrucción yield", "noReturnReturnsNone": "La función con el tipo de valor devuelto declarado \"NoReturn\" no puede devolver \"None\"", "nonDefaultAfterDefault": "El argumento no predeterminado sigue al argumento predeterminado", - "nonLocalInModule": "Declaración no local no permitida a nivel de módulo", - "nonLocalNoBinding": "No se ha encontrado ningún enlace para \"{name}\" no local.", - "nonLocalReassignment": "\"{name}\" se asigna antes de la declaración no local", - "nonLocalRedefinition": "\"{name}\" ya fue declarado no local", + "nonLocalInModule": "Declaración Nonlocal no permitida a nivel de módulo", + "nonLocalNoBinding": "No se ha encontrado ningún enlace para \"{name}\" nonlocal.", + "nonLocalReassignment": "\"{name}\" se asigna antes de la declaración nonlocal", + "nonLocalRedefinition": "\"{name}\" ya fue declarado nonlocal", "noneNotCallable": "No se puede llamar al objeto de tipo \"None\"", - "noneNotIterable": "No se puede utilizar un objeto de tipo \"Ninguno\" como valor iterable", + "noneNotIterable": "No se puede utilizar un objeto de tipo \"None\" como valor iterable", "noneNotSubscriptable": "El objeto de tipo \"None\" no se puede suscribir", - "noneNotUsableWith": "El objeto de tipo \"None\" no puede utilizarse con \"with\".", + "noneNotUsableWith": "Object of type \"None\" cannot be used with \"with\"", "noneOperator": "El operador \"{operator}\" no es compatible con \"None\".", "noneUnknownMember": "\"{name}\" no es un atributo conocido de \"None\"", "notRequiredArgCount": "Se esperaba un único argumento de tipo después de \"NotRequired\".", @@ -353,7 +354,7 @@ "operatorLessOrGreaterDeprecated": "El operador \"<>\" no es admitido en Python 3; utilice en su lugar \"!=\".", "optionalExtraArgs": "Se esperaba un argumento de tipo después de \"Optional\"", "orPatternIrrefutable": "El patrón irrefutable solo se permite como el último subpatrón en un patrón \"or\".", - "orPatternMissingName": "Todos los subpatrones de un patrón \"o\" deben tener los mismos nombres", + "orPatternMissingName": "Todos los subpatrones de un patrón \"or\" deben tener los mismos nombres", "overlappingKeywordArgs": "El diccionario escrito se superpone con el parámetro de palabra clave: {names}", "overlappingOverload": "La sobrecarga {obscured} para \"{name}\" nunca se utilizará porque sus parámetros se superpone con la sobrecarga {obscuredBy}.", "overloadAbstractImplMismatch": "Las sobrecargas deben coincidir con el estado abstracto de la implementación", @@ -364,9 +365,9 @@ "overloadImplementationMismatch": "La implementación de la sobrecarga no es consistente con la firma de la sobrecarga {index}", "overloadReturnTypeMismatch": "La sobrecarga {prevIndex} para \" {name}\" se superpone con la sobrecarga {newIndex} y devuelve un tipo incompatible", "overloadStaticMethodInconsistent": "Las sobrecargas de \"{name}\" usan @staticmethod de forma incoherente", - "overloadWithoutImplementation": "\"{name}\" está marcado como sobrecarga, pero no se proporciona ninguna implementación.", - "overriddenMethodNotFound": "El método \"{name}\" está marcado como invalidación, pero no existe ningún método base con el mismo nombre", - "overrideDecoratorMissing": "El método \"{name}\" no está marcado como invalidación, pero está reemplazando un método de la clase \"{className}\"", + "overloadWithoutImplementation": "\"{name}\" está marcado como overload, pero no se proporciona ninguna implementación.", + "overriddenMethodNotFound": "El método \"{name}\" está marcado como override, pero no existe ningún método base con el mismo nombre", + "overrideDecoratorMissing": "El método \"{name}\" no está marcado como override, pero está reemplazando un método de la clase \"{className}\"", "paramAfterKwargsParam": "El parámetro no puede seguir el parámetro \"**\"", "paramAlreadyAssigned": "El parámetro \"{name}\" ya está asignado", "paramAnnotationMissing": "Falta la anotación de tipo para el parámetro \"{name}\"", @@ -377,7 +378,7 @@ "paramSpecArgsUsage": "El atributo \"args\" de ParamSpec solo es válido cuando se usa con el parámetro *args.", "paramSpecAssignedName": "ParamSpec debe asignarse a una variable llamada \"{name} \"", "paramSpecContext": "ParamSpec no está permitido en este contexto", - "paramSpecDefaultNotTuple": "Se esperaban puntos suspensivos, una expresión de tupla o ParamSpec para el valor predeterminado de ParamSpec", + "paramSpecDefaultNotTuple": "Se esperaban puntos suspensivos, una expresión de tuple o ParamSpec para el valor predeterminado de ParamSpec", "paramSpecFirstArg": "Se esperaba el nombre de ParamSpec como primer argumento", "paramSpecKwargsUsage": "El miembro \"kwargs\" de ParamSpec solo es válido cuando se utiliza con el parámetro **kwargs", "paramSpecNotUsedByOuterScope": "ParamSpec \"{name}\" no tiene significado en este contexto", @@ -387,7 +388,7 @@ "paramTypeCovariant": "La variable de tipo covariante no puede utilizarse en el tipo de parámetro", "paramTypePartiallyUnknown": "El tipo de parámetro \"{paramName}\" es parcialmente desconocido", "paramTypeUnknown": "Se desconoce el tipo del parámetro \"{paramName}\".", - "parenthesizedContextManagerIllegal": "Los paréntesis dentro de la instrucción \"with\" requieren Python 3.9 o posterior", + "parenthesizedContextManagerIllegal": "Parentheses within \"with\" statement requires Python 3.9 or newer", "patternNeverMatches": "El patrón nunca coincidirá para el tipo de asunto \"{type}\"", "positionArgAfterNamedArg": "El argumento posicional no puede aparecer después de los argumentos de palabra clave", "positionOnlyAfterArgs": "No se permite el separador de parámetros de un solo puesto después del parámetro \"*\".", @@ -398,24 +399,24 @@ "privateImportFromPyTypedModule": "\"{name}\" no se exporta desde el módulo \"{module}\"", "privateUsedOutsideOfClass": "\"{name}\" es privado y se utiliza fuera de la clase en la que se declara", "privateUsedOutsideOfModule": "\"{name}\" es privado y se utiliza fuera del módulo en el que se declara", - "propertyOverridden": "\"{name}\" invalida incorrectamente la propiedad del mismo nombre en la clase \"{className}\"", - "propertyStaticMethod": "Métodos estáticos no permitidos para los valores getter, setter o deleter de propiedades", + "propertyOverridden": "\"{name}\" invalida incorrectamente la property del mismo nombre en la clase \"{className}\"", + "propertyStaticMethod": "Métodos estáticos no permitidos para los valores de property getter, setter o deleter", "protectedUsedOutsideOfClass": "\"{name}\" está protegido y se usa fuera de la clase en la que se declara", - "protocolBaseClass": "La clase de protocolo \"{classType}\" no se puede derivar de la clase que no es de protocolo \"{baseType}\"", + "protocolBaseClass": "La clase de Protocol \"{classType}\" no se puede derivar de la clase que no es Protocol \"{baseType}\"", "protocolBaseClassWithTypeArgs": "No se permiten argumentos de tipo con la clase Protocol cuando se usa la sintaxis de parámetro de tipo", "protocolIllegal": "El uso de \"Protocolo\" requiere Python 3.7 o posterior.", "protocolNotAllowed": "\"Protocolo\" no puede utilizarse en este contexto", "protocolTypeArgMustBeTypeParam": "El argumento de tipo para \"Protocol\" debe ser un parámetro de tipo", "protocolUnsafeOverlap": "La clase se superpone \"{name}\" de forma no segura y podría producir una coincidencia en tiempo de ejecución", - "protocolVarianceContravariant": "La variable de tipo \"{variable}\" usada en el protocolo genérico \"{class}\" debe ser contravariante.", - "protocolVarianceCovariant": "La variable de tipo \"{variable}\" usada en el protocolo genérico \"{class}\" debe ser covariante", - "protocolVarianceInvariant": "La variable de tipo \"{variable}\" usada en el protocolo genérico \"{class}\" debe ser invariable.", + "protocolVarianceContravariant": "La variable de tipo \"{variable}\" usada en Protocol genérico \"{class}\" debe ser contravariante", + "protocolVarianceCovariant": "La variable de tipo \"{variable}\" usada en Protocol genérico \"{class}\" debe ser covariante", + "protocolVarianceInvariant": "La variable de tipo \"{variable}\" usada en Protocol genérico \"{class}\" debe ser invariable", "pyrightCommentInvalidDiagnosticBoolValue": "La directiva de comentario Pyright debe ir seguida de \"=\" y un valor de true o false", - "pyrightCommentInvalidDiagnosticSeverityValue": "La directiva de comentario Pyright debe ir seguida de \"=\" y un valor de verdadero, falso, error, advertencia, información o ninguno.", - "pyrightCommentMissingDirective": "El comentario de copyright debe ir seguido de una directiva (básica o estricta) o de una regla de diagnóstico", - "pyrightCommentNotOnOwnLine": "Los comentarios de copyright utilizados para controlar los ajustes a nivel de archivo deben aparecer en su propia línea", + "pyrightCommentInvalidDiagnosticSeverityValue": "La directiva de comentario Pyright debe ir seguida de \"=\" y un valor de true, false, error, warning, information o none.", + "pyrightCommentMissingDirective": "El comentario de Pyright debe ir seguido de una directiva (basic o estricta) o de una regla de diagnóstico", + "pyrightCommentNotOnOwnLine": "Los comentarios de Pyright utilizados para controlar los ajustes a nivel de archivo deben aparecer en su propia línea", "pyrightCommentUnknownDiagnosticRule": "\"{rule}\" es una regla de diagnóstico desconocida para el comentario pyright", - "pyrightCommentUnknownDiagnosticSeverityValue": "\"{value}\" es un valor no válido para el comentario pyright; se espera verdadero, falso, error, advertencia, información o ninguno.", + "pyrightCommentUnknownDiagnosticSeverityValue": "\"{value}\" es un valor no válido para el comentario pyright; se espera true, false, error, warning, information o none.", "pyrightCommentUnknownDirective": "\"{directive}\" es una directiva desconocida para el comentario pyright; se esperaba \"strict\" o \"basic\".", "readOnlyArgCount": "Se esperaba un único argumento de tipo después de \"ReadOnly\"", "readOnlyNotInTypedDict": "\"ReadOnly\" no está permitido en este contexto", @@ -423,33 +424,33 @@ "relativeImportNotAllowed": "Las importaciones relativas no pueden utilizarse con la forma \"import .a\"; utilice en su lugar \"from . import a\"", "requiredArgCount": "Se esperaba un único argumento de tipo después de \"Required\"", "requiredNotInTypedDict": "\"Required\" no está permitido en este contexto", - "returnInAsyncGenerator": "No se permite la instrucción Return con valor en el generador asincrónico", + "returnInAsyncGenerator": "No se permite la instrucción Return con valor en el generador async", "returnMissing": "La función con el tipo de valor devuelto declarado \"{returnType}\" debe devolver un valor en todas las rutas de acceso del código.", "returnOutsideFunction": "\"return\" solo se puede usar dentro de una función", "returnTypeContravariant": "La variable de tipo contravariante no se puede usar en el tipo de valor devuelto", - "returnTypeMismatch": "La expresión de tipo \"{exprType}\" no es compatible con el tipo de valor devuelto \"{returnType}\"", + "returnTypeMismatch": "El tipo \"{exprType}\" no se puede asignar al tipo de valor devuelto \"{returnType}\"", "returnTypePartiallyUnknown": "El tipo de retorno, \"{returnType}\", es parcialmente desconocido", "returnTypeUnknown": "Tipo de retorno desconocido", "revealLocalsArgs": "No se esperaba ningún argumento para la llamada \"reveal_locals\"", - "revealLocalsNone": "No hay locales en este ámbito", + "revealLocalsNone": "No hay locals en este ámbito", "revealTypeArgs": "Se esperaba un único argumento posicional para la llamada \"reveal_type\"", "revealTypeExpectedTextArg": "El argumento \"expected_text\" de la función \"reveal_type\" debe ser un valor literal str.", "revealTypeExpectedTextMismatch": "El tipo de texto no coincide; se esperaba \"{expected}\" pero se ha recibido \"{received}\".", "revealTypeExpectedTypeMismatch": "Error de coincidencia de tipos; se esperaba \"{expected}\", pero se recibió \"{received}\"", "selfTypeContext": "\"Self\" no es válido en este contexto", "selfTypeMetaclass": "\"Self\" no se puede usar dentro de una metaclase (una subclase de \"type\")", - "selfTypeWithTypedSelfOrCls": "\"Auto\" no puede utilizarse en una función con un parámetro `self` o `cls` que tenga una anotación de tipo distinta de \"Auto\".", - "setterGetterTypeMismatch": "El tipo de valor setter de propiedad no se puede asignar al tipo devuelto por el valor setter", + "selfTypeWithTypedSelfOrCls": "\"Self\" no puede utilizarse en una función con un parámetro `self` o `cls` que tenga una anotación de tipo distinta de \"Self\".", + "setterGetterTypeMismatch": "El tipo de valor setter de Property no se puede asignar al tipo devuelto por el valor getter", "singleOverload": "\"{name}\" está marcado como sobrecarga, pero faltan sobrecargas adicionales", "slotsAttributeError": "\"{name}\" no se especificó en __slots__", "slotsClassVarConflict": "\"{name}\" entra en conflicto con la variable de instancia declarada en __slots__", "starPatternInAsPattern": "El patrón estrella no puede utilizarse con el objetivo \"as\"", "starPatternInOrPattern": "El patrón de estrella no puede unirse a otros patrones", "starStarWildcardNotAllowed": "** no puede utilizarse con el comodín \"_\".", - "staticClsSelfParam": "Los métodos estáticos no deben tomar un parámetro \"auto\" o \"cls\".", + "staticClsSelfParam": "Los métodos estáticos no deben tomar un parámetro \"self\" o \"cls\".", "stdlibModuleOverridden": "\"{path}\" está reemplazando el módulo stdlib \"{name}\"", "stringNonAsciiBytes": "Carácter no ASCII no permitido en el literal de cadena de bytes", - "stringNotSubscriptable": "La expresión de cadena no puede ir entre comillas en la anotación de tipo; encierre toda la anotación entre comillas.", + "stringNotSubscriptable": "La expresión de cadena no puede ir entre comillas en la expresión de tipo; encierre toda la expresión entre comillas.", "stringUnsupportedEscape": "Secuencia de escape no admitida en el literal de cadena", "stringUnterminated": "La cadena literal no está terminada", "stubFileMissing": "Archivo Stub no encontrado para \"{importName}\"", @@ -464,24 +465,24 @@ "symbolIsUnbound": "\"{name}\" está sin consolidar", "symbolIsUndefined": "\"{name}\" no está definido", "symbolOverridden": "\"{name}\" anula el símbolo del mismo nombre en la clase \"{className}\"", - "ternaryNotAllowed": "No se permite la expresión ternaria en la anotación de tipo", + "ternaryNotAllowed": "No se permite la expresión de ternario en la expresión de tipo", "totalOrderingMissingMethod": "La clase debe definir uno de \"__lt__\", \"__le__\", \"__gt__\", o \"__ge__\" para utilizar total_ordering", "trailingCommaInFromImport": "No se permite la coma final sin paréntesis alrededor", "tryWithoutExcept": "La instrucción Try debe tener al menos una cláusula except o finally", - "tupleAssignmentMismatch": "La expresión con el tipo \"{type}\" no se puede asignar a la tupla de destino", - "tupleInAnnotation": "No se permite la expresión de tupla en la anotación de tipo", + "tupleAssignmentMismatch": "La expresión con el tipo \"{type}\" no se puede asignar a la tuple de destino", + "tupleInAnnotation": "No se permite la expresión de tuple en la expresión de tipo", "tupleIndexOutOfRange": "El índice {index} está fuera de rango para el tipo {type}.", "typeAliasIllegalExpressionForm": "Forma de expresión no válida para la definición de alias de tipo", "typeAliasIsRecursiveDirect": "El alias de tipo \"{name}\" no puede usarse a sí mismo en su definición", "typeAliasNotInModuleOrClass": "Un TypeAlias solo puede definirse en el ámbito de un módulo o de una clase", "typeAliasRedeclared": "\"{name}\" se declara como TypeAlias y solo puede asignarse una vez", - "typeAliasStatementBadScope": "Una instrucción de tipo solo se puede usar en el ámbito de un módulo o de una clase", + "typeAliasStatementBadScope": "Una instrucción de type solo se puede usar en el ámbito de un módulo o de una clase", "typeAliasStatementIllegal": "La sentencia Type alias requiere Python 3.12 o posterior", "typeAliasTypeBaseClass": "Un alias de tipo definido en una instrucción \"type\" no se puede usar como clase base", "typeAliasTypeMustBeAssigned": "TypeAliasType debe asignarse a una variable con el mismo nombre que el alias de tipo", "typeAliasTypeNameArg": "El primer argumento de TypeAliasType debe ser un literal de cadena que represente el nombre del alias de tipo", "typeAliasTypeNameMismatch": "El nombre del alias de tipo debe coincidir con el nombre de la variable a la que se asigna", - "typeAliasTypeParamInvalid": "La lista de parámetros de tipo debe ser una tupla que contenga solo TypeVar, TypeVarTuple o ParamSpec.", + "typeAliasTypeParamInvalid": "La lista de parámetros de tipo debe ser una tuple que contenga solo TypeVar, TypeVarTuple o ParamSpec.", "typeAnnotationCall": "No se permite la expresión de llamada en la expresión de tipo", "typeAnnotationVariable": "Variable no permitida en la expresión de tipo", "typeAnnotationWithCallable": "El argumento de tipo para \"type\" debe ser una clase; no se admiten invocables", @@ -493,16 +494,17 @@ "typeArgsMissingForClass": "Se esperaban argumentos de tipo para la clase genérica \"{name}\"", "typeArgsTooFew": "Se han proporcionado muy pocos argumentos de tipo para \"{name}\"; se esperaba {expected} pero se ha recibido {received}.", "typeArgsTooMany": "Se proporcionaron demasiados argumentos de tipo para \"{name}\"; se esperaba {expected}, pero se recibieron {received}", - "typeAssignmentMismatch": "La expresión de tipo \"{sourceType}\" no es compatible con el tipo declarado \"{destType}\"", - "typeAssignmentMismatchWildcard": "El símbolo de importación \"{name}\" tiene el tipo \"{sourceType}\", que no es compatible con el tipo declarado \"{destType}\"", - "typeCallNotAllowed": "la llamada a type() no debe utilizarse en la anotación de tipo", + "typeAssignmentMismatch": "El tipo \"{sourceType}\" no se puede asignar al tipo declarado \"{destType}\"", + "typeAssignmentMismatchWildcard": "El símbolo de importación \"{name}\" tiene el tipo \"{sourceType}\", que no se puede asignar al tipo declarado \"{destType}\"", + "typeCallNotAllowed": "La llamada a type() no debe utilizarse en la expresión de tipo", "typeCheckOnly": "\"{name}\" está marcado como @type_check_only y solo se puede usar en anotaciones de tipo", - "typeCommentDeprecated": "El uso de comentarios de tipo está obsoleto; utilice en su lugar anotaciones de tipo.", + "typeCommentDeprecated": "El uso de comentarios de type está obsoleto; utilice en su lugar anotaciones de type.", "typeExpectedClass": "Se esperaba la clase pero se recibió \"{type}\"", + "typeFormArgs": "\"TypeForm\" acepta un único argumento posicional", "typeGuardArgCount": "Se esperaba un único argumento de tipo después de \"TypeGuard\" o \"TypeIs\"", "typeGuardParamCount": "Las funciones y métodos de protección de tipo definidos por el usuario deben tener al menos un parámetro de entrada", "typeIsReturnType": "El tipo de valor devuelto de TypeIs (\"{returnType}\") no es coherente con el tipo de parámetro de valor (\"{type}\")", - "typeNotAwaitable": "\"{type}\" no se puede esperar", + "typeNotAwaitable": "\"{type}\" no se awaitable", "typeNotIntantiable": "\"{type}\" no puede crear instancias", "typeNotIterable": "\"{type}\" no es iterable", "typeNotSpecializable": "No se pudo especializar el tipo \"{type}\"", @@ -537,7 +539,7 @@ "typeVarSingleConstraint": "TypeVar debe tener al menos dos tipos restringidos", "typeVarTupleConstraints": "TypeVarTuple no puede tener restricciones de valor", "typeVarTupleContext": "TypeVarTuple no está permitido en este contexto", - "typeVarTupleDefaultNotUnpacked": "El tipo predeterminado TypeVarTuple debe ser una tupla desempaquetada o TypeVarTuple", + "typeVarTupleDefaultNotUnpacked": "El tipo predeterminado TypeVarTuple debe ser una tuple desempaquetada o TypeVarTuple", "typeVarTupleMustBeUnpacked": "Se requiere el operador Unpack para el valor TypeVarTuple.", "typeVarTupleUnknownParam": "\"{name}\" es un parámetro desconocido para TypeVarTuple", "typeVarUnknownParam": "\"{name}\" es un parámetro desconocido para TypeVar", @@ -551,9 +553,9 @@ "typedDictAssignedName": "TypedDict debe asignarse a una variable denominada \"{name}\"", "typedDictBadVar": "Las clases TypedDict solo pueden contener anotaciones de tipo", "typedDictBaseClass": "Todas las clases base de las clases TypedDict deben ser también clases TypedDict", - "typedDictBoolParam": "Se esperaba que el parámetro \"{name}\" tuviera un valor de Verdadero o Falso.", - "typedDictClosedExtras": "La clase base \"{name}\" es un TypedDict cerrado; los elementos adicionales deben ser de tipo \"{type}\"", - "typedDictClosedNoExtras": "La clase base \"{name}\" es un TypedDict cerrado; no se permiten elementos adicionales", + "typedDictBoolParam": "Se esperaba que el parámetro \"{name}\" tuviera un valor de True o False.", + "typedDictClosedExtras": "La clase base \"{name}\" es un TypedDict closed; los elementos adicionales deben ser de tipo \"{type}\"", + "typedDictClosedNoExtras": "La clase base \"{name}\" es un TypedDict closed; no se permiten elementos adicionales", "typedDictDelete": "No se puede eliminar un elemento en TypedDict", "typedDictEmptyName": "Los nombres de un TypedDict no pueden estar vacíos", "typedDictEntryName": "Cadena literal esperada para el nombre de la entrada del diccionario", @@ -561,7 +563,7 @@ "typedDictExtraArgs": "No se admiten argumentos TypedDict adicionales", "typedDictFieldNotRequiredRedefinition": "El elemento TypedDict \"{name}\" no se puede redefinir como NotRequired", "typedDictFieldReadOnlyRedefinition": "El elemento TypedDict \"{name}\" no se puede redefinir como ReadOnly", - "typedDictFieldRequiredRedefinition": "El elemento TypedDict \"{name}\" no se puede redefinir como Requerido", + "typedDictFieldRequiredRedefinition": "El elemento TypedDict \"{name}\" no se puede redefinir como Required", "typedDictFirstArg": "Nombre de clase TypedDict esperado como primer argumento", "typedDictInitsubclassParameter": "TypedDict no admite __init_subclass__ parámetro \"{name}\"", "typedDictNotAllowed": "\"TypedDict\" no puede utilizarse en este contexto", @@ -574,34 +576,34 @@ "unaccessedSymbol": "No se accede a \"{name}\"", "unaccessedVariable": "No se accede a la variable \"{name} \".", "unannotatedFunctionSkipped": "Se omite el análisis de la función \"{name}\" porque no está anotada", - "unaryOperationNotAllowed": "Operador unario no permitido en la anotación de tipo", + "unaryOperationNotAllowed": "Operador unario no permitido en la expresión de tipo", "unexpectedAsyncToken": "Se esperaba que \"def\", \"with\" o \"for\" siguieran a \"async\".", "unexpectedExprToken": "Token inesperado al final de la expresión", "unexpectedIndent": "sangSangría inesperadaría inesperada", "unexpectedUnindent": "No se espera sangría", "unhashableDictKey": "La clave del diccionario debe ser hash", - "unhashableSetEntry": "La entrada del conjunto debe ser hashable", + "unhashableSetEntry": "La entrada del set debe ser hashable", "uninitializedAbstractVariables": "Las variables definidas en la clase base abstracta no se inicializan en la clase final \"{classType}\"", "uninitializedInstanceVariable": "La variable de instancia \"{name}\" no está inicializada en el cuerpo de la clase o en el método __init__.", "unionForwardReferenceNotAllowed": "Union syntax cannot be used with string operand; use quotes around entire expression", "unionSyntaxIllegal": "La sintaxis alternativa para las uniones requiere Python 3.10 o posterior.", - "unionTypeArgCount": "La unión requiere dos o más argumentos de tipo", - "unionUnpackedTuple": "La unión no puede incluir una tupla desempaquetada", - "unionUnpackedTypeVarTuple": "La unión no puede incluir un TypeVarTuple desempaquetado", + "unionTypeArgCount": "Union requiere dos o más argumentos de tipo", + "unionUnpackedTuple": "La Union no puede incluir una tuple desempaquetada", + "unionUnpackedTypeVarTuple": "La Union no puede incluir un TypeVarTuple desempaquetado", "unnecessaryCast": "Llamada \"cast\" innecesaria; el tipo ya es \"{type}\"", "unnecessaryIsInstanceAlways": "Llamada isinstance innecesaria; \"{testType}\" es siempre una instancia de \"{classType}\"", "unnecessaryIsSubclassAlways": "Llamada de issubclass innecesaria; \"{testType}\" siempre es una subclase de \"{classType}\"", "unnecessaryPyrightIgnore": "Comentario \"# pyright: ignore\" innecesario", "unnecessaryPyrightIgnoreRule": "Regla innecesaria \"# pyright: ignore\": \"{name}\"", "unnecessaryTypeIgnore": "Comentario \"# type: ignore\" innecesario", - "unpackArgCount": "Se esperaba un único argumento de tipo después de \"Desempaquetar\"", - "unpackExpectedTypeVarTuple": "Se esperaba TypeVarTuple o tupla como argumento de tipo para desempaquetar", + "unpackArgCount": "Se esperaba un único argumento de tipo después de \"Unpack\"", + "unpackExpectedTypeVarTuple": "Se esperaba TypeVarTuple o tuple como argumento de tipo para Unpack", "unpackExpectedTypedDict": "Se esperaba un argumento de tipo TypedDict para Unpack", "unpackIllegalInComprehension": "Operación de desempaquetado no permitida en la comprensión", - "unpackInAnnotation": "No se permite el operador desempaquetado en la anotación de tipo", + "unpackInAnnotation": "No se permite el operador desempaquetado en la expresión de tipo", "unpackInDict": "Operación de desempaquetado no permitida en diccionarios", - "unpackInSet": "No se permite el operador Unpack dentro de un conjunto", - "unpackNotAllowed": "El desempaquetado no está permitido en este contexto", + "unpackInSet": "No se permite el operador Unpack dentro de un set", + "unpackNotAllowed": "Unpack no está permitido en este contexto", "unpackOperatorNotAllowed": "La operación de desempaquetado no está permitida en este contexto", "unpackTuplesIllegal": "Operación de desempaquetado no permitida en tuplas anteriores a Python 3.8", "unpackedArgInTypeArgument": "No se pueden usar argumentos sin empaquetar en este contexto", @@ -616,11 +618,11 @@ "unreachableExcept": "La cláusula Excepto es inalcanzable porque la excepción ya está administrada", "unsupportedDunderAllOperation": "No se admite la operación en \"__all__\", por lo que la lista de símbolos exportada puede ser incorrecta.", "unusedCallResult": "El resultado de la expresión de llamada es de tipo \"{type}\" y no se usa; asignar a la variable \"_\" si esto es intencionado", - "unusedCoroutine": "El resultado de la llamada a una función asíncrona no se utiliza; utilice \"await\" o asigne el resultado a una variable.", + "unusedCoroutine": "El resultado de la llamada a una función async no se utiliza; utilice \"await\" o asigne el resultado a una variable.", "unusedExpression": "El valor de expresión no se usa", - "varAnnotationIllegal": "Las anotaciones de tipo para variables requieren Python 3.6 o posterior; utilice el comentario de tipo para la compatibilidad con versiones anteriores.", + "varAnnotationIllegal": "Las anotaciones de type para variables requieren Python 3.6 o posterior; utilice el comentario de tipo para la compatibilidad con versiones anteriores.", "variableFinalOverride": "La variable \"{name}\" está marcada como Final y anula la variable no Final del mismo nombre en la clase \"{className}\".", - "variadicTypeArgsTooMany": "La lista de argumentos de tipo puede tener como máximo una TypeVarTuple o tupla desempaquetada", + "variadicTypeArgsTooMany": "La lista de argumentos de tipo puede tener como máximo una TypeVarTuple o tuple desempaquetada", "variadicTypeParamTooManyAlias": "Los alias de tipo pueden tener como máximo un parámetro de tipo TypeVarTuple, pero reciben varios ({names})", "variadicTypeParamTooManyClass": "La clase genérica puede tener como máximo un parámetro de tipo TypeVarTuple pero recibió múltiples ({names})", "walrusIllegal": "El operador \":=\" requiere Python 3.8 o posterior", @@ -629,35 +631,35 @@ "wildcardLibraryImport": "No se permite la importación de caracteres comodín desde una biblioteca", "wildcardPatternTypePartiallyUnknown": "El tipo capturado por el patrón comodín es parcialmente desconocido", "wildcardPatternTypeUnknown": "Se desconoce el tipo capturado por el patrón de caracteres comodín", - "yieldFromIllegal": "El uso de \"yield\" requiere Python 3.3 o posterior.", - "yieldFromOutsideAsync": "\"yield from\" no permitido en una función asincrónica", + "yieldFromIllegal": "El uso de \"yield from\" requiere Python 3.3 o posterior.", + "yieldFromOutsideAsync": "\"yield from\" no permitido en una función async", "yieldOutsideFunction": "\"yield\" no se permite fuera de una función o lambda", "yieldWithinComprehension": "\"yield\" no está permitido dentro de una comprensión de lista", "zeroCaseStatementsFound": "La instrucción Match debe incluir al menos una instrucción case", - "zeroLengthTupleNotAllowed": "La tupla de longitud cero no está permitida en este contexto" + "zeroLengthTupleNotAllowed": "La tuple de longitud cero no está permitida en este contexto" }, "DiagnosticAddendum": { - "annotatedNotAllowed": "El formulario especial \"Anotado\" no se puede usar con comprobaciones de instancia y clase", + "annotatedNotAllowed": "El formulario especial \"Annotated\" no se puede usar con comprobaciones de instancia y clase", "argParam": "El argumento corresponde al parámetro \"{paramName}\"", "argParamFunction": "El argumento corresponde al parámetro \"{paramName}\" en la función \"{functionName}\"", "argsParamMissing": "El parámetro \"*{paramName}\" no tiene ningún parámetro correspondiente", "argsPositionOnly": "Error de coincidencia del parámetro de solo posición; se esperaba {expected}, pero se recibieron {received}", "argumentType": "El tipo de argumento es \"{type}\"", "argumentTypes": "Tipos de argumento: ({types})", - "assignToNone": "El tipo no es compatible con \"None\"", + "assignToNone": "El tipo no se puede asignar a \"None\"", "asyncHelp": "¿Quería decir \"async with\"?", "baseClassIncompatible": "La clase base \"{baseClass}\" no es compatible con el tipo \"{type}\"", "baseClassIncompatibleSubclass": "La clase base \"{baseClass}\" deriva de \"{subclass}\", que no es compatible con el tipo \"{type}\"", "baseClassOverriddenType": "La clase base \"{baseClass}\" proporciona el tipo \"{type}\", que se sobrescribe", "baseClassOverridesType": "Invalidaciones de clase base \"{baseClass}\" con el tipo \"{type}\"", - "bytesTypePromotions": "Establezca disableBytesTypePromotions en falso para activar el comportamiento de promoción de tipos para \"bytearray\" y \"memoryview\".", + "bytesTypePromotions": "Establezca disableBytesTypePromotions en false para activar el comportamiento de promoción de tipos para \"bytearray\" y \"memoryview\".", "conditionalRequiresBool": "El método __bool__ para el tipo \"{operandType}\" devuelve el tipo \"{boolReturnType}\" en lugar de \"bool\"", "dataClassFieldLocation": "en declaración de campo", "dataClassFrozen": "\"{name}\" está congelado", "dataProtocolUnsupported": "\"{name}\" es un protocolo de datos", "descriptorAccessBindingFailed": "No se pudo enlazar el método \"{name}\" para la clase de descriptor \"{className}\"", "descriptorAccessCallFailed": "No se pudo llamar al método \"{name}\" para la clase de descriptor \"{className}\"", - "finalMethod": "Método final", + "finalMethod": "Final method", "functionParamDefaultMissing": "Falta el argumento predeterminado en el parámetro \"{name}\"", "functionParamName": "Nombre de parámetro no coincidente: \"{destName}\" frente a \"{srcName}\"", "functionParamPositionOnly": "Error de coincidencia del parámetro de solo posición; el parámetro \"{name}\" no es de solo posición", @@ -665,15 +667,15 @@ "functionTooFewParams": "La función acepta muy pocos parámetros posicionales; esperado {expected} pero recibido {received}", "functionTooManyParams": "La función acepta demasiados parámetros posicionales; esperado {expected} pero recibido {received}", "genericClassNotAllowed": "Tipo genérico con argumentos de tipo no permitidos para comprobaciones de instancia o clase", - "incompatibleDeleter": "El método de eliminación de propiedades no es compatible", - "incompatibleGetter": "El método captador de propiedad no es compatible", - "incompatibleSetter": "El método setter de la propiedad no es compatible", + "incompatibleDeleter": "El método de deleter de property no es compatible", + "incompatibleGetter": "El método getter de property no es compatible", + "incompatibleSetter": "El método setter de la property no es compatible", "initMethodLocation": "El método __init__ se define en la clase \"{type}\"", "initMethodSignature": "La firma de __init__ es \"{type}\"", "initSubclassLocation": "El método __init_subclass__ se define en la clase \"{name}\"", - "invariantSuggestionDict": "Considere cambiar de \"predicción\" a \" Asignación\" que es covariante en el tipo de valor", - "invariantSuggestionList": "Considere la posibilidad de cambiar de \"lista\" a \"Secuencia\" que es covariante", - "invariantSuggestionSet": "Considere la posibilidad de cambiar de \"conjunto\" a \"Contenedor\" que es covariante", + "invariantSuggestionDict": "Considere cambiar de \"dict\" a \" Mapping\" que es covariante en el tipo de valor", + "invariantSuggestionList": "Considere la posibilidad de cambiar de \"lista\" a \"Sequence\" que es covariante", + "invariantSuggestionSet": "Considere la posibilidad de cambiar de \"set\" a \"Container\" que es covariante", "isinstanceClassNotSupported": "\"{type}\" no se admite para las comprobaciones de instancia y clase", "keyNotRequired": "\"{name}\" no es una clave necesaria en \"{type}\", por lo que el acceso puede dar lugar a una excepción en tiempo de ejecución", "keyReadOnly": "\"{name}\" es una clave de solo lectura en \"{type}\"", @@ -681,14 +683,14 @@ "keyUndefined": "\"{name}\" no es una clave definida en \"{type}\"", "kwargsParamMissing": "El parámetro \"**{paramName}\" no tiene ningún parámetro correspondiente.", "listAssignmentMismatch": "El tipo \"{type}\" es incompatible con la lista de objetivos", - "literalAssignmentMismatch": "\"{sourceType}\" no es compatible con el tipo \"{destType}\"", + "literalAssignmentMismatch": "\"{sourceType}\" no se puede asignar al tipo \"{destType}\"", "matchIsNotExhaustiveHint": "Si no se pretende un tratamiento exhaustivo, agregue \"case _: pass\"", "matchIsNotExhaustiveType": "Tipo no manejado: \"{type}\"", "memberAssignment": "La expresión de tipo \"{type}\" no se puede asignar al atributo \"{name}\" de la clase \"{classType}\"", "memberIsAbstract": "\"{type}. {name}\" no está implementado", - "memberIsAbstractMore": "y {count} más", + "memberIsAbstractMore": "y {count} más...", "memberIsClassVarInProtocol": "\"{name}\" se define como ClassVar en el protocolo", - "memberIsInitVar": "\"{name}\" es un campo solo de inicialización", + "memberIsInitVar": "\"{name}\" es un campo init-only", "memberIsInvariant": "\"{name}\" es invariable porque es mutable", "memberIsNotClassVarInClass": "\"{name}\" debe definirse como ClassVar para que sea compatible con el protocolo", "memberIsNotClassVarInProtocol": "\"{name}\" no está definido como ClassVar en el protocolo", @@ -699,9 +701,9 @@ "memberTypeMismatch": "\"{name}\" es un tipo incompatible", "memberUnknown": "Atributo \"{name}\" desconocido", "metaclassConflict": "La metaclase \"{metaclass1}\" entra en conflicto con \"{metaclass2}\"", - "missingDeleter": "Falta el método de eliminación de propiedades", - "missingGetter": "Falta el método Getter de la propiedad", - "missingSetter": "Falta el método establecedor de propiedades", + "missingDeleter": "Falta el método de deleter de property", + "missingGetter": "Falta el método getter de la property", + "missingSetter": "Falta el método setter de property", "namedParamMissingInDest": "Parámetro adicional \"{name}\"", "namedParamMissingInSource": "Falta el parámetro de palabra clave \"{name}\"", "namedParamTypeMismatch": "El parámetro de palabra clave \"{name}\" de tipo \"{sourceType}\" no es compatible con el tipo \"{destType}\"", @@ -710,7 +712,7 @@ "newMethodSignature": "La firma de __new__ es \"{type}\"", "newTypeClassNotAllowed": "La clase creada con NewType no se puede usar con comprobaciones de instancia y clase", "noOverloadAssignable": "Ninguna función sobrecargada coincide con el tipo \"{type}\"", - "noneNotAllowed": "No se puede usar ninguno para comprobaciones de instancia o clase", + "noneNotAllowed": "No se puede usar None para comprobaciones de instancia o clase", "orPatternMissingName": "Nombres que faltan: {name}", "overloadIndex": "La sobrecarga {index} es la coincidencia más cercana", "overloadNotAssignable": "Una o más sobrecargas de \"{name}\" no es asignable", @@ -720,7 +722,7 @@ "overrideInvariantMismatch": "El tipo de invalidación “{overrideType}” no es el mismo que el tipo básico “{baseType}”", "overrideIsInvariant": "La variable es mutable, por lo que su tipo es invariable", "overrideNoOverloadMatches": "Ninguna firma de sobrecarga en anulación es compatible con el método base", - "overrideNotClassMethod": "El método base se declara como Método de clase pero el Reemplazar no", + "overrideNotClassMethod": "El método base se declara como classmethod pero el Reemplazar no", "overrideNotInstanceMethod": "El método base se declara como método de instancia, pero la invalidación no", "overrideNotStaticMethod": "El método base se declara como staticmethod pero el reemplazo no", "overrideOverloadNoMatch": "La invalidación no controla todas las sobrecargas del método base", @@ -741,16 +743,16 @@ "paramType": "El tipo de parámetro es \"{paramType}\"", "privateImportFromPyTypedSource": "Importar desde \"{module}\" en su lugar", "propertyAccessFromProtocolClass": "No se puede tener acceso a una propiedad definida dentro de una clase de protocolo como variable de clase", - "propertyMethodIncompatible": "El método de propiedad \"{name}\" no es compatible", - "propertyMethodMissing": "Falta el método de propiedad \"{name}\" en la invalidación", - "propertyMissingDeleter": "La propiedad \"{name}\" no tiene un supresor definido", - "propertyMissingSetter": "La propiedad \"{name}\" no tiene el valor setter definido", + "propertyMethodIncompatible": "El método de property \"{name}\" no es compatible", + "propertyMethodMissing": "Falta el método de property \"{name}\" en la invalidación", + "propertyMissingDeleter": "Property \"{name}\" no tiene un supresor deleter", + "propertyMissingSetter": "Property \"{name}\" no tiene el valor setter definido", "protocolIncompatible": "\"{sourceType}\" no es compatible con el protocolo \"{destType}\"", "protocolMemberMissing": "\"{name}\" no está presente.", - "protocolRequiresRuntimeCheckable": "La clase de protocolo debe ser @runtime_checkable para usarse con comprobaciones de instancia y clase", + "protocolRequiresRuntimeCheckable": "La clase de Protocol debe ser @runtime_checkable para usarse con comprobaciones de instancia y clase", "protocolSourceIsNotConcrete": "\"{sourceType}\" no es un tipo de clase concreto y no se puede asignar al tipo \"{destType}\"", "protocolUnsafeOverlap": "Los atributos de \"{name}\" tienen los mismos nombres que el protocolo", - "pyrightCommentIgnoreTip": "Utilice \"# pyright: ignore[] para suprimir el diagnóstico de una sola línea", + "pyrightCommentIgnoreTip": "Utilice \"# pyright: ignore[]\" para suprimir el diagnóstico de una sola línea", "readOnlyAttribute": "El atributo \"{name}\" es de solo lectura", "seeClassDeclaration": "Ver declaración de clase", "seeDeclaration": "Ver declaración", @@ -759,17 +761,17 @@ "seeParameterDeclaration": "Declaración de parámetro", "seeTypeAliasDeclaration": "Véase la declaración de alias de tipo", "seeVariableDeclaration": "declaración de variable out", - "tupleAssignmentMismatch": "El tipo \"{type}\" no es compatible con la tupla de destino", - "tupleEntryTypeMismatch": "La entrada {entry} de la tupla es de tipo incorrecto", - "tupleSizeIndeterminateSrc": "El tamaño de la tupla no coincide; se esperaba {expected} pero se recibió uno indeterminado", - "tupleSizeIndeterminateSrcDest": "El tamaño de la tupla no coincide; se esperaba {expected} o más, pero se recibió uno indeterminado", - "tupleSizeMismatch": "El tamaño de la tupla no coincide; se esperaba {expected} pero se recibió {received}", - "tupleSizeMismatchIndeterminateDest": "El tamaño de la tupla no coincide; se esperaba {expected} o más, pero se recibió {received}", + "tupleAssignmentMismatch": "El tipo \"{type}\" no es compatible con la tuple de destino", + "tupleEntryTypeMismatch": "La entrada {entry} de la tuple es de tipo incorrecto", + "tupleSizeIndeterminateSrc": "El tamaño de la tuple no coincide; se esperaba {expected} pero se recibió uno indeterminado", + "tupleSizeIndeterminateSrcDest": "El tamaño de la tuple no coincide; se esperaba {expected} o más, pero se recibió uno indeterminado", + "tupleSizeMismatch": "El tamaño de la tuple no coincide; se esperaba {expected} pero se recibió {received}", + "tupleSizeMismatchIndeterminateDest": "El tamaño de la tuple no coincide; se esperaba {expected} o más, pero se recibió {received}", "typeAliasInstanceCheck": "El alias de tipo creado con la instrucción \"type\" no se puede usar con comprobaciones de instancia y clase", - "typeAssignmentMismatch": "El tipo \"{sourceType}\" no es compatible con el tipo \"{destType}\"", - "typeBound": "El tipo \"{sourceType}\" es incompatible con el tipo \"{destType}\" vinculado para la variable de tipo \"{name}\"", - "typeConstrainedTypeVar": "El tipo \"{type}\" no es compatible con la variable de tipo restringido \"{name}\"", - "typeIncompatible": "\"{sourceType}\" no es compatible con \"{destType}\"", + "typeAssignmentMismatch": "El tipo \"{sourceType}\" no se puede asignar al tipo \"{destType}\"", + "typeBound": "El tipo \"{sourceType}\" no se puede asignar al límite superior \"{destType}\" para la variable de tipo \"{name}\"", + "typeConstrainedTypeVar": "El tipo \"{type}\" no se puede asignar a la variable de tipo restringido \"{name}\"", + "typeIncompatible": "\"{sourceType}\" no se puede asignar a \"{destType}\"", "typeNotClass": "\"{type}\" no es una clase", "typeNotStringLiteral": "\"{type}\" no es un literal de cadena", "typeOfSymbol": "El tipo de \"{name}\" es \"{type}\"", @@ -780,11 +782,11 @@ "typeVarIsCovariant": "El parámetro de tipo \"{name}\" es covariante, pero \"{sourceType}\" no es un subtipo de \"{destType}\"", "typeVarIsInvariant": "El parámetro de tipo \"{name}\" es invariable, pero \"{sourceType}\" no es el mismo que \"{destType}\"", "typeVarNotAllowed": "TypeVar no se permite para comprobaciones de instancia o clase", - "typeVarTupleRequiresKnownLength": "TypeVarTuple no se puede enlazar a una tupla de longitud desconocida", + "typeVarTupleRequiresKnownLength": "TypeVarTuple no se puede enlazar a una tuple de longitud desconocida", "typeVarUnnecessarySuggestion": "Usar {type} en su lugar", "typeVarUnsolvableRemedy": "Proporciona una sobrecarga que especifica el tipo de retorno cuando no se proporciona el argumento", "typeVarsMissing": "Faltan variables de tipo: {names}", - "typedDictBaseClass": "La clase “{type}” no es un TypeDict", + "typedDictBaseClass": "La clase “{type}” no es un TypedDict", "typedDictClassNotAllowed": "No se permite la clase TypedDict para comprobaciones de instancia o clase", "typedDictClosedExtraNotAllowed": "No se puede agregar el elemento \"{name}\"", "typedDictClosedExtraTypeMismatch": "No se puede agregar el elemento \"{name}\" con el tipo \"{type}\"", @@ -804,8 +806,8 @@ "uninitializedAbstractVariable": "La variable de instancia \"{name}\" está definida en la clase base abstracta \"{classType} \" pero no inicializada.", "unreachableExcept": "\"{exceptionType}\" es una subclase de \"{parentType}\"", "useDictInstead": "Usar Dict[T1, T2] para indicar un tipo de diccionario", - "useListInstead": "Usar List[T] para indicar un tipo de lista o Union[T1, T2] para indicar un tipo de unión", - "useTupleInstead": "Utilice Tupla[T1, ..., Tn] para indicar un tipo de tupla o Union[T1, T2] para indicar un tipo de unión.", + "useListInstead": "Usar List[T] para indicar un tipo de list o Union[T1, T2] para indicar un tipo de union", + "useTupleInstead": "Utilice tuple[T1, ..., Tn] para indicar un tipo de tuple o Union[T1, T2] para indicar un tipo de union.", "useTypeInstead": "Utilice Type[T] en su lugar", "varianceMismatchForClass": "La varianza del argumento de tipo \"{typeVarName}\" no es compatible con la clase base \"{className}\"", "varianceMismatchForTypeAlias": "La varianza del argumento de tipo \"{typeVarName}\" no es compatible con \"{typeAliasParam}\"" diff --git a/packages/pyright-internal/src/localization/package.nls.fr.json b/packages/pyright-internal/src/localization/package.nls.fr.json index b1b32ce5f..4c28fc87e 100644 --- a/packages/pyright-internal/src/localization/package.nls.fr.json +++ b/packages/pyright-internal/src/localization/package.nls.fr.json @@ -1,7 +1,7 @@ { "CodeAction": { - "createTypeStub": "Créer un stub de type", - "createTypeStubFor": "Créer un stub de type pour « {moduleName} »", + "createTypeStub": "Créer un Stub de type", + "createTypeStubFor": "Créer un Stub de type pour « {moduleName} »", "executingCommand": "Exécution de la commande", "filesToAnalyzeCount": "{count} fichiers à analyser", "filesToAnalyzeOne": "1 fichier à analyser", @@ -18,12 +18,12 @@ "annotatedMetadataInconsistent": "Le type de métadonnées annoté « {metadataType} » n’est pas compatible avec le type « {type} »", "annotatedParamCountMismatch": "Non-concordance du nombre d'annotations de paramètre : attendu {expected} mais reçu {received}", "annotatedTypeArgMissing": "Un argument de type et une ou plusieurs annotations sont attendus pour « Annotated »", - "annotationBytesString": "Les annotations de type ne peuvent pas utiliser de littéraux de chaîne d’octets", - "annotationFormatString": "Les annotations de type ne peuvent pas utiliser de littéraux de chaîne de format (f-strings)", + "annotationBytesString": "Les expressions de type ne peuvent pas utiliser de littéraux de chaîne d'octets", + "annotationFormatString": "Les expressions de type ne peuvent pas utiliser de littéraux de chaîne de format (chaînes f)", "annotationNotSupported": "Annotation de type non prise en charge pour cette instruction", - "annotationRawString": "Les annotations de type ne peuvent pas utiliser de littéraux de chaîne brute", - "annotationSpansStrings": "Les annotations de type ne peuvent pas s'étendre sur plusieurs littéraux de chaîne", - "annotationStringEscape": "Les annotations de type ne peuvent pas contenir de caractères d'échappement", + "annotationRawString": "Les expressions de type ne peuvent pas utiliser de littéraux de chaîne bruts", + "annotationSpansStrings": "Les expressions de type ne peuvent pas s'étendre sur plusieurs littéraux de chaîne", + "annotationStringEscape": "Les expressions de type ne peuvent pas contenir de caractères d'échappement", "argAssignment": "Impossible d’affecter l’argument de type « {argType} » au paramètre de type « {paramType} »", "argAssignmentFunction": "Impossible d’affecter l’argument de type « {argType} » au paramètre de type « {paramType} » dans la fonction « {functionName} »", "argAssignmentParam": "Impossible d’affecter l’argument de type « {argType} » au paramètre « {paramName} » de type « {paramType} »", @@ -47,7 +47,7 @@ "assignmentTargetExpr": "L’expression ne peut pas être une cible d’assignation", "asyncNotInAsyncFunction": "L'utilisation de \"async\" n'est pas autorisée en dehors de la fonction async", "awaitIllegal": "L’utilisation de « await » nécessite Python 3.5 ou version ultérieure", - "awaitNotAllowed": "Les annotations de type ne peuvent pas utiliser « await »", + "awaitNotAllowed": "Les expressions de type ne peuvent pas utiliser « await »", "awaitNotInAsync": "« await » autorisé uniquement dans la fonction asynchrone", "backticksIllegal": "Les expressions entourées de accents inverses ne sont pas prises en charge dans Python 3.x; utiliser repr à la place", "baseClassCircular": "La classe ne peut pas dériver d'elle-même", @@ -57,20 +57,20 @@ "baseClassMethodTypeIncompatible": "Les classes de base de la classe « {classType} » définissent la méthode « {name} » de manière incompatible", "baseClassUnknown": "Le type de classe de base est inconnu, ce qui masque le type de classe dérivée", "baseClassVariableTypeIncompatible": "Les classes de base de la classe « {classType} » définissent la variable « {name} » de manière incompatible", - "binaryOperationNotAllowed": "Opérateur binaire non autorisé dans l’annotation de type", + "binaryOperationNotAllowed": "Opérateur binaire non autorisé dans l'expression de type", "bindTypeMismatch": "Impossible de lier la méthode \"{methodName}\" car \"{type}\" n'est pas attribuable au paramètre \"{paramName}\"", "breakOutsideLoop": "\"break\" ne peut être utilisé qu'à l'intérieur d'une boucle", - "callableExtraArgs": "Seuls deux arguments de type sont attendus pour « Joignable »", + "callableExtraArgs": "Seuls deux arguments de type sont attendus pour « Callable »", "callableFirstArg": "Liste de types de paramètres attendue ou « ... »", "callableNotInstantiable": "Impossible d’instancier le type « {type} »", - "callableSecondArg": "Type de retour attendu en tant que deuxième argument de type pour « Joignable »", + "callableSecondArg": "Type de retour attendu en tant que deuxième argument de type pour « Callable »", "casePatternIsIrrefutable": "Le motif irréfutable n'est autorisé que pour la dernière instruction case", "classAlreadySpecialized": "Le type « {type} » est déjà spécialisé", "classDecoratorTypeUnknown": "Le décorateur de classe non typé masque le type de classe ; décorateur ignorant", "classDefinitionCycle": "La définition de classe pour \"{name}\" dépend d'elle-même", "classGetItemClsParam": "__class_getitem__ remplacement doit prendre un paramètre « cls »", "classMethodClsParam": "Les méthodes de classe doivent prendre un paramètre \"cls\"", - "classNotRuntimeSubscriptable": "L’indice de la classe « {name} » génère une exception d’exécution ; placer l’annotation de type entre guillemets", + "classNotRuntimeSubscriptable": "L'indice pour la classe « {name} » générera une exception d'exécution ; placez l'expression de type entre guillemets", "classPatternBuiltInArgPositional": "Le modèle de classe accepte uniquement le sous-modèle positionnel", "classPatternPositionalArgCount": "Trop de modèles positionnels pour les \"{type}\" de classe ; {expected} attendue mais {received} reçues", "classPatternTypeAlias": "\"{type}\" ne peut pas être utilisé dans un modèle de classe car il s'agit d'un alias de type spécialisé", @@ -87,10 +87,10 @@ "comparisonAlwaysFalse": "La condition prend toujours la valeur False, car les types « {leftType} » et « {rightType} » ne se chevauchent pas", "comparisonAlwaysTrue": "La condition prend toujours la valeur True, car les types « {leftType} » et « {rightType} » ne se chevauchent pas", "comprehensionInDict": "La compréhension ne peut pas être utilisée avec d’autres entrées de dictionnaire", - "comprehensionInSet": "La compréhension ne peut pas être utilisée avec d'autres entrées définies", + "comprehensionInSet": "La compréhension ne peut pas être utilisée avec d’autres entrées set", "concatenateContext": "« Concatenate » n’est pas autorisé dans ce contexte", - "concatenateParamSpecMissing": "Le dernier argument de type pour « Concatener » doit être un ParamSpec ou bien « ... »", - "concatenateTypeArgsMissing": "\"Concaténation\" nécessite au moins deux arguments de type", + "concatenateParamSpecMissing": "Le dernier argument de type pour « Concatenate » doit être un ParamSpec ou bien « ... »", + "concatenateTypeArgsMissing": "« Concatenate » nécessite au moins deux arguments de type", "conditionalOperandInvalid": "Opérande conditionnel non valide de type \"{type}\"", "constantRedefinition": "\"{name}\" est constant (car il est en majuscule) et ne peut pas être redéfini", "constructorParametersMismatch": "Non-concordance entre la signature de __new__ et __init__ dans la classe \"{classType}\"", @@ -111,10 +111,10 @@ "dataClassPostInitType": "Incompatibilité du type de paramètre de méthode __post_init__ Dataclass pour le champ « {fieldName} »", "dataClassSlotsOverwrite": "__slots__ est déjà défini dans la classe", "dataClassTransformExpectedBoolLiteral": "Expression attendue qui prend statiquement la valeur True ou False", - "dataClassTransformFieldSpecifier": "Tuple attendu de classes ou de fonctions mais type reçu \"{type}\"", + "dataClassTransformFieldSpecifier": "Expected tuple of classes or functions but received type \"{type}\"", "dataClassTransformPositionalParam": "Tous les arguments de « dataclass_transform » doivent être des arguments de mot clé", "dataClassTransformUnknownArgument": "L’argument « {name} » n’est pas pris en charge par dataclass_transform", - "dataProtocolInSubclassCheck": "Les protocoles de données (qui incluent des attributs non méthode) ne sont pas autorisés dans les appels de sous-classe", + "dataProtocolInSubclassCheck": "Les protocoles de données (qui incluent des attributs non méthode) ne sont pas autorisés dans les appels de issubclass", "declaredReturnTypePartiallyUnknown": "Le type de retour déclaré « {returnType} » est partiellement inconnu", "declaredReturnTypeUnknown": "Le type de retour déclaré est inconnu", "defaultValueContainsCall": "Les appels de fonction et les objets mutables ne sont pas autorisés dans l'expression de la valeur par défaut du paramètre", @@ -127,20 +127,20 @@ "deprecatedDescriptorSetter": "La méthode « __set__ » du descripteur « {name} » est déconseillée", "deprecatedFunction": "La fonction \"{name}\" est obsolète", "deprecatedMethod": "La méthode \"{name}\" dans la classe \"{className}\" est obsolète", - "deprecatedPropertyDeleter": "Le deleter de la propriété « {name} » est déconseillé", - "deprecatedPropertyGetter": "Le getter de la propriété « {name} » est déconseillé", - "deprecatedPropertySetter": "Le setter de la propriété « {name} » est déconseillé", + "deprecatedPropertyDeleter": "Le deleter de la property « {name} » est déconseillé", + "deprecatedPropertyGetter": "Le getter de la property « {name} » est déconseillé", + "deprecatedPropertySetter": "Le setter de la property « {name} » est déconseillé", "deprecatedType": "Ce type est déconseillé à compter de Python {version}; utiliser « {replacement} » à la place", "dictExpandIllegalInComprehension": "Expansion du dictionnaire non autorisée dans la compréhension", - "dictInAnnotation": "Expression de dictionnaire non autorisée dans l’annotation de type", + "dictInAnnotation": "Expression de dictionnaire non autorisée dans l'expression de type", "dictKeyValuePairs": "Les entrées de dictionnaire doivent contenir des paires clé/valeur", "dictUnpackIsNotMapping": "Mappage attendu pour l’opérateur de décompression de dictionnaire", "dunderAllSymbolNotPresent": "« {name} » est spécifié dans __all__ mais n’est pas présent dans le module", "duplicateArgsParam": "Un seul paramètre « * » est autorisé", "duplicateBaseClass": "Classe de base en double non autorisée", "duplicateCapturePatternTarget": "La cible Capture \"{name}\" ne peut pas apparaître plus d'une fois dans le même modèle", - "duplicateCatchAll": "Une seule clause catch-all sauf autorisée", - "duplicateEnumMember": "Le membre enum « {name} » est déjà déclaré", + "duplicateCatchAll": "Une seule clause catch-all except autorisée", + "duplicateEnumMember": "Le membre Enum « {name} » est déjà déclaré", "duplicateGenericAndProtocolBase": "Une seule classe de base Generic[...] ou Protocol[...] autorisée", "duplicateImport": "« {importName} » est importé plusieurs fois", "duplicateKeywordOnly": "Un seul séparateur « * » autorisé", @@ -154,8 +154,8 @@ "ellipsisContext": "« ... » n’est pas autorisé dans ce contexte", "ellipsisSecondArg": "« ... » n’est autorisé qu’en tant que second des deux arguments", "enumClassOverride": "La classe Enum « {name} » est finale et ne peut pas être sous-classée", - "enumMemberDelete": "Le membre enum « {name} » ne peut pas être supprimé", - "enumMemberSet": "Le membre enum « {name} » ne peut pas être affecté", + "enumMemberDelete": "Le membre Enum « {name} » ne peut pas être supprimé", + "enumMemberSet": "Le membre Enum « {name} » ne peut pas être affecté", "enumMemberTypeAnnotation": "Les annotations de type ne sont pas autorisées pour les membres enum", "exceptionGroupIncompatible": "La syntaxe du groupe d’exceptions (« except* ») nécessite Python 3.11 ou version ultérieure", "exceptionGroupTypeIncorrect": "Le type d’exception dans except* ne peut pas dériver de BaseGroupException", @@ -164,7 +164,7 @@ "exceptionTypeNotInstantiable": "Le constructeur pour le type d’exception « {type} » requiert un ou plusieurs arguments", "expectedAfterDecorator": "Fonction attendue ou déclaration de classe après le décorateur", "expectedArrow": "« -> » attendu suivi d’une annotation de type de retour", - "expectedAsAfterException": "\"comme\" attendu après le type d'exception", + "expectedAsAfterException": "« as » attendu après le type d’exception", "expectedAssignRightHandExpr": "Expression attendue à droite de « = »", "expectedBinaryRightHandExpr": "Expression attendue à droite de l’opérateur", "expectedBoolLiteral": "Attendu True ou False", @@ -182,14 +182,14 @@ "expectedElse": "« else » attendu", "expectedEquals": "« = » attendu", "expectedExceptionClass": "Classe ou objet d'exception non valide", - "expectedExceptionObj": "Objet d’exception attendu, classe d’exception ou Aucun", + "expectedExceptionObj": "Objet d’exception attendu, classe d’exception ou None", "expectedExpr": "Expression attendue", "expectedFunctionAfterAsync": "Définition de fonction attendue après \"async\"", "expectedFunctionName": "Nom de fonction attendu après « def »", "expectedIdentifier": "Identifiant attendu", "expectedImport": "« importation » attendue", "expectedImportAlias": "Symbole attendu après « as »", - "expectedImportSymbols": "Un ou plusieurs noms de symboles attendus après l’importation", + "expectedImportSymbols": "Un ou plusieurs noms de symboles attendus après « l’importation »", "expectedIn": "« in » attendu", "expectedInExpr": "Expression attendue après « in »", "expectedIndentedBlock": "Bloc en retrait attendu", @@ -214,9 +214,9 @@ "finalInLoop": "Impossible d’assigner une variable « Final » dans une boucle", "finalMethodOverride": "La méthode « {name} » ne peut pas remplacer la méthode finale définie dans la classe « {className} »", "finalNonMethod": "La fonction « {name} » ne peut pas être marquée @final, car il ne s’agit pas d’une méthode", - "finalReassigned": "\"{name}\" est déclaré final et ne peut pas être réaffecté", - "finalRedeclaration": "« {name} » a été déclaré comme final", - "finalRedeclarationBySubclass": "« {name} » ne peut pas être redéclaré, car la classe parente « {className} » la déclare final", + "finalReassigned": "« {name} » est déclaré Final et ne peut pas être réaffecté", + "finalRedeclaration": "« {name} » a été déclaré comme Final", + "finalRedeclarationBySubclass": "« {name} » ne peut pas être redéclaré, car la classe parente « {className} » la déclare Final", "finalTooManyArgs": "Argument de type unique attendu après « Final »", "finalUnassigned": "« {name} » est déclaré Final, mais la valeur n’est pas affectée", "formatStringBrace": "Accolade fermante unique non autorisée dans le littéral f-string ; utiliser une double accolade fermée", @@ -237,13 +237,13 @@ "generatorAsyncReturnType": "Le type de retour de la fonction de générateur asynchrone doit être compatible avec « AsyncGenerator[{yieldType}, Any] »", "generatorNotParenthesized": "Les expressions de générateur doivent être entre parenthèses si elles ne sont pas uniquement des arguments", "generatorSyncReturnType": "Le type de retour de la fonction de générateur doit être compatible avec « Generator[{yieldType}, Any, Any] »", - "genericBaseClassNotAllowed": "La classe de base \"générique\" ne peut pas être utilisée avec la syntaxe de paramètre de type", + "genericBaseClassNotAllowed": "La classe de base « Generic » ne peut pas être utilisée avec la syntaxe de paramètre de type", "genericClassAssigned": "Impossible d’attribuer le type de classe générique", "genericClassDeleted": "Le type de classe générique ne peut pas être supprimé", "genericInstanceVariableAccess": "L’accès à une variable d’instance générique via une classe est ambigu", - "genericNotAllowed": "« Générique » n’est pas valide dans ce contexte", + "genericNotAllowed": "« Generic » n’est pas valide dans ce contexte", "genericTypeAliasBoundTypeVar": "L’alias de type générique dans la classe ne peut pas utiliser les variables de type lié {names}", - "genericTypeArgMissing": "« Générique » nécessite au moins un argument de type", + "genericTypeArgMissing": "« Generic » nécessite au moins un argument de type", "genericTypeArgTypeVar": "L’argument de type pour « Generic » doit être une variable de type", "genericTypeArgUnique": "Les arguments de type pour « Generic » doivent être uniques", "globalReassignment": "« {name} » est attribué avant la déclaration globale", @@ -265,7 +265,7 @@ "instanceMethodSelfParam": "Les méthodes d’instance doivent prendre un paramètre « self »", "instanceVarOverridesClassVar": "La variable d'instance \"{name}\" remplace la variable de classe du même nom dans la classe \"{className}\"", "instantiateAbstract": "Impossible d'instancier la classe abstraite \"{type}\"", - "instantiateProtocol": "Impossible d'instancier la classe de protocole \"{type}\"", + "instantiateProtocol": "Impossible d’instancier la classe de Protocol \"{type}\"", "internalBindError": "Une erreur interne s’est produite lors de la liaison du fichier « {file} » : {message}", "internalParseError": "Une erreur interne s’est produite lors de l’analyse du fichier « {file} » : {message}", "internalTypeCheckingError": "Une erreur interne s’est produite lors de la vérification de type du fichier « {file} » : {message}", @@ -274,7 +274,7 @@ "invalidTokenChars": "Caractère non valide \"{text}\" dans le jeton", "isInstanceInvalidType": "Le deuxième argument de \"isinstance\" doit être une classe ou un tuple de classes", "isSubclassInvalidType": "Le deuxième argument de « issubclass » doit être une classe ou un tuple de classes", - "keyValueInSet": "Les paires clé/valeur ne sont pas autorisées dans un ensemble", + "keyValueInSet": "Les paires clé/valeur ne sont pas autorisées dans un set", "keywordArgInTypeArgument": "Les arguments de mot-clé ne peuvent pas être utilisés dans les listes d'arguments de type", "keywordArgShortcutIllegal": "Le raccourci d’argument de mot clé nécessite Python 3.14 ou une version plus récente", "keywordOnlyAfterArgs": "Séparateur d’arguments mot clé uniquement non autorisé après le paramètre « * »", @@ -283,13 +283,13 @@ "lambdaReturnTypePartiallyUnknown": "Le type de retour de lambda, « {returnType} », est partiellement inconnu", "lambdaReturnTypeUnknown": "Le type de retour de lambda est inconnu", "listAssignmentMismatch": "Impossible d’affecter l’expression de type « {type} » à la liste cible", - "listInAnnotation": "Expression de liste non autorisée dans l’annotation de type", + "listInAnnotation": "Expression de List non autorisée dans l’expression de type", "literalEmptyArgs": "Attendu un ou plusieurs arguments de type après \"Literal\"", - "literalNamedUnicodeEscape": "Les séquences d’échappement Unicode nommées ne sont pas prises en charge dans les annotations de chaîne « Littérale »", - "literalNotAllowed": "\"Littéral\" ne peut pas être utilisé dans ce contexte sans argument de type", - "literalNotCallable": "Impossible d’instancier le type littéral", + "literalNamedUnicodeEscape": "Les séquences d’échappement Unicode nommées ne sont pas prises en charge dans les annotations de chaîne « Literal »", + "literalNotAllowed": "« Literal » ne peut pas être utilisé dans ce contexte sans argument de type", + "literalNotCallable": "Impossible d’instancier le type Literal", "literalUnsupportedType": "Les arguments de type pour « Literal » doivent être None, une valeur littérale (int, bool, str ou bytes) ou une valeur enum", - "matchIncompatible": "Les instructions de correspondance nécessitent Python 3.10 ou version ultérieure", + "matchIncompatible": "Les instructions de Match nécessitent Python 3.10 ou version ultérieure", "matchIsNotExhaustive": "Les cas dans l’instruction match ne gèrent pas toutes les valeurs de manière exhaustive", "maxParseDepthExceeded": "Profondeur d’analyse maximale dépassée ; scinder l’expression en sous-expressions plus petites", "memberAccess": "Désolé... Nous ne pouvons pas accéder à l’attribut « {name} » pour la classe « {type} »", @@ -304,6 +304,7 @@ "methodOverridden": "\"{name}\" remplace la méthode du même nom dans la classe \"{className}\" avec un type incompatible \"{type}\"", "methodReturnsNonObject": "La méthode « {name} » ne retourne pas d’objet", "missingSuperCall": "La méthode « {methodName} » n’appelle pas la méthode du même nom dans la classe parente", + "mixingBytesAndStr": "Les valeurs Bytes et str ne peuvent pas être concaténées", "moduleAsType": "Le module ne peut pas être utilisé comme type", "moduleNotCallable": "Le module ne peut pas être appelé", "moduleUnknownMember": "« {memberName} » n’est pas un attribut connu du module « {moduleName} »", @@ -314,10 +315,10 @@ "namedTupleFirstArg": "Nom de classe de tuple nommé attendu en tant que premier argument", "namedTupleMultipleInheritance": "L’héritage multiple avec NamedTuple n’est pas pris en charge", "namedTupleNameKeyword": "Les noms de champs ne peuvent pas être un mot-clé", - "namedTupleNameType": "Tuple à deux entrées attendu spécifiant le nom et le type de l’entrée", + "namedTupleNameType": "Expected two-entry tuple specifying entry name and type", "namedTupleNameUnique": "Les noms dans un tuple nommé doivent être uniques", "namedTupleNoTypes": "« namedtuple » ne fournit aucun type pour les entrées de tuple ; utilisez « NamedTuple » à la place", - "namedTupleSecondArg": "Liste d’entrées de tuple nommée attendue en tant que deuxième argument", + "namedTupleSecondArg": "Expected named tuple entry list as second argument", "newClsParam": "__new__ remplacement doit prendre un paramètre « cls »", "newTypeAnyOrUnknown": "Le deuxième argument de NewType doit être une classe connue, et non Any ou Unknown", "newTypeBadName": "Le premier argument de NewType doit être un littéral de chaîne", @@ -325,20 +326,20 @@ "newTypeNameMismatch": "NewType doit être affecté à une variable portant le même nom", "newTypeNotAClass": "Classe attendue comme deuxième argument de NewType", "newTypeParamCount": "NewType requiert deux arguments positionnels", - "newTypeProtocolClass": "Désolé, nous n’avons pas pu utiliser NewType avec un type structurelle (un protocole ou une classe TypedDict)", + "newTypeProtocolClass": "Désolé, nous n’avons pas pu utiliser NewType avec un type structurelle (un Protocol ou une classe TypedDict)", "noOverload": "Aucune surcharge pour « {name} » ne correspond aux arguments fournis", - "noReturnContainsReturn": "La fonction avec le type de retour déclaré « NoReturn » ne peut pas inclure d’instruction de retour", + "noReturnContainsReturn": "La fonction avec le type de return déclaré « NoReturn » ne peut pas inclure d’instruction de return", "noReturnContainsYield": "La fonction avec le type de retour déclaré « NoReturn » ne peut pas inclure d’instruction yield", "noReturnReturnsNone": "La fonction avec le type de retour déclaré \"NoReturn\" ne peut pas renvoyer \"None\"", "nonDefaultAfterDefault": "L’argument autre que l’argument par défaut suit l’argument par défaut", - "nonLocalInModule": "Déclaration non locale non autorisée au niveau du module", - "nonLocalNoBinding": "Aucune liaison pour le « {name} » non local trouvé", - "nonLocalReassignment": "« {name} » est attribué avant la déclaration non locale", - "nonLocalRedefinition": "« {name} » a déjà été déclaré non local", - "noneNotCallable": "L'objet de type \"Aucun\" ne peut pas être appelé", + "nonLocalInModule": "Déclaration nonlocal non autorisée au niveau du module", + "nonLocalNoBinding": "Aucune liaison pour le « {name} » nonlocal trouvé", + "nonLocalReassignment": "« {name} » est attribué avant la déclaration nonlocal", + "nonLocalRedefinition": "« {name} » a déjà été déclaré nonlocal", + "noneNotCallable": "L’objet de type « None » ne peut pas être appelé", "noneNotIterable": "L’objet de type « None » ne peut pas être utilisé en tant que valeur itérable", - "noneNotSubscriptable": "L'objet de type \"Aucun\" n'est pas inscriptible", - "noneNotUsableWith": "L’objet de type « None » ne peut pas être utilisé avec « with »", + "noneNotSubscriptable": "L’objet de type « None » n’est pas inscriptible", + "noneNotUsableWith": "Object of type \"None\" cannot be used with \"with\"", "noneOperator": "L’opérateur « {operator} » n’est pas pris en charge pour « None »", "noneUnknownMember": "« {name} » n’est pas un attribut connu de « None »", "notRequiredArgCount": "Argument de type unique attendu après « NotRequired »", @@ -351,7 +352,7 @@ "obscuredTypeAliasDeclaration": "La déclaration d’alias de type « {name} » est masquée par une déclaration du même nom", "obscuredVariableDeclaration": "La déclaration « {name} » est masquée par une déclaration du même nom", "operatorLessOrGreaterDeprecated": "L’opérateur « <> » n’est pas pris en charge dans Python 3 ; utilisez « != » à la place", - "optionalExtraArgs": "Attendu un argument de type après \"Facultatif\"", + "optionalExtraArgs": "Attendu un argument de type après « Optional »", "orPatternIrrefutable": "Modèle irréfutable autorisé uniquement en tant que dernier sous-modèle dans un modèle \"ou\"", "orPatternMissingName": "Tous les sous-modèles d’un modèle « or » doivent cibler les mêmes noms", "overlappingKeywordArgs": "Le dictionnaire tapé chevauche avec le mot clé paramètre : {names}", @@ -364,8 +365,8 @@ "overloadImplementationMismatch": "L’implémentation surchargée n’est pas cohérente avec la signature de la surcharge {index}", "overloadReturnTypeMismatch": "La surcharge {prevIndex} pour « {name} » chevauche la surcharge {newIndex} et retourne un type incompatible", "overloadStaticMethodInconsistent": "Les surcharges pour « {name} » utilisent @staticmethod de manière incohérente", - "overloadWithoutImplementation": "\"{name}\" est marqué comme surcharge, mais aucune implémentation n'est fournie", - "overriddenMethodNotFound": "La méthode \"{name}\" est marquée comme prioritaire, mais aucune méthode de base du même nom n'est présente", + "overloadWithoutImplementation": "« {name} » est marqué comme overload, mais aucune implémentation n’est fournie", + "overriddenMethodNotFound": "La méthode « {name} » est marquée comme override, mais aucune méthode de base du même nom n’est présente", "overrideDecoratorMissing": "La méthode \"{name}\" n'est pas marquée comme override mais remplace une méthode dans la classe \"{className}\"", "paramAfterKwargsParam": "Le paramètre ne peut pas suivre le paramètre \"**\"", "paramAlreadyAssigned": "Le paramètre « {name} » est déjà affecté", @@ -387,7 +388,7 @@ "paramTypeCovariant": "Impossible d’utiliser la variable de type Covariant dans le type de paramètre", "paramTypePartiallyUnknown": "Le type du paramètre « {paramName} » est partiellement inconnu", "paramTypeUnknown": "Le type de paramètre « {paramName} » est inconnu", - "parenthesizedContextManagerIllegal": "Les parenthèses dans l'instruction \"with\" nécessitent Python 3.9 ou une version plus récente", + "parenthesizedContextManagerIllegal": "Parentheses within \"with\" statement requires Python 3.9 or newer", "patternNeverMatches": "Le modèle ne sera jamais mis en correspondance pour le type d’objet « {type} »", "positionArgAfterNamedArg": "L’argument positionnel ne peut pas apparaître après les arguments de mot clé", "positionOnlyAfterArgs": "Séparateur de paramètres de position seule non autorisé après le paramètre « * »", @@ -398,40 +399,40 @@ "privateImportFromPyTypedModule": "« {name} » n’est pas exporté à partir du module « {module} »", "privateUsedOutsideOfClass": "« {name} » est privé et utilisé en dehors de la classe dans laquelle il est déclaré", "privateUsedOutsideOfModule": "« {name} » est privé et utilisé en dehors du module dans lequel il est déclaré", - "propertyOverridden": "\"{name}\" remplace à tort la propriété du même nom dans la classe \"{className}\"", - "propertyStaticMethod": "Méthodes statiques non autorisées pour la propriété getter, setter ou deleter", + "propertyOverridden": "« {name} » remplace à tort la property du même nom dans la classe « {className} »", + "propertyStaticMethod": "Méthodes statiques non autorisées pour la property getter, setter ou deleter", "protectedUsedOutsideOfClass": "\"{name}\" est protégé et utilisé en dehors de la classe dans laquelle il est déclaré", - "protocolBaseClass": "La classe de protocole \"{classType}\" ne peut pas dériver de la classe non protocolaire \"{baseType}\"", + "protocolBaseClass": "La classe de Protocol \"{classType}\" ne peut pas dériver de la classe non Protocol \"{baseType}\"", "protocolBaseClassWithTypeArgs": "Les arguments de type ne sont pas autorisés avec la classe Protocol lors de l'utilisation de la syntaxe des paramètres de type", "protocolIllegal": "L’utilisation de « Protocole » nécessite Python 3.7 ou une version plus récente", "protocolNotAllowed": "\"Protocole\" ne peut pas être utilisé dans ce contexte", "protocolTypeArgMustBeTypeParam": "L’argument de type pour « Protocol » doit être un paramètre de type", "protocolUnsafeOverlap": "La classe chevauche « {name} » de manière non sécurisée et peut produire une correspondance au moment de l’exécution", - "protocolVarianceContravariant": "La variable de type \"{variable}\" utilisée dans le protocole générique \"{class}\" doit être contravariante", - "protocolVarianceCovariant": "La variable de type \"{variable}\" utilisée dans le protocole générique \"{class}\" doit être covariante", - "protocolVarianceInvariant": "La variable de type \"{variable}\" utilisée dans le protocole générique \"{class}\" doit être invariante", - "pyrightCommentInvalidDiagnosticBoolValue": "La directive de commentaire Deight doit être suivie de « = » et d’une valeur true ou false", - "pyrightCommentInvalidDiagnosticSeverityValue": "La directive de commentaire Deright doit être suivie de « = » et avoir la valeur true, false, error, warning, information ou none", - "pyrightCommentMissingDirective": "Le commentaire Pyright doit être suivi d’une directive (de base ou stricte) ou d’une règle de diagnostic", - "pyrightCommentNotOnOwnLine": "Les commentaires Ensight utilisés pour contrôler les paramètres au niveau du fichier doivent apparaître sur leur propre ligne", - "pyrightCommentUnknownDiagnosticRule": "« {rule} » est une règle de diagnostic inconnue pour le commentaire deight", - "pyrightCommentUnknownDiagnosticSeverityValue": "« {value} \" n’est pas valide pour le commentaire deight ; true, false, erreur, avertissement, informations ou aucun attendu", - "pyrightCommentUnknownDirective": "« {directive} » est une directive inconnue pour le commentaire deight; « strict » ou « de base » attendu", + "protocolVarianceContravariant": "La variable de type \"{variable}\" utilisée dans le Protocol générique \"{class}\" doit être contravariante", + "protocolVarianceCovariant": "La variable de type \"{variable}\" utilisée dans le Protocol générique \"{class}\" doit être covariante", + "protocolVarianceInvariant": "La variable de type \"{variable}\" utilisée dans le Protocol générique \"{class}\" doit être invariante", + "pyrightCommentInvalidDiagnosticBoolValue": "La directive de commentaire Pyright doit être suivie de « = » et d’une valeur true ou false", + "pyrightCommentInvalidDiagnosticSeverityValue": "La directive de commentaire Pyright doit être suivie de « = » et avoir la valeur true, false, error, warning, information ou none", + "pyrightCommentMissingDirective": "Le commentaire Pyright doit être suivi d’une directive (basic ou strict) ou d’une règle de diagnostic", + "pyrightCommentNotOnOwnLine": "Les commentaires Pyright utilisés pour contrôler les paramètres au niveau du fichier doivent apparaître sur leur propre ligne", + "pyrightCommentUnknownDiagnosticRule": "« {rule} » est une règle de diagnostic inconnue pour le commentaire pyright", + "pyrightCommentUnknownDiagnosticSeverityValue": "« {value} » n’est pas valide pour le commentaire pyright ; true, false, error, warning, information ou none attendu", + "pyrightCommentUnknownDirective": "« {directive} » est une directive inconnue pour le commentaire pyright; « strict » ou « basic » attendu", "readOnlyArgCount": "Attendu un seul argument de type après \"ReadOnly\"", "readOnlyNotInTypedDict": "« ReadOnly » n’est pas autorisé dans ce contexte", "recursiveDefinition": "Le type de \"{name}\" n'a pas pu être déterminé car il fait référence à lui-même", - "relativeImportNotAllowed": "Les importations relatives ne peuvent pas être utilisées avec le formulaire « import .a » ; utiliser « à partir de . importer a » à la place", + "relativeImportNotAllowed": "Les importations relatives ne peuvent pas être utilisées avec le formulaire « import .a » ; utiliser « from . import a » à la place", "requiredArgCount": "Attendu un argument de type unique après \"Required\"", - "requiredNotInTypedDict": "« Obligatoire » n’est pas autorisé dans ce contexte", + "requiredNotInTypedDict": "« Required » n’est pas autorisé dans ce contexte", "returnInAsyncGenerator": "L'instruction de retour avec valeur n'est pas autorisée dans le générateur asynchrone", "returnMissing": "La fonction avec le type de retour déclaré \"{returnType}\" doit renvoyer une valeur sur tous les chemins de code", "returnOutsideFunction": "\"return\" ne peut être utilisé que dans une fonction", "returnTypeContravariant": "La variable de type contravariant ne peut pas être utilisée dans le type de retour", - "returnTypeMismatch": "L’expression de type « {exprType} » est incompatible avec le type de retour « {returnType} »", + "returnTypeMismatch": "Le type « {exprType} » n’est pas assignable au type de retour « {returnType} »", "returnTypePartiallyUnknown": "Le type de retour « {returnType} » est partiellement inconnu", "returnTypeUnknown": "Le type de retour est inconnu", "revealLocalsArgs": "Aucun argument attendu pour l'appel \"reveal_locals\"", - "revealLocalsNone": "Aucun élément local dans cette étendue", + "revealLocalsNone": "Aucun élément locals dans cette étendue", "revealTypeArgs": "Argument positionnel unique attendu pour l’appel « reveal_type »", "revealTypeExpectedTextArg": "L'argument \"expected_text\" pour la fonction \"reveal_type\" doit être une valeur littérale str", "revealTypeExpectedTextMismatch": "Incompatibilité de texte de type ; « {expected} » attendu, mais a reçu « {received} »", @@ -439,7 +440,7 @@ "selfTypeContext": "« Self » n’est pas valide dans ce contexte", "selfTypeMetaclass": "« Self » ne peut pas être utilisé dans une métaclasse (une sous-classe de « type »)", "selfTypeWithTypedSelfOrCls": "« Self » ne peut pas être utilisé dans une fonction avec un paramètre « self » ou « cls » qui a une annotation de type autre que « Self »", - "setterGetterTypeMismatch": "Le type valeur setter de propriété n’est pas assignable au type de retour getter", + "setterGetterTypeMismatch": "Le type valeur setter de property n’est pas assignable au type de retour getter", "singleOverload": "« {name} » est marqué comme surcharge, mais des surcharges supplémentaires sont manquantes", "slotsAttributeError": "\"{name}\" n'est pas spécifié dans __slots__", "slotsClassVarConflict": "\"{name}\" est en conflit avec la variable d'instance déclarée dans __slots__", @@ -449,12 +450,12 @@ "staticClsSelfParam": "Les méthodes statiques ne doivent pas prendre de paramètre « self » ou « cls »", "stdlibModuleOverridden": "\"{path}\" remplace le module stdlib \"{name}\"", "stringNonAsciiBytes": "Caractère non-ASCII non autorisé dans le littéral de chaîne d'octets", - "stringNotSubscriptable": "L’expression de chaîne ne peut pas être en indice dans l’annotation de type ; placer l’annotation entière entre guillemets", + "stringNotSubscriptable": "L'expression de chaîne ne peut pas être indexée dans une expression de type ; placez l'expression entière entre guillemets", "stringUnsupportedEscape": "Séquence d'échappement non prise en charge dans le littéral de chaîne", "stringUnterminated": "Le littéral de chaîne n’est pas spécifié", "stubFileMissing": "Fichier stub introuvable pour « {importName} »", "stubUsesGetAttr": "Le fichier stub de type est incomplet ; « __getattr__ » masque les erreurs de type pour le module", - "sublistParamsIncompatible": "Les paramètres de sous-liste ne sont pas pris en charge dans Python 3.x", + "sublistParamsIncompatible": "Les paramètres de Sublist ne sont pas pris en charge dans Python 3.x", "superCallArgCount": "Pas plus de deux arguments attendus pour l'appel \"super\"", "superCallFirstArg": "Type de classe attendu en tant que premier argument de l’appel « super », mais « {type} » reçu", "superCallSecondArg": "Le deuxième argument de l’appel « super » doit être un objet ou une classe dérivé de « {type} »", @@ -464,12 +465,12 @@ "symbolIsUnbound": "« {name} » est indépendant", "symbolIsUndefined": "« {name} » n’est pas défini", "symbolOverridden": "« {name} » remplace le symbole du même nom dans la classe « {className} »", - "ternaryNotAllowed": "Expression ternaire non autorisée dans l’annotation de type", + "ternaryNotAllowed": "Expression ternaire non autorisée dans l'expression de type", "totalOrderingMissingMethod": "La classe doit définir « __lt__ », « __le__ », « __gt__ » ou « __ge__ » pour utiliser total_ordering", "trailingCommaInFromImport": "Virgule de fin non autorisée sans parenthèses adjacentes", "tryWithoutExcept": "L'instruction try doit avoir au moins une clause except ou finally", "tupleAssignmentMismatch": "L'expression avec le type \"{type}\" ne peut pas être assignée au tuple cible", - "tupleInAnnotation": "Expression de tuple non autorisée dans l'annotation de type", + "tupleInAnnotation": "Expression de tuple non autorisée dans l'expression de type", "tupleIndexOutOfRange": "L’index {index} est hors limites pour le type {type}", "typeAliasIllegalExpressionForm": "Formulaire d’expression non valide pour la définition d’alias de type", "typeAliasIsRecursiveDirect": "L'alias de type \"{name}\" ne peut pas s'utiliser lui-même dans sa définition", @@ -477,7 +478,7 @@ "typeAliasRedeclared": "« {name} » est déclaré en tant que TypeAlias et ne peut être attribué qu’une seule fois", "typeAliasStatementBadScope": "Une instruction de type ne peut être utilisée que dans une étendue de module ou de classe", "typeAliasStatementIllegal": "L’instruction d’alias de type nécessite Python 3.12 ou version ultérieure", - "typeAliasTypeBaseClass": "Un alias de type défini dans une instruction « type » ne peut pas être utilisé en tant que classe de base", + "typeAliasTypeBaseClass": "A type alias defined in a \"type\" statement cannot be used as a base class", "typeAliasTypeMustBeAssigned": "TypeAliasType doit être affecté à une variable portant le même nom que l'alias de type", "typeAliasTypeNameArg": "Le premier argument de TypeAliasType doit être un littéral de chaîne représentant le nom de l'alias de type", "typeAliasTypeNameMismatch": "Le nom de l’alias de type doit correspondre au nom de la variable à laquelle il est affecté", @@ -493,16 +494,17 @@ "typeArgsMissingForClass": "Arguments de type attendus pour la classe générique \"{name}\"", "typeArgsTooFew": "Trop peu d’arguments de type fournis pour « {name} » ; {expected} attendu, mais {received} reçu", "typeArgsTooMany": "Trop d'arguments de type fournis pour \"{name}\" ; attendu {expected} mais reçu {received}", - "typeAssignmentMismatch": "L’expression de type « {sourceType} » est incompatible avec le type déclaré « {destType} »", - "typeAssignmentMismatchWildcard": "Le symbole d’importation « {name} » a le type « {sourceType} » qui n’est pas compatible avec le type déclaré « {destType} »", - "typeCallNotAllowed": "l’appel type() ne doit pas être utilisé dans l’annotation de type", + "typeAssignmentMismatch": "Le type « {sourceType} » n’est pas assignable au type déclaré « {destType} »", + "typeAssignmentMismatchWildcard": "Le symbole d’importation « {name} » a le type « {sourceType} », qui n’est pas assignable au type déclaré « {destType} »", + "typeCallNotAllowed": "l'appel type() ne doit pas être utilisé dans une expression de type", "typeCheckOnly": "\"{name}\" est marqué comme @type_check_only et ne peut être utilisé que dans les annotations de type", "typeCommentDeprecated": "L’utilisation de commentaires de type est déconseillée ; utiliser l’annotation de type à la place", "typeExpectedClass": "Classe attendue mais « {type} » reçu", - "typeGuardArgCount": "Argument de type unique attendu après « TypeGuard » ou « Typels »", + "typeFormArgs": "« TypeForm » accepte un seul argument positionnel", + "typeGuardArgCount": "Argument de type unique attendu après « TypeGuard » ou « TypeIs »", "typeGuardParamCount": "Les méthodes et fonctions de protection de type définies par l’utilisateur doivent avoir au moins un paramètre d’entrée", - "typeIsReturnType": "Le type de retour des TypesIs (« {returnType} ») n’est pas cohérent avec le type de paramètre de valeur (« {type} »)", - "typeNotAwaitable": "\"{type}\" n'est pas attendu", + "typeIsReturnType": "Le type de retour des TypeIs (« {returnType} ») n’est pas cohérent avec le type de paramètre de valeur (« {type} »)", + "typeNotAwaitable": "« {type} » n’est pas awaitable", "typeNotIntantiable": "« {type} » ne peut pas être instancié", "typeNotIterable": "« {type} » n’est pas itérable", "typeNotSpecializable": "Impossible de spécialiser le type \"{type}\"", @@ -552,16 +554,16 @@ "typedDictBadVar": "Les classes TypedDict ne peuvent contenir que des annotations de type", "typedDictBaseClass": "Toutes les classes de base pour les classes TypedDict doivent également être des classes TypedDict", "typedDictBoolParam": "Paramètre « {name} » attendu avec la valeur True ou False", - "typedDictClosedExtras": "La classe de base « {name} » est un TypedDict fermé, les éléments supplémentaires doivent être de type « {type} »", - "typedDictClosedNoExtras": "La classe de base « {name} » est un TypedDict fermé, les éléments supplémentaires ne sont pas autorisés", + "typedDictClosedExtras": "La classe de base « {name} » est un TypedDict closed, les éléments supplémentaires doivent être de type « {type} »", + "typedDictClosedNoExtras": "La classe de base « {name} » est un TypedDict closed, les éléments supplémentaires ne sont pas autorisés", "typedDictDelete": "Impossible de supprimer l’élément dans TypedDict", "typedDictEmptyName": "Les noms dans un TypedDict ne peuvent pas être vides", "typedDictEntryName": "Littéral de chaîne attendu pour le nom d’entrée du dictionnaire", "typedDictEntryUnique": "Les noms dans un dictionnaire doivent être uniques", "typedDictExtraArgs": "Arguments TypedDict supplémentaires non pris en charge", - "typedDictFieldNotRequiredRedefinition": "L’élément TypedDict « {name} » ne peut pas être redéfini comme étant Non requis", - "typedDictFieldReadOnlyRedefinition": "L’élément TypedDict « {name} » ne peut pas être redéfini comme état En lecture seule", - "typedDictFieldRequiredRedefinition": "L’élément TypedDict « {name} » ne peut pas être redéfini comme étant Requis", + "typedDictFieldNotRequiredRedefinition": "L’élément TypedDict « {name} » ne peut pas être redéfini comme étant NotRequired", + "typedDictFieldReadOnlyRedefinition": "L’élément TypedDict « {name} » ne peut pas être redéfini comme état En ReadOnly", + "typedDictFieldRequiredRedefinition": "L’élément TypedDict « {name} » ne peut pas être redéfini comme étant Required", "typedDictFirstArg": "Nom de classe TypedDict attendu comme premier argument", "typedDictInitsubclassParameter": "TypedDict ne prend pas en charge __init_subclass__ paramètre « {name} »", "typedDictNotAllowed": "\"TypedDict\" ne peut pas être utilisé dans ce contexte", @@ -574,7 +576,7 @@ "unaccessedSymbol": "« {name} » n’est pas accessible", "unaccessedVariable": "La variable « {name} » n’est pas accessible", "unannotatedFunctionSkipped": "L'analyse de la fonction \"{name}\" est ignorée car elle n'est pas annotée", - "unaryOperationNotAllowed": "Opérateur unaire non autorisé dans l’annotation de type", + "unaryOperationNotAllowed": "L'opérateur unaire n'est pas autorisé dans l'expression de type", "unexpectedAsyncToken": "« def », « with » ou « for » attendu pour suivre « async »", "unexpectedExprToken": "Jeton inattendu à la fin de l’expression", "unexpectedIndent": "Retrait inattendu", @@ -585,23 +587,23 @@ "uninitializedInstanceVariable": "La variable d’instance « {name} » n’est pas initialisée dans le corps de la classe ou dans la méthode __init__", "unionForwardReferenceNotAllowed": "La syntaxe Union ne peut pas être utilisée avec l’opérande de chaîne ; utiliser des guillemets autour de l’expression entière", "unionSyntaxIllegal": "Une autre syntaxe pour les unions nécessite Python 3.10 ou une version plus récente", - "unionTypeArgCount": "L’union requiert au moins deux arguments de type", + "unionTypeArgCount": "L’Union requiert au moins deux arguments de type", "unionUnpackedTuple": "Union ne peut pas inclure un tuple décompressé", "unionUnpackedTypeVarTuple": "Union ne peut pas inclure un TypeVarTuple décompressé", "unnecessaryCast": "Appel \"cast\" inutile ; le type est déjà \"{type}\"", "unnecessaryIsInstanceAlways": "Appel d’isinstance inutile ; « {testType} » est toujours une instance de « {classType} »", "unnecessaryIsSubclassAlways": "Appel issubclass inutile ; \"{testType}\" est toujours une sous-classe de \"{classType}\"", "unnecessaryPyrightIgnore": "Commentaire \"# pyright: ignore\" inutile", - "unnecessaryPyrightIgnoreRule": "Règle inutile « #ightight: ignore » : « {name} »", + "unnecessaryPyrightIgnoreRule": "Règle inutile « # pyright: ignore » : « {name} »", "unnecessaryTypeIgnore": "Commentaire \"# type: ignore\" inutile", "unpackArgCount": "Attendu un seul argument de type après \"Unpack\"", - "unpackExpectedTypeVarTuple": "TypeVarTuple ou tuple attendu en tant qu’argument de type pour décompresser", + "unpackExpectedTypeVarTuple": "TypeVarTuple ou tuple attendu en tant qu’argument de type pour Unpack", "unpackExpectedTypedDict": "Argument de type TypedDict attendu pour Unpack", "unpackIllegalInComprehension": "Opération de décompression non autorisée dans la compréhension", - "unpackInAnnotation": "Opérateur de décompression non autorisé dans l’annotation de type", + "unpackInAnnotation": "L'opérateur de déballage n'est pas autorisé dans l'expression de type", "unpackInDict": "Opération de décompression non autorisée dans les dictionnaires", - "unpackInSet": "Opérateur de déballage non autorisé dans un ensemble", - "unpackNotAllowed": "Le décompression n’est pas autorisé dans ce contexte", + "unpackInSet": "Opérateur de déballage non autorisé dans un set", + "unpackNotAllowed": "Le Unpack n’est pas autorisé dans ce contexte", "unpackOperatorNotAllowed": "L’opération de décompression n’est pas autorisée dans ce contexte", "unpackTuplesIllegal": "Opération de décompression non autorisée dans les tuples avant Python 3.8", "unpackedArgInTypeArgument": "Les arguments décompressés ne peuvent pas être utilisés dans ce contexte", @@ -619,33 +621,33 @@ "unusedCoroutine": "Le résultat de l’appel de fonction asynchrone n’est pas utilisé ; utiliser « await » ou affecter le résultat à la variable", "unusedExpression": "La valeur de l'expression n'est pas utilisée", "varAnnotationIllegal": "Les annotations de type pour les variables nécessitent Python 3.6 ou une version ultérieure ; utiliser le commentaire de type pour la compatibilité avec les versions précédentes", - "variableFinalOverride": "La variable « {name} » est marquée comme finale et remplace la variable non finale du même nom dans la classe « {className} »", + "variableFinalOverride": "La variable « {name} » est marquée comme Final et remplace la variable non-Final du même nom dans la classe « {className} »", "variadicTypeArgsTooMany": "La liste d’arguments de type peut avoir au plus un TypeVarTuple ou tuple décompressé", "variadicTypeParamTooManyAlias": "L’alias de type peut avoir au plus un paramètre de type TypeVarTuple, mais a reçu plusieurs ({names})", "variadicTypeParamTooManyClass": "La classe générique peut avoir au plus un paramètre de type TypeVarTuple, mais en a reçu plusieurs ({names})", "walrusIllegal": "L’opérateur « := » nécessite Python 3.8 ou version ultérieure", "walrusNotAllowed": "L’opérateur « := » n’est pas autorisé dans ce contexte sans parenthèses adjacentes", - "wildcardInFunction": "Importation de caractères génériques non autorisée dans une classe ou une fonction", - "wildcardLibraryImport": "Importation de caractères génériques à partir d'une bibliothèque non autorisée", + "wildcardInFunction": "import de caractères génériques non autorisée dans une classe ou une fonction", + "wildcardLibraryImport": "import de caractères génériques à partir d’une bibliothèque non autorisée", "wildcardPatternTypePartiallyUnknown": "Le type capturé par le modèle générique est partiellement inconnu", "wildcardPatternTypeUnknown": "Le type capturé par le modèle générique est inconnu", "yieldFromIllegal": "L’utilisation de « yield from » nécessite Python 3.3 ou version ultérieure", "yieldFromOutsideAsync": "« yield from » non autorisé dans une fonction asynchrone", - "yieldOutsideFunction": "\"rendement\" non autorisé en dehors d'une fonction ou d'un lambda", + "yieldOutsideFunction": "« yield » non autorisé en dehors d’une fonction ou d’un lambda", "yieldWithinComprehension": "« yield » n’est pas autorisé dans une compréhension de liste", - "zeroCaseStatementsFound": "L'instruction de correspondance doit inclure au moins une instruction case", + "zeroCaseStatementsFound": "L’instruction de Match doit inclure au moins une instruction case", "zeroLengthTupleNotAllowed": "Le tuple de longueur nulle n’est pas autorisé dans ce contexte" }, "DiagnosticAddendum": { - "annotatedNotAllowed": "Impossible d’utiliser le formulaire spécial « Annoté » avec les vérifications d’instance et de classe", + "annotatedNotAllowed": "Impossible d’utiliser le formulaire spécial « Annotated » avec les vérifications d’instance et de classe", "argParam": "L’argument correspond au paramètre « {paramName} »", "argParamFunction": "L’argument correspond au paramètre « {paramName} » dans la fonction « {functionName} »", "argsParamMissing": "Le paramètre \"*{paramName}\" n'a pas de paramètre correspondant", "argsPositionOnly": "Non-concordance des paramètres de position uniquement ; attendu {expected} mais reçu {received}", "argumentType": "Le type d’argument est « {type} »", "argumentTypes": "Types d'argument : ({types})", - "assignToNone": "Type est incompatible avec « None »", - "asyncHelp": "Vouliez-vous dire \"asynchrone avec\" ?", + "assignToNone": "Le type n’est pas assignable à « None »", + "asyncHelp": "Vouliez-vous dire « async with » ?", "baseClassIncompatible": "La classe de base « {baseClass} » n’est pas compatible avec le type « {type} »", "baseClassIncompatibleSubclass": "La classe de base « {baseClass} » dérive de « {subclass} » qui est incompatible avec le type « {type} »", "baseClassOverriddenType": "La classe de base « {baseClass} » fournit le type « {type} », qui est remplacé", @@ -657,7 +659,7 @@ "dataProtocolUnsupported": "« {name} » est un protocole de données", "descriptorAccessBindingFailed": "Échec de la liaison du « {name} » de méthode pour la classe de descripteur « {className} »", "descriptorAccessCallFailed": "Échec de l’appel du « {name} » de méthode pour la classe de descripteur « {className} »", - "finalMethod": "Méthode finale", + "finalMethod": "Méthode Final", "functionParamDefaultMissing": "Le paramètre \"{name}\" n'a pas d'argument par défaut", "functionParamName": "Incompatibilité de nom de paramètre : « {destName} » et « {srcName} »", "functionParamPositionOnly": "Non-correspondance des paramètres position uniquement ; le paramètre « {name} » n’est pas en position seule", @@ -665,9 +667,9 @@ "functionTooFewParams": "La fonction accepte trop peu de paramètres positionnels ; {expected} attendu, mais {received} reçu", "functionTooManyParams": "La fonction accepte trop de paramètres positionnels ; {expected} attendu, mais {received} reçu", "genericClassNotAllowed": "Type générique avec des arguments de type non autorisé pour les vérifications d’instance ou de classe", - "incompatibleDeleter": "La méthode du deleter de propriété n’est pas compatible", - "incompatibleGetter": "La méthode de récupération de propriété est incompatible", - "incompatibleSetter": "La méthode setter de propriété n’est pas compatible", + "incompatibleDeleter": "La méthode du deleter de property n’est pas compatible", + "incompatibleGetter": "La méthode de getter de property est incompatible", + "incompatibleSetter": "La méthode setter de property n’est pas compatible", "initMethodLocation": "La méthode __init__ est définie dans la classe « {type} »", "initMethodSignature": "La signature de __init__ est « {type} »", "initSubclassLocation": "La méthode __init_subclass__ est définie dans la classe « {name} »", @@ -681,14 +683,14 @@ "keyUndefined": "« {name} » n’est pas une clé définie dans « {type} »", "kwargsParamMissing": "Le paramètre \"**{paramName}\" n'a pas de paramètre correspondant", "listAssignmentMismatch": "Le type « {type} » n’est pas compatible avec la liste cible", - "literalAssignmentMismatch": "« {sourceType} » n’est pas compatible avec le type « {destType} »", + "literalAssignmentMismatch": "« {sourceType} » n’est pas assignable au type « {destType} »", "matchIsNotExhaustiveHint": "Si la gestion exhaustive n’est pas prévue, ajoutez « case _: pass »", "matchIsNotExhaustiveType": "Type non géré : « {type} »", "memberAssignment": "L'expression de type « {type} » ne peut pas être attribuée à l’attribut « {name} » de la classe « {classType} »", "memberIsAbstract": "« {type}.{name} » n’est pas implémenté", "memberIsAbstractMore": "et {count} autres...", "memberIsClassVarInProtocol": "« {name} » est défini en tant que ClassVar dans le protocole", - "memberIsInitVar": "« {name} » est un champ d’initialisation uniquement", + "memberIsInitVar": "« {name} » est un champ init-only", "memberIsInvariant": "« {name} » est invariant, car il est mutable", "memberIsNotClassVarInClass": "« {name} » doit être défini en tant que ClassVar pour être compatible avec le protocole", "memberIsNotClassVarInProtocol": "« {name} » n’est pas défini en tant que ClassVar dans le protocole", @@ -699,9 +701,9 @@ "memberTypeMismatch": "« {name} » est un type incompatible", "memberUnknown": "L’attribut « {name} » est inconnu", "metaclassConflict": "La métaclasse « {metaclass1} » est en conflit avec « {metaclass2} »", - "missingDeleter": "La méthode de suppression de propriétés est manquante", - "missingGetter": "La méthode getter de propriété est manquante", - "missingSetter": "La méthode de définition de propriété est manquante", + "missingDeleter": "La méthode de deleter de property est manquante", + "missingGetter": "La méthode getter de property est manquante", + "missingSetter": "setter de définition de property est manquante", "namedParamMissingInDest": "Paramètre supplémentaire « {name} »", "namedParamMissingInSource": "Paramètre de mot clé manquant « {name} »", "namedParamTypeMismatch": "Le paramètre de mot clé « {name} » de type « {sourceType} » est incompatible avec le type « {destType} »", @@ -710,7 +712,7 @@ "newMethodSignature": "La signature de __new__ est « {type} »", "newTypeClassNotAllowed": "La classe créée avec NewType ne peut pas être utilisée avec des vérifications de instance et de classe", "noOverloadAssignable": "Aucune fonction surchargée ne correspond au type « {type} »", - "noneNotAllowed": "Aucun ne peut être utilisé pour les vérifications de instance ou de classe", + "noneNotAllowed": "None ne peut être utilisé pour les vérifications de instance ou de classe", "orPatternMissingName": "Noms manquants : {name}", "overloadIndex": "La surcharge {index} est la correspondance la plus proche", "overloadNotAssignable": "Une ou plusieurs surcharges de « {name} » ne sont pas assignables", @@ -741,16 +743,16 @@ "paramType": "Le type de paramètre est « {paramType} »", "privateImportFromPyTypedSource": "Importer à partir de « {module} » à la place", "propertyAccessFromProtocolClass": "Une propriété définie dans une classe de protocole n'est pas accessible en tant que variable de classe", - "propertyMethodIncompatible": "La méthode de propriété « {name} » n’est pas compatible", - "propertyMethodMissing": "La méthode de propriété \"{name}\" est manquante dans le remplacement", - "propertyMissingDeleter": "La propriété « {name} » n’a pas de deleter défini", - "propertyMissingSetter": "La propriété « {name} » n’a pas de méthode setter définie", + "propertyMethodIncompatible": "La méthode de property « {name} » n’est pas compatible", + "propertyMethodMissing": "La méthode de property « {name} » est manquante dans le remplacement", + "propertyMissingDeleter": "La property « {name} » n’a pas de deleter défini", + "propertyMissingSetter": "La property « {name} » n’a pas de méthode setter définie", "protocolIncompatible": "\"{sourceType}\" est incompatible avec le protocole \"{destType}\"", "protocolMemberMissing": "« {name} » n’est pas présent", - "protocolRequiresRuntimeCheckable": "La classe de protocole doit être @runtime_checkable à utiliser avec des vérifications d’instance et de classe", + "protocolRequiresRuntimeCheckable": "La classe de Protocol doit être @runtime_checkable à utiliser avec des vérifications d’instance et de classe", "protocolSourceIsNotConcrete": "\"{sourceType}\" n'est pas un type de classe concret et ne peut pas être affecté au type \"{destType}\"", "protocolUnsafeOverlap": "Les attributs de « {name} » ont les mêmes noms que le protocole", - "pyrightCommentIgnoreTip": "Utilisez « #ight: ignore[] pour supprimer les diagnostics pour une seule ligne", + "pyrightCommentIgnoreTip": "Utilisez « # pyright: ignore[] » pour supprimer les diagnostics pour une seule ligne", "readOnlyAttribute": "L’attribut « {name} » est en lecture seule", "seeClassDeclaration": "Voir la déclaration de classe", "seeDeclaration": "Voir la déclaration", @@ -766,10 +768,10 @@ "tupleSizeMismatch": "Incompatibilité de taille de tuple ; attendu {expected} mais reçu {received}", "tupleSizeMismatchIndeterminateDest": "Incompatibilité de taille de tuple : attente de {expected} ou plus, mais réception de {received}", "typeAliasInstanceCheck": "L’alias de type créé avec l’instruction « type » ne peut pas être utilisé avec des vérifications d’instance et de classe", - "typeAssignmentMismatch": "Le type « {sourceType} » n’est pas compatible avec le type « {destType} »", - "typeBound": "Le type « {sourceType} » n’est pas compatible avec le type lié « {destType} » pour la variable de type « {name} »", - "typeConstrainedTypeVar": "Le «{type}» de type n’est pas compatible avec les «{name}» de variable de type contrainte", - "typeIncompatible": "« {sourceType} » n’est pas compatible avec « {destType} »", + "typeAssignmentMismatch": "Le type « {sourceType} » n’est pas assignable au type « {destType} »", + "typeBound": "Le type « {sourceType} » n’est pas assignable à la limite supérieure « {destType} » pour la variable de type « {name} »", + "typeConstrainedTypeVar": "Le type « {type} » n’est pas assignable à la variable de type contrainte « {name} »", + "typeIncompatible": "« {sourceType} » n’est pas assignable à « {destType} »", "typeNotClass": "« {type} » n’est pas une classe", "typeNotStringLiteral": "\"{type}\" n'est pas un littéral de chaîne", "typeOfSymbol": "Le type de \"{name}\" est \"{type}\"", @@ -788,7 +790,7 @@ "typedDictClassNotAllowed": "Classe TypedDict non autorisée pour les vérifications d’instance ou de classe", "typedDictClosedExtraNotAllowed": "Impossible d’ajouter l’élément « {name} »", "typedDictClosedExtraTypeMismatch": "Impossible d’ajouter l’élément « {name} » avec le type « {type} »", - "typedDictClosedFieldNotRequired": "Impossible d’ajouter l’élément « {name} », car il doit être Non requis", + "typedDictClosedFieldNotRequired": "Impossible d’ajouter l’élément « {name} », car il doit être NotRequired", "typedDictExtraFieldNotAllowed": "« {name} » n’est pas présent dans « {type} »", "typedDictExtraFieldTypeMismatch": "Le type de « {name} » est incompatible avec le type « __extra_items__ » dans « {type} »", "typedDictFieldMissing": "« {name} » est manquant dans « {type} »", @@ -806,7 +808,7 @@ "useDictInstead": "Utilisez Dict[T1, T2] pour indiquer un type de dictionnaire", "useListInstead": "Utilisez List[T] pour indiquer un type de liste ou Union[T1, T2] pour indiquer un type d'union", "useTupleInstead": "Utiliser tuple[T1, ..., Tn] pour indiquer un type de tuple ou Union[T1, T2] pour indiquer un type d’union", - "useTypeInstead": "Utiliser le type[T] à la place", + "useTypeInstead": "Utiliser le Type[T] à la place", "varianceMismatchForClass": "La variance de l'argument de type \"{typeVarName}\" est incompatible avec la classe de base \"{className}\"", "varianceMismatchForTypeAlias": "La variance de l'argument de type \"{typeVarName}\" est incompatible avec \"{typeAliasParam}\"" }, diff --git a/packages/pyright-internal/src/localization/package.nls.it.json b/packages/pyright-internal/src/localization/package.nls.it.json index c44cc81ea..70a378d7c 100644 --- a/packages/pyright-internal/src/localization/package.nls.it.json +++ b/packages/pyright-internal/src/localization/package.nls.it.json @@ -1,7 +1,7 @@ { "CodeAction": { - "createTypeStub": "Crea stub di tipo", - "createTypeStubFor": "Crea stub di tipo per \"{moduleName}\"", + "createTypeStub": "Crea Stub di tipo", + "createTypeStubFor": "Crea Stub di tipo per \"{moduleName}\"", "executingCommand": "Esecuzione del comando", "filesToAnalyzeCount": "{count} file da analizzare", "filesToAnalyzeOne": "1 file da analizzare", @@ -18,12 +18,12 @@ "annotatedMetadataInconsistent": "Il tipo di metadati annotati \"{metadataType}\" non è compatibile con il tipo \"{type}\"", "annotatedParamCountMismatch": "Numero di annotazioni dei parametro non corrispondente: previsto {expected} ma ricevuto {received}", "annotatedTypeArgMissing": "Previsto un argomento di tipo e una o più annotazioni per \"Annotated\"", - "annotationBytesString": "Le annotazioni di tipo non possono usare valori letterali stringa byte", - "annotationFormatString": "Le annotazioni di tipo non possono usare valori letterali stringa di formato (stringhe f)", + "annotationBytesString": "Le espressioni di tipo non possono usare valori letterali stringa byte", + "annotationFormatString": "Le espressioni di tipo non possono usare valori letterali stringa di formato (stringhe f)", "annotationNotSupported": "Annotazione di tipo non supportata per questa istruzione", - "annotationRawString": "Le annotazioni di tipo non possono usare valori letterali stringa non elaborati", - "annotationSpansStrings": "Le annotazioni di tipo non possono estendersi su più valori letterali stringa", - "annotationStringEscape": "Le annotazioni di tipo non possono contenere caratteri di escape", + "annotationRawString": "Le espressioni di tipo non possono usare valori letterali stringa non elaborata", + "annotationSpansStrings": "Le espressioni di tipo non possono estendersi su più valori letterali stringa", + "annotationStringEscape": "Le espressioni di tipo non possono contenere caratteri di escape", "argAssignment": "Non è possibile assegnare l'argomento di tipo \"{argType}\" al parametro di tipo \"{paramType}\"", "argAssignmentFunction": "Non è possibile assegnare l'argomento di tipo \"{argType}\" al parametro di tipo \"{paramType}\" nella funzione \"{functionName}\"", "argAssignmentParam": "Non è possibile assegnare l'argomento di tipo \"{argType}\" al parametro \"{paramName}\" di tipo \"{paramType}\"", @@ -45,11 +45,11 @@ "assignmentExprInSubscript": "Le espressioni di assegnazione all'interno di un pedice sono supportate solo in Python 3.10 e versioni successive", "assignmentInProtocol": "Le variabili di istanza o di classe all'interno di una classe Protocollo devono essere dichiarate esplicitamente nel corpo della classe", "assignmentTargetExpr": "L'espressione non può essere una destinazione di assegnazione", - "asyncNotInAsyncFunction": "L'uso di \"async\" non è consentito al di fuori della funzione asincrona", + "asyncNotInAsyncFunction": "L'uso di \"async\" non è consentito al di fuori della funzione async", "awaitIllegal": "L'uso di \"await\" richiede Python 3.5 o versione successiva", - "awaitNotAllowed": "Le annotazioni di tipo non possono usare \"await\"", - "awaitNotInAsync": "\"await\" consentito solo all'interno della funzione asincrona", - "backticksIllegal": "Le espressioni racchiuse tra backticks non sono supportate in Python 3.x; usare la reimpostazione", + "awaitNotAllowed": "Le espressioni di tipo non possono usare \"await\"", + "awaitNotInAsync": "\"await\" consentito solo all'interno della funzione async", + "backticksIllegal": "Le espressioni racchiuse tra backticks non sono supportate in Python 3.x; usare repr invece", "baseClassCircular": "La classe non può derivare da se stessa", "baseClassFinal": "La classe di base \"{type}\" è contrassegnata come finale e non può essere sottoclassata", "baseClassIncompatible": "Le classi di base di {type} sono incompatibili tra di loro", @@ -57,7 +57,7 @@ "baseClassMethodTypeIncompatible": "Le classi di base per la classe \"{classType}\" definiscono il metodo \"{name}\" in modo incompatibile", "baseClassUnknown": "Il tipo della classe di base è sconosciuto. È in corso il tentativo di determinare il tipo della classe derivata", "baseClassVariableTypeIncompatible": "Le classi di base per la classe \"{classType}\" definiscono la variabile \"{name}\" in modo incompatibile", - "binaryOperationNotAllowed": "Operatore binario non consentito nell'annotazione di tipo", + "binaryOperationNotAllowed": "Operatore binario non consentito nell'espressione di tipo", "bindTypeMismatch": "Non è stato possibile associare il metodo \"{methodName}\" perché non è possibile assegnare\"{type}\" al parametro \"{paramName}\"", "breakOutsideLoop": "\"break\" può essere usato solo all'interno di un ciclo", "callableExtraArgs": "Sono previsti solo due argomenti di tipo per \"Callable\"", @@ -70,7 +70,7 @@ "classDefinitionCycle": "La definizione della classe per \"{name}\" dipende da se stessa", "classGetItemClsParam": "__class_getitem__ override deve accettare un parametro \"cls\"", "classMethodClsParam": "I metodi di classe devono accettare un parametro \"cls\"", - "classNotRuntimeSubscriptable": "Il pedice per la classe \"{name}\" genererà un'eccezione di runtime; racchiudere l'annotazione di tipo tra virgolette", + "classNotRuntimeSubscriptable": "Il pedice per la classe \"{name}\" genererà un'eccezione di runtime; racchiudere l'espressione di tipo tra virgolette", "classPatternBuiltInArgPositional": "Il modello di classe accetta solo un sotto pattern posizionale", "classPatternPositionalArgCount": "Troppi modelli posizionale per la classe \"{type}\"; previsto {expected} ma ottenuto {received}", "classPatternTypeAlias": "\"{type}\" non può essere usato in uno schema di classe, perché è un alias di tipo specializzato", @@ -88,9 +88,9 @@ "comparisonAlwaysTrue": "La condizione restituisce sempre True perché i tipi \"{leftType}\" e \"{rightType}\" non si sovrappongono", "comprehensionInDict": "Non è possibile usare la comprensione con altre voci del dizionario", "comprehensionInSet": "Non è possibile usare la comprensione con altre voci del set", - "concatenateContext": "“Concatena” non è consentito in questo contesto", + "concatenateContext": "“Concatenate” non è consentito in questo contesto", "concatenateParamSpecMissing": "L'ultimo argomento di tipo per \"Concatenate\" deve essere un ParamSpec o \"...\"", - "concatenateTypeArgsMissing": "\"Concatena\" richiede almeno due argomenti tipo", + "concatenateTypeArgsMissing": "\"Concatenate\" richiede almeno due argomenti di tipo", "conditionalOperandInvalid": "Operando condizionale non valido di tipo \"{type}\"", "constantRedefinition": "\"{name}\" è costante (perché è in maiuscolo) e non può essere ridefinita", "constructorParametersMismatch": "Mancata corrispondenza tra firma di __new__ e __init__ nella classe \"{classType}\"", @@ -111,7 +111,7 @@ "dataClassPostInitType": "Dataclass __post_init__ tipo di parametro del metodo non corrispondente per il campo \"{fieldName}\"", "dataClassSlotsOverwrite": "__slots__ è già definito nella classe", "dataClassTransformExpectedBoolLiteral": "Espressione prevista che restituisce in modo statico True o False", - "dataClassTransformFieldSpecifier": "È prevista una tupla di classi o funzioni ma è stato ricevuto il tipo \"{type}\"", + "dataClassTransformFieldSpecifier": "È prevista una tuple di classi o funzioni ma è stato ricevuto il tipo \"{type}\"", "dataClassTransformPositionalParam": "Tutti gli argomenti di \"dataclass_transform\" devono essere argomenti di parole chiave", "dataClassTransformUnknownArgument": "Argomento \"{name}\" non supportato da dataclass_transform", "dataProtocolInSubclassCheck": "I protocolli dati (che includono attributi non di metodo) non sono consentiti nelle chiamate issubclass", @@ -127,21 +127,21 @@ "deprecatedDescriptorSetter": "Il metodo \"__set__\" per il descrittore \"{name}\" è deprecato", "deprecatedFunction": "La funzione \"{name}\" è deprecata", "deprecatedMethod": "Il metodo \"{name}\" nella classe \"{className}\" è deprecato", - "deprecatedPropertyDeleter": "Il deleter per la proprietà \"{name}\" è deprecato", - "deprecatedPropertyGetter": "Il getter per la proprietà \"{name}\" è deprecato", - "deprecatedPropertySetter": "Il setter per la proprietà \"{name}\" è deprecato", + "deprecatedPropertyDeleter": "Il deleter per la property \"{name}\" è deprecato", + "deprecatedPropertyGetter": "Il getter per la property \"{name}\" è deprecato", + "deprecatedPropertySetter": "Il setter per la property \"{name}\" è deprecato", "deprecatedType": "Questo tipo è deprecato a partire da Python {version}; usa \"{replacement}\"", "dictExpandIllegalInComprehension": "Espansione del dizionario non consentita nella comprensione", - "dictInAnnotation": "Espressione dizionario non consentita nell'annotazione di tipo", + "dictInAnnotation": "Espressione dizionario non consentita nell'espressione di tipo", "dictKeyValuePairs": "Le voci del dizionario devono contenere coppie chiave-valore", "dictUnpackIsNotMapping": "Mapping previsto per l'operatore di decompressione del dizionario", "dunderAllSymbolNotPresent": "\"{name}\" è specificato in __all__ ma non è presente nel modulo", "duplicateArgsParam": "È consentito un solo parametro \"*\"", "duplicateBaseClass": "Classe di base duplicata non consentita", "duplicateCapturePatternTarget": "La destinazione di acquisizione \"{name}\" non può comparire più di una volta all'interno dello stesso schema", - "duplicateCatchAll": "È consentita una sola clausola catch-all tranne", - "duplicateEnumMember": "Il membro di enumerazione \"{name}\" è già dichiarato", - "duplicateGenericAndProtocolBase": "È consentita una sola classe di base Generic(...) o Protocol[...]", + "duplicateCatchAll": "È consentita una sola clausola catch-all except", + "duplicateEnumMember": "Il membro di Enum \"{name}\" è già dichiarato", + "duplicateGenericAndProtocolBase": "È consentita una sola classe di base Generic[...] o Protocol[...]", "duplicateImport": "\"{importName}\" è stato importato più di una volta", "duplicateKeywordOnly": "È consentito un solo separatore \"*\"", "duplicateKwargsParam": "È consentito un solo parametro \"**\"", @@ -149,13 +149,13 @@ "duplicatePositionOnly": "È consentito un solo parametro \"/\"", "duplicateStarPattern": "In una sequenza di criteri è consentito un solo criterio \"*\"", "duplicateStarStarPattern": "È consentita una sola voce \"**\"", - "duplicateUnpack": "Nell'elenco è consentita una sola operazione di decompressione", - "ellipsisAfterUnpacked": "\"...\" non può essere usato con una tupla o una tupla o TypeVarTuple non compressa", + "duplicateUnpack": "Nell list è consentita una sola operazione di decompressione", + "ellipsisAfterUnpacked": "\"...\" non può essere usato con un argomento TypeVarTuple non compresso o tuple", "ellipsisContext": "\"...\" non è consentito in questo contesto", "ellipsisSecondArg": "\"...\" è consentito solo come secondo di due argomenti", - "enumClassOverride": "La classe di enumerazione \"{name}\" è finale e non può essere sottoclassata", - "enumMemberDelete": "Non è possibile eliminare il membro di enumerazione \"{name}\"", - "enumMemberSet": "Non è possibile assegnare il membro di enumerazione \"{name}\"", + "enumClassOverride": "La classe di Enum \"{name}\" è finale e non può essere sottoclassificata", + "enumMemberDelete": "Non è possibile eliminare il membro di Enum \"{name}\"", + "enumMemberSet": "Non è possibile assegnare il membro di Enum \"{name}\"", "enumMemberTypeAnnotation": "Le annotazioni di tipo non sono consentite per i membri di enumerazione", "exceptionGroupIncompatible": "La sintassi del gruppo di eccezioni (\"except*\") richiede Python 3.11 o versione successiva", "exceptionGroupTypeIncorrect": "Il tipo di eccezione in except* non può derivare da BaseGroupException", @@ -182,14 +182,14 @@ "expectedElse": "Previsto \"else\"", "expectedEquals": "Previsto \"=\"", "expectedExceptionClass": "Classe od oggetto di eccezione non valido", - "expectedExceptionObj": "Previsto oggetto eccezione, classe eccezione o Nessuno", + "expectedExceptionObj": "Previsto oggetto eccezione, classe eccezione o None", "expectedExpr": "Espressione prevista", "expectedFunctionAfterAsync": "Prevista definizione di funzione dopo \"async\"", "expectedFunctionName": "È previsto un nome di funzione dopo \"def\"", "expectedIdentifier": "Identificatore previsto", "expectedImport": "Previsto \"import\"", "expectedImportAlias": "Simbolo previsto dopo \"as\"", - "expectedImportSymbols": "Sono previsti uno o più nomi di simboli dopo l'importazione", + "expectedImportSymbols": "Sono previsti uno o più nomi di simboli dopo “import”", "expectedIn": "previsto 'in'", "expectedInExpr": "Espressione prevista dopo \"in\"", "expectedIndentedBlock": "Previsto un blocco rientrato", @@ -234,7 +234,7 @@ "functionInConditionalExpression": "L'espressione condizionale fa riferimento a una funzione che restituisce sempre True", "functionTypeParametersIllegal": "La sintassi del parametro del tipo di funzione richiede Python 3.12 o versione successiva", "futureImportLocationNotAllowed": "Le importazioni da __future__ devono trovarsi all'inizio del file", - "generatorAsyncReturnType": "Il tipo restituito della funzione del generatore asincrono deve essere compatibile con \"AsyncGenerator[{yieldType}, Any]\"", + "generatorAsyncReturnType": "Il tipo restituito della funzione del generatore async deve essere compatibile con \"AsyncGenerator[{yieldType}, Any]\"", "generatorNotParenthesized": "Le espressioni del generatore devono essere racchiuse tra parentesi se non è l'unico argomento", "generatorSyncReturnType": "Il tipo restituito della funzione del generatore deve essere compatibile con \"Generator[{yieldType}, Any, Any]\"", "genericBaseClassNotAllowed": "Non è possibile usare la classe di base \"Generic\" con la sintassi del parametro di tipo", @@ -265,15 +265,15 @@ "instanceMethodSelfParam": "I metodi di istanza devono accettare un parametro \"self\"", "instanceVarOverridesClassVar": "La variabile di istanza \"{name}\" esegue l'override della variabile di classe con lo stesso nome nella classe \"{className}\"", "instantiateAbstract": "Non è possibile creare un'istanza di classe astratta \"{type}\"", - "instantiateProtocol": "Non è possibile creare un'istanza della classe di protocollo \"{type}\"", + "instantiateProtocol": "Non è possibile creare un'istanza della classe Protocol \"{type}\"", "internalBindError": "Errore interno durante l'associazione del file \"{file}\": {message}", "internalParseError": "Si è verificato un errore interno durante l'analisi del file \"{file}\": {message}", "internalTypeCheckingError": "Errore interno durante il controllo del tipo del file \"{file}\": {message}", "invalidIdentifierChar": "Carattere non valido nell'identificatore", "invalidStubStatement": "L'istruzione non ha significato all'interno di un file stub di tipo", "invalidTokenChars": "Carattere non valido \"{text}\" nel token", - "isInstanceInvalidType": "Il secondo argomento di \"isinstance\" deve essere una classe o una tupla di classi", - "isSubclassInvalidType": "Il secondo argomento di \"issubclass\" deve essere una classe o una tupla di classi", + "isInstanceInvalidType": "Il secondo argomento di \"isinstance\" deve essere una classe o una tuple di classi", + "isSubclassInvalidType": "Il secondo argomento di \"issubclass\" deve essere una classe o una tuple di classi", "keyValueInSet": "Le coppie chiave-valore non sono consentite all'interno di un set", "keywordArgInTypeArgument": "Gli argomenti delle parole chiave non possono essere usati negli elenchi di argomenti tipo", "keywordArgShortcutIllegal": "Il collegamento all'argomento della parola chiave richiede Python 3.14 o versione successiva", @@ -283,11 +283,11 @@ "lambdaReturnTypePartiallyUnknown": "Il tipo restituito dell'espressione lambda \"{returnType}\" è parzialmente sconosciuto", "lambdaReturnTypeUnknown": "Il tipo restituito di lambda è sconosciuto", "listAssignmentMismatch": "Non è possibile assegnare l'espressione con tipo \"{type}\" all'elenco di destinazione", - "listInAnnotation": "Espressione elenco non consentita nell'annotazione di tipo", - "literalEmptyArgs": "Previsto uno o più argomenti tipo dopo \"Valore letterale\"", + "listInAnnotation": "Espressione List non consentita nell'espressione type", + "literalEmptyArgs": "Sono previsti uno o più argomenti di tipo dopo \"Literal\"", "literalNamedUnicodeEscape": "Le sequenze di escape Unicode denominate non sono supportate nelle annotazioni stringa \"Literal\"", "literalNotAllowed": "Non è possibile usare \"Literal\" in questo contesto senza un argomento tipo", - "literalNotCallable": "Non è possibile creare un'istanza del tipo letterale", + "literalNotCallable": "Non è possibile creare un'istanza del tipo Literal", "literalUnsupportedType": "Gli argomenti di tipo per \"Literal\" devono essere None, un valore letterale (int, bool, str o bytes) o un valore di enumerazione", "matchIncompatible": "Le istruzioni match richiedono Python 3.10 o versione successiva", "matchIsNotExhaustive": "I case all'interno dell'istruzione match non gestiscono in modo completo tutti i valori", @@ -304,20 +304,21 @@ "methodOverridden": "\"{name}\" esegue l'override del metodo con lo stesso nome nella classe \"{className}\" con un tipo non compatibile \"{type}\".", "methodReturnsNonObject": "Il metodo \"{name}\" non restituisce un oggetto", "missingSuperCall": "Il metodo \"{methodName}\" non chiama il metodo con lo stesso nome nella classe padre", + "mixingBytesAndStr": "Bytes e valori str non possono essere concatenati", "moduleAsType": "Il modulo non può essere usato come tipo", "moduleNotCallable": "Modulo non chiamabile", "moduleUnknownMember": "\"{memberName}\" non è un attributo noto del modulo \"{moduleName}\"", "namedExceptAfterCatchAll": "Una clausola except denominata non può trovarsi dopo la clausola catch-all except", "namedParamAfterParamSpecArgs": "Il parametro della parola chiave \"{name}\" non può essere visualizzato nella firma dopo il parametro ParamSpec args", - "namedTupleEmptyName": "I nomi all'interno di una tupla denominata non possono essere vuoti", - "namedTupleEntryRedeclared": "Non è possibile eseguire l'override di \"{name}\" perché la classe padre \"{className}\" è una tupla denominata", - "namedTupleFirstArg": "Previsto nome della classe di tupla denominata come primo argomento", + "namedTupleEmptyName": "I nomi all'interno di un tuple denominato non possono essere vuoti", + "namedTupleEntryRedeclared": "Non è possibile eseguire l'override di \"{name}\" perché la classe padre \"{className}\" è un tuple denominato", + "namedTupleFirstArg": "È previsto il nome della classe di tuple denominata come primo argomento", "namedTupleMultipleInheritance": "L'ereditarietà multipla con NamedTuple non è supportata", "namedTupleNameKeyword": "I nomi dei campi non possono essere una parola chiave", - "namedTupleNameType": "Prevista tupla a due voci che specifica il nome e il tipo della voce", - "namedTupleNameUnique": "I nomi all'interno di una tupla denominata devono essere univoci", + "namedTupleNameType": "È prevista una tuple a due voci che specifica il nome e il tipo della voce", + "namedTupleNameUnique": "I nomi all'interno di una tuple denominata devono essere univoci", "namedTupleNoTypes": "\"namedtuple\" non fornisce tipi per le voci di tupla; usare invece \"NamedTuple\"", - "namedTupleSecondArg": "È previsto un elenco di voci di tupla denominate come secondo argomento", + "namedTupleSecondArg": "È previsto un list di voci di tuple denominate come secondo argomento", "newClsParam": "__new__ override deve accettare un parametro \"cls\"", "newTypeAnyOrUnknown": "Il secondo argomento di NewType deve essere una classe nota, non Any o Unknown", "newTypeBadName": "Il primo argomento di NewType deve essere un valore letterale stringa", @@ -325,20 +326,20 @@ "newTypeNameMismatch": "NewType deve essere assegnato a una variabile con lo stesso nome", "newTypeNotAClass": "Classe prevista come secondo argomento di NewType", "newTypeParamCount": "NewType richiede due argomenti posizionali", - "newTypeProtocolClass": "Non è possibile usare NewType con il tipo strutturale (un protocollo o una classe TypedDict)", + "newTypeProtocolClass": "Non è possibile usare NewType con il tipo strutturale (una classe Protocol o TypedDict)", "noOverload": "Nessun overload per \"{name}\" corrisponde agli argomenti specificati", - "noReturnContainsReturn": "La funzione con tipo restituito dichiarato \"NoReturn\" non può includere un'istruzione return", + "noReturnContainsReturn": "La funzione con tipo return dichiarato \"NoReturn\" non può includere un'istruzione return", "noReturnContainsYield": "La funzione con il tipo restituito dichiarato \"NoReturn\" non può includere un'istruzione yield", "noReturnReturnsNone": "La funzione con tipo restituito dichiarato \"NoReturn\" non può restituire \"None\"", "nonDefaultAfterDefault": "L'argomento non predefinito segue l'argomento predefinito", - "nonLocalInModule": "Dichiarazione non locale non consentita a livello di modulo", - "nonLocalNoBinding": "Non è stata trovata alcuna associazione per \"{name}\" non locale", - "nonLocalReassignment": "\"{name}\" è assegnato prima della dichiarazione non locale", - "nonLocalRedefinition": "\"{name}\" è già stato dichiarato non locale", + "nonLocalInModule": "Dichiarazione nonlocale non consentita a livello di modulo", + "nonLocalNoBinding": "Non è stata trovata alcuna associazione per \"{name}\" nonlocal", + "nonLocalReassignment": "\"{name}\" viene assegnato prima della dichiarazione nonlocal", + "nonLocalRedefinition": "\"{name}\" è già stato dichiarato nonlocal", "noneNotCallable": "Non è possibile chiamare l'oggetto di tipo \"None\"", "noneNotIterable": "Impossibile utilizzare l'oggetto di tipo \"None\" come valore iterabile", - "noneNotSubscriptable": "L'oggetto di tipo \"Nessuno\" non è sottoponibile a pedice", - "noneNotUsableWith": "Impossibile utilizzare l'oggetto di tipo \"None\" con \"with\"", + "noneNotSubscriptable": "L'oggetto di tipo \"None\" non è sottoponibile a pedice", + "noneNotUsableWith": "Object of type \"None\" cannot be used with \"with\"", "noneOperator": "Operatore \"{operator}\" non supportato per \"None\"", "noneUnknownMember": "\"{name}\" non è un attributo noto di \"None\"", "notRequiredArgCount": "Previsto un singolo argomento tipo dopo \"NotRequired\"", @@ -351,8 +352,8 @@ "obscuredTypeAliasDeclaration": "La dichiarazione dell'alias di tipo \"{name}\" è nascosta da una dichiarazione con lo stesso nome", "obscuredVariableDeclaration": "La dichiarazione \"{name}\" è oscurata da una dichiarazione con lo stesso nome", "operatorLessOrGreaterDeprecated": "L'operatore \"<>\" non è supportato in Python 3. Usare invece \"!=\"", - "optionalExtraArgs": "Previsto un argomento tipo dopo \"Facoltativo\"", - "orPatternIrrefutable": "Criterio inconfutabile consentito solo come ultimo criterio secondario in un criterio \"o\"", + "optionalExtraArgs": "È previsto un argomento di tipo dopo \"Optional\"", + "orPatternIrrefutable": "Criterio inconfutabile consentito solo come ultimo criterio secondario in un criterio \"or\"", "orPatternMissingName": "Tutti i criteri secondari all'interno di un criterio \"or\" devono avere come destinazione gli stessi nomi", "overlappingKeywordArgs": "Il dizionario tipizzato si sovrappone al parametro della parola chiave: {names}", "overlappingOverload": "L'overload {obscured} per \"{name}\" non verrà mai usato perché i parametri si sovrappongono all'overload {obscuredBy}", @@ -377,9 +378,9 @@ "paramSpecArgsUsage": "L'attributo \"args\" di ParamSpec è valido solo se usato con il parametro *args", "paramSpecAssignedName": "ParamSpec deve essere assegnato a una variabile denominata \"{name}\"", "paramSpecContext": "ParamSpec non è consentito in questo contesto", - "paramSpecDefaultNotTuple": "Sono previsti puntini di sospensione, un'espressione di tupla o ParamSpec per il valore predefinito di ParamSpec", + "paramSpecDefaultNotTuple": "Sono previsti puntini di sospensione, un'espressione di tuple o ParamSpec per il valore predefinito di ParamSpec", "paramSpecFirstArg": "Nome previsto di ParamSpec come primo argomento", - "paramSpecKwargsUsage": "L'attributo \"kwargs\" di ParamSpec è valido solo se usato con il parametro *kwargs", + "paramSpecKwargsUsage": "L'attributo \"kwargs\" di ParamSpec è valido solo se usato con il parametro **kwargs", "paramSpecNotUsedByOuterScope": "ParamSpec \"{name}\" non ha significato in questo contesto", "paramSpecUnknownArg": "ParamSpec non supporta più di un argomento", "paramSpecUnknownMember": "\"{name}\" non è un attributo noto di ParamSpec", @@ -387,7 +388,7 @@ "paramTypeCovariant": "Non è possibile usare la variabile di tipo covariante nel tipo di parametro", "paramTypePartiallyUnknown": "Tipo di parametro \"{paramName}\" parzialmente sconosciuto", "paramTypeUnknown": "Tipo di parametro \"{paramName}\" sconosciuto", - "parenthesizedContextManagerIllegal": "Le parentesi all'interno dell'istruzione \"con\" richiedono Python 3.9 o versione successiva", + "parenthesizedContextManagerIllegal": "Parentheses within \"with\" statement requires Python 3.9 or newer", "patternNeverMatches": "Il criterio non verrà mai confrontato per il tipo di oggetto \"{type}\"", "positionArgAfterNamedArg": "L'argomento posizionale non può essere visualizzato dopo gli argomenti della parola chiave", "positionOnlyAfterArgs": "Separatore di parametri di sola posizione non consentito dopo il parametro \"*\"", @@ -398,21 +399,21 @@ "privateImportFromPyTypedModule": "\"{name}\" non è esportato dal modulo \"{module}\"", "privateUsedOutsideOfClass": "\"{name}\" è privato e utilizzato all'esterno del modulo in cui è dichiarato", "privateUsedOutsideOfModule": "\"{name}\" è privato e utilizzato all'esterno del modulo in cui è dichiarato", - "propertyOverridden": "\"{name}\" esegue erroneamente l’override di una proprietà con lo stesso nome nella classe \"{className}\"", - "propertyStaticMethod": "Metodi statici non consentiti per getter, setter o deleter di proprietà", + "propertyOverridden": "\"{name}\" esegue erroneamente l’override di una property con lo stesso nome nella classe \"{className}\"", + "propertyStaticMethod": "Metodi statici non consentiti per getter, setter o deleter di property", "protectedUsedOutsideOfClass": "\"{name}\" è protetto e usato al di fuori della classe in cui è dichiarato", - "protocolBaseClass": "La classe di protocollo \"{classType}\" non può derivare dalla classe non di protocollo \"{baseType}\".", + "protocolBaseClass": "La classe Protocol \"{classType}\" non può derivare dalla classe non Protocol \"{baseType}\"", "protocolBaseClassWithTypeArgs": "Gli argomenti tipo non sono consentiti con la classe Protocollo quando si usa la sintassi dei parametri tipo", - "protocolIllegal": "L'uso del \"protocollo\" richiede Python 3.7 o versione successiva", + "protocolIllegal": "L'uso di \"Protocol\" richiede Python 3.7 o versione successiva", "protocolNotAllowed": "\"Protocol\" non può essere usato in questo contesto", "protocolTypeArgMustBeTypeParam": "L'argomento di tipo per \"Protocol\" deve essere un parametro di tipo", "protocolUnsafeOverlap": "La classe si sovrappone a \"{name}\" in modo non sicuro e può produrre una corrispondenza in fase di esecuzione", - "protocolVarianceContravariant": "La variabile di tipo \"{variable}\" usata nel protocollo generico \"{class}\" deve essere controvariante", - "protocolVarianceCovariant": "La variabile di tipo \"{variable}\" usata nel protocollo generico \"{class}\" deve essere covariante", - "protocolVarianceInvariant": "La variabile di tipo \"{variable}\" usata nel protocollo generico \"{class}\" deve essere invariabile", + "protocolVarianceContravariant": "La variabile di tipo \"{variable}\" usata in \"{class}\" Protocol generico deve essere controvariante", + "protocolVarianceCovariant": "La variabile di tipo \"{variable}\" usata in \"{class}\" Protocol generico deve essere covariante", + "protocolVarianceInvariant": "La variabile di tipo \"{variable}\" usata in \"{class}\" Protocol generico deve essere invariante", "pyrightCommentInvalidDiagnosticBoolValue": "La direttiva di commento Pyright deve essere seguita da \"=\" e da un valore true o false", "pyrightCommentInvalidDiagnosticSeverityValue": "La direttiva di commento Pyright deve essere seguita da \"=\" e da un valore true, false, error, warning, information o none", - "pyrightCommentMissingDirective": "Il commento pyright deve essere seguito da una direttiva (di base o restrittiva) o da una regola di diagnostica", + "pyrightCommentMissingDirective": "Il commento Pyright deve essere seguito da una direttiva (basic o strict) o da una regola di diagnostica", "pyrightCommentNotOnOwnLine": "I commenti Pyright usati per controllare le impostazioni a livello di file devono essere visualizzati nella propria riga", "pyrightCommentUnknownDiagnosticRule": "\"{rule}\" è una regola di diagnostica sconosciuta per il commento pyright", "pyrightCommentUnknownDiagnosticSeverityValue": "\"{value}\" non è un valore valido per il commento pyright; previsto true, false, error, warning, information o none", @@ -421,17 +422,17 @@ "readOnlyNotInTypedDict": "\"ReadOnly\" non consentito in questo contesto", "recursiveDefinition": "Non è stato possibile determinare il tipo di \"{name}\" perché fa riferimento a se stesso", "relativeImportNotAllowed": "Le importazioni relative non possono essere usate con il modulo \"import .a\". Usare invece \"from . import a\"", - "requiredArgCount": "Previsto un singolo argomento tipo dopo \"Obbligatorio\"", + "requiredArgCount": "È previsto un singolo argomento di tipo dopo \"Required\"", "requiredNotInTypedDict": "\"Required\" non è consentito in questo contesto", - "returnInAsyncGenerator": "L’istruzione return con valore non è consentita nel generatore asincrono", + "returnInAsyncGenerator": "L’istruzione return con valore non è consentita nel generatore async", "returnMissing": "La funzione con tipo restituito dichiarato \"{returnType}\" deve restituire un valore in tutti i percorsi di codice", "returnOutsideFunction": "\"return\" può essere usata solo all'interno di una funzione.", "returnTypeContravariant": "Non è possibile usare la variabile di tipo controvariante nel tipo restituito", - "returnTypeMismatch": "L'espressione di tipo \"{exprType}\" non è compatibile con il tipo restituito \"{returnType}\"", + "returnTypeMismatch": "Il tipo \"{exprType}\" non è assegnabile al tipo restituito \"{returnType}\"", "returnTypePartiallyUnknown": "Il tipo restituito \"{returnType}\" è parzialmente sconosciuto", "returnTypeUnknown": "Il tipo restituito è sconosciuto", "revealLocalsArgs": "Non è previsto alcun argomento per la chiamata \"reveal_locals\"", - "revealLocalsNone": "Non sono presenti variabili locali in questo ambito", + "revealLocalsNone": "Non sono presenti variabili locals in questo ambito", "revealTypeArgs": "Previsto un singolo argomento posizionale per la chiamata \"reveal_type\"", "revealTypeExpectedTextArg": "L'argomento \"expected_text\" per la funzione \"reveal_type\" deve essere un valore letterale str", "revealTypeExpectedTextMismatch": "Testo di tipo non corrispondente; previsto \"{expected}\" ma ricevuto \"{received}\"", @@ -439,7 +440,7 @@ "selfTypeContext": "\"Self\" non è valido in questo contesto", "selfTypeMetaclass": "Impossibile utilizzare “Self” all'interno di una metaclasse (una sottoclasse di “type”)", "selfTypeWithTypedSelfOrCls": "Non è possibile usare \"Self\" in una funzione con un parametro 'self' o 'cls' con un'annotazione di tipo diversa da \"Self\"", - "setterGetterTypeMismatch": "Il tipo di valore del setter di proprietà non è assegnabile al tipo restituito del getter", + "setterGetterTypeMismatch": "Il tipo di valore del setter di Property non è assegnabile al tipo restituito del getter", "singleOverload": "\"{name}\" è contrassegnato come overload, ma mancano altri overload", "slotsAttributeError": "\"{name}\" non è specificato in __slots__", "slotsClassVarConflict": "\"{name}\" è in conflitto con la variabile di istanza dichiarata in __slots__", @@ -449,12 +450,12 @@ "staticClsSelfParam": "I metodi statici non devono accettare un parametro \"self\" o \"cls\"", "stdlibModuleOverridden": "\"{path}\" sta eseguendo l'override del modulo stdlib \"{name}\"", "stringNonAsciiBytes": "Carattere non ASCII non consentito nel valore letterale stringa dei byte", - "stringNotSubscriptable": "L'espressione stringa non può essere in pedice nell'annotazione di tipo. Racchiudere l'intera annotazione tra virgolette", + "stringNotSubscriptable": "L'espressione stringa non può essere in pedice nell'espressione di tipo. Racchiudere l'intera espressione tra virgolette", "stringUnsupportedEscape": "Sequenza di escape non supportata nel valore letterale stringa", "stringUnterminated": "Il valore letterale stringa non è terminato", "stubFileMissing": "File di stub non trovato per \"{importName}\"", "stubUsesGetAttr": "Il file dello stub di tipo è incompleto; \"__getattr__\" nasconde gli errori di tipo per il modulo", - "sublistParamsIncompatible": "I parametri dell’elenco secondario non sono supportati in Python 3.x", + "sublistParamsIncompatible": "I parametri di sublist non sono supportati in Python 3.x", "superCallArgCount": "Non sono previsti più di due argomenti per la chiamata \"super\".", "superCallFirstArg": "È previsto un tipo di classe come primo argomento della chiamata \"super\", ma è stato ricevuto \"{type}\"", "superCallSecondArg": "Il secondo argomento della chiamata \"super\" deve essere un oggetto o una classe che deriva da \"{type}\"", @@ -464,41 +465,42 @@ "symbolIsUnbound": "\"{name}\" non associato", "symbolIsUndefined": "\"{name}\" non è definito", "symbolOverridden": "\"{name}\" esegue l'override del simbolo con lo stesso nome nella classe \"{className}\"", - "ternaryNotAllowed": "Espressione ternaria non consentita nell'annotazione di tipo", + "ternaryNotAllowed": "Espressione ternaria non consentita nell'espressione di tipo", "totalOrderingMissingMethod": "La classe deve definire uno dei valori di \"__lt__\", \"__le__\", \"__gt__\" o \"__ge__\" per usare total_ordering", "trailingCommaInFromImport": "Virgola finale non consentita senza parentesi circostanti", "tryWithoutExcept": "L'istruzione Try deve contenere almeno una clausola except or finally", - "tupleAssignmentMismatch": "Non è possibile assegnare l'espressione con tipo \"{type}\" alla tupla di destinazione", - "tupleInAnnotation": "Espressione di tupla non consentita nell'annotazione di tipo", + "tupleAssignmentMismatch": "Non è possibile assegnare l'espressione con tipo \"{type}\" al tuple di destinazione", + "tupleInAnnotation": "Espressione di tuple non consentita nell'espressione del tipo", "tupleIndexOutOfRange": "L'indice {index} non è compreso nell'intervallo per il tipo {type}", "typeAliasIllegalExpressionForm": "Modulo di espressione non valido per la definizione dell'alias di tipo", "typeAliasIsRecursiveDirect": "L'alias di tipo \"{name}\" non può usare se stesso nella relativa definizione", "typeAliasNotInModuleOrClass": "TypeAlias può essere definito solo all'interno di un modulo o di una classe", "typeAliasRedeclared": "\"{name}\" è dichiarato come TypeAlias e può essere assegnato una sola volta", - "typeAliasStatementBadScope": "Un'istruzione Tipo può essere usata solo all'interno di un modulo o di un ambito della classe", + "typeAliasStatementBadScope": "Un'istruzione type può essere usata solo all'interno di un modulo o di un ambito della classe", "typeAliasStatementIllegal": "L'istruzione alias di tipo richiede Python 3.12 o versione successiva", "typeAliasTypeBaseClass": "Impossibile utilizzare come classe di base un alias di tipo definito in un'istruzione \"type\"", "typeAliasTypeMustBeAssigned": "TypeAliasType deve essere assegnato a una variabile con lo stesso nome dell'alias di tipo", "typeAliasTypeNameArg": "Il primo argomento di TypeAliasType deve essere un valore letterale stringa che rappresenta il nome dell'alias di tipo", "typeAliasTypeNameMismatch": "Il nome dell'alias di tipo deve corrispondere al nome della variabile a cui è assegnato", - "typeAliasTypeParamInvalid": "L'elenco dei parametri del tipo deve essere una tupla contenente solo TypeVar, TypeVarTuple o ParamSpec.", + "typeAliasTypeParamInvalid": "L'elenco dei parametri di tipo deve essere un tuple contenente solo TypeVar, TypeVarTuple o ParamSpec.", "typeAnnotationCall": "Espressione di chiamata non consentita nell'espressione di tipo", "typeAnnotationVariable": "Variabile non consentita nell'espressione di tipo", "typeAnnotationWithCallable": "L'argomento di tipo per \"type\" deve essere una classe. I callable non sono supportati", - "typeArgListExpected": "Previsto ParamSpec, puntini di sospensione o elenco di tipi", - "typeArgListNotAllowed": "Espressione di elenco non consentita per questo argomento tipo", + "typeArgListExpected": "Sono previsti ParamSpec, puntini di sospensione o elenco di list", + "typeArgListNotAllowed": "Espressione di List non consentita per questo argomento di tipo", "typeArgsExpectingNone": "Non sono previsti argomenti di tipo per la classe \"{name}\"", "typeArgsMismatchOne": "Previsto un argomento di tipo, ricevuto {received}", "typeArgsMissingForAlias": "Sono previsti argomenti di tipo per l'alias di tipo generico \"{name}\"", "typeArgsMissingForClass": "Argomenti tipo previsti per la classe generica \"{name}\"", "typeArgsTooFew": "Troppo pochi argomenti tipo forniti per \"{name}\"; previsto {expected} ma ricevuto {received}", "typeArgsTooMany": "Troppi argomenti tipo forniti per \"{name}\"; previsto {expected} ma ricevuto {received}", - "typeAssignmentMismatch": "L'espressione di tipo \"{sourceType}\" non è compatibile con il tipo dichiarato \"{destType}\"", - "typeAssignmentMismatchWildcard": "Il tipo del simbolo di importazione \"{name}\" è \"{sourceType}\", che non è compatibile con il tipo dichiarato \"{destType}\"", - "typeCallNotAllowed": "la chiamata type() non deve essere usata nell'annotazione di tipo", + "typeAssignmentMismatch": "Il tipo \"{sourceType}\" non è assegnabile al tipo dichiarato \"{destType}\"", + "typeAssignmentMismatchWildcard": "Il simbolo di importazione \"{name}\" ha il tipo \"{sourceType}\", che non è assegnabile al tipo dichiarato \"{destType}\"", + "typeCallNotAllowed": "la chiamata type() non deve essere usata nell'espressione di tipo", "typeCheckOnly": "\"{name}\" è contrassegnato come @type_check_only e può essere utilizzato solo nelle annotazioni tipo", - "typeCommentDeprecated": "L'uso dei commenti di tipo è deprecato. Usare l'annotazione di tipo", + "typeCommentDeprecated": "L'uso dei commenti di type è deprecato. Usare invece l'annotazione type", "typeExpectedClass": "Classe prevista ma ricevuta \"{type}\"", + "typeFormArgs": "\"TypeForm\" accetta un singolo argomento posizionale", "typeGuardArgCount": "È previsto un singolo argomento di tipo dopo \"TypeGuard\" o \"TypeIs\"", "typeGuardParamCount": "Le funzioni e i metodi di protezione dei tipi definiti dall'utente devono avere almeno un parametro di input", "typeIsReturnType": "Il tipo restituito di TypeIs (\"{returnType}\") non è coerente con il tipo di parametro di valore (\"{type}\")", @@ -537,9 +539,9 @@ "typeVarSingleConstraint": "TypeVar deve contenere almeno due tipi vincolati", "typeVarTupleConstraints": "TypeVarTuple non può avere vincoli di valore", "typeVarTupleContext": "TypeVarTuple non è consentito in questo contesto", - "typeVarTupleDefaultNotUnpacked": "Il tipo predefinito TypeVarTuple deve essere una tupla non compressa o TypeVarTuple", + "typeVarTupleDefaultNotUnpacked": "Il tipo predefinito TypeVarTuple deve essere un tuple non compresso o TypeVarTuple", "typeVarTupleMustBeUnpacked": "L'operatore Decomprimi è obbligatorio per il valore TypeVarTuple", - "typeVarTupleUnknownParam": "\"{name}\" è un parametro sconosciuto per TypeVar", + "typeVarTupleUnknownParam": "\"{name}\" è un parametro sconosciuto per TypeVarTuple", "typeVarUnknownParam": "\"{name}\" è un parametro sconosciuto per TypeVar", "typeVarUsedByOuterScope": "TypeVar \"{name}\" già in uso da un ambito esterno", "typeVarUsedOnlyOnce": "TypeVar \"{name}\" viene visualizzato una sola volta nella firma della funzione generica", @@ -552,16 +554,16 @@ "typedDictBadVar": "Le classi TypedDict possono contenere solo annotazioni di tipo", "typedDictBaseClass": "Anche tutte le classi di base per le classi TypedDict devono essere classi TypedDict", "typedDictBoolParam": "È previsto che il parametro \"{name}\" abbia il valore True o False", - "typedDictClosedExtras": "La classe di base \"{name}\" è un TypedDict chiuso; gli elementi aggiuntivi devono essere di tipo \"{type}\"", - "typedDictClosedNoExtras": "La classe di base \"{name}\" è un TypedDict chiuso; elementi aggiuntivi non consentiti", + "typedDictClosedExtras": "La classe di base \"{name}\" è un TypedDict closed; gli elementi aggiuntivi devono essere di tipo \"{type}\"", + "typedDictClosedNoExtras": "La classe di base \"{name}\" è un TypedDict closed; elementi aggiuntivi non consentiti", "typedDictDelete": "Non è stato possibile eliminare l'elemento in TypedDict", "typedDictEmptyName": "I nomi all'interno di un TypedDict non possono essere vuoti", "typedDictEntryName": "Valore letterale stringa previsto per il nome della voce del dizionario", "typedDictEntryUnique": "I nomi all'interno di un dizionario devono essere univoci", "typedDictExtraArgs": "Argomenti TypedDict aggiuntivi non supportati", - "typedDictFieldNotRequiredRedefinition": "Non è possibile ridefinire il campo TypedDict \"{name}\" come Non obbligatorio", - "typedDictFieldReadOnlyRedefinition": "Non è possibile ridefinire l’elemento TypedDict \"{name}\" come Sola lettura", - "typedDictFieldRequiredRedefinition": "Non è possibile ridefinire il campo TypedDict \"{name}\" come Obbligatorio", + "typedDictFieldNotRequiredRedefinition": "Non è possibile ridefinire il campo TypedDict \"{name}\" come NotRequired", + "typedDictFieldReadOnlyRedefinition": "Non è possibile ridefinire l’elemento TypedDict \"{name}\" come ReadOnly", + "typedDictFieldRequiredRedefinition": "Non è possibile ridefinire il campo TypedDict \"{name}\" come Required", "typedDictFirstArg": "È previsto il nome della classe TypedDict come primo argomento", "typedDictInitsubclassParameter": "TypedDict non supporta __init_subclass__ parametro “{name}”", "typedDictNotAllowed": "\"TypedDict\" non può essere usato in questo contesto", @@ -574,7 +576,7 @@ "unaccessedSymbol": "Non è possibile accedere a \"{name}\"", "unaccessedVariable": "La variabile \"{name}\" non è accessibile", "unannotatedFunctionSkipped": "L'analisi della funzione \"{name}\" è stata ignorata perché non è annotata", - "unaryOperationNotAllowed": "Operatore unario non consentito nell'annotazione di tipo", + "unaryOperationNotAllowed": "Operatore unario non consentito nell'espressione di tipo", "unexpectedAsyncToken": "È previsto che \"def\", \"with\" o \"for\" seguano \"async\"", "unexpectedExprToken": "Token imprevisto alla fine dell'espressione", "unexpectedIndent": "Rientro imprevisto", @@ -583,25 +585,25 @@ "unhashableSetEntry": "La voce set deve essere hashable", "uninitializedAbstractVariables": "Le variabili definite nella classe di base astratta non vengono inizializzate nella classe finale \"{classType}\"", "uninitializedInstanceVariable": "La variabile di istanza \"{name}\" non è inizializzata nel corpo della classe o nel metodo __init__", - "unionForwardReferenceNotAllowed": "Impossibile utilizzare la sintassi di unione con l'operando stringa. Usare virgolette intorno all'intera espressione", + "unionForwardReferenceNotAllowed": "Impossibile utilizzare la sintassi di Union con l'operando stringa. Usare virgolette intorno all'intera espressione", "unionSyntaxIllegal": "La sintassi alternativa per le unioni richiede Python 3.10 o versione successiva", - "unionTypeArgCount": "L'unione richiede due o più argomenti di tipo", - "unionUnpackedTuple": "L'unione non può includere una tupla decompressa", - "unionUnpackedTypeVarTuple": "L'unione non può includere un TypeVarTuple non compresso", + "unionTypeArgCount": "Unione richiede due o più argomenti di tipo", + "unionUnpackedTuple": "Union non può includere un tuple decompresso", + "unionUnpackedTypeVarTuple": "Union non può includere un TypeVarTuple non compresso", "unnecessaryCast": "Chiamata \"cast\" non necessaria; il tipo è già \"{type}\"", "unnecessaryIsInstanceAlways": "Chiamata isinstance non necessaria; \"{testType}\" è sempre un'istanza di \"{classType}\"", "unnecessaryIsSubclassAlways": "Chiamata issubclass non necessaria; \"{testType}\" è sempre una sottoclasse di \"{classType}\"", "unnecessaryPyrightIgnore": "Commento \"# pyright: ignore\" non necessario", "unnecessaryPyrightIgnoreRule": "Regola \"# pyright: ignore\" non necessaria: \"{name}\"", - "unnecessaryTypeIgnore": "Commento \"# tipo: ignora\" non necessario", - "unpackArgCount": "Previsto un singolo argomento tipo dopo \"Decomprimi\"", - "unpackExpectedTypeVarTuple": "È previsto TypeVarTuple o tupla come argomento di tipo per Unpack", - "unpackExpectedTypedDict": "Previsto argomento di tipo TypedDict per Decomprimi", + "unnecessaryTypeIgnore": "Commento \"# type: ignore\" non necessario", + "unpackArgCount": "Previsto un singolo argomento di tipo dopo \"Unpack\"", + "unpackExpectedTypeVarTuple": "È previsto TypeVarTuple o tuple come argomento di tipo per Unpack", + "unpackExpectedTypedDict": "Previsto argomento di tipo TypedDict per Unpack", "unpackIllegalInComprehension": "Operazione di decompressione non consentita nella comprensione", - "unpackInAnnotation": "Operatore di decompressione non consentito nell'annotazione di tipo", + "unpackInAnnotation": "Operatore di decompressione non consentito nell'espressione di tipo", "unpackInDict": "Operazione di decompressione non consentita nei dizionari", "unpackInSet": "Operatore di decompressione non consentito all’interno di un set", - "unpackNotAllowed": "La decompressione non è consentita in questo contesto", + "unpackNotAllowed": "Unpack non è consentito in questo contesto", "unpackOperatorNotAllowed": "L’operazione di decompressione non è consentita in questo contesto", "unpackTuplesIllegal": "L'operazione di decompressione non è consentita nelle tuple precedenti a Python 3.8", "unpackedArgInTypeArgument": "Non è possibile usare argomenti decompressi in questo contesto", @@ -616,36 +618,36 @@ "unreachableExcept": "La clausola Except non è raggiungibile perché l'eccezione è già gestita", "unsupportedDunderAllOperation": "L'operazione su \"__all__\" non è supportata, di conseguenza l'elenco dei simboli esportati potrebbe non essere corretto", "unusedCallResult": "Il risultato dell'espressione di chiamata è di tipo \"{type}\" e non è usato. Assegnare alla variabile \"_\" se è intenzionale", - "unusedCoroutine": "Il risultato della chiamata di funzione asincrona non viene usato. usare \"await\" o assegnare il risultato alla variabile", + "unusedCoroutine": "Il risultato della chiamata alla funzione async non viene usato. Usare \"await\" o assegnare il risultato alla variabile", "unusedExpression": "Il valore dell'espressione non è utilizzato", - "varAnnotationIllegal": "Le annotazioni di tipo per le variabili richiedono Python 3.6 o versione successiva. Usare il commento di tipo per compatibilità con le versioni precedenti", + "varAnnotationIllegal": "Le annotazioni type per le variabili richiedono Python 3.6 o versione successiva. Usare il commento di type per la compatibilità con le versioni precedenti", "variableFinalOverride": "La variabile \"{name}\" è contrassegnata come Final ed esegue l'override della variabile non Final con lo stesso nome nella classe \"{className}\"", - "variadicTypeArgsTooMany": "L'elenco di argomenti di tipo può contenere al massimo una tupla o TypeVarTuple non compressa", + "variadicTypeArgsTooMany": "L'elenco di argomenti del tipo può contenere al massimo un tuple o TypeVarTuple non compresso", "variadicTypeParamTooManyAlias": "L'alias di tipo può avere al massimo un parametro di tipo TypeVarTuple, ma ne ha ricevuti più ({names})", "variadicTypeParamTooManyClass": "La classe generica può avere al massimo un parametro di tipo TypeVarTuple, ma ne ha ricevuti più ({names})", "walrusIllegal": "L'operatore \":=\" richiede Python 3.8 o versione successiva", "walrusNotAllowed": "L'operatore \":=\" non è consentito in questo contesto senza parentesi circostanti", - "wildcardInFunction": "Importazione di caratteri jolly non consentita all'interno di una classe o di una funzione", - "wildcardLibraryImport": "Importazione di caratteri jolly da una libreria non consentita", + "wildcardInFunction": "Wildcard import non consentito all'interno di una classe o di una funzione", + "wildcardLibraryImport": "Wildcard import da una libreria non consentito", "wildcardPatternTypePartiallyUnknown": "Il tipo acquisito dal modello con caratteri jolly è parzialmente sconosciuto", "wildcardPatternTypeUnknown": "Il tipo acquisito dal criterio con caratteri jolly è sconosciuto", "yieldFromIllegal": "L'uso di \"yield from\" richiede Python 3.3 o versione successiva", - "yieldFromOutsideAsync": "\"yield from\" non consentito in una funzione asincrona", + "yieldFromOutsideAsync": "\"yield from\" non consentito in una funzione async", "yieldOutsideFunction": "\"yield\" non consentito all'esterno di una funzione o di un'espressione lambda", "yieldWithinComprehension": "\"yield\" non consentito all'interno di una comprensione", "zeroCaseStatementsFound": "L’istruzione Match deve includere almeno un’istruzione case", - "zeroLengthTupleNotAllowed": "Tupla di lunghezza zero non è consentita in questo contesto" + "zeroLengthTupleNotAllowed": "Zero-length tuple is not allowed in this context" }, "DiagnosticAddendum": { - "annotatedNotAllowed": "Non è possibile usare il modulo speciale \"Annotato\" con controlli di istanza e classe", + "annotatedNotAllowed": "Non è possibile usare il modulo speciale \"Annotated\" con controlli di istanza e classe", "argParam": "L'argomento corrisponde al parametro \"{paramName}\"", "argParamFunction": "L'argomento corrisponde al parametro \"{paramName}\" nella funzione \"{functionName}\"", "argsParamMissing": "Il parametro \"*{paramName}\" non ha un parametro corrispondente", "argsPositionOnly": "Parametro di sola posizione non corrispondente; previsto {expected} ma ricevuto {received}", "argumentType": "Il tipo di argomento è \"{type}\"", "argumentTypes": "Tipi di argomento: ({types})", - "assignToNone": "Il tipo non è compatibile con \"None\"", - "asyncHelp": "Intendevi \"async con\"?", + "assignToNone": "Il tipo non è assegnabile a \"None\"", + "asyncHelp": "Intendevi \"async with\"?", "baseClassIncompatible": "La classe base \"{baseClass}\" non è compatibile con il tipo \"{type}\"", "baseClassIncompatibleSubclass": "La classe base \"{baseClass}\" deriva da \"{subclass}\", che non è compatibile con il tipo \"{type}\"", "baseClassOverriddenType": "La classe di base \"{baseClass}\" fornisce il tipo \"{type}\", di cui viene eseguito l'override", @@ -657,7 +659,7 @@ "dataProtocolUnsupported": "“{name}” è un protocollo dati", "descriptorAccessBindingFailed": "Impossibile associare il metodo \"{name}\" per la classe descrittore \"{className}\"", "descriptorAccessCallFailed": "Impossibile chiamare il metodo \"{name}\" per la classe descrittore \"{className}\"", - "finalMethod": "Metodo finale", + "finalMethod": "Metodo Final", "functionParamDefaultMissing": "Nel parametro \"{name}\" manca un argomento predefinito", "functionParamName": "Nome del parametro non corrispondente: \"{destName}\" rispetto a \"{srcName}\"", "functionParamPositionOnly": "Parametro di sola posizione non corrispondente; il parametro “{name}” non è di sola posizione", @@ -665,15 +667,15 @@ "functionTooFewParams": "La funzione accetta un numero insufficiente di parametri posizionale. Previsto {expected} ma ricevuto {received}", "functionTooManyParams": "La funzione accetta un numero eccessivo di parametri posizionale. Previsto {expected} ma ricevuto {received}", "genericClassNotAllowed": "Tipo generico con argomenti di tipo non consentiti per i controlli di istanza o classe", - "incompatibleDeleter": "Il metodo di eliminazione delle proprietà non è compatibile", - "incompatibleGetter": "Il metodo getter della proprietà non è compatibile", - "incompatibleSetter": "Il metodo setter di proprietà non è compatibile", + "incompatibleDeleter": "Il metodo deleter di Property non è compatibile", + "incompatibleGetter": "Il metodo getter di Property non è compatibile", + "incompatibleSetter": "Il metodo setter di Property non è compatibile", "initMethodLocation": "Il metodo __init__ è definito nella classe \"{type}\"", "initMethodSignature": "Firma del __init__ \"{type}\"", "initSubclassLocation": "Il metodo __init_subclass__ è definito nella classe \"{name}\"", "invariantSuggestionDict": "Prova a passare da \"dict\" a \"Mapping\", che è covariante nel tipo di valore", "invariantSuggestionList": "Prova a passare da \"list\" a \"Sequence\", che è covariante", - "invariantSuggestionSet": "Provare a passare da \"ste\" a \"contenitore\" che è covariante", + "invariantSuggestionSet": "Prova a passare da \"set\" a \"Container\", che è covariante", "isinstanceClassNotSupported": "\"{type}\" non è supportata per i controlli delle istanze e delle classi", "keyNotRequired": "\"{name}\" non è una chiave obbligatoria in \"{type}\", quindi l'accesso potrebbe causare un'eccezione di runtime", "keyReadOnly": "\"{name}\" è una chiave di sola lettura in \"{type}\"", @@ -681,14 +683,14 @@ "keyUndefined": "\"{name}\" non è una chiave definita in \"{type}\"", "kwargsParamMissing": "Il parametro \"**{paramName}\" non ha un parametro corrispondente", "listAssignmentMismatch": "Il tipo \"{type}\" non è compatibile con l'elenco di destinazione", - "literalAssignmentMismatch": "\"{sourceType}\" non è compatibile con il tipo \"{destType}\"", + "literalAssignmentMismatch": "\"{sourceType}\" non è assegnabile al tipo \"{destType}\"", "matchIsNotExhaustiveHint": "Se la gestione completa non è prevista, aggiungere \"case _: pass\"", "matchIsNotExhaustiveType": "Tipo non gestito: \"{type}\"", "memberAssignment": "L'espressione di tipo \"{type}\" non può essere assegnata all'attributo \"{name}\" della classe \"{classType}\".", "memberIsAbstract": "\"{type}.{name}\" non implementato", "memberIsAbstractMore": "e {{count}} altro...", "memberIsClassVarInProtocol": "“{name}” è definito come ClassVar nel protocollo", - "memberIsInitVar": "\"{name}\" è un campo di sola inizializzazione", + "memberIsInitVar": "\"{name}\" è un campo di init-only", "memberIsInvariant": "\"{name}\" è invariante perché modificabile", "memberIsNotClassVarInClass": "\"{name}\" deve essere definito come ClassVar per essere compatibile con il protocollo", "memberIsNotClassVarInProtocol": "“{name}” non è definito come ClassVar nel protocollo", @@ -699,9 +701,9 @@ "memberTypeMismatch": "\"{name}\" è un tipo non compatibile", "memberUnknown": "L'attributo \"{name}\" è sconosciuto", "metaclassConflict": "La metaclasse \"{metaclass1}\" è in conflitto con \"{metaclass2}\"", - "missingDeleter": "Manca il metodo di eliminazione delle proprietà", - "missingGetter": "Metodo getter proprietà mancante", - "missingSetter": "Metodo setter proprietà mancante", + "missingDeleter": "Metodo deleter di Property mancante", + "missingGetter": "Metodo getter di Property mancante", + "missingSetter": "Metodo setter di Property mancante", "namedParamMissingInDest": "Parametro aggiuntivo “{name}”", "namedParamMissingInSource": "Parametro della parola chiave “{name}” mancante", "namedParamTypeMismatch": "Il parametro \"{name}\" della parola chiave di tipo \"{sourceType}\" non è compatibile con il tipo \"{destType}\"", @@ -720,9 +722,9 @@ "overrideInvariantMismatch": "Il tipo di override \"{overrideType}\" non è uguale al tipo di base \"{baseType}\"", "overrideIsInvariant": "La variabile è modificabile, quindi il relativo tipo è invariante", "overrideNoOverloadMatches": "Nessuna firma di overload nell'override è compatibile con il metodo di base", - "overrideNotClassMethod": "Il metodo di base è dichiarato come metodo di classe, ma l'override non è", + "overrideNotClassMethod": "Il metodo di base viene dichiarato come classmethod, ma l'override non lo è", "overrideNotInstanceMethod": "Il metodo di base è dichiarato come metodo di istanza, ma l’override non lo è", - "overrideNotStaticMethod": "Il metodo di base è dichiarato come metodo statico, ma l'override non è", + "overrideNotStaticMethod": "Il metodo di base viene dichiarato come staticmethod, ma l'override non lo è", "overrideOverloadNoMatch": "La sostituzione non gestisce tutti gli overload del metodo di base", "overrideOverloadOrder": "Gli overload per il metodo di override devono essere nello stesso ordine del metodo di base", "overrideParamKeywordNoDefault": "Parametro della parola chiave \"{name}\" non corrispondente: il parametro di base ha un valore di argomento predefinito, il parametro di override non è", @@ -741,16 +743,16 @@ "paramType": "Tipo di parametro \"{paramType}\"", "privateImportFromPyTypedSource": "Importa da \"{module}\"", "propertyAccessFromProtocolClass": "Non è possibile accedere a una proprietà definita all'interno di una classe di protocollo come variabile di classe", - "propertyMethodIncompatible": "Il metodo di proprietà \"{name}\" non è compatibile", - "propertyMethodMissing": "Metodo di proprietà \"{name}\" mancante nell'override", - "propertyMissingDeleter": "La proprietà \"{name}\" non ha un deleter definito", - "propertyMissingSetter": "La proprietà \"{name}\" non ha un setter definito", + "propertyMethodIncompatible": "Il metodo di Property \"{name}\" non è compatibile", + "propertyMethodMissing": "Metodo di Property \"{name}\" mancante nell'override", + "propertyMissingDeleter": "Property \"{name}\" non dispone di un deleter definito", + "propertyMissingSetter": "Property \"{name}\" non dispone di un setter definito", "protocolIncompatible": "\"{sourceType}\" non è compatibile con il protocollo \"{destType}\"", "protocolMemberMissing": "\"{name}\" non è presente", - "protocolRequiresRuntimeCheckable": "La classe del protocollo deve essere @runtime_checkable in modo che sia possibile usarla con i controlli di istanza e classe", + "protocolRequiresRuntimeCheckable": "La classe di Protocol deve essere @runtime_checkable in modo che sia possibile usarla con i controlli di istanza e classe", "protocolSourceIsNotConcrete": "\"{sourceType}\" non è un tipo di classe concreto e non può essere assegnato al tipo \"{destType}\"", "protocolUnsafeOverlap": "Gli attributi di “{name}” hanno gli stessi nomi del protocollo", - "pyrightCommentIgnoreTip": "Usare \"# pyright: ignore[] per eliminare la diagnostica per una singola riga", + "pyrightCommentIgnoreTip": "Usa \"# pyright: ignore[]\" per eliminare la diagnostica per una singola riga", "readOnlyAttribute": "L'attributo \"{name}\" è di sola lettura", "seeClassDeclaration": "Vedere la dichiarazione di classe", "seeDeclaration": "Vedere la dichiarazione", @@ -759,17 +761,17 @@ "seeParameterDeclaration": "Vedere la dichiarazione del parametro", "seeTypeAliasDeclaration": "Vedere la dichiarazione di alias di tipo", "seeVariableDeclaration": "Vedere la dichiarazione di variabile", - "tupleAssignmentMismatch": "Il tipo \"{type}\" non è compatibile con la tupla di destinazione", - "tupleEntryTypeMismatch": "Il tipo della voce di tupla {entry} non è corretto", - "tupleSizeIndeterminateSrc": "Dimensioni tupla non corrispondenti; previsto {expected} ma ricevuto indeterminato", - "tupleSizeIndeterminateSrcDest": "Dimensioni della tupla non corrispondenti; previsto {expected} o più, ma ricevuto indeterminato", - "tupleSizeMismatch": "Dimensioni tupla non corrispondenti; previsto {expected} ma ricevuto {received}", - "tupleSizeMismatchIndeterminateDest": "Dimensioni della tupla non corrispondenti; previsto {expected} o più ma ricevuto {received}", + "tupleAssignmentMismatch": "Il tipo \"{type}\" non è compatibile con il tuple di destinazione", + "tupleEntryTypeMismatch": "Il tipo della voce di Tuple {entry} non è corretto", + "tupleSizeIndeterminateSrc": "Dimensioni del tuple non corrispondenti; previsto {expected} ma ricevuto indeterminato", + "tupleSizeIndeterminateSrcDest": "Dimensioni del tuple non corrispondenti; previsto {expected} o più, ma ricevuto indeterminato", + "tupleSizeMismatch": "Dimensioni tuple non corrispondenti; previsto {expected} ma ricevuto {received}", + "tupleSizeMismatchIndeterminateDest": "Dimensioni del tuple non corrispondenti; previsto {expected} o più ma ricevuto {received}", "typeAliasInstanceCheck": "Non è possibile usare l'alias di tipo creato con l'istruzione \"type\" con controlli di classe e istanza", - "typeAssignmentMismatch": "Il tipo \"{sourceType}\" non è compatibile con il tipo \"{destType}\"", - "typeBound": "Il tipo \"{sourceType}\" non è compatibile con il tipo associato \"{destType}\" per la variabile di tipo \"{name}\"", - "typeConstrainedTypeVar": "Il tipo \"{type}\" non è compatibile con la variabile di tipo vincolato \"{name}\"", - "typeIncompatible": "\"{sourceType}\" non è compatibile con \"{destType}\"", + "typeAssignmentMismatch": "Il tipo \"{sourceType}\" non è assegnabile al tipo \"{destType}\"", + "typeBound": "Il tipo \"{sourceType}\" non è assegnabile al limite superiore \"{destType}\" per la variabile di tipo \"{name}\"", + "typeConstrainedTypeVar": "Il tipo \"{type}\" non è assegnabile alla variabile di tipo vincolato \"{name}\"", + "typeIncompatible": "\"{sourceType}\" non è assegnabile a \"{destType}\"", "typeNotClass": "\"{type}\" non è una classe", "typeNotStringLiteral": "\"{type}\" non è un valore letterale stringa", "typeOfSymbol": "Il tipo di \"{name}\" è \"{type}\"", @@ -780,7 +782,7 @@ "typeVarIsCovariant": "Il parametro di tipo \"{name}\" è covariante, ma \"{sourceType}\" non è un sottotipo di \"{destType}\"", "typeVarIsInvariant": "Il parametro di tipo \"{name}\" è invariante, ma \"{sourceType}\" non è uguale a \"{destType}\"", "typeVarNotAllowed": "TypeVar non consentito per i controlli di istanze o classi", - "typeVarTupleRequiresKnownLength": "Non è possibile associare TypeVarTuple a una tupla di lunghezza sconosciuta", + "typeVarTupleRequiresKnownLength": "Non è possibile associare TypeVarTuple a un tuple di lunghezza sconosciuta", "typeVarUnnecessarySuggestion": "Usare invece {type}", "typeVarUnsolvableRemedy": "Specificare un overload che specifica il tipo restituito quando l'argomento non viene fornito", "typeVarsMissing": "Variabili di tipo mancanti: {names}", @@ -804,8 +806,8 @@ "uninitializedAbstractVariable": "La variabile di istanza \"{name}\" è definita nella classe di base astratta \"{classType}\" ma non è inizializzata", "unreachableExcept": "\"{exceptionType}\" è una sottoclasse di \"{parentType}\"", "useDictInstead": "Usare Dict[T1, T2] per indicare un tipo di dizionario", - "useListInstead": "Usare List[T] per indicare un tipo di elenco o Union[T1, T2] per indicare un tipo di unione", - "useTupleInstead": "Usare tuple[T1, ..., Tn] per indicare un tipo di tupla o Union[T1, T2] per indicare un tipo di unione", + "useListInstead": "Usare List[T] per indicare un tipo di list o Union[T1, T2] per indicare un tipo di unione", + "useTupleInstead": "Usare tuple[T1, ..., Tn] per indicare un tipo di tuple o Union[T1, T2] per indicare un tipo di unione", "useTypeInstead": "In alternativa, usare Type[T]", "varianceMismatchForClass": "La varianza dell'argomento tipo \"{typeVarName}\" non è compatibile con la classe di base \"{className}\"", "varianceMismatchForTypeAlias": "La varianza dell'argomento tipo \"{typeVarName}\" non è compatibile con \"{typeAliasParam}\"" diff --git a/packages/pyright-internal/src/localization/package.nls.ja.json b/packages/pyright-internal/src/localization/package.nls.ja.json index 4befdc619..12434076f 100644 --- a/packages/pyright-internal/src/localization/package.nls.ja.json +++ b/packages/pyright-internal/src/localization/package.nls.ja.json @@ -1,7 +1,7 @@ { "CodeAction": { - "createTypeStub": "型スタブの作成", - "createTypeStubFor": "\"{moduleName}\" の型スタブを作成する", + "createTypeStub": "型 Stub を作成する", + "createTypeStubFor": "\"{moduleName}\" の型 Stub を作成する", "executingCommand": "コマンドの実行中", "filesToAnalyzeCount": "分析する {count} 個のファイル", "filesToAnalyzeOne": "分析する 1 つのファイル", @@ -18,12 +18,12 @@ "annotatedMetadataInconsistent": "注釈付きのメタデータ型 \"{metadataType}\" は型 \"{type}\" と互換性がありません", "annotatedParamCountMismatch": "パラメーター注釈数の不一致: {expected} が必要ですが、{received} を受信しました", "annotatedTypeArgMissing": "\"Annotated\" には 1 つの型引数と 1 つ以上の注釈が必要です", - "annotationBytesString": "型注釈では、バイト文字列リテラルは使用できません", - "annotationFormatString": "型注釈では、書式指定文字列リテラル (f 文字列) を使用できません", + "annotationBytesString": "型式では、バイト文字列リテラルは使用できません", + "annotationFormatString": "型式では、書式指定文字列リテラル (f 文字列) を使用できません", "annotationNotSupported": "このステートメントでは型注釈はサポートされていません", - "annotationRawString": "型注釈では、生文字列リテラルは使用できません", - "annotationSpansStrings": "型注釈を複数の文字列リテラルにまたがることはできません", - "annotationStringEscape": "型注釈にエスケープ文字を含めることはできません", + "annotationRawString": "型式では、生文字列リテラルは使用できません", + "annotationSpansStrings": "型式は複数の文字列リテラルにまたがることはできません", + "annotationStringEscape": "型式にエスケープ文字を含めることはできません", "argAssignment": "型 \"{argType}\" の引数を型 \"{paramType}\" のパラメーターに割り当てることはできません", "argAssignmentFunction": "型 \"{argType}\" の引数を関数 \"{functionName}\" の型 \"{paramType}\" のパラメーターに割り当てることはできません", "argAssignmentParam": "型 \"{argType}\" の引数を型 \"{paramType}\" のパラメーター \"{paramName}\" に割り当てることはできません", @@ -45,10 +45,10 @@ "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}\" は final とマークされており、サブクラス化できません", @@ -57,7 +57,7 @@ "baseClassMethodTypeIncompatible": "\"{classType}\" の基底クラスは、互換性のない方法でメソッド \"{name}\" を定義します", "baseClassUnknown": "基底クラスの型が不明で、派生クラスの型が不明です", "baseClassVariableTypeIncompatible": "クラス \"{classType}\" の基底クラスは、互換性のない方法で変数 \"{name}\" を定義します", - "binaryOperationNotAllowed": "型の注釈で 2 項演算子は使用できません", + "binaryOperationNotAllowed": "2 項演算子は型式では使用できません", "bindTypeMismatch": "\"{type}\" がパラメーター \"{paramName}\" に割り当てできないため、メソッド \"{methodName}\" をバインドできませんでした", "breakOutsideLoop": "\"break\" はループ内でのみ使用できます", "callableExtraArgs": "\"Callable\" に必要な型引数は 2 つだけです", @@ -70,7 +70,7 @@ "classDefinitionCycle": "\"{name}\" のクラス定義は、それ自体に依存します", "classGetItemClsParam": "__class_getitem__ override は \"cls\" パラメーターを受け取る必要があります", "classMethodClsParam": "クラス メソッドは \"cls\" パラメーターを受け取る必要があります", - "classNotRuntimeSubscriptable": "クラス \"{name}\" の添字はランタイム例外を生成します。型の注釈を引用符で囲む", + "classNotRuntimeSubscriptable": "クラス \"{name}\" の添字はランタイム例外を生成します。型式を引用符で囲んでください", "classPatternBuiltInArgPositional": "クラス パターンは位置指定サブパターンのみを受け入れます", "classPatternPositionalArgCount": "クラス \"{type}\" の位置指定パターンが多すぎます。{expected} が必要ですが、{received} を受信しました", "classPatternTypeAlias": "\"{type}\" は特殊な型エイリアスであるため、クラス パターンでは使用できません", @@ -87,10 +87,10 @@ "comparisonAlwaysFalse": "型 \"{leftType}\" と \"{rightType}\" に重複がないため、条件は常に False に評価されます", "comparisonAlwaysTrue": "型 \"{leftType}\" と \"{rightType}\" に重複がないため、条件は常に True に評価されます", "comprehensionInDict": "他の辞書エントリと共に理解することはできません", - "comprehensionInSet": "他のセット エントリと共に理解を使用することはできません", + "comprehensionInSet": "読解は他の set エントリと併用できません。", "concatenateContext": "\"Concatenate\" はこのコンテキストで許可されていません", "concatenateParamSpecMissing": "\"Concatenate\" の最後の型引数は ParamSpec または \"...\" である必要があります", - "concatenateTypeArgsMissing": "\"連結\" には少なくとも 2 つの型引数が必要です", + "concatenateTypeArgsMissing": "\"Concatenate\" には少なくとも 2 つの型引数が必要です", "conditionalOperandInvalid": "型 \"{type}\" の条件オペランドが無効です", "constantRedefinition": "\"{name}\" は定数であり (大文字であるため)、再定義できません", "constructorParametersMismatch": "クラス \"{classType}\" の__new__と__init__のシグネチャの不一致", @@ -111,7 +111,7 @@ "dataClassPostInitType": "フィールド \"{fieldName}\" の Dataclass __post_init__ メソッド パラメーターの型が一致しません", "dataClassSlotsOverwrite": "__slots__はクラスで既に定義されています", "dataClassTransformExpectedBoolLiteral": "静的に True または False に評価される式が必要です", - "dataClassTransformFieldSpecifier": "クラスまたは関数のタプルが必要ですが、型 \"{type}\" を受け取りました", + "dataClassTransformFieldSpecifier": "クラスまたは関数の tuple が必要ですが、型 \"{type}\" を受け取りました", "dataClassTransformPositionalParam": "\"dataclass_transform\" に対するすべての引数はキーワード引数である必要があります", "dataClassTransformUnknownArgument": "引数 \"{name}\" はdataclass_transform でサポートされていません", "dataProtocolInSubclassCheck": "データ プロトコル (メソッド以外の属性を含む) は、issubclass 呼び出しで使用できません", @@ -127,12 +127,12 @@ "deprecatedDescriptorSetter": "記述子 \"{name}\" の \"__set__\" メソッドは非推奨です", "deprecatedFunction": "関数 \"{name}\" は非推奨です", "deprecatedMethod": "クラス \"{className}\" のメソッド \"{name}\" は非推奨です", - "deprecatedPropertyDeleter": "プロパティ \"{name}\" の削除子は非推奨です", - "deprecatedPropertyGetter": "プロパティ \"{name}\" のゲッターは非推奨です", - "deprecatedPropertySetter": "プロパティ \"{name}\" のセッターは非推奨です", + "deprecatedPropertyDeleter": "The deleter for property \"{name}\" is deprecated", + "deprecatedPropertyGetter": "The getter for property \"{name}\" is deprecated", + "deprecatedPropertySetter": "The setter for property \"{name}\" is deprecated", "deprecatedType": "この型は Python {version} では非推奨です。代わりに\"{replacement}\"を使用してください", "dictExpandIllegalInComprehension": "辞書の展開は理解できません", - "dictInAnnotation": "辞書式は型注釈では使用できません", + "dictInAnnotation": "辞書式は型式では使用できません", "dictKeyValuePairs": "辞書エントリにはキー/値のペアが含まれている必要があります", "dictUnpackIsNotMapping": "ディクショナリ アンパック演算子に必要なマッピング", "dunderAllSymbolNotPresent": "\"{name}\" は __all__ で指定されていますが、モジュールには存在しません", @@ -140,7 +140,7 @@ "duplicateBaseClass": "重複する基底クラスは許可されていません", "duplicateCapturePatternTarget": "Capture ターゲット \"{name}\" を同じパターン内に複数回出現させることはできません", "duplicateCatchAll": "許可される catch-all except 句は 1 つだけです", - "duplicateEnumMember": "列挙型メンバー \"{name}\" は既に宣言されています", + "duplicateEnumMember": "Enum メンバー \"{name}\" は既に宣言されています", "duplicateGenericAndProtocolBase": "許可される Generic[...] または Protocol[...] 基底クラスは 1 つだけです", "duplicateImport": "\"{importName}\" が複数回インポートされています", "duplicateKeywordOnly": "\"*\" 区切り記号を 1 つだけ使用できます", @@ -149,14 +149,14 @@ "duplicatePositionOnly": "許可される \"/\" パラメーターは 1 つだけです", "duplicateStarPattern": "パターン シーケンスで使用できる \"*\" パターンは 1 つだけです", "duplicateStarStarPattern": "許可されている \"**\" エントリは 1 つだけです", - "duplicateUnpack": "リストで許可されているアンパック操作は 1 つだけです", + "duplicateUnpack": "list 内で許可されるアンパック操作は 1 つのみです", "ellipsisAfterUnpacked": "\"...\" はアンパックされた TypeVarTuple または tuple と共に使用することはできません", "ellipsisContext": "\"...\" はこのコンテキストでは許可されていません", "ellipsisSecondArg": "\"...\" は2 つの引数の 2 番目の引数としてのみ使用できます", - "enumClassOverride": "列挙型クラス \"{name}\" は最終的なクラスであり、サブクラス化できません", - "enumMemberDelete": "列挙型メンバー \"{name}\" を削除できません", - "enumMemberSet": "列挙型メンバー \"{name}\" を割り当てることはできません", - "enumMemberTypeAnnotation": "列挙型メンバーには型注釈を使用できません", + "enumClassOverride": "Enum クラス \"{name}\" は final であり、サブクラス化できません", + "enumMemberDelete": "Enum メンバー \"{name}\" を削除できません", + "enumMemberSet": "Enum メンバー \"{name}\" を割り当てることはできません", + "enumMemberTypeAnnotation": "Type annotations are not allowed for enum members", "exceptionGroupIncompatible": "例外グループの構文 (\"except*\") には Python 3.11 以降が必要です", "exceptionGroupTypeIncorrect": "except* の例外型は BaseGroupException から派生できません", "exceptionTypeIncorrect": "\"{type}\" は BaseException から派生していません", @@ -189,7 +189,7 @@ "expectedIdentifier": "必要な識別子", "expectedImport": "\"import\" が必要です", "expectedImportAlias": "\"as\" の後にシンボルが必要です", - "expectedImportSymbols": "インポート後に 1 つ以上のシンボル名が必要です", + "expectedImportSymbols": "\"import\" の後に 1 つ以上のシンボル名が必要です", "expectedIn": "'in' が必要です", "expectedInExpr": "\"in\" の後に式が必要です", "expectedIndentedBlock": "インデントされたブロックが必要です", @@ -212,7 +212,7 @@ "finalClassIsAbstract": "クラス \"{type}\" は final とマークされており、すべての抽象なシンボルを実装する必要があります", "finalContext": "\"Final\" はこのコンテキストでは許可されていません", "finalInLoop": "\"Final\" 変数をループ内で割り当てることはできません", - "finalMethodOverride": "メソッド \"{name}\" は、クラス \"{className}\" で定義されている最終的なメソッドをオーバーライドできません", + "finalMethodOverride": "メソッド \"{name}\" は、クラス \"{className}\" で定義されている final メソッドをオーバーライドできません", "finalNonMethod": "関数 \"{name}\" はメソッドではないため、@final としてマークできません", "finalReassigned": "\"{name}\" は Final として宣言されており、再割り当てできません", "finalRedeclaration": "\"{name}\" は以前に Final として宣言されました", @@ -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\" には少なくとも 1 つの型引数が必要です", "genericTypeArgTypeVar": "\"Generic\" の型引数は型変数である必要があります", "genericTypeArgUnique": "\"Generic\" の型引数は一意である必要があります", - "globalReassignment": "\"{name}\" はグローバル宣言の前に割り当てられます", - "globalRedefinition": "\"{name}\" は既にグローバルに宣言されています", + "globalReassignment": "\"{name}\" は global 宣言の前に割り当てられます", + "globalRedefinition": "\"{name}\" は既に global として宣言されています", "implicitStringConcat": "暗黙的な文字列連結は許可されていません", "importCycleDetected": "インポート チェーンで循環が検出されました", "importDepthExceeded": "インポート チェーンの深さが {depth} を超えました", @@ -260,21 +260,21 @@ "initMethodSelfParamTypeVar": "\"__init__\" メソッドの \"self\" パラメーターの型注釈に、クラス スコープ型の変数を含めることはできません", "initMustReturnNone": "\"__init__\" の戻り値の型は None でなければなりません", "initSubclassCallFailed": "__init_subclass__ メソッドのキーワード引数が正しくありません", - "initSubclassClsParam": "__class_getitem__ override は \"cls\" パラメーターを受け取る必要があります", + "initSubclassClsParam": "__init_subclass__ オーバーライドは \"cls\" パラメーターを受け取る必要があります", "initVarNotAllowed": "\"InitVar\" はこのコンテキストでは許可されていません", "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\" の 2 番目の引数は、クラスのクラスまたはタプルである必要があります", - "isSubclassInvalidType": "\"issubclass\" の 2 番目の引数は、クラスまたはクラスのタプルである必要があります", - "keyValueInSet": "キー/値のペアはセット内では使用できません", + "isInstanceInvalidType": "\"isinstance\" の 2 番目の引数は、クラスまたはクラスの tuple である必要があります", + "isSubclassInvalidType": "\"issubclass\" の 2 番目の引数は、クラスまたはクラスの tuple である必要があります", + "keyValueInSet": "キーと値のペアは set 内では使用できません", "keywordArgInTypeArgument": "キーワード引数は型引数リストでは使用できません", "keywordArgShortcutIllegal": "キーワード引数のショートカットには Python 3.14 以降が必要です", "keywordOnlyAfterArgs": "キーワードのみの引数の区切り記号は、\"*\" パラメーターの後には使用できません", @@ -283,12 +283,12 @@ "lambdaReturnTypePartiallyUnknown": "ラムダの戻り値の型、\"{returnType}\" が部分的に不明です", "lambdaReturnTypeUnknown": "ラムダの戻り値の型が不明です", "listAssignmentMismatch": "型 \"{type}\" の式をターゲット リストに割り当てることはできません", - "listInAnnotation": "型注釈ではリスト式は使用できません", + "listInAnnotation": "List 式は型式では使用できません", "literalEmptyArgs": "\"Literal\" の後に 1 つ以上の型引数が必要です", "literalNamedUnicodeEscape": "名前付き Unicode エスケープ シーケンスは、\"Literal\" 文字列注釈ではサポートされていません", "literalNotAllowed": "\"Literal\" は、型引数なしでこのコンテキストでは使用できません", - "literalNotCallable": "リテラル型をインスタンス化できません", - "literalUnsupportedType": "\"Literal\" の型引数は None、リテラル値 (int、bool、str、または bytes)、または列挙型の値である必要があります", + "literalNotCallable": "Literal 型はインスタンス化できません", + "literalUnsupportedType": "\"Literal\" の型引数は None、literal 値 (int、bool、str、または bytes)、または enum 値である必要があります", "matchIncompatible": "Match ステートメントには Python 3.10 以降が必要です", "matchIsNotExhaustive": "match ステートメント内のケースでは、すべての値が完全に処理されるわけではありません", "maxParseDepthExceeded": "解析の最大深さを超えました。式を小さい部分式に分割する", @@ -304,41 +304,42 @@ "methodOverridden": "\"{name}\" は、クラス \"{className}\" の同じ名前のメソッドを互換性のない型 \"{type}\" でオーバーライドします", "methodReturnsNonObject": "\"{name}\" メソッドはオブジェクトを返しません", "missingSuperCall": "メソッド \"{methodName}\" は親クラスで同じ名前のメソッドを呼び出しません", + "mixingBytesAndStr": "Bytes 値と str 値を連結することはできません", "moduleAsType": "モジュールを型として使用することはできません", "moduleNotCallable": "モジュールは呼び出し可能ではありません", "moduleUnknownMember": "\"{memberName}\" はモジュール \"{moduleName}\" の既知の属性ではありません", "namedExceptAfterCatchAll": "名前付き except 句は、catch-all except 句の後には使用できません", "namedParamAfterParamSpecArgs": "ParamSpec args パラメーターの後にキーワード パラメーター \"{name}\" をシグネチャに含めることはできません", - "namedTupleEmptyName": "名前付きタプル内の名前を空にすることはできません", - "namedTupleEntryRedeclared": "親クラス \"{className}\" が名前付きタプルであるため、\"{name}\" をオーバーライドできません", - "namedTupleFirstArg": "最初の引数として名前付きタプル クラス名が必要です", + "namedTupleEmptyName": "名前付き tuple 内の名前を空にすることはできません", + "namedTupleEntryRedeclared": "親クラス \"{className}\" が名前付き tuple であるため、\"{name}\" をオーバーライドできません", + "namedTupleFirstArg": "最初の引数として名前付き tuple クラス名が必要です", "namedTupleMultipleInheritance": "NamedTuple による複数の継承はサポートされていません", "namedTupleNameKeyword": "フィールド名をキーワードにすることはできません", - "namedTupleNameType": "エントリ名と型を指定する 2 エントリタプルが必要です", - "namedTupleNameUnique": "名前付きタプル内の名前は一意である必要があります", + "namedTupleNameType": "エントリ名と型を指定する 2 エントリの tuple が必要です", + "namedTupleNameUnique": "名前付き tuple 内の名前は一意である必要があります", "namedTupleNoTypes": "\"namedtuple\" はタプル エントリに型を提供しません。代わりに \"NamedTuple\" を使用してください", - "namedTupleSecondArg": "2 番目の引数として名前付きタプル エントリ リストが必要です", + "namedTupleSecondArg": "2 番目の引数として名前付き tuple エントリ list が必要です", "newClsParam": "__new__ override は \"cls\" パラメーターを受け取る必要があります", "newTypeAnyOrUnknown": "NewType の 2 番目の引数は、Any や Unknown ではなく、既知のクラスでなければなりません", "newTypeBadName": "NewType の最初の引数は文字列リテラルである必要があります", - "newTypeLiteral": "NewType はリテラル型では使用できません", + "newTypeLiteral": "NewType は Literal 型では使用できません", "newTypeNameMismatch": "NewType は同じ名前の変数に割り当てる必要があります", "newTypeNotAClass": "NewType の 2 番目の引数としてクラスが必要です", "newTypeParamCount": "NewType には 2 つの位置引数が必要です", - "newTypeProtocolClass": "NewType は構造型 (プロトコルまたは TypedDict クラス) では使用できません", + "newTypeProtocolClass": "NewType は構造型 (Protocolまたは TypedDict クラス) では使用できません", "noOverload": "指定された引数に一致する \"{name}\" のオーバーロードがありません", - "noReturnContainsReturn": "戻り値の型が \"NoReturn\" として宣言されている関数に return ステートメントを含めることはできません", + "noReturnContainsReturn": "Function with declared return type \"NoReturn\" cannot include a return statement", "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\" の後に 1 つの型引数が必要です", @@ -364,9 +365,9 @@ "overloadImplementationMismatch": "オーバーロードされた実装がオーバーロード {index} のシグネチャと一致しません", "overloadReturnTypeMismatch": "\"{name}\" のオーバーロード {prevIndex} はオーバーロード {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,7 +378,7 @@ "paramSpecArgsUsage": "ParamSpec の \"args\" 属性は、*args パラメーターと共に使用する場合にのみ有効です", "paramSpecAssignedName": "ParamSpec は 、\"{name}\" という名前の変数に割り当てる必要があります", "paramSpecContext": "ParamSpec はこのコンテキストでは許可されていません", - "paramSpecDefaultNotTuple": "ParamSpec の既定値には、省略記号、タプル式、または ParamSpec が必要です", + "paramSpecDefaultNotTuple": "ParamSpec の既定値には、省略記号、tuple 式、または ParamSpec が必要です", "paramSpecFirstArg": "最初の引数として ParamSpec の名前が必要です", "paramSpecKwargsUsage": "ParamSpec の \"kwargs\" 属性は、**kwargs パラメーターと共に使用する場合にのみ有効です", "paramSpecNotUsedByOuterScope": "ParamSpec \"{name}\" はこのコンテキストでは意味がありません", @@ -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,40 +399,40 @@ "privateImportFromPyTypedModule": "\"{name}\" はモジュール \"{module}\" からエクスポートされていません", "privateUsedOutsideOfClass": "\"{name}\" はプライベートであり、宣言されているクラスの外部で使用されます", "privateUsedOutsideOfModule": "\"{name}\" はプライベートであり、それが宣言されているモジュールの外部で使用されています", - "propertyOverridden": "\"{name}\" は、クラス \"{className}\" の同じ名前のプロパティを誤ってオーバーライドします", - "propertyStaticMethod": "静的メソッドは、プロパティ getter、setter、または deleter では許可されていません", + "propertyOverridden": "\"{name}\" は、クラス \"{className}\" の同じ名前の property を誤ってオーバーライドします", + "propertyStaticMethod": "静的メソッドは、property の getter、setter または deleter に対して許可されません", "protectedUsedOutsideOfClass": "\"{name}\" は保護され、宣言されているクラスの外部で使用されます", - "protocolBaseClass": "プロトコル クラス \"{classType}\" は非プロトコル クラス \"{baseType}\" から派生できません", + "protocolBaseClass": "Protocol クラス \"{classType}\" は非 Protocol クラス \"{baseType}\" から派生できません", "protocolBaseClassWithTypeArgs": "型パラメーター構文を使用する場合、Protocol クラスでは型引数を使用できません", "protocolIllegal": "\"Protocol\" を使用するには Python 3.7 以降が必要です", "protocolNotAllowed": "\"Protocol\" はこのコンテキストでは使用できません", "protocolTypeArgMustBeTypeParam": "\"Protocol\" の型引数は型パラメーターである必要があります", "protocolUnsafeOverlap": "クラスが安全でない方法で \"{name}\" と重複しており、実行時に一致する可能性があります", - "protocolVarianceContravariant": "ジェネリック プロトコル \"{class}\" で使用される型変数 \"{variable}\" は反変である必要があります", - "protocolVarianceCovariant": "ジェネリック プロトコル \"{class}\" で使用される型変数 \"{variable}\" は共変である必要があります", - "protocolVarianceInvariant": "ジェネリック プロトコル \"{class}\" で使用される型変数 \"{variable}\" は不変である必要があります", + "protocolVarianceContravariant": "ジェネリック Protocol \"{class}\" で使用される型変数 \"{variable}\" は反変である必要があります", + "protocolVarianceCovariant": "ジェネリック Protocol \"{class}\" で使用される型変数 \"{variable}\" は共変である必要があります", + "protocolVarianceInvariant": "ジェネリック Protocol \"{class}\" で使用される型変数 \"{variable}\" は不変である必要があります", "pyrightCommentInvalidDiagnosticBoolValue": "Pyright コメント ディレクティブの後には \"=\" と値 true または false を指定する必要があります", - "pyrightCommentInvalidDiagnosticSeverityValue": "Pyright コメント ディレクティブの後に \"=\" を指定し、true、false、エラー、警告、情報、または none の値を指定する必要があります", - "pyrightCommentMissingDirective": "Pyright コメントの後にはディレクティブ (基本または厳格) または診断規則を指定する必要があります", + "pyrightCommentInvalidDiagnosticSeverityValue": "Pyright コメント ディレクティブの後に \"=\" と true、false、error、warning、information または none の値を指定する必要があります", + "pyrightCommentMissingDirective": "Pyright コメントの後にディレクティブ (basic または strict) または診断規則を指定する必要があります", "pyrightCommentNotOnOwnLine": "ファイル レベルの設定を制御するために使用する Pyright コメントは、独自の行に表示する必要があります", - "pyrightCommentUnknownDiagnosticRule": "\"{rule}\" は、azureight コメントの不明な診断規則です", - "pyrightCommentUnknownDiagnosticSeverityValue": "\"{value}\" は、pyright コメントに対して無効な値です。true、false、エラー、警告、情報、またはなしが必要です", + "pyrightCommentUnknownDiagnosticRule": "\"{rule}\" は pyright コメントの不明な診断規則です", + "pyrightCommentUnknownDiagnosticSeverityValue": "\"{value}\" は、pyright コメントの無効な値です。true、false、error、warning、information または none が必要です", "pyrightCommentUnknownDirective": "\"{directive}\" は、pyright コメントの不明なディレクティブです。\"strict\" または \"basic\" が必要です", "readOnlyArgCount": "\"ReadOnly\" の後に 1 つの型引数が必要です", "readOnlyNotInTypedDict": "\"ReadOnly\" はこのコンテキストでは許可されていません", "recursiveDefinition": "\"{name}\" の型は、それ自体を参照しているため、特定できませんでした", "relativeImportNotAllowed": "相対インポートは、\"import .a\" フォームでは使用できません。代わりに \"from . import a\" を使用します。", "requiredArgCount": "\"Required\" の後に 1 つの型引数が必要です", - "requiredNotInTypedDict": "このコンテキストでは\"必須\" は許可されていません", - "returnInAsyncGenerator": "値を持つ return ステートメントは、非同期ジェネレーターでは使用できません", + "requiredNotInTypedDict": "このコンテキストでは \"Required\" は許可されません", + "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\" 呼び出しに 1 つの位置引数が必要です", "revealTypeExpectedTextArg": "関数 \"reveal_type\" の \"expected_text\" 引数は、str リテラル値である必要があります", "revealTypeExpectedTextMismatch": "入力テキストの不一致;\"{expected}\" が必要ですが、\"{received}\" を受信しました", @@ -439,7 +440,7 @@ "selfTypeContext": "\"Self\" はこのコンテキストでは無効です", "selfTypeMetaclass": "\"Self\" はメタクラス (\"type\" のサブクラス) 内では使用できません", "selfTypeWithTypedSelfOrCls": "\"Self\" は、\"Self\" 以外の型注釈を持つ 'self' または 'cls' パラメーターを持つ関数では使用できません", - "setterGetterTypeMismatch": "プロパティ セッター値の型は、getter の戻り値の型に割り当てできません", + "setterGetterTypeMismatch": "property setter 値の型は、getter の戻り値の型に割り当てることができません", "singleOverload": "\"{name}\" はオーバーロードとしてマークされていますが、追加のオーバーロードがありません", "slotsAttributeError": "__slots__で \"{name}\" が指定されていません", "slotsClassVarConflict": "\"{name}\" が __slots__ で宣言されたインスタンス変数と競合しています", @@ -449,12 +450,12 @@ "staticClsSelfParam": "静的メソッドに \"self\" または \"cls\" パラメーターを指定することはできません", "stdlibModuleOverridden": "\"{path}\" は stdlib モジュール \"{name}\" をオーバーライドしています", "stringNonAsciiBytes": "非 ASCII 文字はバイト文字列リテラルでは使用できません", - "stringNotSubscriptable": "型注釈では文字列式を添字にすることはできません。注釈全体を引用符で囲んでください", + "stringNotSubscriptable": "型式では文字列式を添字にすることはできません。式全体を引用符で囲んでください", "stringUnsupportedEscape": "文字列リテラルでサポートされていないエスケープ シーケンス", "stringUnterminated": "文字列リテラルが未終了です", - "stubFileMissing": "\"{importName}\" のスタブ ファイルが見つかりません", - "stubUsesGetAttr": "スタブ ファイルの種類が不完全です。\"__getattr__\" はモジュールの型エラーを隠します", - "sublistParamsIncompatible": "Python 3.x ではサブリスト パラメーターはサポートされていません", + "stubFileMissing": "\"{importName}\" の stub ファイルが見つかりません", + "stubUsesGetAttr": "型 stub ファイルが不完全です。\"__getattr__\" はモジュールの型エラーを隠します", + "sublistParamsIncompatible": "Python 3.x では sublist パラメーターはサポートされていません", "superCallArgCount": "\"super\" 呼び出しには 2 つ以下の引数が必要です", "superCallFirstArg": "\"super\" 呼び出しの最初の引数としてクラス型が必要ですが、\"{type}\" を受け取りました", "superCallSecondArg": "\"super\" 呼び出しの 2 番目の引数は、\"{type}\" から派生したオブジェクトまたはクラスである必要があります", @@ -464,12 +465,12 @@ "symbolIsUnbound": "\"{name}\" はバインドされていません", "symbolIsUndefined": "\"{name}\" が定義されていません", "symbolOverridden": "\"{name}\" はクラス \"{className}\" の同じ名前のシンボルをオーバーライドします", - "ternaryNotAllowed": "型の注釈で 3 項式 は使用できません", + "ternaryNotAllowed": "3 項式は型式では使用できません", "totalOrderingMissingMethod": "total_orderingを使用するには、クラスで \"__lt__\"、\"__le__\"、\"__gt__\"、または \"__ge__\" のいずれかを定義する必要があります", "trailingCommaInFromImport": "末尾のコンマはかっこで囲まずには使用できません", "tryWithoutExcept": "Try ステートメントには、少なくとも 1 つの except 句または finally 句が必要です", - "tupleAssignmentMismatch": "型 \"{type}\" の式をターゲット タプルに割り当てることはできません", - "tupleInAnnotation": "タプル式は型注釈では使用できません", + "tupleAssignmentMismatch": "型 \"{type}\" の式はターゲット tuple に割り当てることができません", + "tupleInAnnotation": "tuple 式は型式では使用できません", "tupleIndexOutOfRange": "インデックス {index} が型 {type} の範囲外です", "typeAliasIllegalExpressionForm": "型エイリアス定義の式フォームが無効です", "typeAliasIsRecursiveDirect": "型エイリアス \"{name}\" は、その定義でそれ自体を使用できません", @@ -481,28 +482,29 @@ "typeAliasTypeMustBeAssigned": "TypeAliasType は、型エイリアスと同じ名前の変数に割り当てる必要があります", "typeAliasTypeNameArg": "TypeAliasType の最初の引数は、型エイリアスの名前を表す文字列リテラルである必要があります", "typeAliasTypeNameMismatch": "型エイリアスの名前は、それが割り当てられている変数の名前と一致する必要があります", - "typeAliasTypeParamInvalid": "型パラメーター リストは、TypeVar、TypeVarTuple、または ParamSpec のみを含むタプルである必要があります", + "typeAliasTypeParamInvalid": "型パラメーター リストは、TypeVar、TypeVarTuple、または ParamSpec のみを含む tuple である必要があります", "typeAnnotationCall": "型式では呼び出し式を使用できません", "typeAnnotationVariable": "型式では変数を使用できません", "typeAnnotationWithCallable": "\"type\" の型引数はクラスである必要があります。呼び出し可能関数はサポートされていません", - "typeArgListExpected": "ParamSpec、省略記号、または型の一覧が必要です", - "typeArgListNotAllowed": "この型引数にはリスト式を使用できません", + "typeArgListExpected": "ParamSpec、省略記号、または型の list が必要です", + "typeArgListNotAllowed": "この型引数には list 式は使用できません", "typeArgsExpectingNone": "クラス \"{name}\" に型引数が必要ありません", "typeArgsMismatchOne": "1 つの型引数が必要ですが、{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\" は 1 つの位置引数を受け取ります", "typeGuardArgCount": "\"TypeGuard\" または \"TypeIs\" の後に 1 つの型引数が必要です", "typeGuardParamCount": "ユーザー定義型ガード関数とメソッドには、少なくとも 1 つの入力パラメーターが必要です", "typeIsReturnType": "TypeIs の戻り値の型 (\"{returnType}\") と値パラメーターの型 (\"{type}\") が一致しません", - "typeNotAwaitable": "\"{type}\" は待機できません", + "typeNotAwaitable": "\"{type}\" は awaitable ではありません", "typeNotIntantiable": "\"{type}\" をインスタンス化できません", "typeNotIterable": "\"{type}\" は反復できません", "typeNotSpecializable": "型 \"{type}\" を特殊化できませんでした", @@ -537,7 +539,7 @@ "typeVarSingleConstraint": "TypeVar には少なくとも 2 つの制約付き型が必要です", "typeVarTupleConstraints": "TypeVarTuple に値制約を持たせることはできません", "typeVarTupleContext": "TypeVarTuple はこのコンテキストでは許可されていません", - "typeVarTupleDefaultNotUnpacked": "TypeVarTuple の既定の型は、アンパックされたタプルまたは TypeVarTuple である必要があります", + "typeVarTupleDefaultNotUnpacked": "TypeVarTuple の既定の型は、アンパックされた tuple または TypeVarTuple である必要があります", "typeVarTupleMustBeUnpacked": "TypeVarTuple 値にはアンパック演算子が必要です", "typeVarTupleUnknownParam": "\"{name}\" は TypeVarTuple に対する不明なパラメーターです", "typeVarUnknownParam": "\"{name}\" は TypeVar に対する不明なパラメーターです", @@ -552,8 +554,8 @@ "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": "辞書エントリ名に文字列リテラルが必要です", @@ -574,34 +576,34 @@ "unaccessedSymbol": "\"{name}\" は参照されていません", "unaccessedVariable": "変数 \"{name}\" は参照されていません", "unannotatedFunctionSkipped": "関数 \"{name}\" の分析は、表示されないためスキップされます", - "unaryOperationNotAllowed": "型の注釈で単項演算子は使用できません", + "unaryOperationNotAllowed": "単項演算子は型式では使用できません", "unexpectedAsyncToken": "\"def\"、\"with\"、または \"for\" が \"async\" の後に続く必要があります", "unexpectedExprToken": "式の最後に予期しないトークンが含まれています", "unexpectedIndent": "予期しないインデント", "unexpectedUnindent": "インデント解除は予期されていません", "unhashableDictKey": "辞書キーはハッシュ可能である必要があります", - "unhashableSetEntry": "設定エントリはハッシュ可能である必要があります", - "uninitializedAbstractVariables": "抽象基底クラスで定義された変数は、最終クラス \"{classType}\" で初期化されません", + "unhashableSetEntry": "set エントリはハッシュ可能である必要があります", + "uninitializedAbstractVariables": "抽象基底クラスで定義された変数が、final クラス \"{classType}\" で初期化されていません", "uninitializedInstanceVariable": "インスタンス変数 \"{name}\" は、クラス本体または__init__ メソッドで初期化されていません", - "unionForwardReferenceNotAllowed": "共用体構文を文字列オペランドと共に使用することはできません。式全体を引用符で囲んでください", + "unionForwardReferenceNotAllowed": "Union 構文は文字列オペランドで使用できません。式全体を引用符で囲んでください", "unionSyntaxIllegal": "共用体の代替構文には Python 3.10 以降が必要です", - "unionTypeArgCount": "共用体には 2 つ以上の型引数が必要です", - "unionUnpackedTuple": "アンパックされたタプルを union に含めることはできません", - "unionUnpackedTypeVarTuple": "アンパックされた TypeVarTuple を union に含めることはできません", - "unnecessaryCast": "不要な \"キャスト\" 呼び出し。型は既に \"{type}\" です", + "unionTypeArgCount": "Union には 2 つ以上の型引数が必要です", + "unionUnpackedTuple": "Union cannot include an unpacked tuple", + "unionUnpackedTypeVarTuple": "Union cannot include an unpacked TypeVarTuple", + "unnecessaryCast": "不要な \"cast\" 呼び出し。型は既に \"{type}\" です", "unnecessaryIsInstanceAlways": "不要な isinstance 呼び出し。\"{testType}\" は常に \"{classType}\" のインスタンスです", "unnecessaryIsSubclassAlways": "不要な issubclass 呼び出し。\"{testType}\" は常に \"{classType}\" のサブクラスです", - "unnecessaryPyrightIgnore": "不要な \"#ight: ignore\" コメント", + "unnecessaryPyrightIgnore": "不要な \"# pyright: ignore\" コメント", "unnecessaryPyrightIgnoreRule": "不要な \"# pyright: ignore\" ルール: \"{name}\"", "unnecessaryTypeIgnore": "不要な \"# type: ignore\" コメント", "unpackArgCount": "\"Unpack\" の後に 1 つの型引数が必要です", "unpackExpectedTypeVarTuple": "Unpack の型引数として TypeVarTuple または tuple が必要です", "unpackExpectedTypedDict": "Unpack に必要な TypedDict 型引数", "unpackIllegalInComprehension": "アンパック操作は理解できません", - "unpackInAnnotation": "型注釈ではアンパック演算子は使用できません", + "unpackInAnnotation": "アンパック演算子は型式では使用できません", "unpackInDict": "アンパック操作はディクショナリで許可されていません", - "unpackInSet": "アンパック演算子はセット内では使用できません", - "unpackNotAllowed": "アンパックはこのコンテキストでは許可されていません", + "unpackInSet": "アンパック演算子は set 内では使用できません", + "unpackNotAllowed": "Unpack はこのコンテキストでは許可されていません", "unpackOperatorNotAllowed": "このコンテキストではアンパック操作は許可されていません", "unpackTuplesIllegal": "Python 3.8 より前のタプルではアンパック操作は許可されていません", "unpackedArgInTypeArgument": "アンパックされた引数は、このコンテキストでは使用できません", @@ -616,35 +618,35 @@ "unreachableExcept": "例外が既に処理されているため、Except 句に到達できません", "unsupportedDunderAllOperation": "\"__all__\" に対する操作はサポートされていないため、エクスポートされたシンボル リストが正しくない可能性があります", "unusedCallResult": "呼び出し式の結果は \"{type}\" 型であり、使用されません。これが意図的な場合は変数 \"_\" に代入する", - "unusedCoroutine": "非同期関数呼び出しの結果は使用されません。\"await\" を使用するか、結果を変数に代入してください", + "unusedCoroutine": "async 関数呼び出しの結果が使用されていません。\"await\" を使用するか、結果を変数に代入してください。", "unusedExpression": "式の値が使用されていません", - "varAnnotationIllegal": "変数の型注釈には Python 3.6 以降が必要です。以前のバージョンとの互換性のために型コメントを使用する", + "varAnnotationIllegal": "変数の type 注釈には Python 3.6 以降が必要です。以前のバージョンとの互換性を保つために type コメントを使用してください", "variableFinalOverride": "変数 \"{name}\" は Final とマークされ、クラス \"{className}\" の同じ名前の Final 以外の変数をオーバーライドします", "variadicTypeArgsTooMany": "型引数リストには、アンパックされた TypeVarTuple または tuple を最大 1 つ含めることができます", "variadicTypeParamTooManyAlias": "型エイリアスには TypeVarTuple 型パラメーターを最大 1 つ含めることができますが、複数の ({names}) を受け取りました", "variadicTypeParamTooManyClass": "ジェネリック クラスには最大 1 つの TypeVarTuple 型パラメーターを指定できますが、複数の ({names}) を受け取りました", "walrusIllegal": "演算子 \":=\" には Python 3.8 以降が必要です", "walrusNotAllowed": "演算子 \":=\" は、かっこを囲まないこのコンテキストでは使用できません", - "wildcardInFunction": "ワイルドカードのインポートは、クラスまたは関数内では許可されていません", - "wildcardLibraryImport": "ライブラリからのワイルドカードインポートは許可されていません", + "wildcardInFunction": "ワイルドカードの import は、クラス内または関数内では許可されません", + "wildcardLibraryImport": "ライブラリからのワイルドカードの import は許可されていません", "wildcardPatternTypePartiallyUnknown": "ワイルドカード パターンによってキャプチャされた型は部分的に不明です", "wildcardPatternTypeUnknown": "ワイルドカード パターンによってキャプチャされた型が不明です", "yieldFromIllegal": "\"yield from\" を使用するには Python 3.3 以降が必要です", - "yieldFromOutsideAsync": "非同期関数では \"yield from\" は使用できません", + "yieldFromOutsideAsync": "async 関数では \"yield from\" は使用できません", "yieldOutsideFunction": "関数またはラムダの外部では \"yield\" は許可されません", "yieldWithinComprehension": "\"yield\" は内包表記内では使用できません", "zeroCaseStatementsFound": "Match ステートメントには、少なくとも 1 つの case ステートメントを含める必要があります", - "zeroLengthTupleNotAllowed": "このコンテキストでは長さ 0 のタプルは使用できません" + "zeroLengthTupleNotAllowed": "このコンテキストでは長さ 0 の tuple は使用できません" }, "DiagnosticAddendum": { - "annotatedNotAllowed": "\"注釈付き\" 特殊フォームは、インスタンスおよびクラスのチェックでは使用できません", + "annotatedNotAllowed": "\"Annotated\" 特殊フォームは、インスタンスおよびクラスのチェックでは使用できません", "argParam": "引数はパラメーター \"{paramName}\" に対応します", "argParamFunction": "引数は関数 \"{functionName}\" のパラメーター \"{paramName}\" に対応します", "argsParamMissing": "パラメーター \"*{paramName}\" に対応するパラメーターがありません", "argsPositionOnly": "位置のみのパラメーターの不一致。{expected} が必要ですが、{received} を受信しました", "argumentType": "引数の型は \"{type}\" です", "argumentTypes": "引数の型: ({types})", - "assignToNone": "型は \"None\" と互換性がありません", + "assignToNone": "型は \"None\" に割り当てできません", "asyncHelp": "\"async with\" を意味しましたか?", "baseClassIncompatible": "基底クラス \"{baseClass}\" は型 \"{type}\" と互換性がありません", "baseClassIncompatibleSubclass": "基底クラス \"{baseClass}\" は、型 \"{type}\" と互換性のない \"{subclass}\" から派生しています", @@ -657,7 +659,7 @@ "dataProtocolUnsupported": "\"{name}\" はデータ プロトコルです", "descriptorAccessBindingFailed": "記述子クラス \"{className}\" のメソッド \"{name}\" をバインドできませんでした", "descriptorAccessCallFailed": "記述子クラス \"{className}\" のメソッド \"{name}\" を呼び出せませんでした", - "finalMethod": "最終的なメソッド", + "finalMethod": "Final メソッド", "functionParamDefaultMissing": "パラメーター \"{name}\" に既定の引数がありません", "functionParamName": "パラメーター名の不一致: \"{destName}\" と \"{srcName}\"", "functionParamPositionOnly": "位置のみのパラメーターの不一致; パラメーター \"{name}\" は位置のみではありません", @@ -665,9 +667,9 @@ "functionTooFewParams": "関数が受け入れる位置指定パラメーターが少なすぎます。{expected} が必要ですが、{received} を受信しました", "functionTooManyParams": "関数が受け入れる位置指定パラメーターが多すぎます。{expected} が必要ですが、{received} を受信しました", "genericClassNotAllowed": "インスタンスまたはクラスのチェックでは、型引数を含むジェネリック型は使用できません", - "incompatibleDeleter": "プロパティ削除子メソッドに互換性がありません", - "incompatibleGetter": "プロパティ getter メソッドに互換性がありません", - "incompatibleSetter": "プロパティ セッター メソッドに互換性がありません", + "incompatibleDeleter": "property deleter メソッドは互換性がありません", + "incompatibleGetter": "property getter メソッドは互換性がありません", + "incompatibleSetter": "property setter メソッドは互換性がありません", "initMethodLocation": "__init__ メソッドはクラス \"{type}\" で定義されています", "initMethodSignature": "__init__の署名は \"{type}\" です", "initSubclassLocation": "__init_subclass__ メソッドはクラス \"{name}\" で定義されています", @@ -681,14 +683,14 @@ "keyUndefined": "\"{name}\" は \"{type}\" で定義されたキーではありません", "kwargsParamMissing": "パラメーター \"**{paramName}\" に対応するパラメーターがありません", "listAssignmentMismatch": "型 \"{type}\" はターゲット リストと互換性がありません", - "literalAssignmentMismatch": "\"{sourceType}\" は型 \"{destType}\" と互換性がありません", + "literalAssignmentMismatch": "\"{sourceType}\" は型 \"{destType}\" に割り当てできません", "matchIsNotExhaustiveHint": "完全な処理が意図されていない場合は、\"case _: pass\" を追加します", "matchIsNotExhaustiveType": "ハンドルされない型: \"{type}\"", "memberAssignment": "型 \"{type}\" の式をクラス \"{classType}\" の属性 \"{name}\" に割り当てることはできません", "memberIsAbstract": "\"{type}.{name}\" は実装されていません", "memberIsAbstractMore": "その他 {count} 件...", "memberIsClassVarInProtocol": "\"{name}\" はプロトコルで ClassVar として定義されています", - "memberIsInitVar": "\"{name}\" は init 専用フィールドです", + "memberIsInitVar": "\"{name}\" は init-only フィールドです", "memberIsInvariant": "\"{name}\" は変更可能であるため、不変です", "memberIsNotClassVarInClass": "プロトコルと互換性を持たせるには、\"{name}\" を ClassVar として定義する必要があります", "memberIsNotClassVarInProtocol": "\"{name}\" はプロトコルで ClassVar として定義されていません", @@ -699,9 +701,9 @@ "memberTypeMismatch": "\"{name}\" は互換性のない型です", "memberUnknown": "属性 \"{name}\" が不明です", "metaclassConflict": "メタクラス \"{metaclass1}\" が \"{metaclass2}\" と競合しています", - "missingDeleter": "プロパティ削除メソッドがありません", - "missingGetter": "プロパティ getter メソッドがありません", - "missingSetter": "プロパティ セッター メソッドがありません", + "missingDeleter": "property deleter メソッドがありません", + "missingGetter": "property getter メソッドがありません", + "missingSetter": "property setter メソッドがありません", "namedParamMissingInDest": "余分なパラメーター \"{name}\"", "namedParamMissingInSource": "キーワード パラメーター \"{name}\" が見つかりません", "namedParamTypeMismatch": "型 \"{sourceType}\" のキーワード パラメーター \"{name}\" は型 \"{destType}\" と互換性がありません", @@ -710,7 +712,7 @@ "newMethodSignature": "__new__の署名は \"{type}\" です", "newTypeClassNotAllowed": "NewType で作成されたクラスは、インスタンスおよびクラスのチェックでは使用できません", "noOverloadAssignable": "型 \"{type}\" に一致するオーバーロードされた関数はありません", - "noneNotAllowed": "インスタンスまたはクラスのチェックには何も使用できません", + "noneNotAllowed": "インスタンスまたはクラスのチェックには None 使用できません", "orPatternMissingName": "名前がありません: {name}", "overloadIndex": "オーバーロード {index} が最も近い一致です", "overloadNotAssignable": "\"{name}\" の 1 つ以上のオーバーロードが割り当て可能ではありません", @@ -741,16 +743,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": "\"#ight: ignore[] を使用して 1 行の診断を抑制する", + "pyrightCommentIgnoreTip": "\"# pyright: ignore[] を使用して 1 行の診断を抑制します", "readOnlyAttribute": "属性 \"{name}\" は読み取り専用です", "seeClassDeclaration": "クラス宣言を参照してください", "seeDeclaration": "宣言を参照してください", @@ -759,17 +761,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}\" は、型変数 \"{name}\" のバインドされた型 \"{destType}\" と互換性がありません", - "typeConstrainedTypeVar": "型 \"{type}\" は制約付き型変数 \"{name}\" と互換性がありません", - "typeIncompatible": "\"{sourceType}\" は \"{destType}\" と互換性がありません", + "typeAssignmentMismatch": "型 \"{sourceType}\" は型 \"{destType}\" に割り当てできません", + "typeBound": "型 \"{sourceType}\" は、型変数 \"{name}\" の上限 \"{destType}\" に割り当てできません", + "typeConstrainedTypeVar": "型 \"{type}\" は制約付き型変数 \"{name}\" に割り当てできません", + "typeIncompatible": "\"{sourceType}\" は \"{destType}\" に割り当てできません", "typeNotClass": "\"{type}\" はクラスではありません", "typeNotStringLiteral": "\"{type}\" は文字列リテラルではありません", "typeOfSymbol": "\"{name}\" の型は \"{type}\" です", @@ -780,7 +782,7 @@ "typeVarIsCovariant": "型パラメーター \"{name}\" は共変ですが、\"{sourceType}\" は \"{destType}\" のサブタイプではありません", "typeVarIsInvariant": "型パラメーター \"{name}\" は不変ですが、\"{sourceType}\" は \"{destType}\" と同じではありません", "typeVarNotAllowed": "TypeVar は、インスタンスまたはクラスのチェックには使用できません", - "typeVarTupleRequiresKnownLength": "TypeVarTuple を不明な長さのタプルにバインドすることはできません", + "typeVarTupleRequiresKnownLength": "TypeVarTuple を不明な長さの tuple にバインドすることはできません", "typeVarUnnecessarySuggestion": "代わりに {type} を使用してください", "typeVarUnsolvableRemedy": "引数が指定されていない場合に戻り値の型を指定するオーバーロードを指定します", "typeVarsMissing": "型変数がありません: {names}", @@ -804,8 +806,8 @@ "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}\" と互換性がありません" diff --git a/packages/pyright-internal/src/localization/package.nls.ko.json b/packages/pyright-internal/src/localization/package.nls.ko.json index 83a621a2b..b20e9389e 100644 --- a/packages/pyright-internal/src/localization/package.nls.ko.json +++ b/packages/pyright-internal/src/localization/package.nls.ko.json @@ -1,7 +1,7 @@ { "CodeAction": { - "createTypeStub": "형식 스텁 만들기", - "createTypeStubFor": "\"{moduleName}\"에 대한 형식 스텁 만들기", + "createTypeStub": "형식 Stub 만들기", + "createTypeStubFor": "\"{moduleName}\"에 대한 형식 Stub 만들기", "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": "형식 주석에는 이스케이프 문자를 사용할 수 없습니다.", + "annotationRawString": "형식 식은 원시 문자열 리터럴을 사용할 수 없습니다.", + "annotationSpansStrings": "형식 식은 여러 문자열 리터럴에 걸쳐 사용할 수 없습니다.", + "annotationStringEscape": "형식 식에는 이스케이프 문자를 포함할 수 없습니다.", "argAssignment": "\"{argType}\" 형식의 인수를 \"{paramType}\" 형식의 매개 변수에 할당할 수 없습니다.", "argAssignmentFunction": "\"{argType}\" 형식의 인수를 \"{functionName}\" 함수의 \"{paramType}\" 형식의 매개 변수에 할당할 수 없습니다.", "argAssignmentParam": "\"{argType}\" 형식의 인수를 \"{paramType}\" 형식의 \"{paramName}\" 매개 변수에 할당할 수 없습니다.", @@ -45,10 +45,10 @@ "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\" allowed only within async function", "backticksIllegal": "백틱으로 묶인 식은 Python 3.x에서 지원되지 않습니다. 대신 repr 사용", "baseClassCircular": "클래스는 스스로에서 파생될 수 없습니다.", "baseClassFinal": "기본 클래스 \"{type}\"이(가) final로 표시되어 서브클래스할 수 없습니다.", @@ -57,7 +57,7 @@ "baseClassMethodTypeIncompatible": "\"{classType}\" 클래스의 기본 클래스가 호환되지 않는 방식으로 \"{name}\" 메서드를 정의합니다.", "baseClassUnknown": "기본 클래스 형식을 알 수 없으므로 파생 클래스의 형식이 모호합니다.", "baseClassVariableTypeIncompatible": "\"{classType}\" 클래스의 기본 클래스가 \"{name}\" 변수를 호환되지 않는 방식으로 정의합니다.", - "binaryOperationNotAllowed": "형식 주석에는 이항 연산자를 사용할 수 없습니다.", + "binaryOperationNotAllowed": "형식 식에는 이항 연산자를 사용할 수 없습니다.", "bindTypeMismatch": "‘{type}’을(를) 매개 변수 ‘{paramName}’에 할당할 수 없으므로 ‘{methodName}’ 메서드를 바인딩할 수 없습니다.", "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}’은(는) 특수 형식 별칭이므로 클래스 패턴에서 사용할 수 없습니다.", @@ -87,10 +87,10 @@ "comparisonAlwaysFalse": "\"{leftType}\" 및 \"{rightType}\" 형식이 겹치지 않으므로 조건은 항상 False로 평가됩니다.", "comparisonAlwaysTrue": "\"{leftType}\" 및 \"{rightType}\" 형식이 겹치지 않으므로 조건은 항상 True로 평가됩니다.", "comprehensionInDict": "이해력은 다른 사전 항목과 함께 사용할 수 없습니다.", - "comprehensionInSet": "이해력은 다른 집합 항목과 함께 사용할 수 없습니다.", - "concatenateContext": "이 컨텍스트에서는 \"연결\"을 사용할 수 없습니다.", + "comprehensionInSet": "이해력은 다른 set 항목과 함께 사용할 수 없습니다.", + "concatenateContext": "이 컨텍스트에서는 \"Concatenate\"를 사용할 수 없습니다.", "concatenateParamSpecMissing": "\"Concatenate\"의 마지막 형식 인수는 ParamSpec 또는 \"...\"이어야 합니다.", - "concatenateTypeArgsMissing": "‘연결’에는 적어도 두 개의 형식 인수가 필요합니다.", + "concatenateTypeArgsMissing": "\"Concatenate\"에는 적어도 두 개의 형식 인수가 필요합니다.", "conditionalOperandInvalid": "’{type}’ 형식의 조건부 피연산자입니다.", "constantRedefinition": "‘{name}’은(는) 대문자이므로 상수이고 다시 정의할 수 없습니다.", "constructorParametersMismatch": "‘{classType}’ 클래스에서 __new__ 서명과 __init__가 불일치합니다.", @@ -111,7 +111,7 @@ "dataClassPostInitType": "데이터 클래스 __post_init__ 메서드 매개 변수 형식이 필드 \"{fieldName}\"에 대해 일치하지 않습니다.", "dataClassSlotsOverwrite": "__slots__ 클래스에 이미 정의되어 있습니다.", "dataClassTransformExpectedBoolLiteral": "정적으로 True 또는 False로 계산되는 식이 필요합니다.", - "dataClassTransformFieldSpecifier": "클래스 또는 함수의 튜플이 필요하지만 ‘{type}’ 형식을 받았습니다.", + "dataClassTransformFieldSpecifier": "클래스 또는 함수의 tuple이 필요하지만 “{type}” 형식을 받았습니다.", "dataClassTransformPositionalParam": "\"dataclass_transform\"에 대한 모든 인수는 키워드 인수여야 합니다.", "dataClassTransformUnknownArgument": "dataclass_transform은 \"{name}\" 인수를 지원하지 않습니다.", "dataProtocolInSubclassCheck": "데이터 프로토콜(비 메서드 특성 포함)은 issubclass 호출에서 허용되지 않습니다.", @@ -127,20 +127,20 @@ "deprecatedDescriptorSetter": "\"{name}\" 설명자에 대한 \"__set__\" 메서드는 사용되지 않습니다.", "deprecatedFunction": "\"{name}\" 함수는 더 이상 사용되지 않습니다.", "deprecatedMethod": "\"{className}\" 클래스의 \"{name}\" 메서드는 더 이상 사용되지 않습니다.", - "deprecatedPropertyDeleter": "\"{name}\" 속성에 대한 deleter는 사용되지 않습니다.", - "deprecatedPropertyGetter": "\"{name}\" 속성에 대한 getter는 사용되지 않습니다.", - "deprecatedPropertySetter": "\"{name}\" 속성에 대한 setter는 사용되지 않습니다.", + "deprecatedPropertyDeleter": "\"{name}\" property에 대한 deleter는 사용되지 않습니다.", + "deprecatedPropertyGetter": "\"{name}\" property에 대한 getter는 사용되지 않습니다.", + "deprecatedPropertySetter": "\"{name}\" property에 대한 setter는 사용되지 않습니다.", "deprecatedType": "이 형식은 Python {version}부터 사용되지 않습니다. 대신 \"{replacement}\"을(를) 사용하세요.", "dictExpandIllegalInComprehension": "사전 확장은 이해에 사용할 수 없습니다.", - "dictInAnnotation": "형식 주석에는 사전 식을 사용할 수 없습니다.", + "dictInAnnotation": "형식 식에는 사전 식을 사용할 수 없습니다.", "dictKeyValuePairs": "사전 항목은 키/값 쌍을 포함해야 합니다.", "dictUnpackIsNotMapping": "사전 압축 풀기 연산자에 대한 매핑이 필요합니다.", "dunderAllSymbolNotPresent": "\"{name}\"이(가) __all__에 지정되었지만 모듈에 없습니다.", "duplicateArgsParam": "\"*\" 매개 변수 하나만 허용됨", "duplicateBaseClass": "중복 기본 클래스는 허용되지 않습니다.", "duplicateCapturePatternTarget": "‘{name}’ 캡처 대상이 동일한 패턴 내에 두 번 이상 나타날 수 없습니다.", - "duplicateCatchAll": "절을 제외한 하나의 catch-all만 허용됨", - "duplicateEnumMember": "열거형 멤버 \"{name}\"이(가) 이미 선언되었습니다.", + "duplicateCatchAll": "하나의 catch-all except 절만 허용됨", + "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": "Type annotations are not allowed for enum members", "exceptionGroupIncompatible": "예외 그룹 구문(\"except*\")에는 Python 3.11 이상이 필요합니다.", "exceptionGroupTypeIncorrect": "except*의 예외 형식은 BaseGroupException에서 파생될 수 없습니다.", "exceptionTypeIncorrect": "‘{type}’은 BaseException에서 파생되지 않습니다.", @@ -182,14 +182,14 @@ "expectedElse": "\"else\"가 필요합니다.", "expectedEquals": "\"=\"가 필요합니다.", "expectedExceptionClass": "잘못된 예외 클래스 또는 개체", - "expectedExceptionObj": "필요한 예외 개체, 예외 클래스 또는 없음", + "expectedExceptionObj": "필요한 예외 개체, 예외 클래스 또는 None", "expectedExpr": "식이 필요합니다.", "expectedFunctionAfterAsync": "‘async’ 다음에 함수 정의가 필요합니다.", "expectedFunctionName": "\"def\" 뒤에 함수 이름이 필요합니다.", "expectedIdentifier": "식별자가 필요합니다.", "expectedImport": "\"import\"가 필요합니다.", "expectedImportAlias": "\"as\" 뒤에 기호가 필요합니다.", - "expectedImportSymbols": "가져온 후 하나 이상의 기호 이름이 필요합니다.", + "expectedImportSymbols": "\"import\" 뒤에 하나 이상의 기호 이름이 필요합니다.", "expectedIn": "\"in\"이 필요합니다.", "expectedInExpr": "\"in\" 뒤에 식이 필요합니다.", "expectedIndentedBlock": "들여쓰기 블록이 필요합니다.", @@ -209,10 +209,10 @@ "expectedTypeNotString": "형식이 필요하지만 문자열 리터럴을 받았습니다.", "expectedTypeParameterName": "형식 매개 변수 이름이 필요합니다.", "expectedYieldExpr": "yield 문에 식이 필요합니다.", - "finalClassIsAbstract": "\"{type}\" 클래스가 Final로 표시되어 있으며 모든 추상 기호를 구현해야 합니다.", + "finalClassIsAbstract": "\"{type}\" 클래스가 final로 표시되어 있으며 모든 추상 기호를 구현해야 합니다.", "finalContext": "\"Final\"은 이 컨텍스트에서 허용되지 않습니다.", "finalInLoop": "루프 내에는 \"Final\" 변수를 할당할 수 없습니다.", - "finalMethodOverride": "\"{name}\" 메서드는 \"{className}\" 클래스에 정의된 최종 메서드를 재정의할 수 없습니다.", + "finalMethodOverride": "\"{name}\" 메서드는 \"{className}\" 클래스에 정의된 final 메서드를 재정의할 수 없습니다.", "finalNonMethod": "함수 \"{name}\"은(는) 메서드가 아니므로 @final로 표시할 수 없습니다.", "finalReassigned": "‘{name}’이 Final로 선언되었으므로 다시 할당할 수 없습니다.", "finalRedeclaration": "\"{name}\"이(가) 이전에 Final로 선언되었습니다.", @@ -234,10 +234,10 @@ "functionInConditionalExpression": "조건식은 항상 True로 평가되는 함수를 참조합니다.", "functionTypeParametersIllegal": "함수 형식 매개 변수 구문에는 Python 3.12 이상이 필요합니다.", "futureImportLocationNotAllowed": "__future__ 가져오기는 파일의 시작 부분에 있어야 합니다.", - "generatorAsyncReturnType": "비동기 생성기 함수의 반환 형식은 \"AsyncGenerator[{yieldType}, Any]\"와 호환되어야 합니다.", + "generatorAsyncReturnType": "async 생성기 함수의 반환 형식은 \"AsyncGenerator[{yieldType}, Any]\"와 호환되어야 합니다.", "generatorNotParenthesized": "생성기 식은 단독 인수가 아닌 경우 괄호로 지정해야 합니다.", "generatorSyncReturnType": "생성기 함수의 반환 형식은 \"Generator[{yieldType}, Any, Any]\"와 호환되어야 합니다.", - "genericBaseClassNotAllowed": "‘제네릭’ 기본 클래스는 형식 매개 변수 구문과 함께 사용할 수 없습니다.", + "genericBaseClassNotAllowed": "\"Generic\" 기본 클래스는 형식 매개 변수 구문과 함께 사용할 수 없습니다.", "genericClassAssigned": "제네릭 클래스 형식을 할당할 수 없습니다.", "genericClassDeleted": "제네릭 클래스 형식을 삭제할 수 없습니다.", "genericInstanceVariableAccess": "클래스를 통한 제네릭 인스턴스 변수에 대한 액세스가 모호합니다.", @@ -246,8 +246,8 @@ "genericTypeArgMissing": "\"Generic\"에는 하나 이상의 형식 인수가 필요합니다.", "genericTypeArgTypeVar": "\"Generic\"의 형식 인수는 형식 변수여야 합니다.", "genericTypeArgUnique": "\"Generic\"의 형식 인수는 고유해야 합니다.", - "globalReassignment": "전역 선언 전에 \"{name}\"이(가) 할당되었습니다.", - "globalRedefinition": "\"{name}\"이(가) 이미 전역으로 선언되었습니다.", + "globalReassignment": "global 선언 전에 \"{name}\"이(가) 할당되었습니다.", + "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": "‘issubclass’에 대한 두 번째 인수는 클래스 또는 클래스의 튜플이어야 합니다.", - "isSubclassInvalidType": "\"issubclass\"에 대한 두 번째 인수는 클래스 또는 클래스의 튜플이어야 합니다.", - "keyValueInSet": "집합 내에서 키/값 쌍을 사용할 수 없습니다.", + "isInstanceInvalidType": "\"isinstance\"에 대한 두 번째 인수는 클래스 또는 클래스의 tuple이어야 합니다.", + "isSubclassInvalidType": "\"issubclass\"에 대한 두 번째 인수는 클래스 또는 클래스의 tuple이어야 합니다.", + "keyValueInSet": "set 내에서 키/값 쌍을 사용할 수 없습니다.", "keywordArgInTypeArgument": "키워드 인수는 형식 인수 목록에서 사용할 수 없습니다.", "keywordArgShortcutIllegal": "키워드 인수 바로 가기에는 Python 3.14 이상 필요", "keywordOnlyAfterArgs": "키워드 전용 인수 구분 기호는 \"*\" 매개 변수 뒤에 사용할 수 없습니다.", @@ -283,12 +283,12 @@ "lambdaReturnTypePartiallyUnknown": "람다의 반환 형식 \"{returnType}\"을(를) 부분적으로 알 수 없습니다.", "lambdaReturnTypeUnknown": "람다의 반환 형식을 알 수 없습니다.", "listAssignmentMismatch": "형식이 \"{type}\"인 식을 대상 목록에 할당할 수 없습니다.", - "listInAnnotation": "형식 주석에는 목록 식을 사용할 수 없습니다.", + "listInAnnotation": "형식 식에는 List 식을 사용할 수 없습니다.", "literalEmptyArgs": "‘Literal’ 뒤에 하나 이상의 형식 인수가 필요합니다.", "literalNamedUnicodeEscape": "명명된 유니코드 이스케이프 시퀀스는 \"Literal\" 문자열 주석에서 지원되지 않습니다.", "literalNotAllowed": "형식 인수가 없으면 이 컨텍스트에서 \"Literal\"을 사용할 수 없습니다.", - "literalNotCallable": "리터럴 형식은 인스턴스화할 수 없습니다.", - "literalUnsupportedType": "\"Literal\"의 형식 인수는 None, 리터럴 값(int, bool, str 또는 bytes) 또는 열거형 값이어야 합니다.", + "literalNotCallable": "Literal 형식은 인스턴스화할 수 없습니다.", + "literalUnsupportedType": "\"Literal\"의 형식 인수는 None, 리터럴 값(int, bool, str 또는 bytes) 또는 enum 값이어야 합니다.", "matchIncompatible": "Match 문에는 Python 3.10 이상이 필요합니다.", "matchIsNotExhaustive": "match 문 내의 사례는 모든 값을 완전히 처리하지 않습니다.", "maxParseDepthExceeded": "최대 구문 분석 깊이를 초과했습니다. 식을 더 작은 하위 식으로 나누기", @@ -304,41 +304,42 @@ "methodOverridden": "‘{name}’은(는) ‘{className}’ 클래스에서 같은 이름의 메서드를 호환되지 않는 ‘{type}’ 형식으로 재정의합니다.", "methodReturnsNonObject": "\"{name}\" 메서드가 개체를 반환하지 않습니다.", "missingSuperCall": "\"{methodName}\" 메서드가 부모 클래스에서 같은 이름의 메서드를 호출하지 않습니다.", + "mixingBytesAndStr": "Bytes 및 str 값을 연결할 수 없습니다.", "moduleAsType": "모듈은 형식으로 사용할 수 없습니다.", "moduleNotCallable": "모듈을 호출할 수 없습니다.", "moduleUnknownMember": "‘{memberName}’은(는) ‘{moduleName}’ 모듈의 알려진 특성이 아님", "namedExceptAfterCatchAll": "명명된 except 절은 catch-all except 절 뒤에 나타날 수 없습니다.", "namedParamAfterParamSpecArgs": "ParamSpec args 매개 변수 뒤에 키워드 매개 변수 \"{name}\"을(를) 시그니처에 표시할 수 없습니다.", - "namedTupleEmptyName": "명명된 튜플 내의 이름은 비워 둘 수 없습니다.", - "namedTupleEntryRedeclared": "부모 클래스 \"{className}\"이(가) 명명된 튜플이므로 \"{name}\"을(를) 재정의할 수 없습니다.", - "namedTupleFirstArg": "명명된 튜플 클래스 이름이 첫 번째 인수로 필요합니다.", + "namedTupleEmptyName": "명명된 tuple 내의 이름은 비워 둘 수 없습니다.", + "namedTupleEntryRedeclared": "부모 클래스 \"{className}\"이(가) 명명된 tuple이므로 \"{name}\"을(를) 재정의할 수 없습니다.", + "namedTupleFirstArg": "명명된 tuple 클래스 이름이 첫 번째 인수로 필요합니다.", "namedTupleMultipleInheritance": "NamedTuple을 사용한 여러 상속은 지원되지 않습니다.", "namedTupleNameKeyword": "필드 이름은 키워드일 수 없습니다.", - "namedTupleNameType": "항목 이름 및 형식을 지정하는 2개 항목 튜플이 필요합니다.", - "namedTupleNameUnique": "명명된 튜플 내의 이름은 고유해야 합니다.", + "namedTupleNameType": "항목 이름 및 형식을 지정하는 2개 항목 tuple이 필요합니다.", + "namedTupleNameUnique": "명명된 tuple 내의 이름은 고유해야 합니다.", "namedTupleNoTypes": "\"namedtuple\"은 튜플 항목에 대한 형식을 제공하지 않습니다. 대신 \"NamedTuple\" 사용", - "namedTupleSecondArg": "두 번째 인수로 명명된 튜플 항목 목록이 필요합니다.", + "namedTupleSecondArg": "두 번째 인수로 명명된 tuple 항목 list가 필요합니다.", "newClsParam": "__new__ 재정의는 \"cls\" 매개 변수를 사용해야 합니다.", "newTypeAnyOrUnknown": "NewType에 대한 두 번째 인수는 Any 또는 Unknown이 아닌 알려진 클래스여야 합니다.", "newTypeBadName": "NewType의 첫 번째 인수는 문자열 리터럴이어야 합니다.", - "newTypeLiteral": "NewType은 리터럴 형식과 함께 사용할 수 없습니다.", + "newTypeLiteral": "NewType은 Literal 형식과 함께 사용할 수 없습니다.", "newTypeNameMismatch": "NewType은 이름이 같은 변수에 할당되어야 합니다.", "newTypeNotAClass": "NewType에 대한 두 번째 인수로 클래스가 필요합니다.", "newTypeParamCount": "NewType에는 두 개의 위치 인수가 필요합니다.", - "newTypeProtocolClass": "NewType은 구조적 유형(프로토콜 또는 TypedDict 클래스)과 함께 사용할 수 없습니다.", + "newTypeProtocolClass": "구조 형식(Protocol 또는 TypedDict 클래스)과 함께 NewType을 사용할 수 없습니다.", "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": "No binding for nonlocal \"{name}\" found", + "nonLocalReassignment": "\"{name}\" is assigned before nonlocal declaration", + "nonLocalRedefinition": "\"{name}\"이(가) 이미 nonlocal로 선언되었습니다.", "noneNotCallable": "‘None’ 유형의 개체를 호출할 수 없습니다.", "noneNotIterable": "\"None\" 형식의 개체는 반복 가능한 값으로 사용할 수 없습니다.", "noneNotSubscriptable": "’None’ 유형의 개체는 아래 첨자를 사용할 수 없습니다.", - "noneNotUsableWith": "\"None\" 형식의 개체는 \"with\"와 함께 사용할 수 없습니다.", + "noneNotUsableWith": "Object of type \"None\" cannot be used with \"with\"", "noneOperator": "\"None\"에 대해 연산자 \"{operator}\"이(가) 지원되지 않습니다.", "noneUnknownMember": "\"{name}\"은(는) \"None\"의 알려진 특성이 아님", "notRequiredArgCount": "\"NotRequired\" 뒤에 단일 형식 인수가 필요합니다.", @@ -351,7 +352,7 @@ "obscuredTypeAliasDeclaration": "형식 별칭 선언 \"{name}\"이(가) 동일한 이름의 선언으로 가려집니다.", "obscuredVariableDeclaration": "\"{name}\" 선언이 같은 이름의 선언으로 가려집니다.", "operatorLessOrGreaterDeprecated": "\"<>\" 연산자는 Python 3에서 지원되지 않습니다. 대신 \"!=\"를 사용하세요.", - "optionalExtraArgs": "‘선택 사항’ 뒤에 1개의 형식 인수가 필요합니다.", + "optionalExtraArgs": "\"Optional\" 뒤에 1개의 형식 인수가 필요합니다.", "orPatternIrrefutable": "되돌릴 수 없는 패턴은 ‘or’ 패턴의 마지막 하위 페이지로만 허용됩니다.", "orPatternMissingName": "\"or\" 패턴 내의 모든 하위 패턴은 동일한 이름을 대상으로 해야 합니다.", "overlappingKeywordArgs": "형식화된 사전이 키워드 매개 변수 {names}과(와) 겹칩니다.", @@ -364,9 +365,9 @@ "overloadImplementationMismatch": "오버로드된 구현이 오버로드 {index}의 시그니처와 일치하지 않습니다.", "overloadReturnTypeMismatch": "\"{name}\"에 대한 {prevIndex} 오버로드가 오버로드 {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": "ParamSpec의 \"args\" 특성은 *args 매개 변수와 함께 사용할 경우에만 유효함", "paramSpecAssignedName": "ParamSpec을 \"{name}\"이라는 변수에 할당해야 합니다.", "paramSpecContext": "ParamSpec은 이 컨텍스트에서 허용되지 않습니다.", - "paramSpecDefaultNotTuple": "ParamSpec의 기본값에는 줄임표, 튜플 식 또는 ParamSpec이 필요합니다.", + "paramSpecDefaultNotTuple": "ParamSpec의 기본값에는 줄임표, tuple 식 또는 ParamSpec이 필요합니다.", "paramSpecFirstArg": "첫 번째 인수로 ParamSpec의 이름이 필요합니다.", - "paramSpecKwargsUsage": "ParamSpec의 \"kwargs\" 특성은 *kwargs 매개 변수와 함께 사용할 경우에만 유효함", + "paramSpecKwargsUsage": "ParamSpec의 \"kwargs\" 특성은 **kwargs 매개 변수와 함께 사용할 경우에만 유효함", "paramSpecNotUsedByOuterScope": "ParamSpec \"{name}\"은(는) 이 컨텍스트에서 의미가 없습니다.", "paramSpecUnknownArg": "ParamSpec은 한 개 이상의 인수를 지원하지 않습니다.", "paramSpecUnknownMember": "\"{name}\"은(는) ParamSpec의 알려진 특성이 아님", @@ -387,7 +388,7 @@ "paramTypeCovariant": "공변(Covariant) 형식 변수는 매개 변수 형식에 사용할 수 없습니다.", "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": "속성 getter, setter 또는 deleter에는 정적 메서드를 사용할 수 없습니다.", + "propertyOverridden": "“{name}“은(는) “{className}“ 클래스에서 같은 이름의 property를 잘못 재정의합니다.", + "propertyStaticMethod": "Static methods not allowed for property getter, setter or deleter", "protectedUsedOutsideOfClass": "‘{name}’은(는) 선언된 클래스 외부에서 보호되고 사용됩니다.", - "protocolBaseClass": "‘{classType}’ 프로토콜 클래스는 ‘{baseType}’ 비프로토콜 클래스에서 파생될 수 없습니다.", + "protocolBaseClass": "Protocol 클래스 \"{classType}\"은(는) Protocol 아닌 클래스 \"{baseType}\"에서 파생될 수 없습니다.", "protocolBaseClassWithTypeArgs": "형식 매개 변수 구문을 사용할 때는 Protocol 클래스에 형식 인수가 허용되지 않습니다.", - "protocolIllegal": "\"프로토콜\"을 사용하려면 Python 3.7 이상이 필요합니다.", + "protocolIllegal": "\"Protocol\"을 사용하려면 Python 3.7 이상이 필요합니다.", "protocolNotAllowed": "이 컨텍스트에서는 \"Protocol\"을 사용할 수 없습니다.", "protocolTypeArgMustBeTypeParam": "\"Protocol\"의 형식 인수는 형식 매개 변수여야 합니다.", "protocolUnsafeOverlap": "클래스가 \"{name}\"과(와) 안전하지 않게 겹치며 런타임에 일치 항목을 생성할 수 있습니다.", - "protocolVarianceContravariant": "‘{class}‘ 제네릭 프로토콜에서 사용되는 ’{variable}‘ 형식 변수는 반공변이어야 합니다.", - "protocolVarianceCovariant": "‘{class}‘ 제네릭 프로토콜에서 사용되는 ’{variable}‘ 형식 변수는 공변이어야 합니다", - "protocolVarianceInvariant": "‘{class}‘ 제네릭 프로토콜에서 사용되는 ’{variable}‘ 형식 변수는 고정 변수여야 합니다.", + "protocolVarianceContravariant": "제네릭 Protocol \"{class}\"에 사용되는 형식 변수 \"{variable}\"은(는) 반공변이어야 합니다.", + "protocolVarianceCovariant": "제네릭 Protocol \"{class}\"에 사용되는 형식 변수 \"{variable}\"은(는) 공변(covariant)이어야 합니다.", + "protocolVarianceInvariant": "제네릭 Protocol \"{class}\"에 사용되는 형식 변수 \"{variable}\"은(는) 고정되어야 합니다.", "pyrightCommentInvalidDiagnosticBoolValue": "Pyright 주석 지시문 뒤에는 \"=\"와 true 또는 false 값이 와야 합니다.", "pyrightCommentInvalidDiagnosticSeverityValue": "Pyright 주석 지시문 뒤에는 \"=\"와 true, false, error, warning, information 또는 none 값이 와야 합니다.", - "pyrightCommentMissingDirective": "Pyright 주석 뒤에는 지시문(기본 또는 엄격) 또는 진단 규칙이 있어야 합니다.", + "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": "‘reveal_type’ 함수의 ‘expected_text’ 인수는 str 리터럴 값이어야 합니다.", "revealTypeExpectedTextMismatch": "텍스트 형식이 일치하지 않습니다. \"{expected}\"이(가) 필요하지만 \"{received}\"을(를) 받았습니다.", @@ -439,7 +440,7 @@ "selfTypeContext": "이 컨텍스트에서는 \"Self\"가 잘못되었습니다.", "selfTypeMetaclass": "메타클래스(\"type\"의 서브클래스) 내에서 \"Self\"를 사용할 수 없습니다.", "selfTypeWithTypedSelfOrCls": "\"Self\"는 \"Self\" 이외의 형식 주석이 있는 'self' 또는 'cls' 매개 변수가 있는 함수에서 사용할 수 없습니다.", - "setterGetterTypeMismatch": "속성 setter 값 형식을 getter 반환 형식에 할당할 수 없습니다.", + "setterGetterTypeMismatch": "Property setter 값 형식을 getter 반환 형식에 할당할 수 없습니다.", "singleOverload": "\"{name}\"이(가) 오버로드로 표시되었지만 추가 오버로드가 없습니다.", "slotsAttributeError": "__slots__에서 ‘{name}’이(가) 지정되지 않았습니다.", "slotsClassVarConflict": "‘{name}‘이(가) __slots__에 선언된 instance 변수와 충돌합니다.", @@ -449,12 +450,12 @@ "staticClsSelfParam": "정적 메서드는 \"self\" 또는 \"cls\" 매개 변수를 사용하면 안 됩니다.", "stdlibModuleOverridden": "‘{path}’이(가) ‘{name}’ stdlib 모듈을 재정의하고 있습니다.", "stringNonAsciiBytes": "ASCII가 아닌 문자는 바이트 문자열 리터럴에 허용되지 않습니다.", - "stringNotSubscriptable": "형식 주석에는 문자열 식을 첨자할 수 없습니다. 전체 주석을 따옴표로 묶습니다.", + "stringNotSubscriptable": "형식 식에서는 문자열 식을 첨자할 수 없습니다. 전체 식을 따옴표로 묶습니다.", "stringUnsupportedEscape": "문자열 리터럴에 지원되지 않는 이스케이프 시퀀스가 있습니다.", "stringUnterminated": "문자열 리터럴이 종료되지 않았습니다.", - "stubFileMissing": "\"{importName}\"에 대한 스텁 파일을 찾을 수 없습니다.", - "stubUsesGetAttr": "형식 스텁 파일이 불완전합니다. \"__getattr__\"는 모듈에 대한 형식 오류를 모호하게 합니다.", - "sublistParamsIncompatible": "하위 목록 매개 변수는 Python 3.x에서 지원되지 않습니다.", + "stubFileMissing": "\"{importName}\"에 대한 stub 파일을 찾을 수 없습니다.", + "stubUsesGetAttr": "형식 stub 파일이 불완전합니다. \"__getattr__\"는 모듈에 대한 형식 오류를 모호하게 합니다.", + "sublistParamsIncompatible": "Sublist 매개 변수는 Python 3.x에서 지원되지 않습니다.", "superCallArgCount": "‘super’ 호출에는 인수가 2개 이하여야 합니다.", "superCallFirstArg": "\"super\" 호출에 대한 첫 번째 인수로 클래스 형식이 필요하지만 \"{type}\"을(를) 받았습니다.", "superCallSecondArg": "\"super\" 호출에 대한 두 번째 인수는 \"{type}\"에서 파생된 개체 또는 클래스여야 합니다.", @@ -464,12 +465,12 @@ "symbolIsUnbound": "\"{name}\"의 바인딩이 해제되었습니다.", "symbolIsUndefined": "\"{name}\"이(가) 정의되지 않았습니다.", "symbolOverridden": "\"{name}\"이(가) 클래스 \"{className}\"에서 동일한 이름의 기호를 재정의합니다.", - "ternaryNotAllowed": "형식 주석에는 3항 식이 허용되지 않습니다.", + "ternaryNotAllowed": "형식 식에는 3항 식이 허용되지 않습니다.", "totalOrderingMissingMethod": "클래스는 total_ordering을 사용하려면 \"__lt__\", \"__le__\", \"__gt__\" 또는 \"__ge__\" 중 하나를 정의해야 합니다.", "trailingCommaInFromImport": "주변 괄호 없이는 후행 쉼표를 사용할 수 없습니다.", "tryWithoutExcept": "try 문에는 except 또는 finally 절이 하나 이상 있어야 합니다.", - "tupleAssignmentMismatch": "형식이 ‘{type}’인 식을 대상 목록에 할당할 수 없습니다.", - "tupleInAnnotation": "형식 주석에는 튜플 식을 사용할 수 없습니다.", + "tupleAssignmentMismatch": "형식이 “{type}“인 식을 대상 tuple에 할당할 수 없습니다.", + "tupleInAnnotation": "형식 식에는 tuple 식을 사용할 수 없습니다.", "tupleIndexOutOfRange": "{index} 인덱스가 {type} 형식의 범위를 벗어났습니다.", "typeAliasIllegalExpressionForm": "형식 별칭 정의에 대한 식 양식이 잘못되었습니다.", "typeAliasIsRecursiveDirect": "형식 별칭 ‘{name}’의 정의에서 스스로를 사용할 수 없습니다.", @@ -481,28 +482,29 @@ "typeAliasTypeMustBeAssigned": "TypeAliasType은 형식 별칭과 이름이 같은 변수에 할당해야 합니다.", "typeAliasTypeNameArg": "TypeAliasType의 첫 번째 인수는 형식 별칭의 이름을 나타내는 문자열 리터럴이어야 합니다.", "typeAliasTypeNameMismatch": "형식 별칭의 이름은 할당된 변수의 이름과 일치해야 합니다.", - "typeAliasTypeParamInvalid": "형식 매개 변수 목록은 TypeVar, TypeVarTuple 또는 ParamSpec만 포함하는 튜플이어야 합니다.", + "typeAliasTypeParamInvalid": "형식 매개 변수 목록은 TypeVar, TypeVarTuple 또는 ParamSpec만 포함하는 tuple이어야 합니다.", "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}\"에 선언된 형식 \"{destType}\"과(와) 호환되지 않는 \"{sourceType}\" 형식이 있음", - "typeCallNotAllowed": "type() 호출은 형식 주석에 사용하면 안 됩니다.", + "typeAssignmentMismatch": "형식 \"{sourceType}\"을 선언된 형식 \"{destType}\"에 할당할 수 없습니다.", + "typeAssignmentMismatchWildcard": "가져오기 기호 \"{name}\"에 선언된 형식 \"{destType}\"에 할당할 수 없는 \"{sourceType}\" 형식이 있습니다.", + "typeCallNotAllowed": "type() 호출은 형식 식에 사용하면 안 됩니다.", "typeCheckOnly": "\"{name}\"이(가) @type_check_only로 표시되어 있으므로 형식 주석에서만 사용할 수 있습니다.", - "typeCommentDeprecated": "형식 주석의 사용은 더 이상 사용되지 않습니다. 대신 형식 주석 사용", + "typeCommentDeprecated": "type 메모는 더 이상 사용되지 않습니다. 대신 type 주석 사용", "typeExpectedClass": "클래스가 필요하지만 \"{type}\"이(가) 수신됨", + "typeFormArgs": "\"TypeForm\"은 단일 위치 인수를 허용합니다.", "typeGuardArgCount": "\"TypeGuard\" 또는 \"TypeIs\" 뒤에 단일 형식 인수가 필요합니다.", "typeGuardParamCount": "사용자 정의 type guard 함수 및 메서드에는 하나 이상의 입력 매개 변수가 있어야 합니다.", "typeIsReturnType": "TypeIs의 반환 형식(\"{returnType}\")이 값 매개 변수 형식(\"{type}\")과 일치하지 않습니다.", - "typeNotAwaitable": "‘{type}’은(는) 대기할 수 없습니다.", + "typeNotAwaitable": "“{type}“은(는) awaitable이 아닙니다.", "typeNotIntantiable": "\"{type}\"을(를) 인스턴스화할 수 없습니다.", "typeNotIterable": "\"{type}\" 반복할 수 없습니다.", "typeNotSpecializable": "‘{type}’ 형식을 특수화할 수 없습니다.", @@ -537,7 +539,7 @@ "typeVarSingleConstraint": "TypeVar에는 두 개 이상의 제한된 형식이 있어야 합니다.", "typeVarTupleConstraints": "TypeVarTuple에는 값 제약 조건이 있을 수 없습니다.", "typeVarTupleContext": "TypeVarTuple은 이 컨텍스트에서 허용되지 않습니다.", - "typeVarTupleDefaultNotUnpacked": "TypeVarTuple 기본 형식은 압축을 푼 튜플 또는 TypeVarTuple이어야 합니다.", + "typeVarTupleDefaultNotUnpacked": "TypeVarTuple 기본 형식은 압축을 푼 tuple 또는 TypeVarTuple이어야 합니다.", "typeVarTupleMustBeUnpacked": "TypeVarTuple 값에는 압축 풀기 연산자가 필요합니다.", "typeVarTupleUnknownParam": "\"{name}\"은(는) TypeVarTuple에 대한 알 수 없는 매개 변수입니다.", "typeVarUnknownParam": "‘{name}’은(는) TypeVar에 대한 알 수 없는 매개 변수입니다.", @@ -552,8 +554,8 @@ "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": "사전 항목 이름에 필요한 문자열 리터럴", @@ -561,11 +563,11 @@ "typedDictExtraArgs": "추가 TypedDict 인수가 지원되지 않음", "typedDictFieldNotRequiredRedefinition": "TypedDict 항목 \"{name}\"은(는) NotRequired로 재정의될 수 없습니다.", "typedDictFieldReadOnlyRedefinition": "TypedDict 항목 \"{name}\"은(는) ReadOnly로 재정의될 수 없습니다.", - "typedDictFieldRequiredRedefinition": "TypedDict 항목 \"{name}\"은(는) 필수 항목으로 재정의될 수 없습니다.", + "typedDictFieldRequiredRedefinition": "TypedDict 항목 \"{name}\"은(는) Required로 재정의될 수 없습니다.", "typedDictFirstArg": "TypedDict 클래스 이름이 첫 번째 인수로 필요합니다.", "typedDictInitsubclassParameter": "TypedDict는 __init_subclass__ 매개 변수 \"{name}\"을(를) 지원하지 않습니다.", "typedDictNotAllowed": "이 컨텍스트에서는 \"TypedDict\"를 사용할 수 없습니다.", - "typedDictSecondArgDict": "두 번째 매개 변수로 사전 또는 키워드 매개 변수가 필요합니다.", + "typedDictSecondArgDict": "두 번째 매개 변수로 dict 또는 키워드 매개 변수가 필요합니다.", "typedDictSecondArgDictEntry": "단순 사전 항목이 필요합니다.", "typedDictSet": "TypedDict에서 항목을 할당할 수 없습니다.", "unaccessedClass": "‘{name}’ 클래스에 액세스할 수 없습니다.", @@ -574,34 +576,34 @@ "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": "Union은 압축을 푼 튜플을 포함할 수 없습니다.", + "unionTypeArgCount": "Union에는 둘 이상의 형식 인수가 필요합니다.", + "unionUnpackedTuple": "Union은 압축을 푼 tuple을 포함할 수 없습니다.", "unionUnpackedTypeVarTuple": "Union은 압축을 푼 TypeVarTuple을 포함할 수 없습니다.", - "unnecessaryCast": "불필요한 ‘캐스트’ 호출입니다. 형식이 이미 ‘{type}’입니다.", + "unnecessaryCast": "불필요한 \"cast\" 호출입니다. 형식이 이미 “{type}“입니다.", "unnecessaryIsInstanceAlways": "불필요한 isinstance 호출입니다. \"{testType}\"은(는) 항상 \"{classType}\"의 인스턴스입니다.", "unnecessaryIsSubclassAlways": "불필요한 issubclass 호출입니다. ’{testType}‘은(는) 항상 ’{classType}‘의 하위 클래스입니다.", - "unnecessaryPyrightIgnore": "불필요한 ‘# pyright: 무시’ 주석입니다.", - "unnecessaryPyrightIgnoreRule": "불필요한 \"#ight: ignore\" 규칙: \"{name}\"", - "unnecessaryTypeIgnore": "불필요한 ‘# 형식: 무시’ 주석입니다.", - "unpackArgCount": "‘Final’ 뒤에는 단일 형식 인수가 필요합니다.", - "unpackExpectedTypeVarTuple": "Unpack에 대한 형식 인수로 TypeVarTuple 또는 튜플이 필요합니다.", - "unpackExpectedTypedDict": "압축 풀기를 위해서는 TypedDict 형식 인수가 필요합니다.", + "unnecessaryPyrightIgnore": "불필요한 \"# pyright: ignore\" 메모입니다.", + "unnecessaryPyrightIgnoreRule": "불필요한 \"# pyright: ignore\" 규칙: \"{name}\"", + "unnecessaryTypeIgnore": "불필요한 \"# type: ignore\" 메모입니다.", + "unpackArgCount": "\"Unpack\" 뒤에는 단일 형식 인수가 필요합니다.", + "unpackExpectedTypeVarTuple": "Unpack에 대한 형식 인수로 TypeVarTuple 또는 tuple이 필요합니다.", + "unpackExpectedTypedDict": "Unpack을 위해서는 TypedDict 형식 인수가 필요합니다.", "unpackIllegalInComprehension": "압축 풀기 작업은 이해에서 사용할 수 없습니다.", - "unpackInAnnotation": "형식 주석에는 압축 풀기 연산자를 사용할 수 없습니다.", + "unpackInAnnotation": "형식 식에는 Unpack 연산자를 사용할 수 없습니다.", "unpackInDict": "사전에서 압축 풀기 작업이 허용되지 않음", - "unpackInSet": "집합 내에서는 압축 풀기 연산자를 사용할 수 없습니다.", - "unpackNotAllowed": "이 컨텍스트에서는 압축 풀기가 허용되지 않습니다.", + "unpackInSet": "set 내에서는 압축 풀기 연산자를 사용할 수 없습니다.", + "unpackNotAllowed": "이 컨텍스트에서는 Unpack이 허용되지 않습니다.", "unpackOperatorNotAllowed": "이 컨텍스트에서는 압축 풀기 작업이 허용되지 않습니다.", "unpackTuplesIllegal": "Python 3.8 이전의 튜플에서는 압축 풀기 작업이 허용되지 않습니다.", "unpackedArgInTypeArgument": "압축을 푼 인수는 이 컨텍스트에서 사용할 수 없음", @@ -609,42 +611,42 @@ "unpackedDictArgumentNotMapping": "** 뒤의 인수 식은 \"str\" 키 형식의 매핑이어야 합니다.", "unpackedDictSubscriptIllegal": "아래 첨자에서 사전 압축 풀기 연산자는 사용할 수 없습니다.", "unpackedSubscriptIllegal": "아래 첨자의 압축 풀기 연산자에는 Python 3.11 이상이 필요합니다.", - "unpackedTypeVarTupleExpected": "압축 해제된 TypeVarTuple이 필요합니다. 압축 풀기[{name1}] 또는 *{name2} 사용", + "unpackedTypeVarTupleExpected": "압축 해제된 TypeVarTuple이 필요합니다. Unpack[{name1}] 또는 *{name2} 사용", "unpackedTypedDictArgument": "압축되지 않은 TypedDict 인수를 매개 변수와 일치시킬 수 없습니다.", "unreachableCode": "코드에 접근할 수 없습니다.", "unreachableCodeType": "형식 분석을 통해 코드에 연결할 수 없음을 나타냅니다.", "unreachableExcept": "예외가 이미 처리되었으므로 Except 절에 연결할 수 없습니다.", "unsupportedDunderAllOperation": "\"__all__\"에 대한 작업이 지원되지 않으므로 내보낸 기호 목록이 잘못되었을 수 있습니다.", "unusedCallResult": "호출 식의 결과가 ‘{type}’ 형식이므로 사용되지 않습니다. 의도적인 경우 변수 ‘_’에 할당하세요.", - "unusedCoroutine": "비동기 함수 호출의 결과가 사용되지 않습니다. \"await\"를 사용하거나 변수에 결과 할당", + "unusedCoroutine": "async 함수 호출의 결과가 사용되지 않습니다. \"await\"를 사용하거나 변수에 결과 할당", "unusedExpression": "식 값은 사용되지 않습니다.", - "varAnnotationIllegal": "변수에 대한 형식 주석에는 Python 3.6 이상이 필요합니다. 이전 버전과의 호환성을 위해 형식 주석 사용", + "varAnnotationIllegal": "변수에 대한 type 주석에는 Python 3.6 이상이 필요합니다. 이전 버전과의 호환성을 위해 type 메모 사용", "variableFinalOverride": "변수 \"{name}\"이(가) Final로 표시되고 \"{className}\" 클래스에서 이름이 같은 비-Final 변수를 재정의합니다.", - "variadicTypeArgsTooMany": "형식 인수 목록에는 압축을 풀고 있는 TypeVarTuple 또는 튜플이 하나만 있을 수 있습니다.", + "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\"을 사용할 수 없습니다.", + "yieldFromOutsideAsync": "async 함수에서는 \"yield from\"을 사용할 수 없습니다.", "yieldOutsideFunction": "함수 또는 람다 외부에서는 ‘yield’를 사용할 수 없습니다.", - "yieldWithinComprehension": "이해력 내에서는 \"일시 중단\"을 사용할 수 없습니다.", - "zeroCaseStatementsFound": "Match 문에는 Case 문이 하나 이상 포함되어야 합니다.", - "zeroLengthTupleNotAllowed": "길이가 0인 튜플은 이 컨텍스트에서 허용되지 않습니다." + "yieldWithinComprehension": "comprehension 내에서는 \"yield\"를 사용할 수 없습니다.", + "zeroCaseStatementsFound": "Match 문에는 case 문이 하나 이상 포함되어야 합니다.", + "zeroLengthTupleNotAllowed": "길이가 0인 tuple은 이 컨텍스트에서 허용되지 않습니다." }, "DiagnosticAddendum": { - "annotatedNotAllowed": "\"주석이 추가된\" 특수 양식은 인스턴스 및 클래스 검사와 함께 사용할 수 없습니다.", + "annotatedNotAllowed": "\"Annotated\" 특수 양식은 인스턴스 및 클래스 검사와 함께 사용할 수 없습니다.", "argParam": "인수가 \"{paramName}\" 매개 변수에 해당합니다.", "argParamFunction": "인수가 \"{functionName}\" 함수의 \"{paramName}\" 매개 변수에 해당합니다.", "argsParamMissing": "‘*{paramName}’ 매개 변수에 해당하는 매개 변수가 없습니다.", "argsPositionOnly": "위치 전용 매개 변수가 일치하지 않습니다. {expected}이)(가) 필요하지만 {received}을(를) 받았습니다.", "argumentType": "인수 형식이 \"{type}\"입니다.", "argumentTypes": "인수 형식: ({types})", - "assignToNone": "형식이 \"None\"과 호환되지 않음", + "assignToNone": "형식을 \"None\"에 할당할 수 없습니다.", "asyncHelp": "‘async with’를 사용하시겠습니까?", "baseClassIncompatible": "기본 클래스 \"{baseClass}\"은(는) \"{type}\" 유형과 호환되지 않습니다.", "baseClassIncompatibleSubclass": "기본 클래스 \"{baseClass}\"은(는) \"{type}\" 유형과 호환되지 않는 \"{subclass}\"에서 파생됩니다.", @@ -657,7 +659,7 @@ "dataProtocolUnsupported": "\"{name}\"은(는) 데이터 프로토콜입니다.", "descriptorAccessBindingFailed": "설명자 클래스 \"{className}\"에 대한 메서드 \"{name}\"을(를) 바인딩하지 못했습니다.", "descriptorAccessCallFailed": "설명자 클래스 \"{className}\"에 대한 메서드 \"{name}\"을(를) 호출하지 못했습니다.", - "finalMethod": "최종 메서드", + "finalMethod": "Final 메서드", "functionParamDefaultMissing": "‘{name}’ 매개 변수에 기본 인수가 없습니다.", "functionParamName": "매개 변수 이름 불일치: \"{destName}\" 및 \"{srcName}\"", "functionParamPositionOnly": "위치 전용 매개 변수가 일치하지 않습니다. 매개 변수 \"{name}\"은(는) 위치 전용이 아닙니다.", @@ -665,9 +667,9 @@ "functionTooFewParams": "함수가 너무 적은 위치 매개 변수를 허용합니다. {expected}이(가) 필요하지만 {received}을(를) 받았습니다.", "functionTooManyParams": "함수가 너무 많은 위치 매개 변수를 허용합니다. {expected}이(가) 필요하지만 {received}을(를) 받았습니다.", "genericClassNotAllowed": "인스턴스 또는 클래스 검사에 형식 인수가 허용되지 않는 제네릭 형식", - "incompatibleDeleter": "속성 삭제자 메서드가 호환되지 않습니다.", - "incompatibleGetter": "속성 getter 메서드가 호환되지 않습니다.", - "incompatibleSetter": "속성 setter 메서드가 호환되지 않습니다.", + "incompatibleDeleter": "Property deleter 메서드가 호환되지 않습니다.", + "incompatibleGetter": "Property getter 메서드가 호환되지 않습니다.", + "incompatibleSetter": "Property setter 메서드가 호환되지 않습니다.", "initMethodLocation": "__init__ 메서드가 \"{type}\" 클래스에 정의되어 있습니다.", "initMethodSignature": "__init__의 서명은 \"{type}\"입니다.", "initSubclassLocation": "__init_subclass__ 메서드는 \"{name}\" 클래스에 정의되어 있음", @@ -681,14 +683,14 @@ "keyUndefined": "\"{name}\"이 \"{type}\"에 정의된 키가 아닙니다.", "kwargsParamMissing": "‘**{paramName}’ 매개 변수에 해당하는 매개 변수가 없습니다.", "listAssignmentMismatch": "\"{type}\" 형식이 대상 목록과 호환되지 않습니다.", - "literalAssignmentMismatch": "\"{sourceType}\"이(가) \"{destType}\" 형식과 호환되지 않음", + "literalAssignmentMismatch": "\"{sourceType}\"은 형식 \"{destType}\"에 할당할 수 없습니다.", "matchIsNotExhaustiveHint": "전체 처리가 의도되지 않은 경우 \"case _: pass\"를 추가합니다.", "matchIsNotExhaustiveType": "처리되지 않은 형식: \"{type}\"", "memberAssignment": "\"{type}\" 형식의 식을 \"{classType}\" 클래스의 \"{name}\" 특성에 할당할 수 없음", "memberIsAbstract": "\"{type}.{name}\"이(가) 구현되지 않았습니다.", "memberIsAbstractMore": "{count}개 더...", "memberIsClassVarInProtocol": "\"{name}\"은(는) 프로토콜에서 ClassVar로 정의됩니다.", - "memberIsInitVar": "\"{name}\"은(는) 초기화 전용 필드임", + "memberIsInitVar": "\"{name}\"은(는) init-only 필드임", "memberIsInvariant": "\"{name}\"은(는) 변경 가능하므로 고정되지 않습니다.", "memberIsNotClassVarInClass": "\"{name}\"은(는) 프로토콜과 호환되려면 ClassVar로 정의해야 합니다.", "memberIsNotClassVarInProtocol": "\"{name}\"이(가) 프로토콜에서 ClassVar로 정의되지 않았습니다.", @@ -699,9 +701,9 @@ "memberTypeMismatch": "\"{name}\"은(는) 호환되지 않는 형식입니다.", "memberUnknown": "특성 \"{name}\" 알 수 없음", "metaclassConflict": "메타클래스 \"{metaclass1}\"이(가) \"{metaclass2}\"과(와) 충돌합니다.", - "missingDeleter": "속성 삭제자 메서드가 없습니다.", - "missingGetter": "속성 getter 메서드가 없습니다.", - "missingSetter": "속성 setter 메서드가 없습니다.", + "missingDeleter": "Property deleter 메서드가 없습니다.", + "missingGetter": "Property getter 메서드가 없습니다.", + "missingSetter": "Property setter 메서드가 없습니다.", "namedParamMissingInDest": "\"{name}\" 추가 매개 변수", "namedParamMissingInSource": "\"{name}\" 키워드 매개 변수 누락", "namedParamTypeMismatch": "\"{sourceType}\" 형식의 키워드 매개 변수 \"{name}\"이(가) \"{destType}\" 형식과 호환되지 않음", @@ -741,16 +743,16 @@ "paramType": "매개 변수 형식은 \"{paramType}\"입니다.", "privateImportFromPyTypedSource": "대신 \"{module}\"에서 가져오기", "propertyAccessFromProtocolClass": "프로토콜 클래스 내에 정의된 속성은 클래스 변수로 액세스할 수 없습니다.", - "propertyMethodIncompatible": "속성 메서드 \"{name}\"이(가) 호환되지 않습니다.", - "propertyMethodMissing": "재정의에 ‘{name}’ 속성 메서드가 없습니다.", - "propertyMissingDeleter": "\"{name}\" 속성에 정의된 삭제자가 없습니다.", - "propertyMissingSetter": "\"{name}\" 속성에 정의된 setter가 없습니다.", + "propertyMethodIncompatible": "Property 메서드 \"{name}\"이(가) 호환되지 않습니다.", + "propertyMethodMissing": "Property 메서드 “{name}”에 재정의가 없습니다.", + "propertyMissingDeleter": "\"{name}\" property에 정의된 deleter가 없습니다.", + "propertyMissingSetter": "\"{name}\" property에 정의된 setter가 없습니다.", "protocolIncompatible": "‘{sourceType}’은(는) ‘{destType}’ 프로토콜과 호환되지 않습니다.", "protocolMemberMissing": "\"{name}\"이(가) 없습니다.", - "protocolRequiresRuntimeCheckable": "인스턴스 및 클래스 검사와 함께 사용하려면 프로토콜 클래스를 @runtime_checkable 합니다.", + "protocolRequiresRuntimeCheckable": "인스턴스 및 클래스 검사와 함께 사용하려면 Protocol 클래스를 @runtime_checkable 합니다.", "protocolSourceIsNotConcrete": "‘{sourceType}’은(는) 구체적인 클래스 형식이 아니므로 ‘{destType}’ 형식에 할당할 수 없습니다.", "protocolUnsafeOverlap": "\"{name}\"의 특성은 프로토콜과 이름이 같습니다.", - "pyrightCommentIgnoreTip": "\"# pyright: ignore[]을(를) 사용하여 한 줄에 대한 진단을 억제합니다.", + "pyrightCommentIgnoreTip": "\"# pyright: ignore[]\"을 사용하여 한 줄에 대한 진단을 표시하지 않습니다.", "readOnlyAttribute": "특성 \"{name}\"은(는) 읽기 전용입니다.", "seeClassDeclaration": "클래스 선언 참조", "seeDeclaration": "선언 참조", @@ -759,17 +761,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": "형식 변수 \"{name}\"에 대해 형식 \"{sourceType}\"이(가) 바인딩된 형식 \"{destType}\"과(와) 호환되지 않습니다.", - "typeConstrainedTypeVar": "\"{type}\" 형식이 제한된 형식 변수 \"{name}\"과(와) 호환되지 않습니다.", - "typeIncompatible": "\"{sourceType}\"이(가) \"{destType}\"과(와) 호환되지 않습니다.", + "typeAssignmentMismatch": "형식 \"{sourceType}\"은 형식 \"{destType}\"에 할당할 수 없습니다.", + "typeBound": "형식 변수 \"{name}\"에 대한 상한 \"{destType}\"에 형식 \"{sourceType}\"을 할당할 수 없습니다.", + "typeConstrainedTypeVar": "형식 \"{type}\"을 제한된 형식 변수 \"{name}\"에 할당할 수 없습니다.", + "typeIncompatible": "\"{sourceType}\"은 \"{destType}\"에 할당할 수 없습니다.", "typeNotClass": "\"{type}\"이 클래스가 아닙니다.", "typeNotStringLiteral": "‘{type}’은(는) 문자열 리터럴이 아닙니다.", "typeOfSymbol": "‘{name}’의 유형이 ‘{type}’입니다.", @@ -780,7 +782,7 @@ "typeVarIsCovariant": "\"{name}\" 형식 매개 변수는 공변(covariant)이지만 \"{sourceType}\"은(는) \"{destType}\"의 하위 형식이 아닙니다.", "typeVarIsInvariant": "\"{name}\" 형식 매개 변수는 고정이지만 \"{sourceType}\"은(는) \"{destType}\"와 같지 않습니다.", "typeVarNotAllowed": "인스턴스 또는 클래스 검사에 TypeVar가 허용되지 않음", - "typeVarTupleRequiresKnownLength": "TypeVarTuple을 알 수 없는 길이의 튜플에 바인딩할 수 없습니다.", + "typeVarTupleRequiresKnownLength": "TypeVarTuple을 알 수 없는 길이의 tuple에 바인딩할 수 없습니다.", "typeVarUnnecessarySuggestion": "대신 {type}을(를) 사용하세요.", "typeVarUnsolvableRemedy": "인수가 제공되지 않을 때 반환 형식을 지정하는 오버로드를 제공합니다.", "typeVarsMissing": "누락된 형식 변수: {names}", @@ -804,8 +806,8 @@ "uninitializedAbstractVariable": "인스턴스 변수 \"{name}\"이(가) 추상 기본 클래스 \"{classType}\"에 정의되어 있지만 초기화되지 않았습니다.", "unreachableExcept": "\"{exceptionType}\"은(는) \"{parentType}\"의 서브클래스입니다.", "useDictInstead": "사전 형식을 나타내려면 Dict[T1, T2]를 사용하세요.", - "useListInstead": "List[T]를 사용하여 목록 형식을 나타내거나 Union[T1, T2]를 사용하여 공용 구조체 형식을 나타내세요.", - "useTupleInstead": "튜플[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}’와(과) 호환되지 않습니다." diff --git a/packages/pyright-internal/src/localization/package.nls.pl.json b/packages/pyright-internal/src/localization/package.nls.pl.json index 50a363eb1..94b73a7ff 100644 --- a/packages/pyright-internal/src/localization/package.nls.pl.json +++ b/packages/pyright-internal/src/localization/package.nls.pl.json @@ -1,7 +1,7 @@ { "CodeAction": { - "createTypeStub": "Utwórz typ zastępczy", - "createTypeStubFor": "Utwórz typ zastępczy dla „{moduleName}”", + "createTypeStub": "Utwórz typ zastępczy Stub", + "createTypeStubFor": "Utwórz typ Stub dla „{moduleName}”", "executingCommand": "Wykonywanie polecenia", "filesToAnalyzeCount": "Pliki do przeanalizowania: {count}", "filesToAnalyzeOne": "1 plik do analizy", @@ -18,12 +18,12 @@ "annotatedMetadataInconsistent": "Opisany typ metadanych „{metadataType}” nie jest zgodny z typem „{type}”", "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": "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)", + "annotationBytesString": "Wyrażenia typu nie mogą używać literałów ciągu bajtów", + "annotationFormatString": "Wyrażenia typu nie mogą używać literałów ciągów formatu (ciągów f)", "annotationNotSupported": "Adnotacja typu nie jest obsługiwana dla tej instrukcji", - "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", + "annotationRawString": "Wyrażenia typu nie mogą używać nieprzetworzonych literałów ciągów", + "annotationSpansStrings": "Wyrażenia typu nie mogą obejmować wielu literałów ciągów", + "annotationStringEscape": "Wyrażenia typu nie mogą zawierać znaków ucieczki", "argAssignment": "Argumentu typu „{argType}” nie można przypisać do parametru typu „{paramType}”", "argAssignmentFunction": "Argumentu typu „{argType}” nie można przypisać do parametru typu „{paramType}” w funkcji „{functionName}”", "argAssignmentParam": "Argumentu typu „{argType}” nie można przypisać do parametru „{paramName}” typu „{paramType}”", @@ -37,27 +37,27 @@ "argPositionalExpectedOne": "Oczekiwano 1 argumentu pozycyjnego", "argTypePartiallyUnknown": "Typ argumentu jest częściowo nieznany", "argTypeUnknown": "Typ argumentu jest nieznany", - "assertAlwaysTrue": "Wyrażenie Assert zawsze ma wartość Prawda", + "assertAlwaysTrue": "Wyrażenie Assert zawsze ma wartość true", "assertTypeArgs": "Typ „assert_type” oczekuje dwóch argumentów pozycyjnych", "assertTypeTypeMismatch": "Niezgodność „assert_type”; oczekiwano „{expected}”, ale otrzymano „{received}”", "assignmentExprComprehension": "Element docelowy wyrażenia przypisania „{name}” nie może używać tej samej nazwy co zrozumienie dla elementu docelowego", "assignmentExprContext": "Wyrażenie przypisania musi należeć do modułu, funkcji lub wyrażenia lambda", "assignmentExprInSubscript": "Wyrażenia przypisania w indeksie dolnym są obsługiwane tylko w języku Python w wersji 3.10 i nowszej", - "assignmentInProtocol": "Zmienne wystąpienia lub klasy w klasie protokołu muszą być jawnie zadeklarowane w treści klasy", + "assignmentInProtocol": "Zmienne wystąpienia lub klasy w klasie Protocol muszą być jawnie zadeklarowane w treści klasy", "assignmentTargetExpr": "Wyrażenie nie może być elementem docelowym przypisania", "asyncNotInAsyncFunction": "Użycie wartość „async” jest niedozwolone poza funkcją asynchroniczną", - "awaitIllegal": "Użycie „oczekiwania” wymaga języka Python w wersji 3.5 lub nowszej", - "awaitNotAllowed": "Adnotacje typu nie mogą używać elementu „await”", + "awaitIllegal": "Użycie „await” wymaga języka Python w wersji 3.5 lub nowszej", + "awaitNotAllowed": "Wyrażenia typu nie mogą używać instrukcji „await”", "awaitNotInAsync": "Wartość „await” jest dozwolona tylko w ramach funkcji asynchronicznej", "backticksIllegal": "Wyrażenia otoczone znakami wstecznymi nie są obsługiwane w języku Python w wersji 3.x; zamiast tego użyj wyrażenia repr", "baseClassCircular": "Klasa nie może pochodzić od samej siebie", - "baseClassFinal": "Klasa bazowa „{type}” jest oznaczona jako końcowa i nie można jej podzielić na podklasy", + "baseClassFinal": "Klasa bazowa „{type}” jest oznaczona jako final i nie można jej podzielić na podklasy", "baseClassIncompatible": "Klasy bazowe typu {type} są wzajemnie niezgodne", "baseClassInvalid": "Argument klasy musi być klasą bazową", "baseClassMethodTypeIncompatible": "Klasy bazowe dla klasy „{classType}” definiują metodę „{name}” w niezgodny sposób", "baseClassUnknown": "Typ klasy bazowej jest nieznany, zasłaniając typ klasy pochodnej", "baseClassVariableTypeIncompatible": "Klasy bazowe dla klasy „{classType}” definiują zmienną „{name}” w niezgodny sposób", - "binaryOperationNotAllowed": "Operator binarny nie jest dozwolony w adnotacji typu", + "binaryOperationNotAllowed": "Operator binarny nie jest dozwolony w wyrażeniu typu", "bindTypeMismatch": "Nie można powiązać metody „{methodName}”, ponieważ nie można przypisać typu „{type}” do parametru „{paramName}”", "breakOutsideLoop": "Wartość „break” może być używana tylko w pętli", "callableExtraArgs": "Oczekiwano tylko dwóch argumentów typu „Callable”", @@ -70,7 +70,7 @@ "classDefinitionCycle": "Definicja klasy dla „{name}” zależy od niej samej", "classGetItemClsParam": "Przesłonięcie __class_getitem__ powinno przyjmować parametr „cls”.", "classMethodClsParam": "Metody klasy powinny przyjmować parametr „cls”", - "classNotRuntimeSubscriptable": "Indeks dolny dla klasy „{name}” wygeneruje wyjątek czasu uruchamiania; umieść adnotację typu w cudzysłowie", + "classNotRuntimeSubscriptable": "Indeks dolny dla klasy „{name}” wygeneruje wyjątek środowiska uruchomieniowego; umieścić wyrażenie typu w cudzysłowy", "classPatternBuiltInArgPositional": "Wzorzec klasy akceptuje tylko podwzorzec pozycyjny", "classPatternPositionalArgCount": "Zbyt wiele wzorców pozycyjnych dla klasy „{type}”; oczekiwano {expected}, ale otrzymano {received}", "classPatternTypeAlias": "„{type}” nie może być używany we wzorcu klasy, ponieważ jest to alias typu specjalnego", @@ -84,17 +84,17 @@ "clsSelfParamTypeMismatch": "Typ parametru „{name}” musi być nadtypem jego klasy „{classType}”", "codeTooComplexToAnalyze": "Kod jest zbyt złożony, aby go analizować; zmniejsz złożoność przez refaktoryzację w podprocedury lub poprzez zmniejszenie ścieżek kodu warunkowego", "collectionAliasInstantiation": "Nie można utworzyć wystąpienia typu „{type}”. Zamiast niego użyj „{alias}”", - "comparisonAlwaysFalse": "Warunek zawsze będzie miał wartość Fałsz, ponieważ typy „{leftType}” i „{rightType}” nie nakładają się", - "comparisonAlwaysTrue": "Warunek zawsze będzie miał wartość Prawda, ponieważ typy „{leftType}” i „{rightType}” nie nakładają się", + "comparisonAlwaysFalse": "Warunek zawsze będzie miał wartość False, ponieważ typy „{leftType}” i „{rightType}” nie nakładają się", + "comparisonAlwaysTrue": "Warunek zawsze będzie miał wartość True, ponieważ typy „{leftType}” i „{rightType}” nie nakładają się", "comprehensionInDict": "Zrozumienia nie można używać z innymi wpisami słownika", - "comprehensionInSet": "Nie można używać rozumienia z innymi wpisami zestawu", - "concatenateContext": "„Łączenie” jest niedozwolone w tym kontekście", + "comprehensionInSet": "Nie można używać rozumienia z innymi wpisami set", + "concatenateContext": "Klasa „Concatenate” jest niedozwolona w tym kontekście", "concatenateParamSpecMissing": "Ostatni argument typu dla elementu „Concatenate” musi mieć wartość ParamSpec lub „...”", "concatenateTypeArgsMissing": "Element „Concatenate” wymaga co najmniej dwóch argumentów typu", "conditionalOperandInvalid": "Nieprawidłowy warunkowy argument operacji typu „{type}”", "constantRedefinition": "Nazwa „{name}” jest stałą (ponieważ jest pisana wielkimi literami) i nie można jej ponownie zdefiniować", "constructorParametersMismatch": "Niezgodność między sygnaturą „__new__” i „__init__” w klasie „{classType}”", - "containmentAlwaysFalse": "Warunek zawsze będzie miał wartość „Fałsz”, ponieważ typy „{leftType}” i „{rightType}” nie nakładają się na siebie", + "containmentAlwaysFalse": "Warunek zawsze będzie miał wartość False, ponieważ typy „{leftType}” i „{rightType}” nie nakładają się na siebie", "containmentAlwaysTrue": "Warunek zawsze będzie miał wartość „True”, ponieważ typy „{leftType}” i „{rightType}” nie nakładają się na siebie", "continueInFinally": "Wartość „continue” nie może być używana w klauzuli finally", "continueOutsideLoop": "Wartość „continue” może być używana tylko w pętli", @@ -111,7 +111,7 @@ "dataClassPostInitType": "Klasa danych __post_init__ ma niezgodność typu parametru metody dla pola „{fieldName}”", "dataClassSlotsOverwrite": "Element __slots__ jest już zdefiniowany w klasie", "dataClassTransformExpectedBoolLiteral": "Oczekiwano wyrażenia, które statycznie daje w wyniku wartość True lub False", - "dataClassTransformFieldSpecifier": "Oczekiwano krotki klas lub funkcji, a uzyskano typ „{type}”", + "dataClassTransformFieldSpecifier": "Oczekiwano spójnej kolekcji (tuple) klas lub funkcji, a uzyskano typ „{type}”", "dataClassTransformPositionalParam": "Wszystkie argumenty elementu „dataclass_transform” muszą być argumentami słów kluczowych", "dataClassTransformUnknownArgument": "Argument „{name}” nie jest obsługiwany przez dataclass_transform", "dataProtocolInSubclassCheck": "Protokoły danych (które zawierają atrybuty niebędące atrybutami metody) są niedozwolone w wywołaniach klasy issubclass", @@ -127,20 +127,20 @@ "deprecatedDescriptorSetter": "Metoda „__set__” dla deskryptora „{name}” jest przestarzała", "deprecatedFunction": "Ta funkcja „{name}” jest przestarzała", "deprecatedMethod": "Metoda „{name}” w klasie „{className}” jest przestarzała", - "deprecatedPropertyDeleter": "Metoda usuwająca dla właściwości „{name}” jest przestarzała", - "deprecatedPropertyGetter": "Metoda pobierająca dla właściwości „{name}” jest przestarzała", - "deprecatedPropertySetter": "Metoda pobierająca dla właściwości „{name}” jest przestarzała", + "deprecatedPropertyDeleter": "deleter dla property „{name}” jest przestarzała", + "deprecatedPropertyGetter": "getter dla property „{name}” jest przestarzała", + "deprecatedPropertySetter": "setter dla property „{name}” jest przestarzała", "deprecatedType": "Ten typ jest przestarzały dla języka Python w wersji {version}; zamiast tego użyj „{replacement}”.", "dictExpandIllegalInComprehension": "Rozszerzanie słownika jest niedozwolone w rozumieniu", - "dictInAnnotation": "Wyrażenie słownikowe jest niedozwolone w adnotacji typu", + "dictInAnnotation": "Wyrażenie słownika jest niedozwolone w wyrażeniu typu", "dictKeyValuePairs": "Wpisy słownika muszą zawierać pary klucz/wartość", "dictUnpackIsNotMapping": "Oczekiwano mapowania dla operatora rozpakowywania słownika", "dunderAllSymbolNotPresent": "Nazwa „{name}” jest określona w wartości __all__, ale nie występuje w module", "duplicateArgsParam": "Dozwolony tylko jeden parametr „*”", "duplicateBaseClass": "Zduplikowana klasa bazowa jest niedozwolona", "duplicateCapturePatternTarget": "Element docelowy przechwytywania „{name}” nie może występować więcej niż raz w obrębie tego samego wzorca", - "duplicateCatchAll": "Dozwolona jest tylko jedna klauzula typu catch-all z wyjątkiem klauzuli", - "duplicateEnumMember": "Składowa wyliczenia „{name}” jest już zadeklarowana", + "duplicateCatchAll": "Dozwolona jest tylko jedna klauzula typu catch-all except klauzuli", + "duplicateEnumMember": "Składowa Enum „{name}” jest już zadeklarowana", "duplicateGenericAndProtocolBase": "Dozwolona jest tylko jedna klasa bazowa Generic[...] lub Protocol[...].", "duplicateImport": "Nazwa „{importName}” została zaimportowana więcej niż raz", "duplicateKeywordOnly": "Dozwolony tylko jeden separator „*”.", @@ -149,14 +149,14 @@ "duplicatePositionOnly": "Dozwolony tylko jeden parametr „/”", "duplicateStarPattern": "W sekwencji wzorca dozwolony jest tylko jeden wzorzec „*”", "duplicateStarStarPattern": "Dozwolony jest tylko jeden wpis „**”", - "duplicateUnpack": "Na liście dozwolona jest tylko jedna operacja rozpakowywania", - "ellipsisAfterUnpacked": "Nie można używać „...” z rozpakowanym typeVarTuple lub krotką", + "duplicateUnpack": "Na list dozwolona jest tylko jedna operacja rozpakowywania", + "ellipsisAfterUnpacked": "Nie można używać „...” z rozpakowanym parametrem TypeVarTuple lub kolekcją tuple", "ellipsisContext": "Wartość „...” jest niedozwolona w tym kontekście", "ellipsisSecondArg": "Wartość „...” jest dozwolona tylko jako drugi z dwóch argumentów", - "enumClassOverride": "Klasa wyliczenia „{name}” jest ostateczna i nie można jej podzielić na podklasy", - "enumMemberDelete": "Nie można usunąć składowej wyliczenia \"{name}\"", - "enumMemberSet": "Nie można przypisać składowej wyliczenia „{name}”", - "enumMemberTypeAnnotation": "Adnotacje typu nie są dozwolone dla elementów członkowskich wyliczenia", + "enumClassOverride": "Klasa Enum „{name}” jest final i nie można jej podzielić na podklasy", + "enumMemberDelete": "Nie można usunąć składowej Enum \"{name}\"", + "enumMemberSet": "Nie można przypisać składowej Enum „{name}”", + "enumMemberTypeAnnotation": "Adnotacje typu nie są dozwolone dla składowych enum", "exceptionGroupIncompatible": "Składnia grupy wyjątków („except*”) wymaga języka Python w wersji 3.11 lub nowszej", "exceptionGroupTypeIncorrect": "Typ wyjątku w wyrażeniu except* nie może pochodzić z grupy BaseGroupException", "exceptionTypeIncorrect": "Typ „{type}” nie pochodzi od parametru BaseException", @@ -164,7 +164,7 @@ "exceptionTypeNotInstantiable": "Konstruktor typu wyjątku „{type}” wymaga co najmniej jednego argumentu", "expectedAfterDecorator": "Oczekiwano deklaracji funkcji lub klasy po dekoratorze", "expectedArrow": "Oczekiwano wartości „->”, po której następuje adnotacja zwracanego typu", - "expectedAsAfterException": "Oczekiwano „jako” po typie wyjątku", + "expectedAsAfterException": "Oczekiwano wartości „as” po typie wyjątku", "expectedAssignRightHandExpr": "Oczekiwano wyrażenia po prawej stronie znaku „=”", "expectedBinaryRightHandExpr": "Oczekiwano wyrażenia po prawej stronie operatora", "expectedBoolLiteral": "Oczekiwano wartości True lub False", @@ -179,23 +179,23 @@ "expectedDecoratorName": "Oczekiwano nazwy dekoratora", "expectedDecoratorNewline": "Oczekiwano nowego wiersza na końcu dekoratora", "expectedDelExpr": "Oczekiwano wyrażenia po „del”", - "expectedElse": "Oczekiwano elementu „innego”", + "expectedElse": "Oczekiwano elementu „else”", "expectedEquals": "Oczekiwano „=”", "expectedExceptionClass": "Nieprawidłowa klasa lub obiekt wyjątku", - "expectedExceptionObj": "Oczekiwano obiektu wyjątku, klasy wyjątku lub wartości Brak", + "expectedExceptionObj": "Oczekiwano obiektu wyjątku, klasy wyjątku lub wartości None", "expectedExpr": "Oczekiwano wyrażenia", "expectedFunctionAfterAsync": "Oczekiwano definicji funkcji po wartości „async”", "expectedFunctionName": "Oczekiwano nazwy funkcji po wyrażeniu „def”", "expectedIdentifier": "Oczekiwany identyfikator", "expectedImport": "Oczekiwano wartości „import”", "expectedImportAlias": "Oczekiwano symbolu po parametrze „as”", - "expectedImportSymbols": "Oczekiwano jednej lub więcej nazw symboli po zaimportowaniu", + "expectedImportSymbols": "Oczekiwano jednej lub więcej nazw symboli po wyrażeniu „import”", "expectedIn": "Oczekiwano parametru „in”", "expectedInExpr": "Oczekiwano wyrażenia po „in”", "expectedIndentedBlock": "Oczekiwano wciętego bloku", "expectedMemberName": "Oczekiwano nazwy atrybutu po „.”", "expectedModuleName": "Oczekiwana nazwa modułu", - "expectedNameAfterAs": "Oczekiwano nazwy symbolu po „jako”", + "expectedNameAfterAs": "Oczekiwano nazwy symbolu po wartości „as”", "expectedNamedParameter": "Parametr słowa kluczowego musi następować po znaku „*”", "expectedNewline": "Oczekiwano nowego wiersza", "expectedNewlineOrSemicolon": "Instrukcje muszą być oddzielone znakami nowych wierszy lub średnikami", @@ -208,17 +208,17 @@ "expectedSliceIndex": "Oczekiwano wyrażenia indeksu lub wycinka", "expectedTypeNotString": "Oczekiwano typu, ale otrzymano literał ciągu", "expectedTypeParameterName": "Oczekiwano nazwy parametru typu", - "expectedYieldExpr": "Oczekiwano wyrażenia w instrukcji wstrzymywania", - "finalClassIsAbstract": "Klasa „{type}” jest oznaczona jako ostateczna i musi implementować wszystkie symbole abstrakcyjne", + "expectedYieldExpr": "Oczekiwano wyrażenia w instrukcji yield", + "finalClassIsAbstract": "Klasa „{type}” jest oznaczona jako final i musi implementować wszystkie symbole abstrakcyjne", "finalContext": "Wartość „Final” jest niedozwolona w tym kontekście", "finalInLoop": "Nie można przypisać zmiennej „Final” w pętli", - "finalMethodOverride": "Metoda „{name}” nie może przesłonić metody końcowej zdefiniowanej w klasie „{className}”", + "finalMethodOverride": "Metoda „{name}” nie może przesłonić metody final zdefiniowanej w klasie „{className}”", "finalNonMethod": "Nie można oznaczyć funkcji „{name}” jako @final, ponieważ nie jest to metoda", - "finalReassigned": "Element „{name}” jest zadeklarowany jako wersja ostateczna i nie można go ponownie przypisać", - "finalRedeclaration": "Nazwa „{name}” została wcześniej zadeklarowana jako końcowa", - "finalRedeclarationBySubclass": "Nie można ponownie zadeklarować nazwy „{name}”, ponieważ klasa nadrzędna „{className}” deklaruje ją jako końcową", + "finalReassigned": "Element „{name}” jest zadeklarowany jako wersja Final i nie można go ponownie przypisać", + "finalRedeclaration": "Nazwa „{name}” została wcześniej zadeklarowana jako Final", + "finalRedeclarationBySubclass": "Nie można ponownie zadeklarować nazwy „{name}”, ponieważ klasa nadrzędna „{className}” deklaruje ją jako Final", "finalTooManyArgs": "Oczekiwano jednego argumentu typu po wartości „Final”", - "finalUnassigned": "Nazwa „{name}” jest zadeklarowana jako końcowa, ale wartość nie jest przypisana", + "finalUnassigned": "Nazwa „{name}” jest zadeklarowana jako wartość Final, ale wartość nie jest przypisana", "formatStringBrace": "Pojedynczy zamykający nawias klamrowy jest niedozwolony w literale ciągu f; użyj podwójnego zamykającego nawiasu klamrowego", "formatStringBytes": "Literały ciągów formatu (ciągi f) nie mogą być binarne", "formatStringDebuggingIllegal": "Specyfikator debugowania ciągu f „=” wymaga wersji języka Python 3.8 lub nowszej", @@ -231,7 +231,7 @@ "formatStringUnicode": "Literały ciągu formatu (f-strings) nie mogą być formatu unicode", "formatStringUnterminated": "Niezakończone wyrażenie w ciągu f; oczekiwano znaku „}”", "functionDecoratorTypeUnknown": "Nietypowany dekorator funkcji zasłania typ funkcji; ignorując dekoratora", - "functionInConditionalExpression": "Wyrażenie warunkowe odwołuje się do funkcji, której wynikiem zawsze jest wartość Prawda", + "functionInConditionalExpression": "Wyrażenie warunkowe odwołuje się do funkcji, której wynikiem zawsze jest wartość True", "functionTypeParametersIllegal": "Składnia parametru typu klasy wymaga wersji języka Python 3.12 lub nowszej", "futureImportLocationNotAllowed": "Importy z __future__ muszą znajdować się na początku pliku", "generatorAsyncReturnType": "Zwracany typ funkcji generatora asynchronicznego musi być zgodny z elementem „AsyncGenerator[{yieldType}, Any]”", @@ -241,7 +241,7 @@ "genericClassAssigned": "Nie można przypisać ogólnego typu klasy", "genericClassDeleted": "Nie można usunąć ogólnego typu klasy", "genericInstanceVariableAccess": "Dostęp do ogólnej zmiennej wystąpienia za pośrednictwem klasy jest niejednoznaczny", - "genericNotAllowed": "Element „ogólny” jest nieprawidłowy w tym kontekście", + "genericNotAllowed": "Element „Generic” jest nieprawidłowy w tym kontekście", "genericTypeAliasBoundTypeVar": "Alias typu ogólnego w klasie nie może używać zmiennych typu powiązanego {names}", "genericTypeArgMissing": "Wartość „Generic” wymaga co najmniej jednego argumentu typu", "genericTypeArgTypeVar": "Argument typu dla wartości „Generic” musi być zmienną typu", @@ -258,23 +258,23 @@ "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", + "initMustReturnNone": "Zwracany typ „__init__” musi mieć wartość None", "initSubclassCallFailed": "Nieprawidłowe argumenty słów kluczowych dla metody __init_subclass__", "initSubclassClsParam": "Przesłonięcie __init_subclass__ powinno przyjmować parametr „cls”.", "initVarNotAllowed": "Element „InitVar” jest niedozwolony w tym kontekście", "instanceMethodSelfParam": "Metody wystąpienia powinny przyjmować parametr „self”", "instanceVarOverridesClassVar": "Zmienna wystąpienia „{name}” zastępuje zmienną klasy o tej samej nazwie w klasie „{className}”", "instantiateAbstract": "Nie można utworzyć wystąpienia klasy abstrakcyjnej „{type}”", - "instantiateProtocol": "Nie można utworzyć wystąpienia klasy protokołu typu „{type}”", + "instantiateProtocol": "Nie można utworzyć wystąpienia klasy Protocol typu „{type}”", "internalBindError": "Wystąpił błąd wewnętrzny podczas wiązania pliku „{file}”: {message}", "internalParseError": "Wystąpił błąd wewnętrzny podczas analizowania pliku „{file}”: {message}", "internalTypeCheckingError": "Wystąpił błąd wewnętrzny podczas sprawdzania typu pliku „{file}”: {message}", "invalidIdentifierChar": "Nieprawidłowy znak w identyfikatorze", - "invalidStubStatement": "Instrukcja nie ma znaczenia w pliku zastępczym typu", + "invalidStubStatement": "Instrukcja nie ma znaczenia w pliku stub typu", "invalidTokenChars": "Nieprawidłowy znak „{text}” w tokenie", - "isInstanceInvalidType": "Drugi argument instrukcji „isinstance” musi być klasą lub krotką klas", - "isSubclassInvalidType": "Drugi argument „issubclass” musi być klasą lub krotką klas", - "keyValueInSet": "Pary klucz/wartość nie są dozwolone w zestawie", + "isInstanceInvalidType": "Drugi argument instrukcji „isinstance” musi być klasą lub tuple", + "isSubclassInvalidType": "Drugi argument „issubclass” musi być klasą lub tuple", + "keyValueInSet": "Pary klucz/wartość nie są dozwolone w set", "keywordArgInTypeArgument": "Argumentów słów kluczowych nie można używać na listach argumentów typu", "keywordArgShortcutIllegal": "Skrót do argumentu słowa kluczowego wymaga języka Python 3.14 lub nowszego", "keywordOnlyAfterArgs": "Separator argumentów tylko ze słowami kluczowymi jest niedozwolony po parametrze „*”", @@ -283,14 +283,14 @@ "lambdaReturnTypePartiallyUnknown": "Zwracany typ wyrażenia lambda „{returnType}” jest częściowo nieznany", "lambdaReturnTypeUnknown": "Zwracany typ wyrażenia lambda jest nieznany", "listAssignmentMismatch": "Wyrażenia typu „{type}” nie można przypisać do listy docelowej", - "listInAnnotation": "Wyrażenie listy jest niedozwolone w adnotacji typu", + "listInAnnotation": "Wyrażenie List jest niedozwolone w wyrażeniu typu", "literalEmptyArgs": "Oczekiwano co najmniej jednego argumentu typu po wartości „Literal”", "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", + "literalNotAllowed": "Klasa „Literal” nie może być używana w tym kontekście bez argumentu typu", + "literalNotCallable": "Nie można utworzyć wystąpienia typu Literal", + "literalUnsupportedType": "Argumenty typu dla elementu „Literal” muszą mieć wartość None, wartość literału (int, bool, str lub bytes) lub wartość enum", + "matchIncompatible": "Instrukcje Match wymagają języka Python w wersji 3.10 lub nowszej", + "matchIsNotExhaustive": "Przypadki w instrukcji match 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 atrybutu „{name}” dla klasy „{type}”", "memberDelete": "Nie można usunąć atrybutu „{name}” dla klasy „{type}”", @@ -304,43 +304,44 @@ "methodOverridden": "„{name}” przesłania metodę o tej samej nazwie w klasie „{className}” o niezgodnym typie „{type}”", "methodReturnsNonObject": "Metoda „{name}” nie zwraca obiektu", "missingSuperCall": "Metoda „{methodName}” nie wywołuje metody o tej samej nazwie w klasie nadrzędnej", + "mixingBytesAndStr": "Nie można łączyć wartości bytes i str", "moduleAsType": "Nie można użyć modułu jako typu", "moduleNotCallable": "Moduł nie jest wywoływalny", "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", - "namedTupleEntryRedeclared": "Nie można nadpisać „{name}”, ponieważ klasa nadrzędna „{className}” jest nazwaną krotką.", - "namedTupleFirstArg": "Oczekiwano nazwanej nazwy klasy krotki jako pierwszego argumentu", + "namedParamAfterParamSpecArgs": "Parametr słowa kluczowego „{name}” nie może występować w sygnaturze po parametrze ParamSpec args", + "namedTupleEmptyName": "Nazwy w ramach nazwanej kolekcji tuple nie mogą być puste", + "namedTupleEntryRedeclared": "Nie można nadpisać nazwy „{name}”, ponieważ klasa nadrzędna „{className}” jest nazwaną kolekcją tuple", + "namedTupleFirstArg": "Oczekiwano nazwanej nazwy klasy tuple jako pierwszego argumentu", "namedTupleMultipleInheritance": "Wielokrotne dziedziczenie z kotki NamedTuple nie jest obsługiwane", "namedTupleNameKeyword": "Nazwy pól nie mogą być słowem kluczowym", - "namedTupleNameType": "Oczekiwano krotki z dwoma wpisami określającej nazwę i typ wpisu", - "namedTupleNameUnique": "Nazwy w nazwanej krotce muszą być unikatowe", + "namedTupleNameType": "Oczekiwano tuple z dwoma wpisami określającej nazwę i typ wpisu", + "namedTupleNameUnique": "Nazwy w nazwanej tuple muszą być unikatowe", "namedTupleNoTypes": "Krotka „namedtuple” nie zapewnia typów wpisów krotki; zamiast tego użyj „NamedTuple”.", - "namedTupleSecondArg": "Oczekiwano nazwanej listy wpisów krotki jako drugiego argumentu", + "namedTupleSecondArg": "Oczekiwano nazwanej listy wpisów kolekcji tuple jako drugiego argumentu", "newClsParam": "Przesłonięcie __new__ powinno przyjmować parametr „cls”.", - "newTypeAnyOrUnknown": "Drugi argument elementu NewType musi być znaną klasą, a nie dowolną lub nieznaną", + "newTypeAnyOrUnknown": "Drugi argument parametru NewType musi być znaną klasą, a nie wartością Any lub Unknown", "newTypeBadName": "Pierwszy argument elementu NewType musi być literałem ciągu", - "newTypeLiteral": "Typ NewType nie może być używany z typem Literał", + "newTypeLiteral": "Typ NewType nie może być używany z typem Literal", "newTypeNameMismatch": "Element NewType musi być przypisany do zmiennej o tej samej nazwie", "newTypeNotAClass": "Oczekiwano klasy jako drugiego argumentu dla elementu NewType", "newTypeParamCount": "Typ NewType wymaga dwóch argumentów pozycyjnych", - "newTypeProtocolClass": "Elementu NewType nie można używać z typem strukturalnym (protokołem lub klasą TypedDict)", + "newTypeProtocolClass": "Elementu NewType nie można używać z typem strukturalnym (klasy Protocol lub TypedDict)", "noOverload": "Żadne przeciążenia dla nazwy „{name}” nie pasują do podanych argumentów", - "noReturnContainsReturn": "Funkcja z zadeklarowanym zwracanym typem „NoReturn” nie może zawierać instrukcji Return", - "noReturnContainsYield": "Funkcja z zadeklarowanym zwracanym typem „NoReturn” nie może zawierać instrukcji Yield", + "noReturnContainsReturn": "Funkcja z zadeklarowanym return typem „NoReturn” nie może zawierać instrukcji return", + "noReturnContainsYield": "Funkcja z zadeklarowanym zwracanym typem „NoReturn” nie może zawierać instrukcji yield", "noReturnReturnsNone": "Funkcja z zadeklarowanym typem zwracanym „NoReturn” nie może zwracać wartości „None”", "nonDefaultAfterDefault": "Argument inny niż domyślny następuje po argumencie domyślnym", - "nonLocalInModule": "Deklaracja nielokalna nie jest dozwolona na poziomie modułu", - "nonLocalNoBinding": "Nie znaleziono powiązania dla nielokalnej nazwy „{name}”.", - "nonLocalReassignment": "Nazwa „{name}” jest przypisywana przed deklaracją nielokalną", - "nonLocalRedefinition": "Nazwa „{name}” została już zadeklarowana jako nielokalna", + "nonLocalInModule": "Deklaracja nonlocal nie jest dozwolona na poziomie modułu", + "nonLocalNoBinding": "Nie znaleziono powiązania dla nonlocal „{name}”.", + "nonLocalReassignment": "Nazwa „{name}” jest przypisywana przed deklaracją nonlocal", + "nonLocalRedefinition": "Nazwa „{name}” została już zadeklarowana jako nonlocal", "noneNotCallable": "Nie można wywołać obiektu typu „None”", - "noneNotIterable": "Obiekt typu „Brak” nie może być używany jako wartość iterowalna", + "noneNotIterable": "Obiekt typu „None” nie może być używany jako wartość iterowalna", "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": "„{name}” nie jest znanym atrybutem „Brak”", + "noneNotUsableWith": "Object of type \"None\" cannot be used with \"with\"", + "noneOperator": "Operator „{operator}” nie jest obsługiwany dla wartości „None”", + "noneUnknownMember": "Nazwa „{name}” nie jest znanym atrybutem „None”", "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", @@ -364,9 +365,9 @@ "overloadImplementationMismatch": "Przeciążone wdrożenie jest niespójne z sygnaturą przeciążenia {index}", "overloadReturnTypeMismatch": "Przeciążenie {prevIndex} dla nazwy „{name}” nakłada się na przeciążenie {newIndex} i zwraca niezgodny typ", "overloadStaticMethodInconsistent": "Przeciążenia dla nazwy „{name}” używają metody @staticmethod niekonsekwentnie", - "overloadWithoutImplementation": "Element „{name}” jest oznaczony jako przeciążony, ale nie podano implementacji", - "overriddenMethodNotFound": "Metoda „{name}” jest oznaczona jako zastąpienie, ale nie istnieje metoda bazowa o tej samej nazwie", - "overrideDecoratorMissing": "Metoda „{name}” nie jest oznaczona jako zastąpienie, ale zastępuje metodę w klasie „{className}”", + "overloadWithoutImplementation": "Nazwa „{name}” jest oznaczona jako overload, ale nie zapewniono implementacji", + "overriddenMethodNotFound": "Metoda „{name}” jest oznaczona jako override, ale nie istnieje metoda bazowa o tej samej nazwie", + "overrideDecoratorMissing": "Metoda „{name}” nie jest oznaczona jako override, ale zastępuje metodę w klasie „{className}”", "paramAfterKwargsParam": "Parametr nie może następować po parametrze „**”", "paramAlreadyAssigned": "Parametr „{name}” jest już przypisany", "paramAnnotationMissing": "Brak adnotacji typu dla parametru „{name}”", @@ -377,7 +378,7 @@ "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", + "paramSpecDefaultNotTuple": "Oczekiwano wielokropka, wyrażenia kolekcji tuple lub parametru ParamSpec dla wartości domyślnej ParamSpec", "paramSpecFirstArg": "Oczekiwano nazwy parametru ParamSpec jako pierwszego argumentu", "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", @@ -387,7 +388,7 @@ "paramTypeCovariant": "Zmienna typu kowariantnego nie może być używana w typie parametru", "paramTypePartiallyUnknown": "Typ parametru „{paramName}” jest częściowo nieznany", "paramTypeUnknown": "Typ parametru „{paramName}” jest nieznany", - "parenthesizedContextManagerIllegal": "Nawiasy w instrukcji „with” wymagają wersji języka Python 3.9 lub nowszej", + "parenthesizedContextManagerIllegal": "Parentheses within \"with\" statement requires Python 3.9 or newer", "patternNeverMatches": "Wzorzec nigdy nie zostanie dopasowany do typu podmiotu „{type}”", "positionArgAfterNamedArg": "Argument pozycyjny nie może występować po argumentach słów kluczowych", "positionOnlyAfterArgs": "Separator parametru tylko do pozycjonowania jest niedozwolony po parametrze „*”", @@ -398,25 +399,25 @@ "privateImportFromPyTypedModule": "Nazwa „{name}” nie jest eksportowana z modułu „{module}”", "privateUsedOutsideOfClass": "Nazwa „{name}” jest prywatna i używana poza klasą, w której została zadeklarowana", "privateUsedOutsideOfModule": "Nazwa „{name}” jest prywatna i używana poza modułem, w którym została zadeklarowana", - "propertyOverridden": "„{name}” nieprawidłowo zastępuje właściwość o tej samej nazwie w klasie „{className}”", - "propertyStaticMethod": "Metody statyczne nie są dozwolone w przypadku metod pobierających, ustawiających lub usuwających właściwości", + "propertyOverridden": "Nazwa „{name}” nieprawidłowo zastępuje property o tej samej nazwie w klasie „{className}”", + "propertyStaticMethod": "Metody statyczne nie są dozwolone w przypadku getter, setter lub deleter property", "protectedUsedOutsideOfClass": "Nazwa „{name}” jest chroniona i używana poza klasą, w której została zadeklarowana", - "protocolBaseClass": "Klasa protokołu typu „{classType}” nie może pochodzić od klasy niebędącej klasą protokołu typu „{baseType}”", - "protocolBaseClassWithTypeArgs": "Argumenty typu są niedozwolone w przypadku klasy protokołu, gdy jest używana składnia parametru typu", + "protocolBaseClass": "Klasa Protocol typu „{classType}” nie może pochodzić od klasy niebędącej klasą Protocol typu „{baseType}”", + "protocolBaseClassWithTypeArgs": "Argumenty typu są niedozwolone z klasą Protocol, gdy jest używana składnia parametru typu", "protocolIllegal": "Użycie elementu „Protocol” wymaga języka Python w wersji 3.7 lub nowszej", - "protocolNotAllowed": "„Protokół” nie może być używany w tym kontekście", + "protocolNotAllowed": "Klasa „Protocol” nie może być używana w tym kontekście", "protocolTypeArgMustBeTypeParam": "Argument typu dla elementy „Protocol” musi być parametrem typu", "protocolUnsafeOverlap": "Klasa nakłada się niebezpiecznie na element „{name}” i może utworzyć dopasowanie w czasie wykonywania", - "protocolVarianceContravariant": "Zmienna typu „{variable}” używana w klasie protokołu ogólnego „{class}” powinna być kontrawariantna", - "protocolVarianceCovariant": "Zmienna typu „{variable}” używana w klasie protokołu ogólnego „{class}” powinna być kowariantna", - "protocolVarianceInvariant": "Zmienna typu „{variable}” używana w klasie protokołu ogólnego „{class}” powinna być niezmienna", - "pyrightCommentInvalidDiagnosticBoolValue": "Po dyrektywie komentarza Pyright musi następować znak „=” oraz wartość Prawda lub Fałsz", - "pyrightCommentInvalidDiagnosticSeverityValue": "Po dyrektywie komentarza Pyright musi następować znak „=” oraz wartość Prawda, Fałsz, Błąd, Ostrzeżenie, Informacja lub Brak", - "pyrightCommentMissingDirective": "Komentarz Pyright musi poprzedzać dyrektywę (bazową lub ścisłą) lub regułę diagnostyczną", + "protocolVarianceContravariant": "Zmienna typu „{variable}” używana w klasie ogólnej Protocol „{class}” powinna być kontrawariantna", + "protocolVarianceCovariant": "Zmienna typu „{variable}” używana w klasie ogólnej Protocol „{class}” powinna być kowariantna", + "protocolVarianceInvariant": "Zmienna typu „{variable}” używana w klasie ogólnego Protocol „{class}” powinna być niezmienna", + "pyrightCommentInvalidDiagnosticBoolValue": "Po dyrektywie komentarza Pyright musi następować znak „=” oraz wartość true lub false", + "pyrightCommentInvalidDiagnosticSeverityValue": "Po dyrektywie komentarza Pyright musi następować znak „=” oraz wartość true, false, error, warning, information lub none", + "pyrightCommentMissingDirective": "Po komentarzu Pyright musi następować dyrektywa (basic lub strict) lub reguła diagnostyczna", "pyrightCommentNotOnOwnLine": "Komentarze Pyright używane do kontrolowania ustawień na poziomie plików muszą pojawiać się w oddzielnych wierszach", - "pyrightCommentUnknownDiagnosticRule": "Reguła „{rule}” jest nieznaną regułą diagnostyczną dla komentarza Pyright", - "pyrightCommentUnknownDiagnosticSeverityValue": "Wartość „{value}” jest nieprawidłowa dla komentarza Pyright; oczekiwano wartości: Prawda, Fałsz, Błąd, Ostrzeżenie, Informacja lub Brak", - "pyrightCommentUnknownDirective": "Wartość „{directive}” jest nieznaną dyrektywą dla komentarza Pyright; oczekiwano wartości „strict” lub „basic”", + "pyrightCommentUnknownDiagnosticRule": "Reguła „{rule}” jest nieznaną regułą diagnostyczną dla komentarza pyright", + "pyrightCommentUnknownDiagnosticSeverityValue": "Wartość „{value}” jest nieprawidłowa dla komentarza pyright; oczekiwano wartości: true, false, error, warning, information lub none", + "pyrightCommentUnknownDirective": "Wartość „{directive}” jest nieznaną dyrektywą dla komentarza pyright; oczekiwano wartości „strict” lub „basic”", "readOnlyArgCount": "Oczekiwano jednego argumentu typu po wartości „ReadOnly”", "readOnlyNotInTypedDict": "Element „ReadOnly” jest niedozwolony w tym kontekście", "recursiveDefinition": "Nie można określić typu „{name}”, ponieważ odwołuje się on do samego siebie", @@ -427,11 +428,11 @@ "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żenie typu „{exprType}” jest niezgodne z typem zwracania „{returnType}”", + "returnTypeMismatch": "Nie można przypisać typu „{exprType}” do zwracanego typu „{returnType}”", "returnTypePartiallyUnknown": "Zwracany typ „{returnType}” jest częściowo nieznany", "returnTypeUnknown": "Zwracany typ jest nieznany", "revealLocalsArgs": "Oczekiwano braku argumentów dla wywołania „reveal_locals”", - "revealLocalsNone": "Brak elementów lokalnych w tym zakresie", + "revealLocalsNone": "Brak locals w tym zakresie", "revealTypeArgs": "Oczekiwano pojedynczego argumentu pozycyjnego dla wywołania „reveal_type”", "revealTypeExpectedTextArg": "Argument „expected_text” dla funkcji „reveal_type” musi być wartością literału str", "revealTypeExpectedTextMismatch": "Wpisz niezgodność tekstu; oczekiwano „{expected}”, ale otrzymano „{received}”", @@ -439,7 +440,7 @@ "selfTypeContext": "Wartość „Self” jest nieprawidłowa w tym kontekście", "selfTypeMetaclass": "Nie można użyć elementu „Self” w ramach metaklasy (podklasy elementu „type”)", "selfTypeWithTypedSelfOrCls": "Nie można użyć wartości „Self” w funkcji z parametrem „self” lub „cls”, która ma adnotację typu inną niż „Self”", - "setterGetterTypeMismatch": "Typu wartości metody ustawiającej właściwość nie można przypisać do zwracanego typu metody pobierającej", + "setterGetterTypeMismatch": "Typu wartości setter property nie można przypisać do zwracanego typu getter", "singleOverload": "Nazwa „{name}” jest oznaczona jako przeciążona, ale brakuje dodatkowych przeciążeń", "slotsAttributeError": "Nie określono atrybutu „{name}” w elemencie __slots__", "slotsClassVarConflict": "„{name}” powoduje konflikt ze zmienną wystąpienia zadeklarowaną w elemencie „__slots__”", @@ -449,12 +450,12 @@ "staticClsSelfParam": "Metody statyczne nie powinny przyjmować parametru „self” ani „cls”.", "stdlibModuleOverridden": "Ścieżka „{path}” zastępuje moduł stdlib „{name}”", "stringNonAsciiBytes": "Znak inny niż ASCII jest niedozwolony w literale ciągu bajtów", - "stringNotSubscriptable": "Wyrażenie ciągu nie może być indeksowane w adnotacji typu; ujmij całą adnotację w cudzysłów", + "stringNotSubscriptable": "Wyrażenie ciągu nie może być indeksowane w wyrażeniu typu; ujmij całe wyrażenie w cudzysłowy", "stringUnsupportedEscape": "Nieobsługiwana sekwencja ucieczki w literale ciągu", "stringUnterminated": "Literał ciągu jest niezakończony", - "stubFileMissing": "Nie znaleziono pliku zastępczego dla „{importName}”", - "stubUsesGetAttr": "Typ pliku zastępczego jest niekompletny; element „__getattr__” przesłania błędy typu dla modułu", - "sublistParamsIncompatible": "Parametry podlisty nie są obsługiwane w wersji języka Python 3.x", + "stubFileMissing": "Nie znaleziono pliku stub dla nazwy „{importName}”", + "stubUsesGetAttr": "Plik stub typu jest niekompletny; element „__getattr__” przesłania błędy w przypadku modułu", + "sublistParamsIncompatible": "Parametry sublisty nie są obsługiwane w wersji języka Python 3.x", "superCallArgCount": "Oczekiwano nie więcej niż dwóch argumentów wywołania „super”", "superCallFirstArg": "Oczekiwano typu klasy jako pierwszego argumentu wywołania „super”, ale otrzymano „{type}”", "superCallSecondArg": "Drugi argument wywołania „super” musi być obiektem lub klasą wywodzącą się z typu „{type}”", @@ -464,24 +465,24 @@ "symbolIsUnbound": "Nazwa „{name}” jest niepowiązana", "symbolIsUndefined": "Nazwa „{name}” nie jest zdefiniowana", "symbolOverridden": "Nazwa „{name}” przesłania symbol o tej samej nazwie w klasie „{className}”", - "ternaryNotAllowed": "Wyrażenie słownikowe jest niedozwolone w adnotacji typu", + "ternaryNotAllowed": "Wyrażenie trójskładnikowe nie jest dozwolone w wyrażeniu typu", "totalOrderingMissingMethod": "Klasa musi definiować jedną z następujących wartości: „__lt__”, „__le__”, „__gt__” lub „__ge__”, aby użyć parametru total_ordering", "trailingCommaInFromImport": "Końcowy przecinek nie jest dozwolony bez otaczających nawiasów", "tryWithoutExcept": "Instrukcja „Try” musi mieć co najmniej jedną klauzulę „except” lub „finally”", - "tupleAssignmentMismatch": "Wyrażenia typu „{type}” nie można przypisać do docelowej krotki", - "tupleInAnnotation": "Wyrażenie krotki jest niedozwolone w adnotacji typu", + "tupleAssignmentMismatch": "Nie można przypisywać wyrażenia w ramach typu „{type}” do docelowej kolekcji tuple", + "tupleInAnnotation": "Wyrażenie kolekcji tuple jest niedozwolone w wyrażeniu typu", "tupleIndexOutOfRange": "Indeks {index} jest poza zakresem dla typu {type}", "typeAliasIllegalExpressionForm": "Nieprawidłowy formularz wyrażenia dla definicji aliasu typu", "typeAliasIsRecursiveDirect": "Alias typu „{name}” nie może używać samego siebie w swojej definicji", "typeAliasNotInModuleOrClass": "Typ TypeAlias można zdefiniować tylko w zakresie modułu lub klasy", "typeAliasRedeclared": "Nazwa „{name}” jest zadeklarowana jako TypeAlias i może być przypisana tylko raz", - "typeAliasStatementBadScope": "Deklaracja typu może być użyta tylko w zakresie modułu lub klasy", + "typeAliasStatementBadScope": "Instrukcja type może być użyta tylko w zakresie modułu lub klasy", "typeAliasStatementIllegal": "Instrukcja typu alias wymaga języka Python w wersji 3.12 lub nowszej", - "typeAliasTypeBaseClass": "Alias typu zdefiniowany w instrukcji „{type}” nie może być użyty jako klasa bazowa", + "typeAliasTypeBaseClass": "A type alias defined in a \"type\" statement cannot be used as a base class", "typeAliasTypeMustBeAssigned": "Typ TypeAliasType musi być przypisany do zmiennej o takiej samej nazwie jak alias typu", - "typeAliasTypeNameArg": "Pierwszy argument dla typu typeAliasType musi być literałem ciągu reprezentującym nazwę aliasu typu", + "typeAliasTypeNameArg": "Pierwszy argument dla typu TypeAliasType musi być literałem ciągu reprezentującym nazwę aliasu typu", "typeAliasTypeNameMismatch": "Nazwa aliasu typu musi być zgodna z nazwą zmiennej, do której jest przypisana", - "typeAliasTypeParamInvalid": "Lista parametrów typu musi być krotką zawierającą tylko parametry TypeVar, TypeVarTuple lub ParamSpec", + "typeAliasTypeParamInvalid": "Lista parametrów typu musi być kolekcją tuple zawierającą tylko parametry TypeVar, TypeVarTuple lub ParamSpec", "typeAnnotationCall": "Wyrażenie wywołania jest niedozwolone w wyrażeniu typu", "typeAnnotationVariable": "Zmienna niedozwolona w wyrażeniu typu", "typeAnnotationWithCallable": "Argument typu „type” musi być klasą; elementy wywoływane nie są obsługiwane", @@ -493,16 +494,17 @@ "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}” 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", + "typeAssignmentMismatch": "Nie można przypisać typu „{sourceType}” do zadeklarowanego typu „{destType}”", + "typeAssignmentMismatchWildcard": "Symbol importu „{name}” ma typ „{sourceType}”, którego nie można przypisać do zadeklarowanego typu „{destType}”", + "typeCallNotAllowed": "wywołanie type() nie powinno być używane w wyrażeniu 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", + "typeCommentDeprecated": "Use of type comments is deprecated; use type annotation instead", "typeExpectedClass": "Oczekiwano klasy, ale odebrano typ „{type}”", + "typeFormArgs": "„TypeForm” akceptuje pojedynczy argument pozycyjny", "typeGuardArgCount": "Oczekiwano pojedynczego argumentu typu po parametrze „TypeGuard” lub „TypeIs”", "typeGuardParamCount": "Funkcje i metody zabezpieczające typu zdefiniowane przez użytkownika muszą mieć co najmniej jeden parametr wejściowy", "typeIsReturnType": "Zwracany typ TypeIs („{returnType}”) jest niezgodny z typem parametru wartości („{type}”)", - "typeNotAwaitable": "Nie można oczekiwać typu „{type}”", + "typeNotAwaitable": "\"{type}\" is not awaitable", "typeNotIntantiable": "Nie można utworzyć wystąpienia „{type}”", "typeNotIterable": "Typ „{type}” nie jest iterowalny", "typeNotSpecializable": "Nie można specjalizować typu „{type}”", @@ -537,7 +539,7 @@ "typeVarSingleConstraint": "Typ TypeVar musi mieć co najmniej dwa typy ograniczone", "typeVarTupleConstraints": "Element TypeVarTuple nie może mieć ograniczeń wartości", "typeVarTupleContext": "Wartość TypeVarTuple jest niedozwolona w tym kontekście", - "typeVarTupleDefaultNotUnpacked": "Typ domyślny TypeVarTuple musi być nierozpakowaną krotką lub parametrem TypeVarTuple", + "typeVarTupleDefaultNotUnpacked": "Typ domyślny TypeVarTuple musi być nierozpakowaną kolekcją tuple lub parametrem TypeVarTuple", "typeVarTupleMustBeUnpacked": "Operator rozpakowywania jest wymagany dla wartości parametru TypeVarTuple", "typeVarTupleUnknownParam": "Nazwa „{name}” jest nieznanym parametrem typu TypeVarTuple", "typeVarUnknownParam": "„{name}” jest nieznanym parametrem dla argumentu TypeVar", @@ -551,17 +553,17 @@ "typedDictAssignedName": "Element TypedDict musi być przypisany do zmiennej o nazwie „{name}”", "typedDictBadVar": "Klasy TypedDict mogą zawierać tylko adnotacje typu", "typedDictBaseClass": "Wszystkie klasy bazowe dla klas TypedDict muszą być również klasami TypedDict", - "typedDictBoolParam": "Oczekiwano, że parametr „{name}” będzie miał wartość Prawda lub Fałsz", - "typedDictClosedExtras": "Klasa bazowa „{name}” jest zamkniętym elementem TypedDict; dodatkowe elementy muszą być typu „{type}”", - "typedDictClosedNoExtras": "Klasa bazowa „{name}” jest zamkniętym elementem TypedDict; dodatkowe elementy są niedozwolone", + "typedDictBoolParam": "Oczekiwano, że parametr „{name}” będzie miał wartość True lub False", + "typedDictClosedExtras": "Klasa bazowa „{name}” jest closed TypedDict; dodatkowe elementy muszą być typu „{type}”", + "typedDictClosedNoExtras": "Klasa bazowa „{name}” jest closed TypedDict; dodatkowe elementy są niedozwolone", "typedDictDelete": "Nie można usunąć elementu w typie TypedDict", "typedDictEmptyName": "Nazwy w elemencie TypedDict nie mogą być puste", "typedDictEntryName": "Oczekiwano literału ciągu dla nazwy wpisu słownika", "typedDictEntryUnique": "Nazwy w słowniku muszą być unikatowe", "typedDictExtraArgs": "Dodatkowe argumenty TypedDict nie są obsługiwane", - "typedDictFieldNotRequiredRedefinition": "Element TypedDict „{name}” nie może zostać przedefiniowany jako Niewymagany", - "typedDictFieldReadOnlyRedefinition": "Element TypedDict „{name}” nie może być przedefiniowany jako Tylko do odczytu.", - "typedDictFieldRequiredRedefinition": "Element TypedDict „{name}” nie może zostać przedefiniowany jako Wymagany", + "typedDictFieldNotRequiredRedefinition": "Element TypedDict „{name}” nie może zostać przedefiniowany jako NotRequired", + "typedDictFieldReadOnlyRedefinition": "Element TypedDict „{name}” nie może być przedefiniowany jako ReadOnly.", + "typedDictFieldRequiredRedefinition": "Element TypedDict „{name}” nie może zostać przedefiniowany jako Required", "typedDictFirstArg": "Oczekiwano nazwy klasy TypedDict jako pierwszego argumentu", "typedDictInitsubclassParameter": "Element TypedDict nie obsługuje parametru __init_subclass__ „{name}”", "typedDictNotAllowed": "Nie można użyć elementu „TypedDict” w tym kontekście", @@ -574,34 +576,34 @@ "unaccessedSymbol": "Brak dostępu do „{name}”.", "unaccessedVariable": "Brak dostępu do zmiennej „{name}”.", "unannotatedFunctionSkipped": "Analiza funkcji „{name}” została pominięta, ponieważ nie ma adnotacji", - "unaryOperationNotAllowed": "Operator jednoargumentowy nie jest dozwolony w adnotacji typu", + "unaryOperationNotAllowed": "Operator jednoargumentowy nie jest dozwolony w wyrażeniu typu", "unexpectedAsyncToken": "Oczekiwano wartości „def”, „with” lub „for” po „async”", "unexpectedExprToken": "Nieoczekiwany token na końcu wyrażenia", "unexpectedIndent": "Nieoczekiwane wcięcie", "unexpectedUnindent": "Nieoczekiwany brak wcięcia", "unhashableDictKey": "Klucz słownika musi być wartością skrótu", - "unhashableSetEntry": "Ustawiany wpis musi być wartością skrótu", - "uninitializedAbstractVariables": "Zmienne zdefiniowane w abstrakcyjnej klasie bazowej nie są inicjowane w klasie końcowej „{classType}”", + "unhashableSetEntry": "Set wpis musi być wartością skrótu", + "uninitializedAbstractVariables": "Zmienne zdefiniowane w abstrakcyjnej klasie bazowej nie są inicjowane w klasie final „{classType}”", "uninitializedInstanceVariable": "Zmienna wystąpienia „{name}” nie została zainicjowana w treści klasy ani w metodzie __init__", - "unionForwardReferenceNotAllowed": "Składnia unii nie może być używana z operandem ciągu; użyj cudzysłowów wokół całego wyrażenia", + "unionForwardReferenceNotAllowed": "Składnia elementu Union nie może być używana z operandem ciągu; użyj cudzysłowów wokół całego wyrażenia", "unionSyntaxIllegal": "Alternatywna składnia unii wymaga języka Python w wersji 3.10 lub nowszej", - "unionTypeArgCount": "Unia wymaga co najmniej dwóch argumentów typu", - "unionUnpackedTuple": "Związek nie może zawierać rozpakowanej krotki", - "unionUnpackedTypeVarTuple": "Unia nie może zawierać rozpakowanego elementu TypeVarTuple", + "unionTypeArgCount": "Element Union wymaga co najmniej dwóch argumentów typu", + "unionUnpackedTuple": "Typ Union nie może zawierać niespakowanej kolekcji tuple", + "unionUnpackedTypeVarTuple": "Typ Union nie może zawierać niespakowanego parametru TypeVarTuple", "unnecessaryCast": "Niepotrzebne wywołanie „cast”; typ jest już „{type}”", - "unnecessaryIsInstanceAlways": "Niepotrzebne wywołanie wystąpienia; „{testType}” jest zawsze wystąpieniem „{classType}”", + "unnecessaryIsInstanceAlways": "Niepotrzebne wywołanie elementu isinstance; „{testType}” jest zawsze wystąpieniem „{classType}”", "unnecessaryIsSubclassAlways": "Niepotrzebne wywołanie „issubclass”; „{testType}” jest zawsze podklasą klasy „{classType}”", "unnecessaryPyrightIgnore": "Niepotrzebny komentarz „# pyright: ignore”", "unnecessaryPyrightIgnoreRule": "Niepotrzebna reguła „# pyright: ignore”: „{name}”", "unnecessaryTypeIgnore": "Niepotrzebny komentarz „# type: ignore”", "unpackArgCount": "Oczekiwano jednego argumentu typu po wartości „Unpack”", - "unpackExpectedTypeVarTuple": "Oczekiwano typu TypeVarTuple lub krotki jako argumentu typu dla rozpakowywania", - "unpackExpectedTypedDict": "Oczekiwano argumentu typu TypedDict dla rozpakowywania", + "unpackExpectedTypeVarTuple": "Oczekiwano typu TypeVarTuple lub tuple jako argumentu typu dla elementu Unpack", + "unpackExpectedTypedDict": "Oczekiwano argumentu typu TypedDict dla elementu Unpack", "unpackIllegalInComprehension": "Operacja rozpakowywania nie jest dozwolona w rozumieniu", - "unpackInAnnotation": "Operator rozpakowywania nie jest dozwolony w adnotacji typu", + "unpackInAnnotation": "Operator rozpakowywania nie jest dozwolony w wyrażeniu typu", "unpackInDict": "Operacja rozpakowywania nie jest dozwolona w słownikach", - "unpackInSet": "Rozpakowywanie operatora jest niedozwolone w zestawie", - "unpackNotAllowed": "Rozpakowywanie jest niedozwolone w tym kontekście", + "unpackInSet": "Rozpakowywanie operatora jest niedozwolone w set", + "unpackNotAllowed": "Element Unpack jest niedozwolony w tym kontekście", "unpackOperatorNotAllowed": "Operacja rozpakowywania jest niedozwolona w tym kontekście", "unpackTuplesIllegal": "Operacja rozpakowywania nie jest dozwolona w krotkach przed językiem Python w wersji 3.8", "unpackedArgInTypeArgument": "Nie można użyć nierozpakowanych argumentów w tym kontekście", @@ -613,38 +615,38 @@ "unpackedTypedDictArgument": "Nie można dopasować nierozpakowanego argumentu TypedDict do parametrów", "unreachableCode": "Kod jest nieosiągalny", "unreachableCodeType": "Analiza typów wskazuje, że kod jest nieosiągalny", - "unreachableExcept": "Klauzula wyjątku jest nieosiągalna, ponieważ wyjątek jest już obsługiwany", + "unreachableExcept": "Klauzula Except jest nieosiągalna, ponieważ wyjątek jest już obsługiwany", "unsupportedDunderAllOperation": "Operacja na elemencie „__all__” nie jest obsługiwana, więc wyeksportowana lista symboli może być nieprawidłowa", "unusedCallResult": "Wynik wyrażenia wywołania jest typu „{type}” i nie jest używany; przypisz do zmiennej „_”, jeśli jest to zamierzone", "unusedCoroutine": "Wynik wywołania funkcji asynchronicznej nie jest używany; użyj wartości „await” lub przypisz wynik do zmiennej", "unusedExpression": "Wartość wyrażenia jest nieużywana", - "varAnnotationIllegal": "Adnotacje typu dla zmiennych wymagają języka Python w wersji 3.6 lub nowszej; użyj komentarza typu, aby uzyskać zgodność z poprzednimi wersjami", - "variableFinalOverride": "Zmienna „{name}” jest oznaczona jako końcowa i zastępuje zmienną inną niż końcowa o tej samej nazwie w klasie „{className}”", - "variadicTypeArgsTooMany": "Lista argumentów typu może zawierać co najwyżej jeden nierozpakowany typ TypeVarTuple lub krotkę", + "varAnnotationIllegal": "Type annotations for variables requires Python 3.6 or newer; use type comment for compatibility with previous versions", + "variableFinalOverride": "Zmienna „{name}” jest oznaczona jako Final i zastępuje zmienną inną non-Final o tej samej nazwie w klasie „{className}”", + "variadicTypeArgsTooMany": "Lista argumentów typu może zawierać co najwyżej jeden nierozpakowany typ TypeVarTuple lub tuple", "variadicTypeParamTooManyAlias": "Alias typu może mieć co najwyżej jeden parametr typu TypeVarTuple, ale otrzymał wiele ({names})", "variadicTypeParamTooManyClass": "Klasa ogólna może mieć co najwyżej jeden parametr typu TypeVarTuple, ale otrzymał wiele ({names})", "walrusIllegal": "Operator „:=” wymaga języka Python w wersji 3.8 lub nowszej", "walrusNotAllowed": "Operator „:=” jest niedozwolony w tym kontekście bez otaczających nawiasów", - "wildcardInFunction": "Importowanie symboli wieloznacznych jest niedozwolone w obrębie klasy lub funkcji", - "wildcardLibraryImport": "Importowanie symboli wieloznacznych z biblioteki jest niedozwolone", + "wildcardInFunction": "Wildcard import not allowed within a class or function", + "wildcardLibraryImport": "Wildcard import from a library not allowed", "wildcardPatternTypePartiallyUnknown": "Typ przechwycony przez wzorzec symboli wieloznacznych jest częściowo nieznany", "wildcardPatternTypeUnknown": "Typ przechwycony przez wzorzec symboli wieloznacznych jest nieznany", "yieldFromIllegal": "Użycie wartości „yield from” wymaga języka Python w wersji 3.3 lub nowszej", "yieldFromOutsideAsync": "Instrukcja „yield from” jest niedozwolona w funkcji asynchronicznej", "yieldOutsideFunction": "Instrukcja „yield” jest niedozwolona poza funkcją lub wyrażeniem lambda", "yieldWithinComprehension": "Instrukcja „yield” nie jest dozwolona w rozumieniu", - "zeroCaseStatementsFound": "Instrukcja dopasowania musi zawierać co najmniej jedną instrukcję dotyczącą wielkości liter", - "zeroLengthTupleNotAllowed": "Krotka o zerowej długości jest niedozwolona w tym kontekście" + "zeroCaseStatementsFound": "Match statement must include at least one case statement", + "zeroLengthTupleNotAllowed": "Zero-length tuple is not allowed in this context" }, "DiagnosticAddendum": { - "annotatedNotAllowed": "Formularza specjalnego „Adnotacja” nie można używać z kontrolami wystąpień i klas", + "annotatedNotAllowed": "Formularza specjalnego „Annotated” nie można używać z kontrolami wystąpień i klas", "argParam": "Argument odpowiada parametrowi „{paramName}”", "argParamFunction": "Argument odpowiada parametrowi „{paramName}” w funkcji „{functionName}”", "argsParamMissing": "Parametr „*{paramName}” nie ma odpowiadającego mu parametru", "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": "Typ jest niezgodny z wartością „Brak”", + "assignToNone": "Nie można przypisać typu do elementu „None”", "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}”", @@ -657,7 +659,7 @@ "dataProtocolUnsupported": "Element „{name}” to protokół danych", "descriptorAccessBindingFailed": "Nie można powiązać metody „{name}” dla klasy deskryptora „{className}”", "descriptorAccessCallFailed": "Nie można wywołać metody „{name}” dla klasy deskryptora „{className}”", - "finalMethod": "Metoda końcowa", + "finalMethod": "Final method", "functionParamDefaultMissing": "Brak domyślnego argumentu dla parametru „{name}”", "functionParamName": "Niezgodność nazw parametrów: „{destName}” a „{srcName}”", "functionParamPositionOnly": "Niezgodność parametrów tylko do położenia; parametr „{name}” nie jest tylko pozycją", @@ -665,9 +667,9 @@ "functionTooFewParams": "Funkcja akceptuje zbyt mało parametrów pozycyjnych; oczekiwano {expected}, ale otrzymano {received}", "functionTooManyParams": "Funkcja akceptuje zbyt wiele parametrów pozycyjnych; oczekiwano {expected}, ale otrzymano {received}", "genericClassNotAllowed": "Typ ogólny z argumentami typu jest niedozwolony dla sprawdzania wystąpienia lub klasy", - "incompatibleDeleter": "Metoda usuwająca właściwości jest niezgodna", - "incompatibleGetter": "Metoda pobierająca właściwości jest niezgodna", - "incompatibleSetter": "Metoda ustawiająca właściwości jest niezgodna", + "incompatibleDeleter": "Property deleter method is incompatible", + "incompatibleGetter": "Property getter method is incompatible", + "incompatibleSetter": "Property setter method is incompatible", "initMethodLocation": "Metoda __init__ jest zdefiniowana w klasie „{type}”", "initMethodSignature": "Sygnatura __init__ to typ „{type}”", "initSubclassLocation": "Metoda __init_subclass__ jest zdefiniowana w klasie „{name}”", @@ -681,14 +683,14 @@ "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": "„{sourceType}” jest niezgodny z typem „{destType}”", + "literalAssignmentMismatch": "Nie można przypisać typu „{sourceType}” do typu „{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 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", - "memberIsInitVar": "Składowa „{name}” jest polem tylko do operacji init", + "memberIsInitVar": "Składowa „{name}” jest polem do operacji init-only", "memberIsInvariant": "Nazwa „{name}” jest niezmienna, ponieważ jest modyfikowalna", "memberIsNotClassVarInClass": "Element „{name}” musi być zdefiniowany jako ClassVar, aby był zgodny z protokołem", "memberIsNotClassVarInProtocol": "Element „{name}” nie jest zdefiniowany jako ClassVar w protokole", @@ -699,9 +701,9 @@ "memberTypeMismatch": "Nazwa „{name}” jest niezgodnym typem", "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", + "missingDeleter": "Property deleter method is missing", + "missingGetter": "Property getter method is missing", + "missingSetter": "Property setter method is missing", "namedParamMissingInDest": "Dodatkowy parametr „{name}”", "namedParamMissingInSource": "Brak parametru słowa kluczowego „{name}”", "namedParamTypeMismatch": "Parametr słowa kluczowego „{name}” typu „{sourceType}” jest niezgodny z typem „{destType}”", @@ -710,7 +712,7 @@ "newMethodSignature": "Sygnatura __new__ to typ „{type}”", "newTypeClassNotAllowed": "Klasy utworzonej za pomocą elementu NewType nie można używać z sprawdzaniem wystąpień i klas", "noOverloadAssignable": "Żadna przeciążona funkcja nie pasuje do typu „{type}”", - "noneNotAllowed": "Żadne nie może być używane do sprawdzania wystąpienia ani klasy", + "noneNotAllowed": "Wartość None nie może być używana w przypadku kontroli wystąpień lub klas", "orPatternMissingName": "Brak nazw: {name}", "overloadIndex": "Przeciążenie {index} jest najbardziej zbliżonym dopasowaniem", "overloadNotAssignable": "Nie można przypisać jednego lub więcej przeciążeń „{name}”.", @@ -722,7 +724,7 @@ "overrideNoOverloadMatches": "Żadna sygnatura przeciążenia w przesłonięciu nie jest zgodna z metodą bazową", "overrideNotClassMethod": "Metoda bazowa jest zadeklarowana jako metoda classmethod, ale przesłonięcie nie", "overrideNotInstanceMethod": "Metoda bazowa jest zadeklarowana jako metoda wystąpienia, ale zastąpienie nie jest", - "overrideNotStaticMethod": "Metoda bazowa jest zadeklarowana jako metoda statyczna, ale przesłonięcie nie", + "overrideNotStaticMethod": "Metoda bazowa jest zadeklarowana jako staticmethod, ale przesłonięcie nie", "overrideOverloadNoMatch": "Zastąpienie nie obsługuje wszystkich przeciążeń metody podstawowej", "overrideOverloadOrder": "Przeciążenia dla metody przesłaniania muszą być w takiej samej kolejności, co metoda bazowa", "overrideParamKeywordNoDefault": "Niezgodność parametru słowa kluczowego „{name}”: parametr bazowy ma domyślną wartość argumentu, parametr zastąpienia nie ma jej", @@ -741,16 +743,16 @@ "paramType": "Typ parametru to „{paramType}”", "privateImportFromPyTypedSource": "Zamiast tego importuj z modułu „{module}”.", "propertyAccessFromProtocolClass": "Nie można uzyskać dostępu do właściwości zdefiniowanej w klasie protokołu jako zmiennej klasy", - "propertyMethodIncompatible": "Metoda właściwości „{name}” jest niezgodna", - "propertyMethodMissing": "Brak metody właściwości „{name}” w zastąpieniu", - "propertyMissingDeleter": "Właściwość „{name}” nie ma zdefiniowanego elementu usuwającego", - "propertyMissingSetter": "Właściwość „{name}” nie ma zdefiniowanej metody ustawiającej", + "propertyMethodIncompatible": "Property method \"{name}\" is incompatible", + "propertyMethodMissing": "Property method \"{name}\" is missing in override", + "propertyMissingDeleter": "Property \"{name}\" has no defined deleter", + "propertyMissingSetter": "Property \"{name}\" has no defined setter", "protocolIncompatible": "Protokół „{sourceType}” jest niezgodny z protokołem „{destType}”", "protocolMemberMissing": "Brak nazwy „{name}”.", - "protocolRequiresRuntimeCheckable": "Klasa protokołu musi być @runtime_checkable, aby mogła być używana ze sprawdzaniem wystąpienia i klasy", + "protocolRequiresRuntimeCheckable": "Klasa Protocol musi być @runtime_checkable, aby mogła być używana z kontrolami wystąpień i klas", "protocolSourceIsNotConcrete": "„{sourceType}” nie jest typem specyficznej klasy i nie można go przypisać do typu „{destType}”", "protocolUnsafeOverlap": "Atrybuty „{name}” mają takie same nazwy jak protokół", - "pyrightCommentIgnoreTip": "Użyj polecenia „# pyright: ignore[], aby pominąć diagnostykę przez jeden wiersz", + "pyrightCommentIgnoreTip": "Użyj polecenia „# pyright: ignore[]”, aby wyłączyć diagnostykę dla pojedynczego wiersza", "readOnlyAttribute": "Atrybut „{name}” jest tylko do odczytu", "seeClassDeclaration": "Zobacz deklarację klasy", "seeDeclaration": "Zobacz deklarację", @@ -759,17 +761,17 @@ "seeParameterDeclaration": "Zobacz deklarację parametru", "seeTypeAliasDeclaration": "Zobacz deklarację aliasu typu", "seeVariableDeclaration": "Zobacz deklarację zmiennej", - "tupleAssignmentMismatch": "Typ „{type}” jest niezgodny z docelową krotką", - "tupleEntryTypeMismatch": "Wpis krotki {entry} jest nieprawidłowego typu", - "tupleSizeIndeterminateSrc": "Niezgodność rozmiaru krotki; oczekiwano {expected}, ale otrzymano nieokreślony", - "tupleSizeIndeterminateSrcDest": "Niezgodność rozmiaru krotki; oczekiwano {expected}, a otrzymano rozmiar nieokreślony", - "tupleSizeMismatch": "Niezgodność rozmiaru krotki; oczekiwano {expected}, ale otrzymano {received}", - "tupleSizeMismatchIndeterminateDest": "Niezgodność rozmiaru krotki; oczekiwano {expected}, a otrzymano {received}", + "tupleAssignmentMismatch": "Typ „{type}” jest niezgodny z docelową tuple", + "tupleEntryTypeMismatch": "Wpis tuple {entry} jest nieprawidłowego typu", + "tupleSizeIndeterminateSrc": "Niezgodność rozmiaru kolekcji tuple; oczekiwano {expected}, ale otrzymano rozmiar nieokreślony", + "tupleSizeIndeterminateSrcDest": "Niezgodność rozmiaru kolekcji tuple; oczekiwano {expected} lub więcej, a otrzymano rozmiar nieokreślony", + "tupleSizeMismatch": "Niezgodność rozmiaru tuple; oczekiwano {expected}, ale otrzymano {received}", + "tupleSizeMismatchIndeterminateDest": "Niezgodność rozmiaru kolekcji tuple; oczekiwano {expected} lub więcej, a otrzymano {received}", "typeAliasInstanceCheck": "Alias typu utworzony za pomocą instrukcji „{type}” nie może być użyty do sprawdzania wystąpień i klas", - "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}”", + "typeAssignmentMismatch": "Typu „{sourceType}” nie można przypisać do typu „{destType}”", + "typeBound": "Typu „{sourceType}” nie można przypisać do górnej granicy „{destType}” dla zmiennej typu „{name}”", + "typeConstrainedTypeVar": "Typu „{type}” nie można przypisać do zmiennej typu ograniczonego „{name}”", + "typeIncompatible": "Nie można przypisać typu „{sourceType}” do typu „{destType}”", "typeNotClass": "Typ „{type}” nie jest klasą", "typeNotStringLiteral": "„{type}” nie jest literałem ciągu", "typeOfSymbol": "Typ nazwy „{name}” jest to „{type}”", @@ -780,7 +782,7 @@ "typeVarIsCovariant": "Parametr typu „{name}” jest kowariantny, ale „{sourceType}” nie jest podtypem „{destType}”", "typeVarIsInvariant": "Parametr typu „{name}” jest niezmienny, ale „{sourceType}” nie jest taki sam jak „{destType}”", "typeVarNotAllowed": "Typ TypeVar nie jest dozwolony dla sprawdzania wystąpienia lub klasy", - "typeVarTupleRequiresKnownLength": "Nie można powiązać parametru TypeVarTuple z krotką o nieznanej długości", + "typeVarTupleRequiresKnownLength": "Nie można powiązać parametru TypeVarTuple ze tuple o nieznanej długości", "typeVarUnnecessarySuggestion": "Zamiast tego użyj elementu {type}", "typeVarUnsolvableRemedy": "Podaj przeciążenie, które określa zwracany typ, gdy nie podano argumentu", "typeVarsMissing": "Brak zmiennych typu: {names}", @@ -804,8 +806,8 @@ "uninitializedAbstractVariable": "zmienna wystąpienia „{name}” jest zdefiniowana w abstrakcyjnej klasie bazowej „{classType}” ale nie została zainicjowana", "unreachableExcept": "Typ „{exceptionType}” jest podklasą typu „{parentType}”", "useDictInstead": "Użyj funkcji Dict[T1, T2], aby wskazać typ słownika", - "useListInstead": "Użyj funkcji List[T], aby wskazać typ listy, lub Union[T1, T2], aby wskazać typ unii", - "useTupleInstead": "Użyj Tuple[T1, ..., Tn], aby wskazać typ krotki lub Union[T1, T2], aby wskazać typ unii", + "useListInstead": "Use List[T] to indicate a list type or Union[T1, T2] to indicate a union type", + "useTupleInstead": "Use tuple[T1, ..., Tn] to indicate a tuple type or Union[T1, T2] to indicate a union type", "useTypeInstead": "Zamiast tego użyj typu Type[T].", "varianceMismatchForClass": "Wariancja argumentu typu „{typeVarName}” jest niezgodna z klasą bazową „{className}”", "varianceMismatchForTypeAlias": "Wariancja argumentu typu „{typeVarName}” jest niezgodna z parametrem „{typeAliasParam}”" diff --git a/packages/pyright-internal/src/localization/package.nls.pt-br.json b/packages/pyright-internal/src/localization/package.nls.pt-br.json index aaf617bb2..adbbd9f88 100644 --- a/packages/pyright-internal/src/localization/package.nls.pt-br.json +++ b/packages/pyright-internal/src/localization/package.nls.pt-br.json @@ -1,7 +1,7 @@ { "CodeAction": { "createTypeStub": "Criar Stub de Tipo", - "createTypeStubFor": "Criar stub de tipo para \"{moduleName}\"", + "createTypeStubFor": "Criar Stub de tipo para \"{moduleName}\"", "executingCommand": "Executando comando", "filesToAnalyzeCount": "{count} arquivos a serem analisados", "filesToAnalyzeOne": "1 arquivo a ser analisado", @@ -18,12 +18,12 @@ "annotatedMetadataInconsistent": "O tipo de metadados anotados \"{metadataType}\" não é compatível com o tipo \"{type}\"", "annotatedParamCountMismatch": "Incompatibilidade de contagem de anotações de parâmetro: esperado {expected}, mas recebido {received}", "annotatedTypeArgMissing": "Esperava-se um argumento de tipo e uma ou mais anotações para \"Annotated\"", - "annotationBytesString": "Anotações de tipo não podem usar literais de cadeia de caracteres de bytes", - "annotationFormatString": "As anotações de tipo não podem usar literais de cadeia de caracteres de formato (cadeias de caracteres f)", + "annotationBytesString": "Expressões de tipo não podem usar literais de cadeia de caracteres de bytes", + "annotationFormatString": "As expressões de tipo não podem usar literais de cadeia de caracteres de formato (cadeias de caracteres f)", "annotationNotSupported": "Anotação de tipo sem suporte para esta instrução", - "annotationRawString": "As anotações de tipo não podem usar literais de cadeia de caracteres brutas", - "annotationSpansStrings": "Anotações de tipo não podem abranger vários literais de cadeia de caracteres", - "annotationStringEscape": "Anotações de tipo não podem conter caracteres de escape", + "annotationRawString": "Expressões de tipo não podem usar literais de cadeia de caracteres brutas", + "annotationSpansStrings": "Expressões de tipo não podem abranger vários literais de cadeia de caracteres", + "annotationStringEscape": "Expressões de tipo não podem conter caracteres de escape", "argAssignment": "O argumento do tipo \"{argType}\" não pode ser atribuído ao parâmetro do tipo \"{paramType}\"", "argAssignmentFunction": "O argumento do tipo \"{argType}\" não pode ser atribuído ao parâmetro do tipo \"{paramType}\" na função \"{functionName}\"", "argAssignmentParam": "O argumento do tipo \"{argType}\" não pode ser atribuído ao parâmetro \"{paramName}\" do tipo \"{paramType}\"", @@ -45,10 +45,10 @@ "assignmentExprInSubscript": "Expressões de atribuição em um subscrito são compatíveis apenas no Python 3.10 e mais recente", "assignmentInProtocol": "As variáveis de instância ou classe dentro de uma classe Protocol devem ser declaradas explicitamente dentro do corpo da classe", "assignmentTargetExpr": "A expressão não pode ser o destino de atribuição", - "asyncNotInAsyncFunction": "Uso de \"async\" não permitido fora da função assíncrona", + "asyncNotInAsyncFunction": "Uso de \"async\" não permitido fora da função async", "awaitIllegal": "O uso de \"await\" requer o Python 3.5 ou mais recente", - "awaitNotAllowed": "Anotações de tipo não podem usar \"await\"", - "awaitNotInAsync": "\"await\" permitido somente dentro da função assíncrona", + "awaitNotAllowed": "Expressões de tipo não podem usar \"await\"", + "awaitNotInAsync": "\"await\" permitido somente dentro da função async", "backticksIllegal": "Não há suporte para expressões delimitadas por backticks no Python 3.x. Use repr em vez disso", "baseClassCircular": "A classe não pode derivar de si mesma", "baseClassFinal": "A classe base \"{type}\" está marcada como final e não pode ser subclasse", @@ -57,7 +57,7 @@ "baseClassMethodTypeIncompatible": "Classes base para a classe \"{classType}\" definem o método \"{name}\" de maneira incompatível", "baseClassUnknown": "O tipo de classe base é desconhecido, ocultando o tipo de classe derivada", "baseClassVariableTypeIncompatible": "Classes base para a classe \"{classType}\" definem a variável \"{name}\" de maneira incompatível", - "binaryOperationNotAllowed": "Operador binário não permitido na anotação de tipo", + "binaryOperationNotAllowed": "Operador binário não permitido na expressão de tipo", "bindTypeMismatch": "Não foi possível associar o método \"{methodName}\" porque \"{type}\" não é atribuível ao parâmetro \"{paramName}\"", "breakOutsideLoop": "\"break\" só pode ser usado dentro de um loop", "callableExtraArgs": "Esperava-se apenas dois argumentos de tipo para \"Callable\"", @@ -70,7 +70,7 @@ "classDefinitionCycle": "A definição de classe para \"{name}\" depende de si mesma", "classGetItemClsParam": "A substituição__class_getitem__ deve usar um parâmetro \"cls\"", "classMethodClsParam": "Os métodos de classe devem usar um parâmetro \"cls\"", - "classNotRuntimeSubscriptable": "O subscrito para a classe \"{name}\" gerará uma exceção de runtime. Coloque a anotação de tipo entre aspas", + "classNotRuntimeSubscriptable": "O subscrito para a classe \"{name}\" gerará uma exceção de runtime. Coloque a expressão de tipo entre aspas", "classPatternBuiltInArgPositional": "O padrão de classe aceita apenas sub-padrão posicional", "classPatternPositionalArgCount": "Muitos padrões posicionais para a classe \"{type}\"; esperado {expected} mas recebido {received}", "classPatternTypeAlias": "\"{type}\" não pode ser usado em um padrão de classe porque é um alias de tipo especializado", @@ -87,7 +87,7 @@ "comparisonAlwaysFalse": "A condição sempre será avaliada como False, pois os tipos \"{leftType}\" e \"{rightType}\" não têm sobreposição", "comparisonAlwaysTrue": "A condição sempre será avaliada como True, pois os tipos \"{leftType}\" e \"{rightType}\" não têm sobreposição", "comprehensionInDict": "A compreensão não pode ser usada com outras entradas de dicionário", - "comprehensionInSet": "A compreensão não pode ser usada com outras entradas definidas", + "comprehensionInSet": "A compreensão não pode ser usada com outras entradas de set", "concatenateContext": "\"Concatenate\" não é permitido nesse contexto", "concatenateParamSpecMissing": "O último tipo de argumento para \"Concatenate\" deve ser um ParamSpec ou \"...\"", "concatenateTypeArgsMissing": "\"Concatenate\" requer pelo menos dois argumentos de tipo", @@ -111,7 +111,7 @@ "dataClassPostInitType": "Incompatibilidade de tipo de parâmetro de método de dataclasse __post_init__ para o campo \"{fieldName}\"", "dataClassSlotsOverwrite": "__slots__ já está definido na classe", "dataClassTransformExpectedBoolLiteral": "Expressão esperada que é avaliada estaticamente como True ou False", - "dataClassTransformFieldSpecifier": "Esperava-se tupla de classes ou funções, mas recebeu o tipo \"{type}\"", + "dataClassTransformFieldSpecifier": "Esperava-se tuple de classes ou funções, mas recebeu o tipo \"{type}\"", "dataClassTransformPositionalParam": "Todos os argumentos para \"dataclass_transform\" devem ser argumentos de palavra-chave", "dataClassTransformUnknownArgument": "O argumento \"{name}\" dataclass_transform não é compatível", "dataProtocolInSubclassCheck": "Protocolos de dados (que incluem atributos que não são de método) não são permitidos em chamadas issubclass", @@ -127,20 +127,20 @@ "deprecatedDescriptorSetter": "O método \"__set__\" para o descritor \"{name}\" está preterido", "deprecatedFunction": "A função \"{name}\" está obsoleta", "deprecatedMethod": "O método \"{name}\" na classe \"{className}\" está obsoleto", - "deprecatedPropertyDeleter": "O excluídor da propriedade \"{name}\" foi preterido", - "deprecatedPropertyGetter": "O getter da propriedade \"{name}\" foi preterido", - "deprecatedPropertySetter": "O setter da propriedade \"{name}\" está preterido", + "deprecatedPropertyDeleter": "O deleter da property \"{name}\" foi preterido", + "deprecatedPropertyGetter": "O getter da property \"{name}\" foi preterido", + "deprecatedPropertySetter": "O setter da property \"{name}\" está preterido", "deprecatedType": "Este tipo foi preterido no Python {version}. Use \"{replacement}\" em vez disso", "dictExpandIllegalInComprehension": "Expansão de dicionário não permitida na compreensão", - "dictInAnnotation": "Expressão de dicionário não permitida na anotação de tipo", + "dictInAnnotation": "Expressão de dicionário não permitida na expressão de tipo", "dictKeyValuePairs": "Entradas de dicionário devem conter pares chave/valor", "dictUnpackIsNotMapping": "Mapeamento esperado para o operador de desempacotamento de dicionário", "dunderAllSymbolNotPresent": "\"{name}\" está especificado no __all__ mas não está presente no módulo", "duplicateArgsParam": "Somente um parâmetro \"*\" permitido", "duplicateBaseClass": "Classe base duplicada não permitida", "duplicateCapturePatternTarget": "O destino de captura \"{name}\" não pode aparecer mais de uma vez dentro do mesmo padrão", - "duplicateCatchAll": "Somente uma cláusula de exceção catch-all é permitida", - "duplicateEnumMember": "O membro de enumeração \"{name}\" já está declarado", + "duplicateCatchAll": "Somente uma cláusula de except catch-all é permitida", + "duplicateEnumMember": "O membro de Enum \"{name}\" já está declarado", "duplicateGenericAndProtocolBase": "Somente uma classe base Generic[...] ou Protocol[...] é permitida", "duplicateImport": "\"{importName}\" foi importado mais de uma vez", "duplicateKeywordOnly": "Somente um separador \"*\" permitido", @@ -150,12 +150,12 @@ "duplicateStarPattern": "Somente um padrão \"*\" permitido em uma sequência de padrões", "duplicateStarStarPattern": "Somente uma entrada \"**\" é permitida", "duplicateUnpack": "Somente uma operação unpack é permitida na lista", - "ellipsisAfterUnpacked": "\"...\" não pode ser usado com um TypeVarTuple ou tupla descompactado", + "ellipsisAfterUnpacked": "\"...\" não pode ser usado com um TypeVarTuple ou tuple descompactado", "ellipsisContext": "\"...\" não é permitido neste contexto", "ellipsisSecondArg": "\"...\" é permitido apenas como o segundo de dois argumentos", "enumClassOverride": "A classe Enum \"{name}\" é final e não pode ser subclasse", - "enumMemberDelete": "O membro enumerado \"{name}\" não pode ser excluído", - "enumMemberSet": "O membro enumerado \"{name}\" não pode ser atribuído", + "enumMemberDelete": "O membro Enum \"{name}\" não pode ser excluído", + "enumMemberSet": "O membro Enum \"{name}\" não pode ser atribuído", "enumMemberTypeAnnotation": "Anotações de tipo não são permitidas para membros de enumeração", "exceptionGroupIncompatible": "A sintaxe do grupo de exceção (\"except*\") requer o Python 3.11 ou mais recente", "exceptionGroupTypeIncorrect": "O tipo de exceção em except* não pode derivar de BaseGroupException", @@ -184,12 +184,12 @@ "expectedExceptionClass": "Classe ou objeto de exceção inválido", "expectedExceptionObj": "Objeto de exceção esperado: classe de exceção ou None", "expectedExpr": "Expressão esperada", - "expectedFunctionAfterAsync": "Definição de função esperada após \"assíncrona\"", + "expectedFunctionAfterAsync": "Definição de função esperada após \"async\"", "expectedFunctionName": "Nome da função esperado após \"def\"", "expectedIdentifier": "Identificador esperado", "expectedImport": "\"importação\" esperada", "expectedImportAlias": "Símbolo esperado após \"as\"", - "expectedImportSymbols": "Esperado um ou mais nomes de símbolo após a importação", + "expectedImportSymbols": "Esperado um ou mais nomes de símbolos após “importar”", "expectedIn": "Esperava-se \"in\"", "expectedInExpr": "Expressão esperada após \"in\"", "expectedIndentedBlock": "Bloco recuado esperado", @@ -234,18 +234,18 @@ "functionInConditionalExpression": "Função de referências de expressão condicional que sempre é avaliada como True", "functionTypeParametersIllegal": "A sintaxe do parâmetro de tipo de função requer o Python 3.12 ou mais recente", "futureImportLocationNotAllowed": "As importações __future__ devem estar no início do arquivo", - "generatorAsyncReturnType": "O tipo de retorno da função geradora assíncrona deve ser compatível com \"AsyncGenerator[{yieldType}, Any]\"", + "generatorAsyncReturnType": "O tipo de retorno da função geradora async deve ser compatível com \"AsyncGenerator[{yieldType}, Any]\"", "generatorNotParenthesized": "As expressões de gerador devem estar entre parênteses se não forem argumentos exclusivos", "generatorSyncReturnType": "O tipo de retorno da função de gerador deve ser compatível com \"Generator[{yieldType}, Any, Any]\"", "genericBaseClassNotAllowed": "A classe base \"Generic\" não pode ser usada com sintaxe de parâmetro de tipo", "genericClassAssigned": "O tipo de classe genérica não pode ser atribuído", "genericClassDeleted": "O tipo de classe genérica não pode ser excluído", "genericInstanceVariableAccess": "O acesso à variável de instância genérica por meio da classe é ambíguo", - "genericNotAllowed": "__arglist não é válido neste contexto", + "genericNotAllowed": "\"Generic\" não é válido neste contexto", "genericTypeAliasBoundTypeVar": "O alias de tipo genérico dentro da classe não pode usar variáveis de tipo associado {names}", "genericTypeArgMissing": "\"Generic\" requer pelo menos um argumento de tipo", "genericTypeArgTypeVar": "O argumento de tipo para \"Generic\" deve ser uma variável de tipo", - "genericTypeArgUnique": "Os argumentos de tipo para \"Genérico\" devem ser exclusivos", + "genericTypeArgUnique": "Os argumentos de tipo para \"Generic\" devem ser exclusivos", "globalReassignment": "\"{name}\" é atribuído antes da declaração global", "globalRedefinition": "\"{name}\" já foi declarado global", "implicitStringConcat": "Concatenação de cadeia de caracteres implícita não permitida", @@ -265,16 +265,16 @@ "instanceMethodSelfParam": "Os métodos de instância devem usar um parâmetro \"self\"", "instanceVarOverridesClassVar": "A variável de instância \"{name}\" substitui a variável de classe de mesmo nome na classe \"{className}\"", "instantiateAbstract": "Não é possível instanciar a classe abstrata \"{type}\"", - "instantiateProtocol": "Não é possível instanciar a classe de protocolo \"{type}\"", + "instantiateProtocol": "Não é possível instanciar a classe Protocol \"{type}\"", "internalBindError": "Erro interno ao associar o arquivo de associação \"{file}\": {message}", "internalParseError": "Ocorreu um erro interno ao analisar o arquivo \"{file}\": {message}", "internalTypeCheckingError": "Erro interno ao digitar o arquivo de verificação \"{file}\": {message}", "invalidIdentifierChar": "Caractere inválido no identificador", "invalidStubStatement": "A instrução não faz sentido dentro de um arquivo stub de tipo", "invalidTokenChars": "Caractere inválido \"{text}\" no token", - "isInstanceInvalidType": "O segundo argumento para \"instance\" deve ser uma classe ou tupla de classes", - "isSubclassInvalidType": "O segundo argumento para \"issubclass\" deve ser uma classe ou tupla de classes", - "keyValueInSet": "Pares chave/valor não são permitidos em um conjunto", + "isInstanceInvalidType": "O segundo argumento para \"isinstance\" deve ser uma classe ou tuple de classes", + "isSubclassInvalidType": "O segundo argumento para \"issubclass\" deve ser uma classe ou tuple de classes", + "keyValueInSet": "Pares chave/valor não são permitidos em um set", "keywordArgInTypeArgument": "Argumentos de palavra-chave não podem ser usados em listas de argumentos de tipo", "keywordArgShortcutIllegal": "O atalho do argumento de palavra-chave requer Python 3.14 ou mais recente", "keywordOnlyAfterArgs": "Separador de argumento somente palavra-chave não permitido após o parâmetro \"*\"", @@ -283,13 +283,13 @@ "lambdaReturnTypePartiallyUnknown": "O tipo de retorno de lambda, \"{returnType}\", é parcialmente desconhecido", "lambdaReturnTypeUnknown": "O tipo de retorno de lambda é desconhecido", "listAssignmentMismatch": "A expressão com o tipo \"{type}\" não pode ser atribuída à lista de destino", - "listInAnnotation": "Expressão de lista não permitida na anotação de tipo", + "listInAnnotation": "Expressão de List não permitida na expressão de tipo", "literalEmptyArgs": "Um ou mais argumentos de tipo esperados após \"Literal\"", - "literalNamedUnicodeEscape": "Não há suporte para sequências de escape unicode nomeadas em anotações de cadeia de caracteres \"Literais\"", + "literalNamedUnicodeEscape": "Não há suporte para sequências de escape unicode nomeadas em anotações de cadeia de caracteres \"Literal\"", "literalNotAllowed": "\"Literal\" não pode ser usado nesse contexto sem um argumento de tipo", - "literalNotCallable": "O tipo literal não pode ser instanciado", + "literalNotCallable": "O tipo Literal não pode ser instanciado", "literalUnsupportedType": "Os argumentos de tipo para \"Literal\" devem ser None, um valor literal (int, bool, str ou bytes) ou um valor de enumeração", - "matchIncompatible": "As instruções de correspondência exigem Python 3.10 ou mais recente", + "matchIncompatible": "As match de correspondência exigem Python 3.10 ou mais recente", "matchIsNotExhaustive": "Os casos dentro da instrução match não lidam exaustivamente com todos os valores", "maxParseDepthExceeded": "Profundidade máxima de análise excedida. Divida a expressão em subexpressões menores", "memberAccess": "Não é possível acessar o atributo \"{name}\" para a classe \"{type}\"", @@ -304,41 +304,42 @@ "methodOverridden": "\"{name}\" substitui o método de mesmo nome na classe \"{className}\" pelo tipo incompatível \"{type}\"", "methodReturnsNonObject": "O método \"{name}\" não retorna um objeto", "missingSuperCall": "O método \"{methodName}\" não chama o método do mesmo nome na classe pai", + "mixingBytesAndStr": "Valores de bytes e str não podem ser concatenados", "moduleAsType": "O módulo não pode ser usado como um tipo.", "moduleNotCallable": "O módulo não pode ser chamado", "moduleUnknownMember": "\"{memberName}\" não é um atributo conhecido do módulo \"{moduleName}\"", "namedExceptAfterCatchAll": "Uma cláusula except nomeada não pode aparecer após a cláusula catch-all except", "namedParamAfterParamSpecArgs": "O parâmetro de palavra-chave \"{name}\" não pode aparecer na assinatura após o parâmetro args ParamSpec", - "namedTupleEmptyName": "Nomes dentro de uma tupla nomeada não podem ficar vazios", - "namedTupleEntryRedeclared": "Não é possível substituir \"{name}\" porque a classe pai \"{className}\" é uma tupla nomeada", - "namedTupleFirstArg": "Nome de classe de tupla nomeado esperado como primeiro argumento", + "namedTupleEmptyName": "Nomes dentro de uma tuple nomeada não podem ficar vazios", + "namedTupleEntryRedeclared": "Não é possível substituir \"{name}\" porque a classe pai \"{className}\" é uma tuple nomeada", + "namedTupleFirstArg": "Nome de classe de tuple nomeado esperado como primeiro argumento", "namedTupleMultipleInheritance": "Não há suporte para herança múltipla com NamedTuple", "namedTupleNameKeyword": "Os nomes dos campos não podem ser uma palavra-chave", - "namedTupleNameType": "Tupla de duas entradas esperada especificando o nome e o tipo de entrada", - "namedTupleNameUnique": "Os nomes dentro de uma tupla nomeada devem ser exclusivos", + "namedTupleNameType": "Expected two-entry tuple specifying entry name and type", + "namedTupleNameUnique": "Os nomes dentro de uma tuple nomeada devem ser exclusivos", "namedTupleNoTypes": "\"namedtuple\" não fornece tipos para entradas de tupla. Em vez disso, use \"NamedTuple\"", - "namedTupleSecondArg": "Lista de entrada de tupla nomeada esperada como segundo argumento", + "namedTupleSecondArg": "Expected named tuple entry list as second argument", "newClsParam": "A substituição __new__ deve usar um parâmetro \"cls\"", - "newTypeAnyOrUnknown": "O segundo argumento para NewType deve ser uma classe conhecida, não Qualquer ou Desconhecido", + "newTypeAnyOrUnknown": "O segundo argumento para NewType deve ser uma classe conhecida, não Any ou Unknown", "newTypeBadName": "O primeiro argumento para NewType deve ser um literal de cadeia de caracteres", "newTypeLiteral": "NewType não pode ser usado com o tipo Literal", "newTypeNameMismatch": "NewType deve ser atribuído a uma variável com o mesmo nome", "newTypeNotAClass": "Classe esperada como segundo argumento para NewType", "newTypeParamCount": "NewType requer dois argumentos posicionais", - "newTypeProtocolClass": "NewType não pode ser usado com tipo estrutural (um protocolo ou classe TypedDict)", + "newTypeProtocolClass": "NewType não pode ser usado com um tipo estrutural (uma classe Protocol ou TypedDict)", "noOverload": "Nenhuma sobrecarga para \"{name}\" corresponde aos argumentos fornecidos", - "noReturnContainsReturn": "A função com o tipo de retorno declarado \"NoReturn\" não pode incluir uma instrução return", + "noReturnContainsReturn": "A função com o tipo de return declarado \"NoReturn\" não pode incluir uma instrução return", "noReturnContainsYield": "A função com o tipo de retorno declarado \"NoReturn\" não pode incluir uma instrução yield", "noReturnReturnsNone": "Função com tipo de retorno declarado \"NoReturn\" não pode retornar \"None\"", "nonDefaultAfterDefault": "O argumento não padrão segue o argumento padrão", - "nonLocalInModule": "Declaração não local não permitida no nível do módulo", - "nonLocalNoBinding": "Nenhuma associação para \"{name}\" não local encontrada", - "nonLocalReassignment": "\"{name}\" é atribuído antes da declaração não local", - "nonLocalRedefinition": "\"{name}\" já foi declarado não local", + "nonLocalInModule": "Declaração nonlocal não permitida no nível do módulo", + "nonLocalNoBinding": "Nenhuma associação para \"{name}\" nonlocal encontrada", + "nonLocalReassignment": "\"{name}\" é atribuído antes da declaração nonlocal", + "nonLocalRedefinition": "\"{name}\" já foi declarado nonlocal", "noneNotCallable": "O objeto do tipo \"None\" não pode ser chamado", "noneNotIterable": "O objeto do tipo \"None\" não pode ser usado como valor iterável", "noneNotSubscriptable": "O objeto do tipo \"None\" não é subscrito", - "noneNotUsableWith": "O objeto do tipo \"None\" não pode ser usado com \"with\"", + "noneNotUsableWith": "Object of type \"None\" cannot be used with \"with\"", "noneOperator": "Operador \"{operator}\" incompatível com \"None\"", "noneUnknownMember": "\"{name}\" não é um atributo conhecido de \"None\"", "notRequiredArgCount": "Argumento de tipo único esperado após \"NotRequired\"", @@ -351,9 +352,9 @@ "obscuredTypeAliasDeclaration": "A declaração de alias de tipo \"{name}\" é obscurecida por uma declaração de mesmo nome", "obscuredVariableDeclaration": "A declaração \"{name}\" é obscurecida por uma declaração de mesmo nome", "operatorLessOrGreaterDeprecated": "O operador \"<>\" não é compatível no Python 3. Use \"!=\" em vez disso", - "optionalExtraArgs": "Espera-se um argumento de tipo após \"Opcional\"", + "optionalExtraArgs": "Espera-se um argumento de tipo após \"Optional\"", "orPatternIrrefutable": "Padrão irrefutável permitido somente como o último subpadrão em um padrão \"or\"", - "orPatternMissingName": "Todos os subpadrões dentro de um padrão \"ou\" devem ter como destino os mesmos nomes", + "orPatternMissingName": "Todos os subpadrões dentro de um padrão \"or\" devem ter como destino os mesmos nomes", "overlappingKeywordArgs": "O dicionário digitado se sobrepõe ao parâmetro de palavra-chave: {names}", "overlappingOverload": "A sobrecarga {obscured} para \"{name}\" nunca será usada porque seus parâmetros se sobrepõem à sobrecarga {obscuredBy}", "overloadAbstractImplMismatch": "As sobrecargas devem corresponder ao status abstrato da implementação", @@ -364,9 +365,9 @@ "overloadImplementationMismatch": "A implementação sobrecarregada não é consistente com a assinatura da sobrecarga {index}", "overloadReturnTypeMismatch": "A sobrecarga {prevIndex} para \"{name}\" sobrepõe a sobrecarga {newIndex} e retorna um tipo incompatível", "overloadStaticMethodInconsistent": "Sobrecargas para \"{name}\" usam @staticmethod inconsistentemente", - "overloadWithoutImplementation": "\"{name}\" está marcado como sobrecarga, mas nenhuma implementação foi fornecida", - "overriddenMethodNotFound": "O método \"{name}\" está marcado como substituição, mas nenhum método base de mesmo nome está presente", - "overrideDecoratorMissing": "O método \"{name}\" não está marcado como substituição, mas está substituindo um método na classe \"{className}\"", + "overloadWithoutImplementation": "\"{name}\" está marcado como overload, mas nenhuma implementação foi fornecida", + "overriddenMethodNotFound": "O método \"{name}\" está marcado como override, mas nenhum método base de mesmo nome está presente", + "overrideDecoratorMissing": "O método \"{name}\" não está marcado como override, mas está substituindo um método na classe \"{className}\"", "paramAfterKwargsParam": "O parâmetro não pode seguir o parâmetro \"**\"", "paramAlreadyAssigned": "O parâmetro \"{name}\" já está atribuído", "paramAnnotationMissing": "A anotação de tipo está ausente para o parâmetro \"{name}\"", @@ -377,7 +378,7 @@ "paramSpecArgsUsage": "O atributo \"args\" de ParamSpec é válido somente quando usado com o parâmetro *args", "paramSpecAssignedName": "ParamSpec deve ser atribuído a uma variável chamada \"{name}\"", "paramSpecContext": "ParamSpec não é permitido neste contexto", - "paramSpecDefaultNotTuple": "Reticências esperadas, uma expressão de tupla ou ParamSpec para o valor padrão de ParamSpec", + "paramSpecDefaultNotTuple": "Reticências esperadas, uma expressão de tuple ou ParamSpec para o valor padrão de ParamSpec", "paramSpecFirstArg": "Nome esperado de ParamSpec como primeiro argumento", "paramSpecKwargsUsage": "O atributo \"kwargs\" de ParamSpec é válido somente quando usado com o parâmetro **kwargs", "paramSpecNotUsedByOuterScope": "O ParamSpec \"{name}\" não tem significado neste contexto", @@ -387,7 +388,7 @@ "paramTypeCovariant": "Variável de tipo covariante não pode ser usada no tipo de parâmetro", "paramTypePartiallyUnknown": "O tipo de parâmetro \"{paramName}\" é parcialmente desconhecido", "paramTypeUnknown": "O tipo de parâmetro \"{paramName}\" é desconhecido", - "parenthesizedContextManagerIllegal": "Parênteses dentro da instrução \"with\" exigem Python 3.9 ou mais recente", + "parenthesizedContextManagerIllegal": "Parentheses within \"with\" statement requires Python 3.9 or newer", "patternNeverMatches": "O padrão nunca será correspondido para o tipo de assunto \"{type}\"", "positionArgAfterNamedArg": "O argumento posicional não pode aparecer após argumentos de palavra-chave", "positionOnlyAfterArgs": "Separador de parâmetro somente de posição não permitido após o parâmetro \"*\"", @@ -398,40 +399,40 @@ "privateImportFromPyTypedModule": "\"{name}\" não é exportado do módulo \"{module}\"", "privateUsedOutsideOfClass": "\"{name}\" é privado e usado fora da classe na qual é declarado", "privateUsedOutsideOfModule": "\"{name}\" é privado e usado fora do módulo no qual ele é declarado", - "propertyOverridden": "\"{name}\" substitui incorretamente a propriedade de mesmo nome na classe \"{className}\"", - "propertyStaticMethod": "Métodos estáticos não permitidos para as propriedades getter, setter ou deleter", + "propertyOverridden": "\"{name}\" override incorretamente a property de mesmo nome na classe \"{className}\"", + "propertyStaticMethod": "Métodos estáticos não permitidos para as property getter, setter ou deleter", "protectedUsedOutsideOfClass": "\"{name}\" está protegido e usado fora da classe na qual está declarado", - "protocolBaseClass": "A classe de protocolo \"{classType}\" não pode derivar da classe \"{baseType}\" que não é de protocolo", + "protocolBaseClass": "A classe \"{classType}\" Protocol não pode derivar da classe não Protocol \"{baseType}\"", "protocolBaseClassWithTypeArgs": "Argumentos de tipo não são permitidos com a classe Protocol ao usar a sintaxe de parâmetro de tipo", "protocolIllegal": "O uso de \"Protocol\" requer o Python 3.7 ou mais recente", "protocolNotAllowed": "\"Protocol\" não pode ser usado nesse contexto", "protocolTypeArgMustBeTypeParam": "O argumento de tipo para o \"Protocolo\" deve ser um parâmetro de tipo", "protocolUnsafeOverlap": "A classe se sobrepõe a \"{name}\" de forma não segura e pode produzir uma correspondência em runtime", - "protocolVarianceContravariant": "A variável de tipo \"{variable}\" usada no protocolo genérico \"{class}\" deve ser contravariante", - "protocolVarianceCovariant": "A variável de tipo \"{variable}\" usada no protocolo genérico \"{class}\" deve ser covariante", - "protocolVarianceInvariant": "A variável de tipo \"{variable}\" usada no protocolo genérico \"{class}\" deve ser invariável", + "protocolVarianceContravariant": "A variável de tipo \"{variable}\" usada na \"{class}\" Protocol genérica deve ser contravariante", + "protocolVarianceCovariant": "A variável de tipo \"{variable}\" usada na \"{class}\" Protocol genérica deve ser covariante", + "protocolVarianceInvariant": "A variável de tipo \"{variable}\" usada na \"{class}\" Protocol genérica deve ser invariável", "pyrightCommentInvalidDiagnosticBoolValue": "A diretiva de comentário Pyright deve ser seguida por \"=\" e um valor true ou false", "pyrightCommentInvalidDiagnosticSeverityValue": "A diretiva de comentário Pyright deve ser seguida por \"=\" e um valor de true, false, error, warning, information ou none", - "pyrightCommentMissingDirective": "O comentário pyright deve ser seguido por uma diretiva (básica ou estrita) ou uma regra de diagnóstico", - "pyrightCommentNotOnOwnLine": "Comentários pyright usados para controlar as configurações de nível de arquivo devem aparecer em sua própria linha", + "pyrightCommentMissingDirective": "O comentário Pyright deve ser seguido por uma diretiva (basic ou strict) ou uma regra de diagnóstico", + "pyrightCommentNotOnOwnLine": "Comentários Pyright usados para controlar as configurações de nível de arquivo devem aparecer em sua própria linha", "pyrightCommentUnknownDiagnosticRule": "\"{rule}\" é uma regra de diagnóstico desconhecida para o comentário pyright", - "pyrightCommentUnknownDiagnosticSeverityValue": "\"{value}\" é um valor inválido para o comentário pyright. True, false, error, warning, information ou none esperados.", - "pyrightCommentUnknownDirective": "\"{directive}\" é uma diretiva desconhecida para o comentário pyright. Esperava-se \"estrito\" ou \"básico\"", + "pyrightCommentUnknownDiagnosticSeverityValue": "\"{value}\" é um valor inválido para o comentário pyright. true, false, error, warning, information ou none esperados.", + "pyrightCommentUnknownDirective": "\"{directive}\" é uma diretiva desconhecida para o comentário pyright. Esperava-se \"strict\" ou \"basic\"", "readOnlyArgCount": "Argumento de tipo único esperado após \"ReadOnly\"", "readOnlyNotInTypedDict": "\"ReadOnly\" não é permitido neste contexto", "recursiveDefinition": "Não foi possível determinar o tipo de \"{name}\" porque ele refere-se a si mesmo", - "relativeImportNotAllowed": "Importações relativas não podem ser usadas com o formulário \"import. a\". Use \"from . import a\" em vez disso", - "requiredArgCount": "Argumento de tipo único esperado após \"Obrigatório\"", - "requiredNotInTypedDict": "\"Obrigatório\" não é permitido neste contexto", - "returnInAsyncGenerator": "A instrução return com valor não é permitida no gerador assíncrono", + "relativeImportNotAllowed": "Importações relativas não podem ser usadas com o formulário \"import .a\". Use \"from . import a\" em vez disso", + "requiredArgCount": "Argumento de tipo único esperado após \"Required\"", + "requiredNotInTypedDict": "\"Required\" não é permitido neste contexto", + "returnInAsyncGenerator": "A instrução return com valor não é permitida no gerador async", "returnMissing": "Função com tipo de retorno declarado \"{returnType}\" deve retornar valor em todos os caminhos de código", "returnOutsideFunction": "\"return\" só pode ser usado dentro de uma função", "returnTypeContravariant": "A variável de tipo contravariante não pode ser usada no tipo de retorno", - "returnTypeMismatch": "A expressão do tipo \"{exprType}\" é incompatível com o tipo de retorno \"{returnType}\"", + "returnTypeMismatch": "O tipo \"{exprType}\" não pode ser atribuído ao tipo \"{returnType}\"", "returnTypePartiallyUnknown": "O tipo de retorno, \"{returnType}\", é parcialmente desconhecido", "returnTypeUnknown": "O tipo de retorno é desconhecido", "revealLocalsArgs": "Nenhum argumento esperado para a chamada \"reveal_locals\"", - "revealLocalsNone": "Nenhum local neste escopo", + "revealLocalsNone": "Nenhum locals neste escopo", "revealTypeArgs": "Esperava-se um único argumento posicional para a chamada \"reveal_type\"", "revealTypeExpectedTextArg": "O argumento \"expected_text\" para a função \"reveal_type\" deve ser um valor literal str", "revealTypeExpectedTextMismatch": "Tipo de incompatibilidade de texto. O esperado era \"{expected}\", mas recebeu \"{received}\"", @@ -439,7 +440,7 @@ "selfTypeContext": "\"Self\" não é válido neste contexto.", "selfTypeMetaclass": "\"Self\" não pode ser usado em uma metaclasse (uma subclasse de \"type\")", "selfTypeWithTypedSelfOrCls": "\"Self\" não pode ser usado em uma função com um parâmetro `self` ou `cls que tenha uma anotação de tipo diferente de \"Self\"", - "setterGetterTypeMismatch": "O tipo de valor do setter da propriedade não é atribuível ao tipo de retorno getter", + "setterGetterTypeMismatch": "O tipo de valor do setter da property não é atribuível ao tipo de retorno getter", "singleOverload": "\"{name}\" está marcado como sobrecarga, mas sobrecargas adicionais estão ausentes", "slotsAttributeError": "\"{name}\" não está especificado em __slots__", "slotsClassVarConflict": "\"{name}\" está em conflito com a variável de instância declarada __slots__", @@ -449,7 +450,7 @@ "staticClsSelfParam": "Os métodos estáticos não devem usar um parâmetro \"self\" ou \"cls\"", "stdlibModuleOverridden": "\"{path}\" está substituindo o módulo stdlib \"{name}\"", "stringNonAsciiBytes": "Caractere não ASCII não permitido em literal de cadeia de caracteres de bytes", - "stringNotSubscriptable": "A expressão de cadeia de caracteres não pode ser subscrito na anotação de tipo. Coloque a anotação inteira entre aspas", + "stringNotSubscriptable": "A expressão de cadeia de caracteres não pode ser subscrita na expressão de tipo. Coloque toda a expressão entre aspas", "stringUnsupportedEscape": "Sequência de escape sem suporte no literal de cadeia de caracteres", "stringUnterminated": "Literal de cadeia de caracteres não finalizado", "stubFileMissing": "Arquivo stub não encontrado para \"{importName}\"", @@ -464,12 +465,12 @@ "symbolIsUnbound": "\"{name}\" não está associado", "symbolIsUndefined": "\"{name}\" não está definido", "symbolOverridden": "\"{name}\" substitui o símbolo de mesmo nome na classe \"{className}\"", - "ternaryNotAllowed": "Expressão de ternário não permitida na anotação de tipo", + "ternaryNotAllowed": "Expressão de ternário não permitida na expressão de tipo", "totalOrderingMissingMethod": "A classe deve definir um dos \"__lt__\", \"__le__\", \"__gt__\" ou \"__ge__\" para usar total_ordering", "trailingCommaInFromImport": "A vírgula à direita não é permitida sem parênteses ao redor", "tryWithoutExcept": "A instrução Try deve ter pelo menos uma cláusula except ou finally", - "tupleAssignmentMismatch": "A expressão com o tipo \"{type}\" não pode ser atribuída à tupla de destino", - "tupleInAnnotation": "Expressão de tupla não permitida na anotação de tipo", + "tupleAssignmentMismatch": "A expressão com o tipo \"{type}\" não pode ser atribuída à tuple de destino", + "tupleInAnnotation": "Expressão de tuple não permitida na expressão de tipo", "tupleIndexOutOfRange": "O índice {index} está fora do intervalo para o tipo {type}", "typeAliasIllegalExpressionForm": "Formulário de expressão inválido para definição de alias de tipo", "typeAliasIsRecursiveDirect": "O alias de tipo \"{name}\" não pode usar a si mesmo em sua definição", @@ -481,7 +482,7 @@ "typeAliasTypeMustBeAssigned": "TypeAliasType deve ser atribuído a uma variável com o mesmo nome que o alias de tipo", "typeAliasTypeNameArg": "O primeiro argumento para TypeAliasType deve ser um literal de cadeia de caracteres que representa o nome do alias de tipo", "typeAliasTypeNameMismatch": "O nome do alias de tipo deve corresponder ao nome da variável à qual ela está atribuída", - "typeAliasTypeParamInvalid": "A lista de parâmetros de tipo deve ser uma tupla contendo apenas TypeVar, TypeVarTuple ou ParamSpec", + "typeAliasTypeParamInvalid": "A lista de parâmetros de tipo deve ser uma tuple contendo apenas TypeVar, TypeVarTuple ou ParamSpec", "typeAnnotationCall": "Expressão de chamada não permitida na expressão de tipo", "typeAnnotationVariable": "Variável não permitida na expressão de tipo", "typeAnnotationWithCallable": "O argumento de tipo para \"type\" deve ser uma classe; não há suporte para callables", @@ -493,16 +494,17 @@ "typeArgsMissingForClass": "Argumentos de tipo esperados para a classe genérica \"{name}\"", "typeArgsTooFew": "Poucos argumentos de tipo fornecidos para \"{name}\". Esperava-se {expected}, mas recebeu {received}", "typeArgsTooMany": "Muitos argumentos de tipo fornecidos para \"{name}\". Esperava-se {expected}, mas recebeu {received}", - "typeAssignmentMismatch": "A expressão do tipo \"{sourceType}\" é incompatível com o tipo declarado \"{destType}\"", - "typeAssignmentMismatchWildcard": "O símbolo de importação \"{name}\" tem o tipo \"{sourceType}\", que é incompatível com o tipo declarado \"{destType}\"", - "typeCallNotAllowed": "A chamada type() não deve ser usada na anotação de tipo", + "typeAssignmentMismatch": "O tipo \"{sourceType}\" não pode ser atribuído ao tipo declarado \"{destType}\"", + "typeAssignmentMismatchWildcard": "O símbolo de importação \"{name}\" tem o tipo \"{sourceType}\", que não pode ser atribuído ao tipo declarado \"{destType}\"", + "typeCallNotAllowed": "A chamada type() não deve ser usada na expressão de tipo", "typeCheckOnly": "\"{name}\" está marcado como @type_check_only e pode ser usado apenas em anotações de tipo", - "typeCommentDeprecated": "O uso de comentários de tipo foi preterido. Use anotação de tipo em vez disso", + "typeCommentDeprecated": "O uso de comentários de type foi preterido. Use anotação de type em vez disso", "typeExpectedClass": "Classe esperada, mas a recebida foi \"{type}\"", + "typeFormArgs": "\"TypeForm\" aceita um único argumento posicional", "typeGuardArgCount": "Argumento de tipo único esperado após \"TypeGuard\" ou \"TypeIs\"", "typeGuardParamCount": "Funções e métodos de proteção de tipo definidos pelo usuário devem ter pelo menos um parâmetro de entrada", "typeIsReturnType": "O tipo de retorno de TypeIs (\"{returnType}\") não é consistente com o tipo de parâmetro de valor (\"{type}\")", - "typeNotAwaitable": "\"{type}\" não é previsível", + "typeNotAwaitable": "\"{type}\" não é awaitable", "typeNotIntantiable": "\"{type}\" não pode ser instanciado", "typeNotIterable": "\"{type}\" não é iterável", "typeNotSpecializable": "Não foi possível especializar o tipo \"{type}\"", @@ -537,7 +539,7 @@ "typeVarSingleConstraint": "TypeVar deve ter pelo menos dois tipos restritos", "typeVarTupleConstraints": "TypeVarTuple não pode ter restrições de valor", "typeVarTupleContext": "TypeVarTuple não é permitido neste contexto", - "typeVarTupleDefaultNotUnpacked": "O tipo padrão TypeVarTuple deve ser uma tupla desempacotamento ou TypeVarTuple", + "typeVarTupleDefaultNotUnpacked": "O tipo padrão TypeVarTuple deve ser uma tuple desempacotamento ou TypeVarTuple", "typeVarTupleMustBeUnpacked": "O operador Unpack é necessário para o valor TypeVarTuple", "typeVarTupleUnknownParam": "\"{name}\" é um parâmetro desconhecido para TypeVarTuple", "typeVarUnknownParam": "\"{name}\" é um parâmetro desconhecido para TypeVar", @@ -552,8 +554,8 @@ "typedDictBadVar": "As classes TypedDict podem conter apenas anotações de tipo", "typedDictBaseClass": "Todas as classes base para classes TypedDict também devem ser classes TypedDict", "typedDictBoolParam": "Esperava-se que o parâmetro \"{name}\" tivesse um valor True ou False", - "typedDictClosedExtras": "A classe base \"{name}\" é um TypedDict fechado; itens extras devem ser do tipo \"{type}\"", - "typedDictClosedNoExtras": "A classe base \"{name}\" é um TypedDict fechado; itens extras não são permitidos", + "typedDictClosedExtras": "A classe base \"{name}\" é um TypedDict closed; itens extras devem ser do tipo \"{type}\"", + "typedDictClosedNoExtras": "A classe base \"{name}\" é um TypedDict closed; itens extras não são permitidos", "typedDictDelete": "Não foi possível excluir o item em TypedDict", "typedDictEmptyName": "Os nomes dentro de um TypedDict não podem estar vazios", "typedDictEntryName": "Literal de cadeia de caracteres esperado para o nome da entrada do dicionário", @@ -561,7 +563,7 @@ "typedDictExtraArgs": "Argumentos TypedDict extras são incompatíveis", "typedDictFieldNotRequiredRedefinition": "O item TypedDict \"{name}\" não pode ser redefinido como NotRequired", "typedDictFieldReadOnlyRedefinition": "O item TypedDict \"{name}\" não pode ser redefinido como ReadOnly", - "typedDictFieldRequiredRedefinition": "O item TypedDict \"{name}\" não pode ser redefinido como Obrigatório", + "typedDictFieldRequiredRedefinition": "O item TypedDict \"{name}\" não pode ser redefinido como Required", "typedDictFirstArg": "Nome da classe TypedDict esperado como primeiro argumento", "typedDictInitsubclassParameter": "TypedDict não dá suporte ao parâmetro __init_subclass__ \"{name}\"", "typedDictNotAllowed": "\"TypedDict\" não pode ser usado neste contexto", @@ -574,7 +576,7 @@ "unaccessedSymbol": "\"{name}\" não foi acessado", "unaccessedVariable": "A variável \"{name}\" não foi acessada", "unannotatedFunctionSkipped": "A análise da função \"{name}\" foi ignorada porque não foi anotada", - "unaryOperationNotAllowed": "Operador unário não permitido na anotação de tipo", + "unaryOperationNotAllowed": "Operador unário não permitido na expressão de tipo", "unexpectedAsyncToken": "Esperado \"def\", \"with\" ou \"for\" para acompanhar \"async\"", "unexpectedExprToken": "Token inesperado no final da expressão", "unexpectedIndent": "Recuo inesperado", @@ -583,25 +585,25 @@ "unhashableSetEntry": "A entrada set deve ser permitir hash", "uninitializedAbstractVariables": "As variáveis definidas na classe base abstrata não são inicializadas na classe final \"{classType}\"", "uninitializedInstanceVariable": "A variável de instância \"{name}\" não foi inicializada no corpo da classe ou no método __init__", - "unionForwardReferenceNotAllowed": "A sintaxe de união não pode ser usada com operando de cadeia de caracteres. Use aspas em toda a expressão", + "unionForwardReferenceNotAllowed": "A sintaxe de Union não pode ser usada com operando de cadeia de caracteres. Use aspas em toda a expressão", "unionSyntaxIllegal": "A sintaxe alternativa para uniões requer o Python 3.10 ou mais recente", - "unionTypeArgCount": "A união requer dois ou mais argumentos de tipo", - "unionUnpackedTuple": "A união não pode incluir uma tupla desempacotada", - "unionUnpackedTypeVarTuple": "A união não pode incluir um TypeVarTuple desempacotado", + "unionTypeArgCount": "A Union requer dois ou mais argumentos de tipo", + "unionUnpackedTuple": "A Union não pode incluir uma tuple desempacotada", + "unionUnpackedTypeVarTuple": "A Union não pode incluir um TypeVarTuple desempacotado", "unnecessaryCast": "Chamada \"cast\" desnecessária. O tipo já é \"{type}\"", - "unnecessaryIsInstanceAlways": "Chamada de iinstância desnecessária. \"{testType}\" é sempre uma instância de \"{classType}\"", + "unnecessaryIsInstanceAlways": "Chamada de isinstance desnecessária. \"{testType}\" é sempre uma instância de \"{classType}\"", "unnecessaryIsSubclassAlways": "Chamada issubclass desnecessária. \"{testType}\" é sempre uma subclasse de \"{classType}\"", "unnecessaryPyrightIgnore": "Comentário desnecessário \"# pyright: ignore\"", "unnecessaryPyrightIgnoreRule": "Regra desnecessária \"# pyright: ignore\": \"{name}\"", "unnecessaryTypeIgnore": "Comentário \"# type: ignore\" desnecessário", "unpackArgCount": "Argumento de tipo único esperado após \"Unpack\"", - "unpackExpectedTypeVarTuple": "TypeVarTuple ou tupla esperado como argumento de tipo para Unpack", - "unpackExpectedTypedDict": "Argumento de tipo TypedDict esperado para Desempacotar", + "unpackExpectedTypeVarTuple": "TypeVarTuple ou tuple esperado como argumento de tipo para Unpack", + "unpackExpectedTypedDict": "Argumento de tipo TypedDict esperado para Unpack", "unpackIllegalInComprehension": "Operação de desempacotamento não permitida na compreensão", - "unpackInAnnotation": "Operador Desempacotar não permitido na anotação de tipo", + "unpackInAnnotation": "Operador de desempacotamento não permitido na expressão de tipo", "unpackInDict": "Operação de desempacotamento não permitida em dicionários", - "unpackInSet": "Operador unpack não permitido em um conjunto", - "unpackNotAllowed": "Descompactar não é permitido neste contexto", + "unpackInSet": "Operador unpack não permitido em um set", + "unpackNotAllowed": "Unpack não é permitido neste contexto", "unpackOperatorNotAllowed": "A operação de descompactação não é permitida neste contexto", "unpackTuplesIllegal": "Operação de desempacotamento não permitida em tuplas anteriores ao Python 3.8", "unpackedArgInTypeArgument": "Os argumentos descompactados não podem ser usados nesse contexto", @@ -616,35 +618,35 @@ "unreachableExcept": "A cláusula Except está inacessível porque a exceção já foi tratada", "unsupportedDunderAllOperation": "A operação em \"__all__\" não é compatível, portanto, a lista de símbolos exportada pode estar incorreta", "unusedCallResult": "O resultado da expressão de chamada é do tipo \"{type}\" e não é usado. Atribua à variável \"_\" se isso for intencional", - "unusedCoroutine": "O resultado da chamada de função assíncrona não foi usado. Use \"await\" ou atribua o resultado à variável", + "unusedCoroutine": "O resultado da chamada de função async não foi usado. Use \"await\" ou atribua o resultado à variável", "unusedExpression": "O valor da expressão não é usado", - "varAnnotationIllegal": "As anotações de tipo para variáveis exigem Python 3.6 ou mais recente. Use comentário de tipo para compatibilidade com versões anteriores", - "variableFinalOverride": "A variável \"{name}\" está marcada como Final e substitui a variável não final de mesmo nome na classe \"{className}\"", - "variadicTypeArgsTooMany": "A lista de argumentos de tipo pode ter no máximo um TypeVarTuple ou tupla descompactado", + "varAnnotationIllegal": "As anotações de tipo para variáveis exigem Python 3.6 ou mais recente. Use comentário de type para compatibilidade com versões anteriores", + "variableFinalOverride": "A variável \"{name}\" está marcada como Final e substitui a variável não Final de mesmo nome na classe \"{className}\"", + "variadicTypeArgsTooMany": "A lista de argumentos de tipo pode ter no máximo um TypeVarTuple ou tuple descompactado", "variadicTypeParamTooManyAlias": "O alias de tipo pode ter no máximo um parâmetro de tipo TypeVarTuple, mas recebeu vários ({names})", "variadicTypeParamTooManyClass": "A classe genérica pode ter no máximo um parâmetro de tipo TypeVarTuple, mas recebeu vários ({names})", "walrusIllegal": "O operador \":=\" requer o Python 3.8 ou mais recente", "walrusNotAllowed": "Operador \":=\" não é permitido neste contexto sem parênteses", - "wildcardInFunction": "Importação de curinga não permitida em uma classe ou função", - "wildcardLibraryImport": "Importação de curinga de uma biblioteca não permitida", + "wildcardInFunction": "Wildcard import not allowed within a class or function", + "wildcardLibraryImport": "Wildcard import from a library not allowed", "wildcardPatternTypePartiallyUnknown": "O tipo capturado pelo padrão curinga é parcialmente desconhecido", "wildcardPatternTypeUnknown": "O tipo capturado pelo padrão curinga é desconhecido", "yieldFromIllegal": "O uso de \"yield from\" requer o Python 3.3 ou mais recente", - "yieldFromOutsideAsync": "\"yield from\" não é permitido em uma função assíncrona", + "yieldFromOutsideAsync": "\"yield from\" não é permitido em uma função async", "yieldOutsideFunction": "\"yield\" não permitido fora de uma função ou lambda", "yieldWithinComprehension": "\"yield\" não é permitido dentro de uma compreensão", "zeroCaseStatementsFound": "A instrução Match deve incluir pelo menos uma instrução case", - "zeroLengthTupleNotAllowed": "Tupla de comprimento zero não é permitida neste contexto" + "zeroLengthTupleNotAllowed": "Zero-length tuple is not allowed in this context" }, "DiagnosticAddendum": { - "annotatedNotAllowed": "O formulário especial \"Anotado\" não pode ser usado com verificações de instância e classe", + "annotatedNotAllowed": "O formulário especial \"Annotated\" não pode ser usado com verificações de instância e classe", "argParam": "O argumento corresponde ao parâmetro \"{paramName}\"", "argParamFunction": "O argumento corresponde ao parâmetro \"{paramName}\" na função \"{functionName}\"", "argsParamMissing": "O parâmetro \"*{paramName}\" não tem nenhum parâmetro correspondente", "argsPositionOnly": "Incompatibilidade de parâmetro somente de posição; esperava-se {expected}, mas recebeu {received}", "argumentType": "O tipo de argumento é \"{type}\"", "argumentTypes": "Tipos de argumento: ({types})", - "assignToNone": "O tipo é incompatível com \"None\"", + "assignToNone": "O tipo não pode ser atribuído a \"None\"", "asyncHelp": "Você quis dizer \"async with\"?", "baseClassIncompatible": "A classe base \"{baseClass}\" é incompatível com o tipo \"{type}\"", "baseClassIncompatibleSubclass": "A classe base \"{baseClass}\" deriva de \"{subclass}\" que é incompatível com o tipo \"{type}\"", @@ -657,7 +659,7 @@ "dataProtocolUnsupported": "\"{name}\" é um protocolo de dados", "descriptorAccessBindingFailed": "Falha ao associar o método \"{name}\" para a classe de descritor \"{className}\"", "descriptorAccessCallFailed": "Falha ao chamar o método \"{name}\" para a classe de descritor \"{className}\"", - "finalMethod": "Método final", + "finalMethod": "Método Final", "functionParamDefaultMissing": "O parâmetro \"{name}\" não tem um argumento padrão", "functionParamName": "Incompatibilidade de nome de parâmetro: \"{destName}\" versus \"{srcName}\"", "functionParamPositionOnly": "Incompatibilidade de parâmetro somente posição; o parâmetro \"{name}\" não é somente posição", @@ -665,9 +667,9 @@ "functionTooFewParams": "A função aceita poucos parâmetros posicionais. Esperava-se {expected}, mas recebeu {received}", "functionTooManyParams": "A função aceita muitos parâmetros posicionais. Esperava-se {expected}, mas recebeu {received}", "genericClassNotAllowed": "Tipo genérico com argumentos de tipo não permitidos para verificações de instância ou de classe", - "incompatibleDeleter": "O método de exclusão de propriedade é incompatível", - "incompatibleGetter": "O método getter de propriedade é incompatível", - "incompatibleSetter": "O método setter de propriedade é incompatível", + "incompatibleDeleter": "O método de deleter de property é incompatível", + "incompatibleGetter": "O método getter de property é incompatível", + "incompatibleSetter": "O método setter de property é incompatível", "initMethodLocation": "O método __init__ é definido na classe \"{type}\"", "initMethodSignature": "A assinatura de __init__ é \"{type}\"", "initSubclassLocation": "O método __init_subclass__ é definido na classe \"{name}\"", @@ -681,14 +683,14 @@ "keyUndefined": "\"{name}\" não é uma chave definida em \"{type}\"", "kwargsParamMissing": "O parâmetro \"**{paramName}\" não tem nenhum parâmetro correspondente", "listAssignmentMismatch": "O tipo \"{type}\" é incompatível com a lista de destino", - "literalAssignmentMismatch": "\"{sourceType}\" é incompatível com o tipo \"{destType}\"", + "literalAssignmentMismatch": "\"{sourceType}\" não pode ser atribuído a o tipo\"{destType}\"", "matchIsNotExhaustiveHint": "Se não pretende usar a manipulação exaustiva, adicione \"case _: pass\"", "matchIsNotExhaustiveType": "Tipo sem tratamento: \"{type}\"", "memberAssignment": "A expressão do tipo \"{type}\" não pode ser atribuída ao atributo \"{name}\" da classe \"{classType}\"", "memberIsAbstract": "\"{type}.{name}\" não está implementado", "memberIsAbstractMore": "e mais {count}...", "memberIsClassVarInProtocol": "\"{name}\" é definido como um ClassVar no protocolo", - "memberIsInitVar": "\"{name}\" é um campo somente de inicialização", + "memberIsInitVar": "\"{name}\" é um campo somente de init-only", "memberIsInvariant": "\"{name}\" é invariável porque é mutável", "memberIsNotClassVarInClass": "\"{name}\" deve ser definido como um ClassVar para ser compatível com o protocolo", "memberIsNotClassVarInProtocol": "\"{name}\" não está definido como um ClassVar no protocolo", @@ -699,9 +701,9 @@ "memberTypeMismatch": "\"{name}\" é um tipo incompatível", "memberUnknown": "O atributo \"{name}\" é desconhecido", "metaclassConflict": "A metaclasse \"{metaclass1}\" entra em conflito com \"{metaclass2}\"", - "missingDeleter": "O método de exclusão de propriedade está ausente", - "missingGetter": "O método getter da propriedade está ausente", - "missingSetter": "O método setter da propriedade está ausente", + "missingDeleter": "O método de deleter de property está ausente", + "missingGetter": "O método getter da property está ausente", + "missingSetter": "O método setter da property está ausente", "namedParamMissingInDest": "Parâmetro extra \"{name}\"", "namedParamMissingInSource": "Parâmetro de palavra-chave ausente \"{name}\"", "namedParamTypeMismatch": "O parâmetro de palavra-chave \"{name}\" do tipo \"{sourceType}\" é incompatível com o tipo \"{destType}\"", @@ -710,7 +712,7 @@ "newMethodSignature": "A assinatura de__new__ é \"{type}\"", "newTypeClassNotAllowed": "A classe criada com NewType não pode ser usada com verificações de instância e classe", "noOverloadAssignable": "Nenhuma função sobrecarregada corresponde ao tipo \"{type}\"", - "noneNotAllowed": "Nenhum não pode ser usado para verificações de instância ou de classe", + "noneNotAllowed": "None não pode ser usado para verificações de instância ou de classe", "orPatternMissingName": "Nomes ausentes: {name}", "overloadIndex": "Sobrecarga {index} é a correspondência mais próxima", "overloadNotAssignable": "Uma ou mais sobrecargas de \"{name}\" não podem ser atribuídas", @@ -741,16 +743,16 @@ "paramType": "O tipo de parâmetro é \"{paramType}\"", "privateImportFromPyTypedSource": "Em vez disso, importe de \"{module}\"", "propertyAccessFromProtocolClass": "Uma propriedade definida dentro de uma classe de protocolo não pode ser acessada como uma variável de classe", - "propertyMethodIncompatible": "O método de propriedade \"{name}\" é incompatível", - "propertyMethodMissing": "O método de propriedade \"{name}\" está ausente na substituição", - "propertyMissingDeleter": "A propriedade \"{name}\" não tem nenhum excluidor definido", - "propertyMissingSetter": "A propriedade \"{name}\" não tem um setter definido", + "propertyMethodIncompatible": "O método de property \"{name}\" é incompatível", + "propertyMethodMissing": "O método de property \"{name}\" está ausente na substituição", + "propertyMissingDeleter": "A property \"{name}\" não tem nenhum deleter definido", + "propertyMissingSetter": "A property \"{name}\" não tem um setter definido", "protocolIncompatible": "\"{sourceType}\" é incompatível com o protocolo \"{destType}\"", "protocolMemberMissing": "\"{name}\" não está presente", - "protocolRequiresRuntimeCheckable": "A classe do protocolo deve ser @runtime_checkable para ser usada com verificações de instância e de classe", + "protocolRequiresRuntimeCheckable": "A classe do Protocol deve ser @runtime_checkable para ser usada com verificações de instância e de classe", "protocolSourceIsNotConcrete": "\"{sourceType}\" não é um tipo de classe concreta e não pode ser atribuído ao tipo \"{destType}\"", "protocolUnsafeOverlap": "Os atributos de \"{name}\" têm os mesmos nomes que o protocolo", - "pyrightCommentIgnoreTip": "Use \"# pyright: ignore[] para suprimir o diagnóstico de uma única linha", + "pyrightCommentIgnoreTip": "Use \"# pyright: ignore[]\" para suprimir o diagnóstico de uma única linha", "readOnlyAttribute": "O atributo \"{name}\" é somente leitura", "seeClassDeclaration": "Consulte a declaração de classe", "seeDeclaration": "Consulte a declaração", @@ -759,17 +761,17 @@ "seeParameterDeclaration": "Consulte a declaração de parâmetro", "seeTypeAliasDeclaration": "Ver declaração de alias de tipo", "seeVariableDeclaration": "Consulte a declaração de variável", - "tupleAssignmentMismatch": "O tipo \"{type}\" é incompatível com a tupla de destino", - "tupleEntryTypeMismatch": "A entrada de tupla {entry} é do tipo incorreto", - "tupleSizeIndeterminateSrc": "Incompatibilidade de tamanho de tupla; esperado {expected} mas recebido indeterminado", - "tupleSizeIndeterminateSrcDest": "Incompatibilidade de tamanho de tupla; {expected} ou mais esperado, mas indeterminado recebido", - "tupleSizeMismatch": "Incompatibilidade de tamanho de tupla; esperado {expected} mas recebido {received}", - "tupleSizeMismatchIndeterminateDest": "Incompatibilidade de tamanho de tupla; {expected} ou mais esperado, mas {received} recebido", + "tupleAssignmentMismatch": "O tipo \"{type}\" é incompatível com a tuple de destino", + "tupleEntryTypeMismatch": "A entrada de tuple {entry} é do tipo incorreto", + "tupleSizeIndeterminateSrc": "Incompatibilidade de tamanho de tuple; esperado {expected} mas recebido indeterminado", + "tupleSizeIndeterminateSrcDest": "Incompatibilidade de tamanho de tuple; {expected} ou mais esperado, mas indeterminado recebido", + "tupleSizeMismatch": "Incompatibilidade de tamanho de tuple; esperado {expected} mas recebido {received}", + "tupleSizeMismatchIndeterminateDest": "Incompatibilidade de tamanho de tuple; {expected} ou mais esperado, mas {received} recebido", "typeAliasInstanceCheck": "O alias de tipo criado com a instrução \"type\" não pode ser usado com verificações de instância e de classe", - "typeAssignmentMismatch": "O tipo \"{sourceType}\" é incompatível com o tipo \"{destType}\"", - "typeBound": "O tipo \"{sourceType}\" é incompatível com o tipo associado \"{destType}\" para a variável de tipo \"{name}\"", - "typeConstrainedTypeVar": "O tipo \"{type}\" é incompatível com a variável de tipo restrita \"{name}\"", - "typeIncompatible": "\"{sourceType}\" é incompatível com \"{destType}\"", + "typeAssignmentMismatch": "\"{sourceType}\" não pode ser atribuído ao tipo\"{destType}\"", + "typeBound": "O tipo \"{sourceType}\" não pode ser atribuído ao limite superior \"{destType}\" na variável do tipo \"{name}\"", + "typeConstrainedTypeVar": "O tipo \"{type}\" não pode ser atribuído à variável do tipo restrita \"{name}\"", + "typeIncompatible": "\"{sourceType}\" não pode ser atribuído a \"{destType}\"", "typeNotClass": "\"{type}\" não é uma classe.", "typeNotStringLiteral": "\"{type}\" não é um literal de cadeia de caracteres", "typeOfSymbol": "O tipo de \"{name}\" é \"{type}\"", @@ -780,7 +782,7 @@ "typeVarIsCovariant": "O parâmetro de tipo \"{name}\" é covariante, mas \"{sourceType}\" não é um subtipo de \"{destType}\"", "typeVarIsInvariant": "O parâmetro de tipo \"{name}\" é invariável, mas \"{sourceType}\" não é o mesmo que \"{destType}\"", "typeVarNotAllowed": "TypeVar não permitido para verificações de instância ou de classe", - "typeVarTupleRequiresKnownLength": "TypeVarTuple não pode ser associado a uma tupla de comprimento desconhecido", + "typeVarTupleRequiresKnownLength": "TypeVarTuple não pode ser associado a uma tuple de comprimento desconhecido", "typeVarUnnecessarySuggestion": "Use {type} em vez disso", "typeVarUnsolvableRemedy": "Forneça uma sobrecarga que especifica o tipo de retorno quando o argumento não é fornecido", "typeVarsMissing": "Variáveis de tipo ausentes: {names}", @@ -804,8 +806,8 @@ "uninitializedAbstractVariable": "A variável de instância \"{name}\" está definida na classe base abstrata \"{classType}\", mas não foi inicializada", "unreachableExcept": "\"{exceptionType}\" é uma subclasse de \"{parentType}\"", "useDictInstead": "Use Dict[T1, T2] para indicar um tipo de dicionário", - "useListInstead": "Use List[T] para indicar um tipo de lista ou Union[T1, T2] para indicar um tipo de união", - "useTupleInstead": "Use tuple[T1, ..., Tn] para indicar um tipo de tupla ou Union[T1, T2] para indicar um tipo de união", + "useListInstead": "Use List[T] para indicar um tipo de lista ou Union[T1, T2] para indicar um tipo de union", + "useTupleInstead": "Use tuple[T1, ..., Tn] para indicar um tipo de tuple ou Union[T1, T2] para indicar um tipo de union", "useTypeInstead": "Use Type[T] em vez disso", "varianceMismatchForClass": "A variação do argumento de tipo \"{typeVarName}\" é incompatível com a classe base \"{className}\"", "varianceMismatchForTypeAlias": "A variação do argumento de tipo \"{typeVarName}\" é incompatível com \"{typeAliasParam}\"" diff --git a/packages/pyright-internal/src/localization/package.nls.qps-ploc.json b/packages/pyright-internal/src/localization/package.nls.qps-ploc.json index efa1c25b3..f111be752 100644 --- a/packages/pyright-internal/src/localization/package.nls.qps-ploc.json +++ b/packages/pyright-internal/src/localization/package.nls.qps-ploc.json @@ -1,7 +1,7 @@ { "CodeAction": { - "createTypeStub": "[4i3uH][นั้Çrëætë Tÿpë §tµþẤğ倪İЂҰนั้ढूँ]", - "createTypeStubFor": "[oXYb0][นั้Çrëætë Tÿpë §tµþ Før \"{møðµlëÑæmë}\"Ấğ倪İЂҰक्र्तिृまนั้ढूँ]", + "createTypeStub": "[4i3uH][นั้Çrëætë Tÿpë StubẤğ倪İЂҰนั้ढूँ]", + "createTypeStubFor": "[oXYb0][นั้Çrëætë Tÿpë Stub Før \"{møðµlëÑæmë}\"Ấğ倪İЂҰक्र्तिृまนั้ढूँ]", "executingCommand": "[AxS1Z][นั้Ëxëçµtïñg çømmæñðẤğ倪İЂҰक्นั้ढूँ]", "filesToAnalyzeCount": "[94Ml3][นั้{çøµñt} fïlës tø æñælÿzëẤğ倪İЂҰक्र्นั้ढूँ]", "filesToAnalyzeOne": "[2zuMu][นั้1 fïlë tø æñælÿzëẤğ倪İЂҰक्นั้ढूँ]", @@ -18,12 +18,12 @@ "annotatedMetadataInconsistent": "[iOP70][นั้Æññøtætëð mëtæðætæ tÿpë \"{mëtæðætæTÿpë}\" ïs ñøt çømpætïþlë wïth tÿpë \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", "annotatedParamCountMismatch": "[VZvZc][นั้Pæræmëtër æññøtætïøñ çøµñt mïsmætçh: ëxpëçtëð {ëxpëçtëð} þµt rëçëïvëð {rëçëïvëð}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "annotatedTypeArgMissing": "[mTgtG][นั้Ëxpëçtëð øñë tÿpë ærgµmëñt æñð øñë ør mørë æññøtætïøñs før \"Annotated\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "annotationBytesString": "[W1g86][นั้Tÿpë æññøtætïøñs çæññøt µsë þÿtës strïñg lïtërælsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "annotationFormatString": "[zaI8H][นั้Tÿpë æññøtætïøñs çæññøt µsë førmæt strïñg lïtëræls (f-strïñgs)Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "annotationBytesString": "[W1g86][นั้Tÿpë ëxprëssïøñs çæññøt µsë þÿtës strïñg lïtërælsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "annotationFormatString": "[zaI8H][นั้Tÿpë ëxprëssïøñs çæññøt µsë førmæt strïñg lïtëræls (f-strïñgs)Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "annotationNotSupported": "[xYlM8][นั้Tÿpë æññøtætïøñ ñøt sµppørtëð før thïs stætëmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "annotationRawString": "[WOMum][นั้Tÿpë æññøtætïøñs çæññøt µsë ræw strïñg lïtërælsẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "annotationSpansStrings": "[6Gg9x][นั้Tÿpë æññøtætïøñs çæññøt spæñ mµltïplë strïñg lïtërælsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "annotationStringEscape": "[MQdsm][นั้Tÿpë æññøtætïøñs çæññøt çøñtæïñ ësçæpë çhæræçtërsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "annotationRawString": "[WOMum][นั้Tÿpë ëxprëssïøñs çæññøt µsë ræw strïñg lïtërælsẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "annotationSpansStrings": "[6Gg9x][นั้Tÿpë ëxprëssïøñs çæññøt spæñ mµltïplë strïñg lïtërælsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "annotationStringEscape": "[MQdsm][นั้Tÿpë ëxprëssïøñs çæññøt çøñtæïñ ësçæpë çhæræçtërsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "argAssignment": "[7pdVt][นั้Ærgµmëñt øf tÿpë \"{ærgTÿpë}\" çæññøt þë æssïgñëð tø pæræmëtër øf tÿpë \"{pæræmTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", "argAssignmentFunction": "[J08ms][นั้Ærgµmëñt øf tÿpë \"{ærgTÿpë}\" çæññøt þë æssïgñëð tø pæræmëtër øf tÿpë \"{pæræmTÿpë}\" ïñ fµñçtïøñ \"{fµñçtïøñÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "argAssignmentParam": "[hEBRl][นั้Ærgµmëñt øf tÿpë \"{ærgTÿpë}\" çæññøt þë æssïgñëð tø pæræmëtër \"{pæræmÑæmë}\" øf tÿpë \"{pæræmTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", @@ -37,68 +37,68 @@ "argPositionalExpectedOne": "[XW4kV][นั้Ëxpëçtëð 1 pøsïtïøñæl ærgµmëñtẤğ倪İЂҰक्र्तिृนั้ढूँ]", "argTypePartiallyUnknown": "[Y02o3][นั้Ærgµmëñt tÿpë ïs pærtïællÿ µñkñøwñẤğ倪İЂҰक्र्तिृまนั้ढूँ]", "argTypeUnknown": "[l0ccD][นั้Ærgµmëñt tÿpë ïs µñkñøwñẤğ倪İЂҰक्र्นั้ढूँ]", - "assertAlwaysTrue": "[5Weld][นั้Æssërt ëxprëssïøñ ælwæÿs ëvælµætës tø trµëẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "assertTypeArgs": "[QHRQ7][นั้\"æssërt_tÿpë\" ëxpëçts twø pøsïtïøñæl ærgµmëñtsẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "assertTypeTypeMismatch": "[fc1Kk][นั้\"æssërt_tÿpë\" mïsmætçh: ëxpëçtëð \"{ëxpëçtëð}\" þµt rëçëïvëð \"{rëçëïvëð}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "assertAlwaysTrue": "[5Weld][นั้Æssërt ëxprëssïøñ ælwæÿs ëvælµætës tø trueẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "assertTypeArgs": "[QHRQ7][นั้\"assert_type\" ëxpëçts twø pøsïtïøñæl ærgµmëñtsẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "assertTypeTypeMismatch": "[fc1Kk][นั้\"assert_type\" mïsmætçh: ëxpëçtëð \"{ëxpëçtëð}\" þµt rëçëïvëð \"{rëçëïvëð}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", "assignmentExprComprehension": "[F5OTr][นั้Æssïgñmëñt ëxprëssïøñ tærgët \"{ñæmë}\" çæññøt µsë sæmë ñæmë æs çømprëhëñsïøñ før tærgëtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "assignmentExprContext": "[U4d41][นั้Æssïgñmëñt ëxprëssïøñ mµst þë wïthïñ møðµlë, fµñçtïøñ ør læmþðæẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "assignmentExprInSubscript": "[mnJzw][นั้Æssïgñmëñt ëxprëssïøñs wïthïñ æ sµþsçrïpt ærë sµppørtëð øñlÿ ïñ Pÿthøñ 3.10 æñð ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "assignmentInProtocol": "[vey5h][นั้Ïñstæñçë ør çlæss værïæþlës wïthïñ æ Prøtøçøl çlæss mµst þë ëxplïçïtlÿ ðëçlærëð wïthïñ thë çlæss þøðÿẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "assignmentInProtocol": "[vey5h][นั้Ïñstæñçë ør çlæss værïæþlës wïthïñ æ Protocol çlæss mµst þë ëxplïçïtlÿ ðëçlærëð wïthïñ thë çlæss þøðÿẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "assignmentTargetExpr": "[22xbu][นั้Ëxprëssïøñ çæññøt þë æssïgñmëñt tærgëtẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "asyncNotInAsyncFunction": "[u0Y7U][นั้Üsë øf \"æsÿñç\" ñøt ælløwëð øµtsïðë øf æsÿñç fµñçtïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "awaitIllegal": "[2Wa68][นั้Üsë øf \"æwæït\" rëqµïrës Pÿthøñ 3.5 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "awaitNotAllowed": "[TpX77][นั้Tÿpë æññøtætïøñs çæññøt µsë \"æwæït\"Ấğ倪İЂҰक्र्तिृまนั้ढूँ]", - "awaitNotInAsync": "[qau2Q][นั้\"æwæït\" ælløwëð øñlÿ wïthïñ æsÿñç fµñçtïøñẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "backticksIllegal": "[V1LZI][นั้Ëxprëssïøñs sµrrøµñðëð þÿ þæçktïçks ærë ñøt sµppørtëð ïñ Pÿthøñ 3.x; µsë rëpr ïñstëæðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "asyncNotInAsyncFunction": "[u0Y7U][นั้Üsë øf \"async\" ñøt ælløwëð øµtsïðë øf async fµñçtïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "awaitIllegal": "[2Wa68][นั้Üsë øf \"await\" rëqµïrës Pÿthøñ 3.5 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "awaitNotAllowed": "[TpX77][นั้Tÿpë ëxprëssïøñs çæññøt µsë \"await\"Ấğ倪İЂҰक्र्तिृまนั้ढूँ]", + "awaitNotInAsync": "[qau2Q][นั้\"await\" ælløwëð øñlÿ wïthïñ async fµñçtïøñẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "backticksIllegal": "[V1LZI][นั้Ëxprëssïøñs sµrrøµñðëð þÿ þæçktïçks ærë ñøt sµppørtëð ïñ Pÿthøñ 3.x; µsë repr ïñstëæðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "baseClassCircular": "[frqWt][นั้Çlæss çæññøt ðërïvë frøm ïtsëlfẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "baseClassFinal": "[C9i92][นั้ßæsë çlæss \"{tÿpë}\" ïs mærkëð fïñæl æñð çæññøt þë sµþçlæssëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "baseClassFinal": "[C9i92][นั้ßæsë çlæss \"{tÿpë}\" ïs mærkëð final æñð çæññøt þë sµþçlæssëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "baseClassIncompatible": "[K3wZ2][นั้ßæsë çlæssës øf {tÿpë} ærë mµtµællÿ ïñçømpætïþlëẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", "baseClassInvalid": "[qULQr][นั้Ærgµmëñt tø çlæss mµst þë æ þæsë çlæssẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", "baseClassMethodTypeIncompatible": "[2lM0z][นั้ßæsë çlæssës før çlæss \"{çlæssTÿpë}\" ðëfïñë mëthøð \"{ñæmë}\" ïñ ïñçømpætïþlë wæÿẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "baseClassUnknown": "[QQxIX][นั้ßæsë çlæss tÿpë ïs µñkñøwñ, øþsçµrïñg tÿpë øf ðërïvëð çlæssẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "baseClassVariableTypeIncompatible": "[YmxlD][นั้ßæsë çlæssës før çlæss \"{çlæssTÿpë}\" ðëfïñë værïæþlë \"{ñæmë}\" ïñ ïñçømpætïþlë wæÿẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "binaryOperationNotAllowed": "[1lzlz][นั้ßïñærÿ øpërætør ñøt ælløwëð ïñ tÿpë æññøtætïøñẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "binaryOperationNotAllowed": "[1lzlz][นั้ßïñærÿ øpërætør ñøt ælløwëð ïñ tÿpë ëxprëssïøñẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "bindTypeMismatch": "[x4sbf][นั้Çøµlð ñøt þïñð mëthøð \"{mëthøðÑæmë}\" þëçæµsë \"{tÿpë}\" ïs ñøt æssïgñæþlë tø pæræmëtër \"{pæræmÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "breakOutsideLoop": "[Ca4Ip][นั้\"þrëæk\" çæñ þë µsëð øñlÿ wïthïñ æ løøpẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "callableExtraArgs": "[M3UIb][นั้Ëxpëçtëð øñlÿ twø tÿpë ærgµmëñts tø \"Çællæþlë\"Ấğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "breakOutsideLoop": "[Ca4Ip][นั้\"break\" çæñ þë µsëð øñlÿ wïthïñ æ løøpẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "callableExtraArgs": "[M3UIb][นั้Ëxpëçtëð øñlÿ twø tÿpë ærgµmëñts tø \"Callable\"Ấğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "callableFirstArg": "[W1wTU][นั้Ëxpëçtëð pæræmëtër tÿpë lïst ør \"...\"Ấğ倪İЂҰक्र्तिृまẤนั้ढूँ]", "callableNotInstantiable": "[sJ0Q8][นั้Çæññøt ïñstæñtïætë tÿpë \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]", - "callableSecondArg": "[9c1cS][นั้Ëxpëçtëð rëtµrñ tÿpë æs sëçøñð tÿpë ærgµmëñt før \"Çællæþlë\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "callableSecondArg": "[9c1cS][นั้Ëxpëçtëð rëtµrñ tÿpë æs sëçøñð tÿpë ærgµmëñt før \"Callable\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "casePatternIsIrrefutable": "[NR6tj][นั้Ïrrëfµtæþlë pættërñ ïs ælløwëð øñlÿ før thë læst çæsë stætëmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "classAlreadySpecialized": "[Puetc][นั้Tÿpë \"{tÿpë}\" ïs ælrëæðÿ spëçïælïzëðẤğ倪İЂҰक्र्तिृまนั้ढूँ]", "classDecoratorTypeUnknown": "[FhL8V][นั้Üñtÿpëð çlæss ðëçørætør øþsçµrës tÿpë øf çlæss; ïgñørïñg ðëçørætørẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "classDefinitionCycle": "[21Tlp][นั้Çlæss ðëfïñïtïøñ før \"{ñæmë}\" ðëpëñðs øñ ïtsëlfẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "classGetItemClsParam": "[A2iHF][นั้__çlæss_gëtïtëm__ øvërrïðë shøµlð tækë æ \"çls\" pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "classMethodClsParam": "[aWMN3][นั้Çlæss mëthøðs shøµlð tækë æ \"çls\" pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "classNotRuntimeSubscriptable": "[O9BL6][นั้§µþsçrïpt før çlæss \"{ñæmë}\" wïll gëñërætë rµñtïmë ëxçëptïøñ; ëñçløsë tÿpë æññøtætïøñ ïñ qµøtësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "classGetItemClsParam": "[A2iHF][นั้__class_getitem__ øvërrïðë shøµlð tækë æ \"cls\" pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "classMethodClsParam": "[aWMN3][นั้Çlæss mëthøðs shøµlð tækë æ \"cls\" pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "classNotRuntimeSubscriptable": "[O9BL6][นั้§µþsçrïpt før çlæss \"{ñæmë}\" wïll gëñërætë rµñtïmë ëxçëptïøñ; ëñçløsë tÿpë ëxprëssïøñ ïñ qµøtësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "classPatternBuiltInArgPositional": "[DOfs5][นั้Çlæss pættërñ æççëpts øñlÿ pøsïtïøñæl sµþ-pættërñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "classPatternPositionalArgCount": "[B65y5][นั้Tøø mæñÿ pøsïtïøñæl pættërñs før çlæss \"{tÿpë}\"; ëxpëçtëð {ëxpëçtëð} þµt rëçëïvëð {rëçëïvëð}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "classPatternTypeAlias": "[AxDtv][นั้\"{tÿpë}\" çæññøt þë µsëð ïñ æ çlæss pættërñ þëçæµsë ït ïs æ spëçïælïzëð tÿpë ælïæsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "classPropertyDeprecated": "[Q6JgP][นั้Çlæss prøpërtïës ærë ðëprëçætëð ïñ Pÿthøñ 3.11 æñð wïll ñøt þë sµppørtëð ïñ Pÿthøñ 3.13Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "classTypeParametersIllegal": "[GybXD][นั้Çlæss tÿpë pæræmëtër sÿñtæx rëqµïrës Pÿthøñ 3.12 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "classVarFirstArgMissing": "[VtcEd][นั้Ëxpëçtëð æ tÿpë ærgµmëñt æftër \"ÇlæssVær\"Ấğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "classVarNotAllowed": "[BU07G][นั้\"ÇlæssVær\" ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "classVarFirstArgMissing": "[VtcEd][นั้Ëxpëçtëð æ tÿpë ærgµmëñt æftër \"ClassVar\"Ấğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "classVarNotAllowed": "[BU07G][นั้\"ClassVar\" ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "classVarOverridesInstanceVar": "[UEaro][นั้Çlæss værïæþlë \"{ñæmë}\" øvërrïðës ïñstæñçë værïæþlë øf sæmë ñæmë ïñ çlæss \"{çlæssÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "classVarTooManyArgs": "[Mj1R5][นั้Ëxpëçtëð øñlÿ øñë tÿpë ærgµmëñt æftër \"ÇlæssVær\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "classVarWithTypeVar": "[6mnjY][นั้\"ÇlæssVær\" tÿpë çæññøt ïñçlµðë tÿpë værïæþlësẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "classVarTooManyArgs": "[Mj1R5][นั้Ëxpëçtëð øñlÿ øñë tÿpë ærgµmëñt æftër \"ClassVar\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "classVarWithTypeVar": "[6mnjY][นั้\"ClassVar\" tÿpë çæññøt ïñçlµðë tÿpë værïæþlësẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "clsSelfParamTypeMismatch": "[MBrCQ][นั้Tÿpë øf pæræmëtër \"{ñæmë}\" mµst þë æ sµpërtÿpë øf ïts çlæss \"{çlæssTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", "codeTooComplexToAnalyze": "[FNQd7][นั้Çøðë ïs tøø çømplëx tø æñælÿzë; rëðµçë çømplëxïtÿ þÿ rëfæçtørïñg ïñtø sµþrøµtïñës ør rëðµçïñg çøñðïtïøñæl çøðë pæthsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "collectionAliasInstantiation": "[rZb8i][นั้Tÿpë \"{tÿpë}\" çæññøt þë ïñstæñtïætëð, µsë \"{ælïæs}\" ïñstëæðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "comparisonAlwaysFalse": "[N16ve][นั้Çøñðïtïøñ wïll ælwæÿs ëvælµætë tø Fælsë sïñçë thë tÿpës \"{lëftTÿpë}\" æñð \"{rïghtTÿpë}\" hævë ñø øvërlæpẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "comparisonAlwaysTrue": "[0TOLo][นั้Çøñðïtïøñ wïll ælwæÿs ëvælµætë tø Trµë sïñçë thë tÿpës \"{lëftTÿpë}\" æñð \"{rïghtTÿpë}\" hævë ñø øvërlæpẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "comparisonAlwaysFalse": "[N16ve][นั้Çøñðïtïøñ wïll ælwæÿs ëvælµætë tø False sïñçë thë tÿpës \"{lëftTÿpë}\" æñð \"{rïghtTÿpë}\" hævë ñø øvërlæpẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "comparisonAlwaysTrue": "[0TOLo][นั้Çøñðïtïøñ wïll ælwæÿs ëvælµætë tø True sïñçë thë tÿpës \"{lëftTÿpë}\" æñð \"{rïghtTÿpë}\" hævë ñø øvërlæpẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "comprehensionInDict": "[Orm2O][นั้Çømprëhëñsïøñ çæññøt þë µsëð wïth øthër ðïçtïøñærÿ ëñtrïësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "comprehensionInSet": "[YUnu9][นั้Çømprëhëñsïøñ çæññøt þë µsëð wïth øthër sët ëñtrïësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "concatenateContext": "[8tRy6][นั้\"Çøñçætëñætë\" ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "concatenateParamSpecMissing": "[3s1CV][นั้£æst tÿpë ærgµmëñt før \"Çøñçætëñætë\" mµst þë æ Pæræm§pëç ør \"...\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "concatenateTypeArgsMissing": "[aH5g8][นั้\"Çøñçætëñætë\" rëqµïrës æt lëæst twø tÿpë ærgµmëñtsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "comprehensionInSet": "[YUnu9][นั้Çømprëhëñsïøñ çæññøt þë µsëð wïth øthër set ëñtrïësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "concatenateContext": "[8tRy6][นั้\"Concatenate\" ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "concatenateParamSpecMissing": "[3s1CV][นั้£æst tÿpë ærgµmëñt før \"Concatenate\" mµst þë æ ParamSpec ør \"...\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "concatenateTypeArgsMissing": "[aH5g8][นั้\"Concatenate\" rëqµïrës æt lëæst twø tÿpë ærgµmëñtsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "conditionalOperandInvalid": "[HnbrG][นั้Ïñvælïð çøñðïtïøñæl øpëræñð øf tÿpë \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "constantRedefinition": "[oRKBh][นั้\"{ñæmë}\" ïs çøñstæñt (þëçæµsë ït ïs µppërçæsë) æñð çæññøt þë rëðëfïñëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "constructorParametersMismatch": "[WWloK][นั้Mïsmætçh þëtwëëñ sïgñætµrë øf __ñëw__ æñð __ïñït__ ïñ çlæss \"{çlæssTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "containmentAlwaysFalse": "[e6PIv][นั้Ëxprëssïøñ wïll ælwæÿs ëvælµætë tø Fælsë sïñçë thë tÿpës \"{lëftTÿpë}\" æñð \"{rïghtTÿpë}\" hævë ñø øvërlæpẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "containmentAlwaysTrue": "[8OhUO][นั้Ëxprëssïøñ wïll ælwæÿs ëvælµætë tø Trµë sïñçë thë tÿpës \"{lëftTÿpë}\" æñð \"{rïghtTÿpë}\" hævë ñø øvërlæpẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "continueInFinally": "[RZIyI][นั้\"çøñtïñµë\" çæññøt þë µsëð wïthïñ æ fïñællÿ çlæµsëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "continueOutsideLoop": "[6ACvd][นั้\"çøñtïñµë\" çæñ þë µsëð øñlÿ wïthïñ æ løøpẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "coroutineInConditionalExpression": "[ygK2r][นั้Çøñðïtïøñæl ëxprëssïøñ rëfërëñçës çørøµtïñë whïçh ælwæÿs ëvælµætës tø TrµëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "constructorParametersMismatch": "[WWloK][นั้Mïsmætçh þëtwëëñ sïgñætµrë øf __new__ æñð __init__ ïñ çlæss \"{çlæssTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "containmentAlwaysFalse": "[e6PIv][นั้Ëxprëssïøñ wïll ælwæÿs ëvælµætë tø False sïñçë thë tÿpës \"{lëftTÿpë}\" æñð \"{rïghtTÿpë}\" hævë ñø øvërlæpẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "containmentAlwaysTrue": "[8OhUO][นั้Ëxprëssïøñ wïll ælwæÿs ëvælµætë tø True sïñçë thë tÿpës \"{lëftTÿpë}\" æñð \"{rïghtTÿpë}\" hævë ñø øvërlæpẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "continueInFinally": "[RZIyI][นั้\"continue\" çæññøt þë µsëð wïthïñ æ finally çlæµsëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "continueOutsideLoop": "[6ACvd][นั้\"continue\" çæñ þë µsëð øñlÿ wïthïñ æ løøpẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "coroutineInConditionalExpression": "[ygK2r][นั้Çøñðïtïøñæl ëxprëssïøñ rëfërëñçës çørøµtïñë whïçh ælwæÿs ëvælµætës tø TrueẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "dataClassBaseClassFrozen": "[jjiw4][นั้Æ ñøñ-frøzëñ çlæss çæññøt ïñhërït frøm æ çlæss thæt ïs frøzëñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "dataClassBaseClassNotFrozen": "[KOz4K][นั้Æ frøzëñ çlæss çæññøt ïñhërït frøm æ çlæss thæt ïs ñøt frøzëñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "dataClassConverterFunction": "[FxD8r][นั้Ærgµmëñt øf tÿpë \"{ærgTÿpë}\" ïs ñøt æ vælïð çøñvërtër før fïëlð \"{fïëlðÑæmë}\" øf tÿpë \"{fïëlðTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", @@ -107,14 +107,14 @@ "dataClassFieldWithDefault": "[iJuju][นั้Fïëlðs wïthøµt ðëfæµlt vælµës çæññøt æppëær æftër fïëlðs wïth ðëfæµlt vælµësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "dataClassFieldWithPrivateName": "[miQYb][นั้Ðætæçlæss fïëlð çæññøt µsë prïvætë ñæmëẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "dataClassFieldWithoutAnnotation": "[zq5t5][นั้Ðætæçlæss fïëlð wïthøµt tÿpë æññøtætïøñ wïll çæµsë rµñtïmë ëxçëptïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "dataClassPostInitParamCount": "[yl0Bg][นั้Ðætæçlæss __pøst_ïñït__ ïñçørrëçt pæræmëtër çøµñt; ñµmþër øf ÏñïtVær fïëlðs ïs {ëxpëçtëð}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "dataClassPostInitType": "[74TW4][นั้Ðætæçlæss __pøst_ïñït__ mëthøð pæræmëtër tÿpë mïsmætçh før fïëlð \"{fïëlðÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "dataClassSlotsOverwrite": "[D17er][นั้__sløts__ ïs ælrëæðÿ ðëfïñëð ïñ çlæssẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "dataClassTransformExpectedBoolLiteral": "[y2upJ][นั้Ëxpëçtëð ëxprëssïøñ thæt stætïçællÿ ëvælµætës tø Trµë ør FælsëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "dataClassTransformFieldSpecifier": "[xE1Cp][นั้Ëxpëçtëð tµplë øf çlæssës ør fµñçtïøñs þµt rëçëïvëð tÿpë \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "dataClassTransformPositionalParam": "[Cu7w4][นั้Æll ærgµmëñts tø \"ðætæçlæss_træñsførm\" mµst þë këÿwørð ærgµmëñtsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "dataClassTransformUnknownArgument": "[hLQXL][นั้Ærgµmëñt \"{ñæmë}\" ïs ñøt sµppørtëð þÿ ðætæçlæss_træñsførmẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "dataProtocolInSubclassCheck": "[kIIkO][นั้Ðætæ prøtøçøls (whïçh ïñçlµðë ñøñ-mëthøð ættrïþµtës) ærë ñøt ælløwëð ïñ ïssµþçlæss çællsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "dataClassPostInitParamCount": "[yl0Bg][นั้Ðætæçlæss __post_init__ ïñçørrëçt pæræmëtër çøµñt; ñµmþër øf InitVar fïëlðs ïs {ëxpëçtëð}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "dataClassPostInitType": "[74TW4][นั้Ðætæçlæss __post_init__ mëthøð pæræmëtër tÿpë mïsmætçh før fïëlð \"{fïëlðÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "dataClassSlotsOverwrite": "[D17er][นั้__slots__ ïs ælrëæðÿ ðëfïñëð ïñ çlæssẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "dataClassTransformExpectedBoolLiteral": "[y2upJ][นั้Ëxpëçtëð ëxprëssïøñ thæt stætïçællÿ ëvælµætës tø True ør FalseẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "dataClassTransformFieldSpecifier": "[xE1Cp][นั้Ëxpëçtëð tuple øf çlæssës ør fµñçtïøñs þµt rëçëïvëð tÿpë \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "dataClassTransformPositionalParam": "[Cu7w4][นั้Æll ærgµmëñts tø \"dataclass_transform\" mµst þë këÿwørð ærgµmëñtsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "dataClassTransformUnknownArgument": "[hLQXL][นั้Ærgµmëñt \"{ñæmë}\" ïs ñøt sµppørtëð þÿ dataclass_transformẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "dataProtocolInSubclassCheck": "[kIIkO][นั้Ðætæ prøtøçøls (whïçh ïñçlµðë ñøñ-mëthøð ættrïþµtës) ærë ñøt ælløwëð ïñ issubclass çællsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "declaredReturnTypePartiallyUnknown": "[pDeOu][นั้Ðëçlærëð rëtµrñ tÿpë, \"{rëtµrñTÿpë}\", ïs pærtïællÿ µñkñøwñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "declaredReturnTypeUnknown": "[XRFJs][นั้Ðëçlærëð rëtµrñ tÿpë ïs µñkñøwñẤğ倪İЂҰक्र्तिृนั้ढूँ]", "defaultValueContainsCall": "[G3smw][นั้Fµñçtïøñ çælls æñð mµtæþlë øþjëçts ñøt ælløwëð wïthïñ pæræmëtër ðëfæµlt vælµë ëxprëssïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", @@ -127,21 +127,21 @@ "deprecatedDescriptorSetter": "[6nQQu][นั้Thë \"__sët__\" mëthøð før ðësçrïptør \"{ñæmë}\" ïs ðëprëçætëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "deprecatedFunction": "[GdF0l][นั้Thë fµñçtïøñ \"{ñæmë}\" ïs ðëprëçætëðẤğ倪İЂҰक्र्तिृまนั้ढूँ]", "deprecatedMethod": "[GxfND][นั้Thë mëthøð \"{ñæmë}\" ïñ çlæss \"{çlæssÑæmë}\" ïs ðëprëçætëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "deprecatedPropertyDeleter": "[BUlI2][นั้Thë ðëlëtër før prøpërtÿ \"{ñæmë}\" ïs ðëprëçætëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "deprecatedPropertyGetter": "[54BuI][นั้Thë gëttër før prøpërtÿ \"{ñæmë}\" ïs ðëprëçætëðẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "deprecatedPropertySetter": "[EHGoz][นั้Thë sëttër før prøpërtÿ \"{ñæmë}\" ïs ðëprëçætëðẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "deprecatedPropertyDeleter": "[BUlI2][นั้Thë deleter før property \"{ñæmë}\" ïs ðëprëçætëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "deprecatedPropertyGetter": "[54BuI][นั้Thë getter før property \"{ñæmë}\" ïs ðëprëçætëðẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "deprecatedPropertySetter": "[EHGoz][นั้Thë setter før property \"{ñæmë}\" ïs ðëprëçætëðẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "deprecatedType": "[IWdSs][นั้Thïs tÿpë ïs ðëprëçætëð æs øf Pÿthøñ {vërsïøñ}; µsë \"{rëplæçëmëñt}\" ïñstëæðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "dictExpandIllegalInComprehension": "[3B8LL][นั้Ðïçtïøñærÿ ëxpæñsïøñ ñøt ælløwëð ïñ çømprëhëñsïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "dictInAnnotation": "[0UcII][นั้Ðïçtïøñærÿ ëxprëssïøñ ñøt ælløwëð ïñ tÿpë æññøtætïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "dictInAnnotation": "[0UcII][นั้Ðïçtïøñærÿ ëxprëssïøñ ñøt ælløwëð ïñ tÿpë ëxprëssïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "dictKeyValuePairs": "[Hnd6W][นั้Ðïçtïøñærÿ ëñtrïës mµst çøñtæïñ këÿ/vælµë pæïrsẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", "dictUnpackIsNotMapping": "[RhO60][นั้Ëxpëçtëð mæppïñg før ðïçtïøñærÿ µñpæçk øpërætørẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "dunderAllSymbolNotPresent": "[mlrcI][นั้\"{ñæmë}\" ïs spëçïfïëð ïñ __æll__ þµt ïs ñøt prësëñt ïñ møðµlëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "dunderAllSymbolNotPresent": "[mlrcI][นั้\"{ñæmë}\" ïs spëçïfïëð ïñ __all__ þµt ïs ñøt prësëñt ïñ møðµlëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "duplicateArgsParam": "[bt3Os][นั้Øñlÿ øñë \"*\" pæræmëtër ælløwëðẤğ倪İЂҰक्र्तिृนั้ढूँ]", "duplicateBaseClass": "[HIzyw][นั้еplïçætë þæsë çlæss ñøt ælløwëðẤğ倪İЂҰक्र्तिृนั้ढूँ]", "duplicateCapturePatternTarget": "[zq38Z][นั้Çæptµrë tærgët \"{ñæmë}\" çæññøt æppëær mørë thæñ øñçë wïthïñ thë sæmë pættërñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "duplicateCatchAll": "[6gO00][นั้Øñlÿ øñë çætçh-æll ëxçëpt çlæµsë ælløwëðẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "duplicateEnumMember": "[k9W8A][นั้Ëñµm mëmþër \"{ñæmë}\" ïs ælrëæðÿ ðëçlærëðẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "duplicateGenericAndProtocolBase": "[4EO4W][นั้Øñlÿ øñë Gëñërïç[...] ør Prøtøçøl[...] þæsë çlæss ælløwëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "duplicateCatchAll": "[6gO00][นั้Øñlÿ øñë çætçh-æll except çlæµsë ælløwëðẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "duplicateEnumMember": "[k9W8A][นั้Enum mëmþër \"{ñæmë}\" ïs ælrëæðÿ ðëçlærëðẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "duplicateGenericAndProtocolBase": "[4EO4W][นั้Øñlÿ øñë Generic[...] ør Protocol[...] þæsë çlæss ælløwëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "duplicateImport": "[qgZGm][นั้\"{ïmpørtÑæmë}\" ïs ïmpørtëð mørë thæñ øñçëẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "duplicateKeywordOnly": "[pbf3W][นั้Øñlÿ øñë \"*\" sëpærætør ælløwëðẤğ倪İЂҰक्र्तिृนั้ढूँ]", "duplicateKwargsParam": "[4QsUE][นั้Øñlÿ øñë \"**\" pæræmëtër ælløwëðẤğ倪İЂҰक्र्तिृนั้ढूँ]", @@ -149,26 +149,26 @@ "duplicatePositionOnly": "[9hzW4][นั้Øñlÿ øñë \"/\" pæræmëtër ælløwëðẤğ倪İЂҰक्र्तिृนั้ढूँ]", "duplicateStarPattern": "[8quwQ][นั้Øñlÿ øñë \"*\" pættërñ ælløwëð ïñ æ pættërñ sëqµëñçëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "duplicateStarStarPattern": "[wScoI][นั้Øñlÿ øñë \"**\" ëñtrÿ ælløwëðẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "duplicateUnpack": "[wjeOP][นั้Øñlÿ øñë µñpæçk øpërætïøñ ælløwëð ïñ lïstẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "ellipsisAfterUnpacked": "[4EsWH][นั้\"...\" çæññøt þë µsëð wïth æñ µñpæçkëð TÿpëVærTµplë ør tµplëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "duplicateUnpack": "[wjeOP][นั้Øñlÿ øñë µñpæçk øpërætïøñ ælløwëð ïñ listẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "ellipsisAfterUnpacked": "[4EsWH][นั้\"...\" çæññøt þë µsëð wïth æñ µñpæçkëð TypeVarTuple ør tupleẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "ellipsisContext": "[Y4jK3][นั้\"...\" ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまนั้ढूँ]", "ellipsisSecondArg": "[pvXJA][นั้\"...\" ïs ælløwëð øñlÿ æs thë sëçøñð øf twø ærgµmëñtsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "enumClassOverride": "[2JsL1][นั้Ëñµm çlæss \"{ñæmë}\" ïs fïñæl æñð çæññøt þë sµþçlæssëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "enumMemberDelete": "[5wmRY][นั้Ëñµm mëmþër \"{ñæmë}\" çæññøt þë ðëlëtëðẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "enumMemberSet": "[mBLro][นั้Ëñµm mëmþër \"{ñæmë}\" çæññøt þë æssïgñëðẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "enumMemberTypeAnnotation": "[z8FaL][นั้Tÿpë æññøtætïøñs ærë ñøt ælløwëð før ëñµm mëmþërsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "enumClassOverride": "[2JsL1][นั้Enum çlæss \"{ñæmë}\" ïs final æñð çæññøt þë sµþçlæssëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "enumMemberDelete": "[5wmRY][นั้Enum mëmþër \"{ñæmë}\" çæññøt þë ðëlëtëðẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "enumMemberSet": "[mBLro][นั้Enum mëmþër \"{ñæmë}\" çæññøt þë æssïgñëðẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "enumMemberTypeAnnotation": "[z8FaL][นั้Tÿpë æññøtætïøñs ærë ñøt ælløwëð før enum mëmþërsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "exceptionGroupIncompatible": "[d0SLP][นั้Ëxçëptïøñ grøµp sÿñtæx (\"except*\") rëqµïrës Pÿthøñ 3.11 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "exceptionGroupTypeIncorrect": "[Kanvz][นั้Ëxçëptïøñ tÿpë ïñ except* çæññøt ðërïvë frøm BaseGroupExceptionẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "exceptionTypeIncorrect": "[G7AZt][นั้\"{tÿpë}\" ðøës ñøt ðërïvë frøm ßæsëËxçëptïøñẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "exceptionTypeIncorrect": "[G7AZt][นั้\"{tÿpë}\" ðøës ñøt ðërïvë frøm BaseExceptionẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", "exceptionTypeNotClass": "[v1FmY][นั้\"{tÿpë}\" ïs ñøt æ vælïð ëxçëptïøñ çlæssẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "exceptionTypeNotInstantiable": "[PfdeG][นั้Çøñstrµçtør før ëxçëptïøñ tÿpë \"{tÿpë}\" rëqµïrës øñë ør mørë ærgµmëñtsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", "expectedAfterDecorator": "[rzMVF][นั้Ëxpëçtëð fµñçtïøñ ør çlæss ðëçlærætïøñ æftër ðëçørætørẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "expectedArrow": "[DrZKr][นั้Ëxpëçtëð \"->\" følløwëð þÿ rëtµrñ tÿpë æññøtætïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "expectedAsAfterException": "[FDdTe][นั้Ëxpëçtëð \"æs\" æftër ëxçëptïøñ tÿpëẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "expectedAsAfterException": "[FDdTe][นั้Ëxpëçtëð \"as\" æftër ëxçëptïøñ tÿpëẤğ倪İЂҰक्र्तिृまนั้ढूँ]", "expectedAssignRightHandExpr": "[mPzHP][นั้Ëxpëçtëð ëxprëssïøñ tø thë rïght øf \"=\"Ấğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "expectedBinaryRightHandExpr": "[MgqnF][นั้Ëxpëçtëð ëxprëssïøñ tø thë rïght øf øpërætørẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "expectedBoolLiteral": "[bhZAe][นั้Ëxpëçtëð True ør FalseẤğ倪İЂҰक्र्นั้ढूँ]", - "expectedCase": "[kQ1sa][นั้Ëxpëçtëð \"çæsë\" stætëmëñtẤğ倪İЂҰक्र्นั้ढूँ]", + "expectedCase": "[kQ1sa][นั้Ëxpëçtëð \"case\" stætëmëñtẤğ倪İЂҰक्र्นั้ढूँ]", "expectedClassName": "[f0XRc][นั้Ëxpëçtëð çlæss ñæmëẤğ倪İЂҰक्นั้ढूँ]", "expectedCloseBrace": "[MQHKY][นั้\"{\" wæs ñøt çløsëðẤğ倪İЂҰक्นั้ढूँ]", "expectedCloseBracket": "[YfM0n][นั้\"[\" wæs ñøt çløsëðẤğ倪İЂҰक्นั้ढूँ]", @@ -178,24 +178,24 @@ "expectedDecoratorExpr": "[415JG][นั้Ëxprëssïøñ førm ñøt sµppørtëð før ðëçørætør prïør tø Pÿthøñ 3.9Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "expectedDecoratorName": "[IKO4m][นั้Ëxpëçtëð ðëçørætør ñæmëẤğ倪İЂҰक्र्นั้ढूँ]", "expectedDecoratorNewline": "[Bsyx3][นั้Ëxpëçtëð ñëw lïñë æt ëñð øf ðëçørætørẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "expectedDelExpr": "[u8JgL][นั้Ëxpëçtëð ëxprëssïøñ æftër \"ðël\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]", - "expectedElse": "[eROaU][นั้Ëxpëçtëð \"ëlsë\"Ấğ倪İЂҰนั้ढूँ]", + "expectedDelExpr": "[u8JgL][นั้Ëxpëçtëð ëxprëssïøñ æftër \"del\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]", + "expectedElse": "[eROaU][นั้Ëxpëçtëð \"else\"Ấğ倪İЂҰนั้ढूँ]", "expectedEquals": "[TXK4x][นั้Ëxpëçtëð \"=\"Ấğ倪İЂนั้ढूँ]", "expectedExceptionClass": "[sYtUr][นั้Ïñvælïð ëxçëptïøñ çlæss ør øþjëçtẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "expectedExceptionObj": "[w4tAQ][นั้Ëxpëçtëð ëxçëptïøñ øþjëçt, ëxçëptïøñ çlæss ør ÑøñëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "expectedExceptionObj": "[w4tAQ][นั้Ëxpëçtëð ëxçëptïøñ øþjëçt, ëxçëptïøñ çlæss ør NoneẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "expectedExpr": "[iKSsw][นั้Ëxpëçtëð ëxprëssïøñẤğ倪İЂҰक्นั้ढूँ]", - "expectedFunctionAfterAsync": "[fWBMb][นั้Ëxpëçtëð fµñçtïøñ ðëfïñïtïøñ æftër \"æsÿñç\"Ấğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "expectedFunctionName": "[cR036][นั้Ëxpëçtëð fµñçtïøñ ñæmë æftër \"ðëf\"Ấğ倪İЂҰक्र्तिृまนั้ढूँ]", + "expectedFunctionAfterAsync": "[fWBMb][นั้Ëxpëçtëð fµñçtïøñ ðëfïñïtïøñ æftër \"async\"Ấğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "expectedFunctionName": "[cR036][นั้Ëxpëçtëð fµñçtïøñ ñæmë æftër \"def\"Ấğ倪İЂҰक्र्तिृまนั้ढूँ]", "expectedIdentifier": "[Lj4l5][นั้Ëxpëçtëð ïðëñtïfïërẤğ倪İЂҰक्นั้ढूँ]", - "expectedImport": "[FNK2F][นั้Ëxpëçtëð \"ïmpørt\"Ấğ倪İЂҰक्นั้ढूँ]", - "expectedImportAlias": "[mb4fF][นั้Ëxpëçtëð sÿmþøl æftër \"æs\"Ấğ倪İЂҰक्र्นั้ढूँ]", - "expectedImportSymbols": "[QUZ7S][นั้Ëxpëçtëð øñë ør mørë sÿmþøl ñæmës æftër ïmpørtẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "expectedIn": "[9XkiC][นั้Ëxpëçtëð \"ïñ\"Ấğ倪İЂนั้ढूँ]", - "expectedInExpr": "[RXryp][นั้Ëxpëçtëð ëxprëssïøñ æftër \"ïñ\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]", + "expectedImport": "[FNK2F][นั้Ëxpëçtëð \"import\"Ấğ倪İЂҰक्นั้ढूँ]", + "expectedImportAlias": "[mb4fF][นั้Ëxpëçtëð sÿmþøl æftër \"as\"Ấğ倪İЂҰक्र्นั้ढूँ]", + "expectedImportSymbols": "[QUZ7S][นั้Ëxpëçtëð øñë ør mørë sÿmþøl ñæmës æftër \"import\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "expectedIn": "[9XkiC][นั้Ëxpëçtëð \"in\"Ấğ倪İЂนั้ढूँ]", + "expectedInExpr": "[RXryp][นั้Ëxpëçtëð ëxprëssïøñ æftër \"in\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]", "expectedIndentedBlock": "[7ZvJC][นั้Ëxpëçtëð ïñðëñtëð þløçkẤğ倪İЂҰक्र्นั้ढूँ]", "expectedMemberName": "[VvTAF][นั้Ëxpëçtëð ættrïþµtë ñæmë æftër \".\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]", "expectedModuleName": "[Jky7g][นั้Ëxpëçtëð møðµlë ñæmëẤğ倪İЂҰक्นั้ढूँ]", - "expectedNameAfterAs": "[KnNbR][นั้Ëxpëçtëð sÿmþøl ñæmë æftër \"æs\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]", + "expectedNameAfterAs": "[KnNbR][นั้Ëxpëçtëð sÿmþøl ñæmë æftër \"as\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]", "expectedNamedParameter": "[ZsE8l][นั้Këÿwørð pæræmëtër mµst følløw \"*\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]", "expectedNewline": "[bW0cY][นั้Ëxpëçtëð ñëwlïñëẤğ倪İЂҰนั้ढूँ]", "expectedNewlineOrSemicolon": "[av2Gz][นั้§tætëmëñts mµst þë sëpærætëð þÿ ñëwlïñës ør sëmïçøløñsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", @@ -203,22 +203,22 @@ "expectedParamName": "[b0il7][นั้Ëxpëçtëð pæræmëtër ñæmëẤğ倪İЂҰक्र्นั้ढूँ]", "expectedPatternExpr": "[76AU4][นั้Ëxpëçtëð pættërñ ëxprëssïøñẤğ倪İЂҰक्र्तिृนั้ढूँ]", "expectedPatternSubjectExpr": "[GUw9q][นั้Ëxpëçtëð pættërñ sµþjëçt ëxprëssïøñẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "expectedPatternValue": "[Ah06c][นั้Ëxpëçtëð pættërñ vælµë ëxprëssïøñ øf thë førm \"æ.þ\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "expectedReturnExpr": "[nyeYf][นั้Ëxpëçtëð ëxprëssïøñ æftër \"rëtµrñ\"Ấğ倪İЂҰक्र्तिृまนั้ढूँ]", + "expectedPatternValue": "[Ah06c][นั้Ëxpëçtëð pættërñ vælµë ëxprëssïøñ øf thë førm \"a.b\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "expectedReturnExpr": "[nyeYf][นั้Ëxpëçtëð ëxprëssïøñ æftër \"return\"Ấğ倪İЂҰक्र्तिृまนั้ढूँ]", "expectedSliceIndex": "[0HjFA][นั้Ëxpëçtëð ïñðëx ør slïçë ëxprëssïøñẤğ倪İЂҰक्र्तिृまนั้ढूँ]", "expectedTypeNotString": "[FXeAr][นั้Ëxpëçtëð tÿpë þµt rëçëïvëð æ strïñg lïtërælẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", "expectedTypeParameterName": "[aHX5Q][นั้Ëxpëçtëð tÿpë pæræmëtër ñæmëẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "expectedYieldExpr": "[TrB0N][นั้Ëxpëçtëð ëxprëssïøñ ïñ ÿïëlð stætëmëñtẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "finalClassIsAbstract": "[qEcDN][นั้Çlæss \"{tÿpë}\" ïs mærkëð fïñæl æñð mµst ïmplëmëñt æll æþstræçt sÿmþølsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "finalContext": "[KT2Ma][นั้\"Fïñæl\" ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "finalInLoop": "[yUnYn][นั้Æ \"Fïñæl\" værïæþlë çæññøt þë æssïgñëð wïthïñ æ løøpẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "finalMethodOverride": "[rVyi2][นั้Mëthøð \"{ñæmë}\" çæññøt øvërrïðë fïñæl mëthøð ðëfïñëð ïñ çlæss \"{çlæssÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "finalNonMethod": "[ITFlU][นั้Fµñçtïøñ \"{ñæmë}\" çæññøt þë mærkëð @fïñæl þëçæµsë ït ïs ñøt æ mëthøðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "finalReassigned": "[fgpqP][นั้\"{ñæmë}\" ïs ðëçlærëð æs Fïñæl æñð çæññøt þë rëæssïgñëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "finalRedeclaration": "[8jVSa][นั้\"{ñæmë}\" wæs prëvïøµslÿ ðëçlærëð æs FïñælẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "finalRedeclarationBySubclass": "[0VswQ][นั้\"{ñæmë}\" çæññøt þë rëðëçlærëð þëçæµsë pærëñt çlæss \"{çlæssÑæmë}\" ðëçlærës ït æs FïñælẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "finalTooManyArgs": "[9fleE][นั้Ëxpëçtëð æ sïñglë tÿpë ærgµmëñt æftër \"Fïñæl\"Ấğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "finalUnassigned": "[PmdtN][นั้\"{ñæmë}\" ïs ðëçlærëð Fïñæl, þµt vælµë ïs ñøt æssïgñëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "expectedYieldExpr": "[TrB0N][นั้Ëxpëçtëð ëxprëssïøñ ïñ yield stætëmëñtẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "finalClassIsAbstract": "[qEcDN][นั้Çlæss \"{tÿpë}\" ïs mærkëð final æñð mµst ïmplëmëñt æll æþstræçt sÿmþølsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "finalContext": "[KT2Ma][นั้\"Final\" ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "finalInLoop": "[yUnYn][นั้Æ \"Final\" værïæþlë çæññøt þë æssïgñëð wïthïñ æ løøpẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "finalMethodOverride": "[rVyi2][นั้Mëthøð \"{ñæmë}\" çæññøt øvërrïðë final mëthøð ðëfïñëð ïñ çlæss \"{çlæssÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "finalNonMethod": "[ITFlU][นั้Fµñçtïøñ \"{ñæmë}\" çæññøt þë mærkëð @final þëçæµsë ït ïs ñøt æ mëthøðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "finalReassigned": "[fgpqP][นั้\"{ñæmë}\" ïs ðëçlærëð æs Final æñð çæññøt þë rëæssïgñëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "finalRedeclaration": "[8jVSa][นั้\"{ñæmë}\" wæs prëvïøµslÿ ðëçlærëð æs FinalẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "finalRedeclarationBySubclass": "[0VswQ][นั้\"{ñæmë}\" çæññøt þë rëðëçlærëð þëçæµsë pærëñt çlæss \"{çlæssÑæmë}\" ðëçlærës ït æs FinalẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "finalTooManyArgs": "[9fleE][นั้Ëxpëçtëð æ sïñglë tÿpë ærgµmëñt æftër \"Final\"Ấğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "finalUnassigned": "[PmdtN][นั้\"{ñæmë}\" ïs ðëçlærëð Final, þµt vælµë ïs ñøt æssïgñëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "formatStringBrace": "[j606J][นั้§ïñglë çløsë þræçë ñøt ælløwëð wïthïñ f-strïñg lïtëræl; µsë ðøµþlë çløsë þræçëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", "formatStringBytes": "[1Xo44][นั้Førmæt strïñg lïtëræls (f-strïñgs) çæññøt þë þïñærÿẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "formatStringDebuggingIllegal": "[mQueA][นั้F-strïñg ðëþµggïñg spëçïfïër \"=\" rëqµïrës Pÿthøñ 3.8 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", @@ -231,23 +231,23 @@ "formatStringUnicode": "[RCCfD][นั้Førmæt strïñg lïtëræls (f-strïñgs) çæññøt þë µñïçøðëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "formatStringUnterminated": "[PnOZr][นั้Üñtërmïñætëð ëxprëssïøñ ïñ f-strïñg; ëxpëçtïñg \"}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "functionDecoratorTypeUnknown": "[Gv66U][นั้Üñtÿpëð fµñçtïøñ ðëçørætør øþsçµrës tÿpë øf fµñçtïøñ; ïgñørïñg ðëçørætørẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "functionInConditionalExpression": "[9A68n][นั้Çøñðïtïøñæl ëxprëssïøñ rëfërëñçës fµñçtïøñ whïçh ælwæÿs ëvælµætës tø TrµëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "functionInConditionalExpression": "[9A68n][นั้Çøñðïtïøñæl ëxprëssïøñ rëfërëñçës fµñçtïøñ whïçh ælwæÿs ëvælµætës tø TrueẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", "functionTypeParametersIllegal": "[0JM96][นั้Fµñçtïøñ tÿpë pæræmëtër sÿñtæx rëqµïrës Pÿthøñ 3.12 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "futureImportLocationNotAllowed": "[IdoQY][นั้Ïmpørts frøm __fµtµrë__ mµst þë æt thë þëgïññïñg øf thë fïlëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "generatorAsyncReturnType": "[dYKl9][นั้Rëtµrñ tÿpë øf æsÿñç gëñërætør fµñçtïøñ mµst þë çømpætïþlë wïth \"ÆsÿñçGëñërætør[{ÿïëlðTÿpë}, Æñÿ]\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "futureImportLocationNotAllowed": "[IdoQY][นั้Ïmpørts frøm __future__ mµst þë æt thë þëgïññïñg øf thë fïlëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "generatorAsyncReturnType": "[dYKl9][นั้Rëtµrñ tÿpë øf async gëñërætør fµñçtïøñ mµst þë çømpætïþlë wïth \"AsyncGenerator[{yieldType}, Any]\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "generatorNotParenthesized": "[WmWZM][นั้Gëñërætør ëxprëssïøñs mµst þë pærëñthësïzëð ïf ñøt sølë ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "generatorSyncReturnType": "[ASD1z][นั้Rëtµrñ tÿpë øf gëñërætør fµñçtïøñ mµst þë çømpætïþlë wïth \"Gëñërætør[{ÿïëlðTÿpë}, Æñÿ, Æñÿ]\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "genericBaseClassNotAllowed": "[fniUT][นั้\"Gëñërïç\" þæsë çlæss çæññøt þë µsëð wïth tÿpë pæræmëtër sÿñtæxẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "generatorSyncReturnType": "[ASD1z][นั้Rëtµrñ tÿpë øf gëñërætør fµñçtïøñ mµst þë çømpætïþlë wïth \"Generator[{yieldType}, Any, Any]\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "genericBaseClassNotAllowed": "[fniUT][นั้\"Generic\" þæsë çlæss çæññøt þë µsëð wïth tÿpë pæræmëtër sÿñtæxẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "genericClassAssigned": "[iU1tH][นั้Gëñërïç çlæss tÿpë çæññøt þë æssïgñëðẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", "genericClassDeleted": "[C942e][นั้Gëñërïç çlæss tÿpë çæññøt þë ðëlëtëðẤğ倪İЂҰक्र्तिृまนั้ढूँ]", "genericInstanceVariableAccess": "[rpanq][นั้Æççëss tø gëñërïç ïñstæñçë værïæþlë thrøµgh çlæss ïs æmþïgµøµsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "genericNotAllowed": "[vnF07][นั้\"Gëñërïç\" ïs ñøt vælïð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "genericNotAllowed": "[vnF07][นั้\"Generic\" ïs ñøt vælïð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", "genericTypeAliasBoundTypeVar": "[S1NAS][นั้Gëñërïç tÿpë ælïæs wïthïñ çlæss çæññøt µsë þøµñð tÿpë værïæþlës {ñæmës}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "genericTypeArgMissing": "[OlCEv][นั้\"Gëñërïç\" rëqµïrës æt lëæst øñë tÿpë ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "genericTypeArgTypeVar": "[09E7H][นั้Tÿpë ærgµmëñt før \"Gëñërïç\" mµst þë æ tÿpë værïæþlëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "genericTypeArgUnique": "[xHwpY][นั้Tÿpë ærgµmëñts før \"Gëñërïç\" mµst þë µñïqµëẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "globalReassignment": "[B2UyK][นั้\"{ñæmë}\" ïs æssïgñëð þëførë gløþæl ðëçlærætïøñẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "globalRedefinition": "[UZSMp][นั้\"{ñæmë}\" wæs ælrëæðÿ ðëçlærëð gløþælẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "genericTypeArgMissing": "[OlCEv][นั้\"Generic\" rëqµïrës æt lëæst øñë tÿpë ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "genericTypeArgTypeVar": "[09E7H][นั้Tÿpë ærgµmëñt før \"Generic\" mµst þë æ tÿpë værïæþlëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "genericTypeArgUnique": "[xHwpY][นั้Tÿpë ærgµmëñts før \"Generic\" mµst þë µñïqµëẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "globalReassignment": "[B2UyK][นั้\"{ñæmë}\" ïs æssïgñëð þëførë global ðëçlærætïøñẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "globalRedefinition": "[UZSMp][นั้\"{ñæmë}\" wæs ælrëæðÿ ðëçlærëð globalẤğ倪İЂҰक्र्तिृまนั้ढूँ]", "implicitStringConcat": "[t0D1l][นั้Ïmplïçït strïñg çøñçætëñætïøñ ñøt ælløwëðẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "importCycleDetected": "[FFPSZ][นั้Çÿçlë ðëtëçtëð ïñ ïmpørt çhæïñẤğ倪İЂҰक्र्तिृนั้ढूँ]", "importDepthExceeded": "[8G4s1][นั้Ïmpørt çhæïñ ðëpth ëxçëëðëð {ðëpth}Ấğ倪İЂҰक्र्तिृまนั้ढूँ]", @@ -257,24 +257,24 @@ "incompatibleMethodOverride": "[i45Ka][นั้Mëthøð \"{ñæmë}\" øvërrïðës çlæss \"{çlæssÑæmë}\" ïñ æñ ïñçømpætïþlë mæññërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", "inconsistentIndent": "[gdrcy][นั้Üñïñðëñt æmøµñt ðøës ñøt mætçh prëvïøµs ïñðëñtẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "inconsistentTabs": "[I3Z6K][นั้Ïñçøñsïstëñt µsë øf tæþs æñð spæçës ïñ ïñðëñtætïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "initMethodSelfParamTypeVar": "[S5RC7][นั้Tÿpë æññøtætïøñ før \"sëlf\" pæræmëtër øf \"__ïñït__\" mëthøð çæññøt çøñtæïñ çlæss-sçøpëð tÿpë værïæþlësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "initMustReturnNone": "[RlXyC][นั้Rëtµrñ tÿpë øf \"__ïñït__\" mµst þë ÑøñëẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "initSubclassCallFailed": "[w22Kh][นั้Ïñçørrëçt këÿwørð ærgµmëñts før __ïñït_sµþçlæss__ mëthøðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "initSubclassClsParam": "[6CWuS][นั้__ïñït_sµþçlæss__ øvërrïðë shøµlð tækë æ \"çls\" pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "initVarNotAllowed": "[Bb6V0][นั้\"ÏñïtVær\" ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "instanceMethodSelfParam": "[dPZPj][นั้Ïñstæñçë mëthøðs shøµlð tækë æ \"sëlf\" pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "initMethodSelfParamTypeVar": "[S5RC7][นั้Tÿpë æññøtætïøñ før \"self\" pæræmëtër øf \"__init__\" mëthøð çæññøt çøñtæïñ çlæss-sçøpëð tÿpë værïæþlësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "initMustReturnNone": "[RlXyC][นั้Rëtµrñ tÿpë øf \"__init__\" mµst þë NoneẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "initSubclassCallFailed": "[w22Kh][นั้Ïñçørrëçt këÿwørð ærgµmëñts før __init_subclass__ mëthøðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "initSubclassClsParam": "[6CWuS][นั้__init_subclass__ øvërrïðë shøµlð tækë æ \"cls\" pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "initVarNotAllowed": "[Bb6V0][นั้\"InitVar\" ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "instanceMethodSelfParam": "[dPZPj][นั้Ïñstæñçë mëthøðs shøµlð tækë æ \"self\" pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", "instanceVarOverridesClassVar": "[cfYeg][นั้Ïñstæñçë værïæþlë \"{ñæmë}\" øvërrïðës çlæss værïæþlë øf sæmë ñæmë ïñ çlæss \"{çlæssÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "instantiateAbstract": "[IyeLb][นั้Çæññøt ïñstæñtïætë æþstræçt çlæss \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "instantiateProtocol": "[Xa6p2][นั้Çæññøt ïñstæñtïætë prøtøçøl çlæss \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "instantiateProtocol": "[Xa6p2][นั้Çæññøt ïñstæñtïætë Protocol çlæss \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", "internalBindError": "[PnkgK][นั้Æñ ïñtërñæl ërrør øççµrrëð whïlë þïñðïñg fïlë \"{fïlë}\": {mëssægë}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "internalParseError": "[T91nL][นั้Æñ ïñtërñæl ërrør øççµrrëð whïlë pærsïñg fïlë \"{fïlë}\": {mëssægë}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "internalTypeCheckingError": "[9E5Bn][นั้Æñ ïñtërñæl ërrør øççµrrëð whïlë tÿpë çhëçkïñg fïlë \"{fïlë}\": {mëssægë}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", "invalidIdentifierChar": "[Vpy5i][นั้Ïñvælïð çhæræçtër ïñ ïðëñtïfïërẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "invalidStubStatement": "[sxuu1][นั้§tætëmëñt ïs mëæñïñglëss wïthïñ æ tÿpë stµþ fïlëẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "invalidStubStatement": "[sxuu1][นั้§tætëmëñt ïs mëæñïñglëss wïthïñ æ tÿpë stub fïlëẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", "invalidTokenChars": "[n9Jty][นั้Ïñvælïð çhæræçtër \"{tëxt}\" ïñ tøkëñẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "isInstanceInvalidType": "[Q3jK3][นั้§ëçøñð ærgµmëñt tø \"ïsïñstæñçë\" mµst þë æ çlæss ør tµplë øf çlæssësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "isSubclassInvalidType": "[6Q7qf][นั้§ëçøñð ærgµmëñt tø \"ïssµþçlæss\" mµst þë æ çlæss ør tµplë øf çlæssësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "keyValueInSet": "[tmmyt][นั้Këÿ/vælµë pæïrs ærë ñøt ælløwëð wïthïñ æ sëtẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "isInstanceInvalidType": "[Q3jK3][นั้§ëçøñð ærgµmëñt tø \"isinstance\" mµst þë æ çlæss ør tuple øf çlæssësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "isSubclassInvalidType": "[6Q7qf][นั้§ëçøñð ærgµmëñt tø \"issubclass\" mµst þë æ çlæss ør tuple øf çlæssësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "keyValueInSet": "[tmmyt][นั้Këÿ/vælµë pæïrs ærë ñøt ælløwëð wïthïñ æ setẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "keywordArgInTypeArgument": "[BzcKx][นั้Këÿwørð ærgµmëñts çæññøt þë µsëð ïñ tÿpë ærgµmëñt lïstsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "keywordArgShortcutIllegal": "[KU0tn][นั้Këÿwørð ærgµmëñt shørtçµt rëqµïrës Pÿthøñ 3.14 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "keywordOnlyAfterArgs": "[RLvT4][นั้Këÿwørð-øñlÿ ærgµmëñt sëpærætør ñøt ælløwëð æftër \"*\" pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", @@ -283,14 +283,14 @@ "lambdaReturnTypePartiallyUnknown": "[Z5ML1][นั้Rëtµrñ tÿpë øf læmþðæ, \"{rëtµrñTÿpë}\", ïs pærtïællÿ µñkñøwñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "lambdaReturnTypeUnknown": "[h4icY][นั้Rëtµrñ tÿpë øf læmþðæ ïs µñkñøwñẤğ倪İЂҰक्र्तिृนั้ढूँ]", "listAssignmentMismatch": "[DZh64][นั้Ëxprëssïøñ wïth tÿpë \"{tÿpë}\" çæññøt þë æssïgñëð tø tærgët lïstẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "listInAnnotation": "[i5U8t][นั้£ïst ëxprëssïøñ ñøt ælløwëð ïñ tÿpë æññøtætïøñẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "literalEmptyArgs": "[VkrFm][นั้Ëxpëçtëð øñë ør mørë tÿpë ærgµmëñts æftër \"£ïtëræl\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "literalNamedUnicodeEscape": "[8cbe7][นั้Ñæmëð µñïçøðë ësçæpë sëqµëñçës ærë ñøt sµppørtëð ïñ \"£ïtëræl\" strïñg æññøtætïøñsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "literalNotAllowed": "[FAk6E][นั้\"£ïtëræl\" çæññøt þë µsëð ïñ thïs çøñtëxt wïthøµt æ tÿpë ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "literalNotCallable": "[C75sx][นั้£ïtëræl tÿpë çæññøt þë ïñstæñtïætëðẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "literalUnsupportedType": "[10Yse][นั้Tÿpë ærgµmëñts før \"£ïtëræl\" mµst þë Ñøñë, æ lïtëræl vælµë (ïñt, þøøl, str, ør þÿtës), ør æñ ëñµm vælµëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "matchIncompatible": "[9ljpM][นั้Mætçh stætëmëñts rëqµïrë Pÿthøñ 3.10 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "matchIsNotExhaustive": "[BJ8EI][นั้Çæsës wïthïñ mætçh stætëmëñt ðø ñøt ëxhæµstïvëlÿ hæñðlë æll vælµësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "listInAnnotation": "[i5U8t][นั้List ëxprëssïøñ ñøt ælløwëð ïñ tÿpë ëxprëssïøñẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "literalEmptyArgs": "[VkrFm][นั้Ëxpëçtëð øñë ør mørë tÿpë ærgµmëñts æftër \"Literal\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "literalNamedUnicodeEscape": "[8cbe7][นั้Ñæmëð µñïçøðë ësçæpë sëqµëñçës ærë ñøt sµppørtëð ïñ \"Literal\" strïñg æññøtætïøñsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "literalNotAllowed": "[FAk6E][นั้\"Literal\" çæññøt þë µsëð ïñ thïs çøñtëxt wïthøµt æ tÿpë ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "literalNotCallable": "[C75sx][นั้Literal tÿpë çæññøt þë ïñstæñtïætëðẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "literalUnsupportedType": "[10Yse][นั้Tÿpë ærgµmëñts før \"Literal\" mµst þë None, æ lïtëræl vælµë (int, bool, str, ør bytes), ør æñ enum vælµëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "matchIncompatible": "[9ljpM][นั้Match stætëmëñts rëqµïrë Pÿthøñ 3.10 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "matchIsNotExhaustive": "[BJ8EI][นั้Çæsës wïthïñ match stætëmëñt ðø ñøt ëxhæµstïvëlÿ hæñðlë æll vælµësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "maxParseDepthExceeded": "[5nAZx][นั้Mæxïmµm pærsë ðëpth ëxçëëðëð; þrëæk ëxprëssïøñ ïñtø smællër sµþ-ëxprëssïøñsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "memberAccess": "[YP5V0][นั้Çæññøt æççëss ættrïþµtë \"{ñæmë}\" før çlæss \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "memberDelete": "[o47cn][นั้Çæññøt ðëlëtë ættrïþµtë \"{ñæmë}\" før çlæss \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", @@ -304,45 +304,46 @@ "methodOverridden": "[2Bu15][นั้\"{ñæmë}\" øvërrïðës mëthøð øf sæmë ñæmë ïñ çlæss \"{çlæssÑæmë}\" wïth ïñçømpætïþlë tÿpë \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "methodReturnsNonObject": "[9nnVb][นั้\"{ñæmë}\" mëthøð ðøës ñøt rëtµrñ æñ øþjëçtẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "missingSuperCall": "[jNXGA][นั้Mëthøð \"{mëthøðÑæmë}\" ðøës ñøt çæll thë mëthøð øf thë sæmë ñæmë ïñ pærëñt çlæssẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "mixingBytesAndStr": "[Ng6gL][นั้Bytes æñð str vælµës çæññøt þë çøñçætëñætëðẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", "moduleAsType": "[p9N4B][นั้Møðµlë çæññøt þë µsëð æs æ tÿpëẤğ倪İЂҰक्र्तिृนั้ढूँ]", "moduleNotCallable": "[YY0Jq][นั้Møðµlë ïs ñøt çællæþlëẤğ倪İЂҰक्र्นั้ढूँ]", "moduleUnknownMember": "[tegoa][นั้\"{mëmþërÑæmë}\" ïs ñøt æ kñøwñ ættrïþµtë øf møðµlë \"{møðµlëÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "namedExceptAfterCatchAll": "[pMR1l][นั้Æ ñæmëð ëxçëpt çlæµsë çæññøt æppëær æftër çætçh-æll ëxçëpt çlæµsëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "namedParamAfterParamSpecArgs": "[sF38r][นั้Këÿwørð pæræmëtër \"{ñæmë}\" çæññøt æppëær ïñ sïgñætµrë æftër Pæræm§pëç ærgs pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "namedTupleEmptyName": "[vnXqF][นั้Ñæmës wïthïñ æ ñæmëð tµplë çæññøt þë ëmptÿẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "namedTupleEntryRedeclared": "[0tiaC][นั้Çæññøt øvërrïðë \"{ñæmë}\" þëçæµsë pærëñt çlæss \"{çlæssÑæmë}\" ïs æ ñæmëð tµplëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "namedTupleFirstArg": "[L5ZXq][นั้Ëxpëçtëð ñæmëð tµplë çlæss ñæmë æs fïrst ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "namedTupleMultipleInheritance": "[KYJOA][นั้Mµltïplë ïñhërïtæñçë wïth ÑæmëðTµplë ïs ñøt sµppørtëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "namedExceptAfterCatchAll": "[pMR1l][นั้Æ ñæmëð except çlæµsë çæññøt æppëær æftër çætçh-æll except çlæµsëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "namedParamAfterParamSpecArgs": "[sF38r][นั้Këÿwørð pæræmëtër \"{ñæmë}\" çæññøt æppëær ïñ sïgñætµrë æftër ParamSpec args pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "namedTupleEmptyName": "[vnXqF][นั้Ñæmës wïthïñ æ ñæmëð tuple çæññøt þë ëmptÿẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "namedTupleEntryRedeclared": "[0tiaC][นั้Çæññøt øvërrïðë \"{ñæmë}\" þëçæµsë pærëñt çlæss \"{çlæssÑæmë}\" ïs æ ñæmëð tupleẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "namedTupleFirstArg": "[L5ZXq][นั้Ëxpëçtëð ñæmëð tuple çlæss ñæmë æs fïrst ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "namedTupleMultipleInheritance": "[KYJOA][นั้Mµltïplë ïñhërïtæñçë wïth NamedTuple ïs ñøt sµppørtëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "namedTupleNameKeyword": "[g6NTa][นั้Fïëlð ñæmës çæññøt þë æ këÿwørðẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "namedTupleNameType": "[AxfdS][นั้Ëxpëçtëð twø-ëñtrÿ tµplë spëçïfÿïñg ëñtrÿ ñæmë æñð tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "namedTupleNameUnique": "[TQaej][นั้Ñæmës wïthïñ æ ñæmëð tµplë mµst þë µñïqµëẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "namedTupleNameType": "[AxfdS][นั้Ëxpëçtëð twø-ëñtrÿ tuple spëçïfÿïñg ëñtrÿ ñæmë æñð tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "namedTupleNameUnique": "[TQaej][นั้Ñæmës wïthïñ æ ñæmëð tuple mµst þë µñïqµëẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "namedTupleNoTypes": "[Fn6FF][นั้\"ñæmëðtµplë\" prøvïðës ñø tÿpës før tµplë ëñtrïës; µsë \"ÑæmëðTµplë\" ïñstëæðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "namedTupleSecondArg": "[SqoXY][นั้Ëxpëçtëð ñæmëð tµplë ëñtrÿ lïst æs sëçøñð ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "newClsParam": "[EUESX][นั้__ñëw__ øvërrïðë shøµlð tækë æ \"çls\" pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "newTypeAnyOrUnknown": "[D4ZjA][นั้Thë sëçøñð ærgµmëñt tø ÑëwTÿpë mµst þë æ kñøwñ çlæss, ñøt Æñÿ ør ÜñkñøwñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "newTypeBadName": "[cqWvO][นั้Thë fïrst ærgµmëñt tø ÑëwTÿpë mµst þë æ strïñg lïtërælẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "newTypeLiteral": "[4k8om][นั้ÑëwTÿpë çæññøt þë µsëð wïth £ïtëræl tÿpëẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "newTypeNameMismatch": "[kQgMv][นั้ÑëwTÿpë mµst þë æssïgñëð tø æ værïæþlë wïth thë sæmë ñæmëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "newTypeNotAClass": "[ta6tZ][นั้Ëxpëçtëð çlæss æs sëçøñð ærgµmëñt tø ÑëwTÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "newTypeParamCount": "[6b2ro][นั้ÑëwTÿpë rëqµïrës twø pøsïtïøñæl ærgµmëñtsẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "newTypeProtocolClass": "[1l02t][นั้ÑëwTÿpë çæññøt þë µsëð wïth strµçtµræl tÿpë (æ prøtøçøl ør TÿpëðÐïçt çlæss)Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "namedTupleSecondArg": "[SqoXY][นั้Ëxpëçtëð ñæmëð tuple ëñtrÿ list æs sëçøñð ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "newClsParam": "[EUESX][นั้__new__ øvërrïðë shøµlð tækë æ \"cls\" pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "newTypeAnyOrUnknown": "[D4ZjA][นั้Thë sëçøñð ærgµmëñt tø NewType mµst þë æ kñøwñ çlæss, ñøt Any ør UnknownẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "newTypeBadName": "[cqWvO][นั้Thë fïrst ærgµmëñt tø NewType mµst þë æ strïñg lïtërælẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "newTypeLiteral": "[4k8om][นั้NewType çæññøt þë µsëð wïth Literal tÿpëẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "newTypeNameMismatch": "[kQgMv][นั้NewType mµst þë æssïgñëð tø æ værïæþlë wïth thë sæmë ñæmëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "newTypeNotAClass": "[ta6tZ][นั้Ëxpëçtëð çlæss æs sëçøñð ærgµmëñt tø NewTypeẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "newTypeParamCount": "[6b2ro][นั้NewType rëqµïrës twø pøsïtïøñæl ærgµmëñtsẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "newTypeProtocolClass": "[1l02t][นั้NewType çæññøt þë µsëð wïth strµçtµræl tÿpë (æ Protocol ør TypedDict çlæss)Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "noOverload": "[IcBNQ][นั้Ñø øvërløæðs før \"{ñæmë}\" mætçh thë prøvïðëð ærgµmëñtsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "noReturnContainsReturn": "[nBLDq][นั้Fµñçtïøñ wïth ðëçlærëð rëtµrñ tÿpë \"ÑøRëtµrñ\" çæññøt ïñçlµðë æ rëtµrñ stætëmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "noReturnContainsYield": "[V3G36][นั้Fµñçtïøñ wïth ðëçlærëð rëtµrñ tÿpë \"ÑøRëtµrñ\" çæññøt ïñçlµðë æ ÿïëlð stætëmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "noReturnReturnsNone": "[O3XA6][นั้Fµñçtïøñ wïth ðëçlærëð rëtµrñ tÿpë \"ÑøRëtµrñ\" çæññøt rëtµrñ \"Ñøñë\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "noReturnContainsReturn": "[nBLDq][นั้Fµñçtïøñ wïth ðëçlærëð return tÿpë \"NoReturn\" çæññøt ïñçlµðë æ return stætëmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "noReturnContainsYield": "[V3G36][นั้Fµñçtïøñ wïth ðëçlærëð rëtµrñ tÿpë \"NoReturn\" çæññøt ïñçlµðë æ yield stætëmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "noReturnReturnsNone": "[O3XA6][นั้Fµñçtïøñ wïth ðëçlærëð rëtµrñ tÿpë \"NoReturn\" çæññøt rëtµrñ \"None\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "nonDefaultAfterDefault": "[mFFgP][นั้Ñøñ-ðëfæµlt ærgµmëñt følløws ðëfæµlt ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "nonLocalInModule": "[kmLlv][นั้Ñøñløçæl ðëçlærætïøñ ñøt ælløwëð æt møðµlë lëvëlẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "nonLocalNoBinding": "[WTA2d][นั้Ñø þïñðïñg før ñøñløçæl \"{ñæmë}\" føµñðẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "nonLocalReassignment": "[T1M6J][นั้\"{ñæmë}\" ïs æssïgñëð þëførë ñøñløçæl ðëçlærætïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "nonLocalRedefinition": "[gwh1h][นั้\"{ñæmë}\" wæs ælrëæðÿ ðëçlærëð ñøñløçælẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "noneNotCallable": "[sIZ5J][นั้Øþjëçt øf tÿpë \"Ñøñë\" çæññøt þë çællëðẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "noneNotIterable": "[spDD0][นั้Øþjëçt øf tÿpë \"Ñøñë\" çæññøt þë µsëð æs ïtëræþlë vælµëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "noneNotSubscriptable": "[Emzwj][นั้Øþjëçt øf tÿpë \"Ñøñë\" ïs ñøt sµþsçrïptæþlëẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "noneNotUsableWith": "[zlOOD][นั้Øþjëçt øf tÿpë \"Ñøñë\" çæññøt þë µsëð wïth \"wïth\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "noneOperator": "[3U0d3][นั้Øpërætør \"{øpërætør}\" ñøt sµppørtëð før \"Ñøñë\"Ấğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "noneUnknownMember": "[4KvEX][นั้\"{ñæmë}\" ïs ñøt æ kñøwñ ættrïþµtë øf \"Ñøñë\"Ấğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "notRequiredArgCount": "[uOeAb][นั้Ëxpëçtëð æ sïñglë tÿpë ærgµmëñt æftër \"ÑøtRëqµïrëð\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "notRequiredNotInTypedDict": "[Vl6XL][นั้\"ÑøtRëqµïrëð\" ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "nonLocalInModule": "[kmLlv][นั้Nonlocal ðëçlærætïøñ ñøt ælløwëð æt møðµlë lëvëlẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "nonLocalNoBinding": "[WTA2d][นั้Ñø þïñðïñg før nonlocal \"{ñæmë}\" føµñðẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "nonLocalReassignment": "[T1M6J][นั้\"{ñæmë}\" ïs æssïgñëð þëførë nonlocal ðëçlærætïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "nonLocalRedefinition": "[gwh1h][นั้\"{ñæmë}\" wæs ælrëæðÿ ðëçlærëð nonlocalẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "noneNotCallable": "[sIZ5J][นั้Øþjëçt øf tÿpë \"None\" çæññøt þë çællëðẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "noneNotIterable": "[spDD0][นั้Øþjëçt øf tÿpë \"None\" çæññøt þë µsëð æs ïtëræþlë vælµëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "noneNotSubscriptable": "[Emzwj][นั้Øþjëçt øf tÿpë \"None\" ïs ñøt sµþsçrïptæþlëẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "noneNotUsableWith": "[zlOOD][นั้Øþjëçt øf tÿpë \"None\" çæññøt þë µsëð with \"with\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "noneOperator": "[3U0d3][นั้Øpërætør \"{øpërætør}\" ñøt sµppørtëð før \"None\"Ấğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "noneUnknownMember": "[4KvEX][นั้\"{ñæmë}\" ïs ñøt æ kñøwñ ættrïþµtë øf \"None\"Ấğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "notRequiredArgCount": "[uOeAb][นั้Ëxpëçtëð æ sïñglë tÿpë ærgµmëñt æftër \"NotRequired\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "notRequiredNotInTypedDict": "[Vl6XL][นั้\"NotRequired\" ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "objectNotCallable": "[bzlKk][นั้Øþjëçt øf tÿpë \"{tÿpë}\" ïs ñøt çællæþlëẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "obscuredClassDeclaration": "[ixjN9][นั้Çlæss ðëçlærætïøñ \"{ñæmë}\" ïs øþsçµrëð þÿ æ ðëçlærætïøñ øf thë sæmë ñæmëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", "obscuredFunctionDeclaration": "[O71DX][นั้Fµñçtïøñ ðëçlærætïøñ \"{ñæmë}\" ïs øþsçµrëð þÿ æ ðëçlærætïøñ øf thë sæmë ñæmëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", @@ -351,43 +352,43 @@ "obscuredTypeAliasDeclaration": "[0GZdR][นั้Tÿpë ælïæs ðëçlærætïøñ \"{ñæmë}\" ïs øþsçµrëð þÿ æ ðëçlærætïøñ øf thë sæmë ñæmëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", "obscuredVariableDeclaration": "[HR10j][นั้Ðëçlærætïøñ \"{ñæmë}\" ïs øþsçµrëð þÿ æ ðëçlærætïøñ øf thë sæmë ñæmëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "operatorLessOrGreaterDeprecated": "[bNZp7][นั้Øpërætør \"<>\" ïs ñøt sµppørtëð ïñ Pÿthøñ 3; µsë \"!=\" ïñstëæðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "optionalExtraArgs": "[yW5W0][นั้Ëxpëçtëð øñë tÿpë ærgµmëñt æftër \"Øptïøñæl\"Ấğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "orPatternIrrefutable": "[peFRW][นั้Ïrrëfµtæþlë pættërñ ælløwëð øñlÿ æs thë læst sµþpættërñ ïñ æñ \"ør\" pættërñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "orPatternMissingName": "[OxMxP][นั้Æll sµþpættërñs wïthïñ æñ \"ør\" pættërñ mµst tærgët thë sæmë ñæmësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "optionalExtraArgs": "[yW5W0][นั้Ëxpëçtëð øñë tÿpë ærgµmëñt æftër \"Optional\"Ấğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "orPatternIrrefutable": "[peFRW][นั้Ïrrëfµtæþlë pættërñ ælløwëð øñlÿ æs thë læst sµþpættërñ ïñ æñ \"or\" pættërñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "orPatternMissingName": "[OxMxP][นั้Æll sµþpættërñs wïthïñ æñ \"or\" pættërñ mµst tærgët thë sæmë ñæmësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "overlappingKeywordArgs": "[46dQE][นั้Tÿpëð ðïçtïøñærÿ øvërlæps wïth këÿwørð pæræmëtër: {ñæmës}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "overlappingOverload": "[SCQMv][นั้Øvërløæð {øþsçµrëð} før \"{ñæmë}\" wïll ñëvër þë µsëð þëçæµsë ïts pæræmëtërs øvërlæp øvërløæð {øþsçµrëðßÿ}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", "overloadAbstractImplMismatch": "[IgMzu][นั้Øvërløæðs mµst mætçh æþstræçt stætµs øf ïmplëmëñtætïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "overloadAbstractMismatch": "[54DCM][นั้Øvërløæðs mµst æll þë æþstræçt ør ñøtẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "overloadClassMethodInconsistent": "[8y6vM][นั้Øvërløæðs før \"{ñæmë}\" µsë @çlæssmëthøð ïñçøñsïstëñtlÿẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "overloadFinalInconsistencyImpl": "[0hpZY][นั้Øvërløæð før \"{ñæmë}\" ïs mærkëð @fïñæl þµt ïmplëmëñtætïøñ ïs ñøtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "overloadFinalInconsistencyNoImpl": "[Z6TSL][นั้Øvërløæð {ïñðëx} før \"{ñæmë}\" ïs mærkëð @fïñæl þµt øvërløæð 1 ïs ñøtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "overloadClassMethodInconsistent": "[8y6vM][นั้Øvërløæðs før \"{ñæmë}\" µsë @classmethod ïñçøñsïstëñtlÿẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "overloadFinalInconsistencyImpl": "[0hpZY][นั้Øvërløæð før \"{ñæmë}\" ïs mærkëð @final þµt ïmplëmëñtætïøñ ïs ñøtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "overloadFinalInconsistencyNoImpl": "[Z6TSL][นั้Øvërløæð {ïñðëx} før \"{ñæmë}\" ïs mærkëð @final þµt øvërløæð 1 ïs ñøtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "overloadImplementationMismatch": "[dXlXE][นั้Øvërløæðëð ïmplëmëñtætïøñ ïs ñøt çøñsïstëñt wïth sïgñætµrë øf øvërløæð {ïñðëx}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", "overloadReturnTypeMismatch": "[6BN74][นั้Øvërløæð {prëvÏñðëx} før \"{ñæmë}\" øvërlæps øvërløæð {ñëwÏñðëx} æñð rëtµrñs æñ ïñçømpætïþlë tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "overloadStaticMethodInconsistent": "[PKQvM][นั้Øvërløæðs før \"{ñæmë}\" µsë @stætïçmëthøð ïñçøñsïstëñtlÿẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "overloadWithoutImplementation": "[mn33a][นั้\"{ñæmë}\" ïs mærkëð æs øvërløæð, þµt ñø ïmplëmëñtætïøñ ïs prøvïðëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "overriddenMethodNotFound": "[YKdBy][นั้Mëthøð \"{ñæmë}\" ïs mærkëð æs øvërrïðë, þµt ñø þæsë mëthøð øf sæmë ñæmë ïs prësëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "overrideDecoratorMissing": "[2BnJq][นั้Mëthøð \"{ñæmë}\" ïs ñøt mærkëð æs øvërrïðë þµt ïs øvërrïðïñg æ mëthøð ïñ çlæss \"{çlæssÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "overloadStaticMethodInconsistent": "[PKQvM][นั้Øvërløæðs før \"{ñæmë}\" µsë @staticmethod ïñçøñsïstëñtlÿẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "overloadWithoutImplementation": "[mn33a][นั้\"{ñæmë}\" ïs mærkëð æs overload, þµt ñø ïmplëmëñtætïøñ ïs prøvïðëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "overriddenMethodNotFound": "[YKdBy][นั้Mëthøð \"{ñæmë}\" ïs mærkëð æs override, þµt ñø þæsë mëthøð øf sæmë ñæmë ïs prësëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "overrideDecoratorMissing": "[2BnJq][นั้Mëthøð \"{ñæmë}\" ïs ñøt mærkëð æs override þµt ïs øvërrïðïñg æ mëthøð ïñ çlæss \"{çlæssÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "paramAfterKwargsParam": "[wJZkp][นั้Pæræmëtër çæññøt følløw \"**\" pæræmëtërẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", "paramAlreadyAssigned": "[srzhT][นั้Pæræmëtër \"{ñæmë}\" ïs ælrëæðÿ æssïgñëðẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", "paramAnnotationMissing": "[1OYGc][นั้Tÿpë æññøtætïøñ ïs mïssïñg før pæræmëtër \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "paramAssignmentMismatch": "[Q8zha][นั้Ëxprëssïøñ øf tÿpë \"{søµrçëTÿpë}\" çæññøt þë æssïgñëð tø pæræmëtër øf tÿpë \"{pæræmTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "paramNameMissing": "[ivXu4][นั้Ñø pæræmëtër ñæmëð \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]", - "paramSpecArgsKwargsUsage": "[oVRV0][นั้\"ærgs\" æñð \"kwærgs\" ættrïþµtës øf Pæræm§pëç mµst þøth æppëær wïthïñ æ fµñçtïøñ sïgñætµrëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "paramSpecArgsMissing": "[rd6zO][นั้Ærgµmëñts før Pæræm§pëç \"{tÿpë}\" ærë mïssïñgẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "paramSpecArgsUsage": "[2U9SN][นั้\"ærgs\" ættrïþµtë øf Pæræm§pëç ïs vælïð øñlÿ whëñ µsëð wïth *ærgs pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "paramSpecAssignedName": "[ww5mM][นั้Pæræm§pëç mµst þë æssïgñëð tø æ værïæþlë ñæmëð \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "paramSpecContext": "[y6xyK][นั้Pæræm§pëç ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "paramSpecDefaultNotTuple": "[6Tdff][นั้Ëxpëçtëð ëllïpsïs, æ tµplë ëxprëssïøñ, ør Pæræm§pëç før ðëfæµlt vælµë øf Pæræm§pëçẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "paramSpecFirstArg": "[W2Y3X][นั้Ëxpëçtëð ñæmë øf Pæræm§pëç æs fïrst ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "paramSpecKwargsUsage": "[2UE71][นั้\"kwærgs\" ættrïþµtë øf Pæræm§pëç ïs vælïð øñlÿ whëñ µsëð wïth **kwærgs pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "paramSpecNotUsedByOuterScope": "[5Pk7H][นั้Pæræm§pëç \"{ñæmë}\" hæs ñø mëæñïñg ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "paramSpecUnknownArg": "[6zeYc][นั้Pæræm§pëç ðøës ñøt sµppørt mørë thæñ øñë ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "paramSpecUnknownMember": "[GhhiY][นั้\"{ñæmë}\" ïs ñøt æ kñøwñ ættrïþµtë øf Pæræm§pëçẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "paramSpecUnknownParam": "[YADLo][นั้\"{ñæmë}\" ïs µñkñøwñ pæræmëtër tø Pæræm§pëçẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "paramSpecArgsKwargsUsage": "[oVRV0][นั้\"args\" æñð \"kwargs\" ættrïþµtës øf ParamSpec mµst þøth æppëær wïthïñ æ fµñçtïøñ sïgñætµrëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "paramSpecArgsMissing": "[rd6zO][นั้Ærgµmëñts før ParamSpec \"{tÿpë}\" ærë mïssïñgẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "paramSpecArgsUsage": "[2U9SN][นั้\"args\" ættrïþµtë øf ParamSpec ïs vælïð øñlÿ whëñ µsëð wïth *args pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "paramSpecAssignedName": "[ww5mM][นั้ParamSpec mµst þë æssïgñëð tø æ værïæþlë ñæmëð \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "paramSpecContext": "[y6xyK][นั้ParamSpec ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "paramSpecDefaultNotTuple": "[6Tdff][นั้Ëxpëçtëð ëllïpsïs, æ tuple ëxprëssïøñ, ør ParamSpec før ðëfæµlt vælµë øf ParamSpecẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "paramSpecFirstArg": "[W2Y3X][นั้Ëxpëçtëð ñæmë øf ParamSpec æs fïrst ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "paramSpecKwargsUsage": "[2UE71][นั้\"kwargs\" ættrïþµtë øf ParamSpec ïs vælïð øñlÿ whëñ µsëð wïth **kwargs pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "paramSpecNotUsedByOuterScope": "[5Pk7H][นั้ParamSpec \"{ñæmë}\" hæs ñø mëæñïñg ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "paramSpecUnknownArg": "[6zeYc][นั้ParamSpec ðøës ñøt sµppørt mørë thæñ øñë ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "paramSpecUnknownMember": "[GhhiY][นั้\"{ñæmë}\" ïs ñøt æ kñøwñ ættrïþµtë øf ParamSpecẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "paramSpecUnknownParam": "[YADLo][นั้\"{ñæmë}\" ïs µñkñøwñ pæræmëtër tø ParamSpecẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", "paramTypeCovariant": "[USAuF][นั้Çøværïæñt tÿpë værïæþlë çæññøt þë µsëð ïñ pæræmëtër tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "paramTypePartiallyUnknown": "[1ShLP][นั้Tÿpë øf pæræmëtër \"{pæræmÑæmë}\" ïs pærtïællÿ µñkñøwñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "paramTypeUnknown": "[fweDh][นั้Tÿpë øf pæræmëtër \"{pæræmÑæmë}\" ïs µñkñøwñẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "parenthesizedContextManagerIllegal": "[NBxCb][นั้Pærëñthësës wïthïñ \"wïth\" stætëmëñt rëqµïrës Pÿthøñ 3.9 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "parenthesizedContextManagerIllegal": "[NBxCb][นั้Pærëñthësës withïñ \"with\" stætëmëñt rëqµïrës Pÿthøñ 3.9 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "patternNeverMatches": "[lyG7p][นั้Pættërñ wïll ñëvër þë mætçhëð før sµþjëçt tÿpë \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "positionArgAfterNamedArg": "[szCz2][นั้Pøsïtïøñæl ærgµmëñt çæññøt æppëær æftër këÿwørð ærgµmëñtsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "positionOnlyAfterArgs": "[Vqb7c][นั้Pøsïtïøñ-øñlÿ pæræmëtër sëpærætør ñøt ælløwëð æftër \"*\" pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", @@ -398,111 +399,112 @@ "privateImportFromPyTypedModule": "[VRdf4][นั้\"{ñæmë}\" ïs ñøt ëxpørtëð frøm møðµlë \"{møðµlë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", "privateUsedOutsideOfClass": "[3YBNL][นั้\"{ñæmë}\" ïs prïvætë æñð µsëð øµtsïðë øf thë çlæss ïñ whïçh ït ïs ðëçlærëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", "privateUsedOutsideOfModule": "[TgDgt][นั้\"{ñæmë}\" ïs prïvætë æñð µsëð øµtsïðë øf thë møðµlë ïñ whïçh ït ïs ðëçlærëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "propertyOverridden": "[mwp5C][นั้\"{ñæmë}\" ïñçørrëçtlÿ øvërrïðës prøpërtÿ øf sæmë ñæmë ïñ çlæss \"{çlæssÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "propertyStaticMethod": "[qs3pr][นั้§tætïç mëthøðs ñøt ælløwëð før prøpërtÿ gëttër, sëttër ør ðëlëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "propertyOverridden": "[mwp5C][นั้\"{ñæmë}\" ïñçørrëçtlÿ øvërrïðës property øf sæmë ñæmë ïñ çlæss \"{çlæssÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "propertyStaticMethod": "[qs3pr][นั้§tætïç mëthøðs ñøt ælløwëð før property getter, setter ør deleterẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "protectedUsedOutsideOfClass": "[z2Y7X][นั้\"{ñæmë}\" ïs prøtëçtëð æñð µsëð øµtsïðë øf thë çlæss ïñ whïçh ït ïs ðëçlærëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "protocolBaseClass": "[lv3rP][นั้Prøtøçøl çlæss \"{çlæssTÿpë}\" çæññøt ðërïvë frøm ñøñ-prøtøçøl çlæss \"{þæsëTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "protocolBaseClassWithTypeArgs": "[tpYEx][นั้Tÿpë ærgµmëñts ærë ñøt ælløwëð wïth Prøtøçøl çlæss whëñ µsïñg tÿpë pæræmëtër sÿñtæxẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "protocolIllegal": "[jYjYe][นั้Üsë øf \"Prøtøçøl\" rëqµïrës Pÿthøñ 3.7 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "protocolNotAllowed": "[2GEt6][นั้\"Prøtøçøl\" çæññøt þë µsëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "protocolTypeArgMustBeTypeParam": "[WTgkM][นั้Tÿpë ærgµmëñt før \"Prøtøçøl\" mµst þë æ tÿpë pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "protocolBaseClass": "[lv3rP][นั้Protocol çlæss \"{çlæssTÿpë}\" çæññøt ðërïvë frøm ñøñ-Protocol çlæss \"{þæsëTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "protocolBaseClassWithTypeArgs": "[tpYEx][นั้Tÿpë ærgµmëñts ærë ñøt ælløwëð wïth Protocol çlæss whëñ µsïñg tÿpë pæræmëtër sÿñtæxẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "protocolIllegal": "[jYjYe][นั้Üsë øf \"Protocol\" rëqµïrës Pÿthøñ 3.7 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "protocolNotAllowed": "[2GEt6][นั้\"Protocol\" çæññøt þë µsëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "protocolTypeArgMustBeTypeParam": "[WTgkM][นั้Tÿpë ærgµmëñt før \"Protocol\" mµst þë æ tÿpë pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "protocolUnsafeOverlap": "[79LbC][นั้Çlæss øvërlæps \"{ñæmë}\" µñsæfëlÿ æñð çøµlð prøðµçë æ mætçh æt rµñtïmëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "protocolVarianceContravariant": "[B4htZ][นั้Tÿpë værïæþlë \"{værïæþlë}\" µsëð ïñ gëñërïç prøtøçøl \"{çlæss}\" shøµlð þë çøñtræværïæñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "protocolVarianceCovariant": "[Hcnn5][นั้Tÿpë værïæþlë \"{værïæþlë}\" µsëð ïñ gëñërïç prøtøçøl \"{çlæss}\" shøµlð þë çøværïæñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "protocolVarianceInvariant": "[o8oB7][นั้Tÿpë værïæþlë \"{værïæþlë}\" µsëð ïñ gëñërïç prøtøçøl \"{çlæss}\" shøµlð þë ïñværïæñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "pyrightCommentInvalidDiagnosticBoolValue": "[eaJY0][นั้Pÿrïght çømmëñt ðïrëçtïvë mµst þë følløwëð þÿ \"=\" æñð æ vælµë øf trµë ør fælsëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "pyrightCommentInvalidDiagnosticSeverityValue": "[2YA7K][นั้Pÿrïght çømmëñt ðïrëçtïvë mµst þë følløwëð þÿ \"=\" æñð æ vælµë øf trµë, fælsë, ërrør, wærñïñg, ïñførmætïøñ, ør ñøñëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "pyrightCommentMissingDirective": "[yy6rB][นั้Pÿrïght çømmëñt mµst þë følløwëð þÿ æ ðïrëçtïvë (þæsïç ør strïçt) ør æ ðïægñøstïç rµlëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "pyrightCommentNotOnOwnLine": "[mM2bV][นั้Pÿrïght çømmëñts µsëð tø çøñtrøl fïlë-lëvël sëttïñgs mµst æppëær øñ thëïr øwñ lïñëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "pyrightCommentUnknownDiagnosticRule": "[DFAZp][นั้\"{rµlë}\" ïs æñ µñkñøwñ ðïægñøstïç rµlë før pÿrïght çømmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "pyrightCommentUnknownDiagnosticSeverityValue": "[Tgt0Y][นั้\"{vælµë}\" ïs ïñvælïð vælµë før pÿrïght çømmëñt; ëxpëçtëð trµë, fælsë, ërrør, wærñïñg, ïñførmætïøñ, ør ñøñëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "pyrightCommentUnknownDirective": "[HD6T4][นั้\"{ðïrëçtïvë}\" ïs æñ µñkñøwñ ðïrëçtïvë før pÿrïght çømmëñt; ëxpëçtëð \"strïçt\" ør \"þæsïç\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "readOnlyArgCount": "[B1Erm][นั้Ëxpëçtëð æ sïñglë tÿpë ærgµmëñt æftër \"RëæðØñlÿ\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "readOnlyNotInTypedDict": "[xJrLN][นั้\"RëæðØñlÿ\" ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "protocolVarianceContravariant": "[B4htZ][นั้Tÿpë værïæþlë \"{værïæþlë}\" µsëð ïñ gëñërïç Protocol \"{çlæss}\" shøµlð þë çøñtræværïæñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "protocolVarianceCovariant": "[Hcnn5][นั้Tÿpë værïæþlë \"{værïæþlë}\" µsëð ïñ gëñërïç Protocol \"{çlæss}\" shøµlð þë çøværïæñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "protocolVarianceInvariant": "[o8oB7][นั้Tÿpë værïæþlë \"{værïæþlë}\" µsëð ïñ gëñërïç Protocol \"{çlæss}\" shøµlð þë ïñværïæñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "pyrightCommentInvalidDiagnosticBoolValue": "[eaJY0][นั้Pyright çømmëñt ðïrëçtïvë mµst þë følløwëð þÿ \"=\" æñð æ vælµë øf true ør falseẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "pyrightCommentInvalidDiagnosticSeverityValue": "[2YA7K][นั้Pyright çømmëñt ðïrëçtïvë mµst þë følløwëð þÿ \"=\" æñð æ vælµë øf true, false, error, warning, information, ør noneẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "pyrightCommentMissingDirective": "[yy6rB][นั้Pyright çømmëñt mµst þë følløwëð þÿ æ ðïrëçtïvë (basic ør strict) ør æ ðïægñøstïç rµlëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "pyrightCommentNotOnOwnLine": "[mM2bV][นั้Pyright çømmëñts µsëð tø çøñtrøl fïlë-lëvël sëttïñgs mµst æppëær øñ thëïr øwñ lïñëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "pyrightCommentUnknownDiagnosticRule": "[DFAZp][นั้\"{rµlë}\" ïs æñ µñkñøwñ ðïægñøstïç rµlë før pyright çømmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "pyrightCommentUnknownDiagnosticSeverityValue": "[Tgt0Y][นั้\"{vælµë}\" ïs ïñvælïð vælµë før pyright çømmëñt; ëxpëçtëð true, false, error, warning, information, ør noneẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "pyrightCommentUnknownDirective": "[HD6T4][นั้\"{ðïrëçtïvë}\" ïs æñ µñkñøwñ ðïrëçtïvë før pyright çømmëñt; ëxpëçtëð \"strict\" ør \"basic\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "readOnlyArgCount": "[B1Erm][นั้Ëxpëçtëð æ sïñglë tÿpë ærgµmëñt æftër \"ReadOnly\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "readOnlyNotInTypedDict": "[xJrLN][นั้\"ReadOnly\" ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "recursiveDefinition": "[G3UUN][นั้Tÿpë øf \"{ñæmë}\" çøµlð ñøt þë ðëtërmïñëð þëçæµsë ït rëfërs tø ïtsëlfẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "relativeImportNotAllowed": "[JZqjC][นั้Rëlætïvë ïmpørts çæññøt þë µsëð wïth \"ïmpørt .æ\" førm; µsë \"frøm . ïmpørt æ\" ïñstëæðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "requiredArgCount": "[aZX4z][นั้Ëxpëçtëð æ sïñglë tÿpë ærgµmëñt æftër \"Rëqµïrëð\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "requiredNotInTypedDict": "[TArW6][นั้\"Rëqµïrëð\" ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "returnInAsyncGenerator": "[qb5pt][นั้Rëtµrñ stætëmëñt wïth vælµë ïs ñøt ælløwëð ïñ æsÿñç gëñërætørẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "relativeImportNotAllowed": "[JZqjC][นั้Rëlætïvë ïmpørts çæññøt þë µsëð wïth \"import .a\" førm; µsë \"from . import a\" ïñstëæðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "requiredArgCount": "[aZX4z][นั้Ëxpëçtëð æ sïñglë tÿpë ærgµmëñt æftër \"Required\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "requiredNotInTypedDict": "[TArW6][นั้\"Required\" ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "returnInAsyncGenerator": "[qb5pt][นั้Rëtµrñ stætëmëñt wïth vælµë ïs ñøt ælløwëð ïñ async gëñërætørẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "returnMissing": "[kPevK][นั้Fµñçtïøñ wïth ðëçlærëð rëtµrñ tÿpë \"{rëtµrñTÿpë}\" mµst rëtµrñ vælµë øñ æll çøðë pæthsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "returnOutsideFunction": "[O4SJp][นั้\"rëtµrñ\" çæñ þë µsëð øñlÿ wïthïñ æ fµñçtïøñẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "returnOutsideFunction": "[O4SJp][นั้\"return\" çæñ þë µsëð øñlÿ wïthïñ æ fµñçtïøñẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", "returnTypeContravariant": "[KkMhh][นั้Çøñtræværïæñt tÿpë værïæþlë çæññøt þë µsëð ïñ rëtµrñ tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "returnTypeMismatch": "[QYqHy][นั้Ëxprëssïøñ øf tÿpë \"{ëxprTÿpë}\" ïs ïñçømpætïþlë wïth rëtµrñ tÿpë \"{rëtµrñTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "returnTypeMismatch": "[QYqHy][นั้Tÿpë \"{ëxprTÿpë}\" ïs ñøt æssïgñæþlë tø rëtµrñ tÿpë \"{rëtµrñTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "returnTypePartiallyUnknown": "[261DZ][นั้Rëtµrñ tÿpë, \"{rëtµrñTÿpë}\", ïs pærtïællÿ µñkñøwñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "returnTypeUnknown": "[II3Ix][นั้Rëtµrñ tÿpë ïs µñkñøwñẤğ倪İЂҰक्र्นั้ढूँ]", - "revealLocalsArgs": "[qKEIL][นั้Ëxpëçtëð ñø ærgµmëñts før \"rëvëæl_løçæls\" çællẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "revealLocalsNone": "[xOTfI][นั้Ñø løçæls ïñ thïs sçøpëẤğ倪İЂҰक्र्นั้ढूँ]", - "revealTypeArgs": "[Sdo9V][นั้Ëxpëçtëð æ sïñglë pøsïtïøñæl ærgµmëñt før \"rëvëæl_tÿpë\" çællẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "revealTypeExpectedTextArg": "[6cFBk][นั้Thë \"ëxpëçtëð_tëxt\" ærgµmëñt før fµñçtïøñ \"rëvëæl_tÿpë\" mµst þë æ str lïtëræl vælµëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "revealLocalsArgs": "[qKEIL][นั้Ëxpëçtëð ñø ærgµmëñts før \"reveal_locals\" çællẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "revealLocalsNone": "[xOTfI][นั้Ñø locals ïñ thïs sçøpëẤğ倪İЂҰक्र्นั้ढूँ]", + "revealTypeArgs": "[Sdo9V][นั้Ëxpëçtëð æ sïñglë pøsïtïøñæl ærgµmëñt før \"reveal_type\" çællẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "revealTypeExpectedTextArg": "[6cFBk][นั้Thë \"expected_text\" ærgµmëñt før fµñçtïøñ \"reveal_type\" mµst þë æ str lïtëræl vælµëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", "revealTypeExpectedTextMismatch": "[ILnEV][นั้Tÿpë tëxt mïsmætçh; ëxpëçtëð \"{ëxpëçtëð}\" þµt rëçëïvëð \"{rëçëïvëð}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "revealTypeExpectedTypeMismatch": "[3XS8T][นั้Tÿpë mïsmætçh; ëxpëçtëð \"{ëxpëçtëð}\" þµt rëçëïvëð \"{rëçëïvëð}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "selfTypeContext": "[Hugyy][นั้\"§ëlf\" ïs ñøt vælïð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "selfTypeMetaclass": "[YvoBy][นั้\"§ëlf\" çæññøt þë µsëð wïthïñ æ mëtæçlæss (æ sµþçlæss øf \"tÿpë\")Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "selfTypeWithTypedSelfOrCls": "[sYgyY][นั้\"§ëlf\" çæññøt þë µsëð ïñ æ fµñçtïøñ wïth æ `sëlf` ør `çls` pæræmëtër thæt hæs æ tÿpë æññøtætïøñ øthër thæñ \"§ëlf\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "setterGetterTypeMismatch": "[8ZD1z][นั้Prøpërtÿ sëttër vælµë tÿpë ïs ñøt æssïgñæþlë tø thë gëttër rëtµrñ tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "selfTypeContext": "[Hugyy][นั้\"Self\" ïs ñøt vælïð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "selfTypeMetaclass": "[YvoBy][นั้\"Self\" çæññøt þë µsëð wïthïñ æ mëtæçlæss (æ sµþçlæss øf \"tÿpë\")Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "selfTypeWithTypedSelfOrCls": "[sYgyY][นั้\"Self\" çæññøt þë µsëð ïñ æ fµñçtïøñ wïth æ `self` ør `cls` pæræmëtër thæt hæs æ tÿpë æññøtætïøñ øthër thæñ \"Self\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "setterGetterTypeMismatch": "[8ZD1z][นั้Property setter vælµë tÿpë ïs ñøt æssïgñæþlë tø thë getter rëtµrñ tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", "singleOverload": "[YQVUc][นั้\"{ñæmë}\" ïs mærkëð æs øvërløæð, þµt æððïtïøñæl øvërløæðs ærë mïssïñgẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "slotsAttributeError": "[OF4rK][นั้\"{ñæmë}\" ïs ñøt spëçïfïëð ïñ __sløts__Ấğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "slotsClassVarConflict": "[tcS3q][นั้\"{ñæmë}\" çøñflïçts wïth ïñstæñçë værïæþlë ðëçlærëð ïñ __sløts__Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "starPatternInAsPattern": "[ZFdWe][นั้§tær pættërñ çæññøt þë µsëð wïth \"æs\" tærgëtẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "slotsAttributeError": "[OF4rK][นั้\"{ñæmë}\" ïs ñøt spëçïfïëð ïñ __slots__Ấğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "slotsClassVarConflict": "[tcS3q][นั้\"{ñæmë}\" çøñflïçts wïth ïñstæñçë værïæþlë ðëçlærëð ïñ __slots__Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "starPatternInAsPattern": "[ZFdWe][นั้§tær pættërñ çæññøt þë µsëð wïth \"as\" tærgëtẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "starPatternInOrPattern": "[y9LX3][นั้§tær pættërñ çæññøt þë ØRëð wïthïñ øthër pættërñsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "starStarWildcardNotAllowed": "[Ll1UV][นั้** çæññøt þë µsëð wïth wïlðçærð \"_\"Ấğ倪İЂҰक्र्तिृまนั้ढूँ]", - "staticClsSelfParam": "[mO4QU][นั้§tætïç mëthøðs shøµlð ñøt tækë æ \"sëlf\" ør \"çls\" pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "stdlibModuleOverridden": "[AV6K3][นั้\"{pæth}\" ïs øvërrïðïñg thë stðlïþ møðµlë \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "stringNonAsciiBytes": "[dFNRn][นั้Ñøñ-ƧÇÏÏ çhæræçtër ñøt ælløwëð ïñ þÿtës strïñg lïtërælẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "stringNotSubscriptable": "[hKZT7][นั้§trïñg ëxprëssïøñ çæññøt þë sµþsçrïptëð ïñ tÿpë æññøtætïøñ; ëñçløsë ëñtïrë æññøtætïøñ ïñ qµøtësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "staticClsSelfParam": "[mO4QU][นั้§tætïç mëthøðs shøµlð ñøt tækë æ \"self\" ør \"cls\" pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "stdlibModuleOverridden": "[AV6K3][นั้\"{pæth}\" ïs øvërrïðïñg thë stdlib møðµlë \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "stringNonAsciiBytes": "[dFNRn][นั้Ñøñ-ASCII çhæræçtër ñøt ælløwëð ïñ þÿtës strïñg lïtërælẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "stringNotSubscriptable": "[hKZT7][นั้§trïñg ëxprëssïøñ çæññøt þë sµþsçrïptëð ïñ tÿpë ëxprëssïøñ; ëñçløsë ëñtïrë ëxprëssïøñ ïñ qµøtësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "stringUnsupportedEscape": "[K2WsY][นั้Üñsµppørtëð ësçæpë sëqµëñçë ïñ strïñg lïtërælẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "stringUnterminated": "[jUKYA][นั้§trïñg lïtëræl ïs µñtërmïñætëðẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "stubFileMissing": "[Ua5GT][นั้§tµþ fïlë ñøt føµñð før \"{ïmpørtÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "stubUsesGetAttr": "[KMBwK][นั้Tÿpë stµþ fïlë ïs ïñçømplëtë; \"__gëtættr__\" øþsçµrës tÿpë ërrørs før møðµlëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "sublistParamsIncompatible": "[582LE][นั้§µþlïst pæræmëtërs ærë ñøt sµppørtëð ïñ Pÿthøñ 3.xẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "superCallArgCount": "[iLYq6][นั้Ëxpëçtëð ñø mørë thæñ twø ærgµmëñts tø \"sµpër\" çællẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "superCallFirstArg": "[HSEvD][นั้Ëxpëçtëð çlæss tÿpë æs fïrst ærgµmëñt tø \"sµpër\" çæll þµt rëçëïvëð \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "superCallSecondArg": "[dKoHi][นั้§ëçøñð ærgµmëñt tø \"sµpër\" çæll mµst þë øþjëçt ør çlæss thæt ðërïvës frøm \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "superCallZeroArgForm": "[0XO27][นั้Zërø-ærgµmëñt førm øf \"sµpër\" çæll ïs vælïð øñlÿ wïthïñ æ mëthøðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "superCallZeroArgFormStaticMethod": "[9hJPB][นั้Zërø-ærgµmëñt førm øf \"sµpër\" çæll ïs ñøt vælïð wïthïñ æ stætïç mëthøðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "stubFileMissing": "[Ua5GT][นั้Stub fïlë ñøt føµñð før \"{ïmpørtÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "stubUsesGetAttr": "[KMBwK][นั้Tÿpë stub fïlë ïs ïñçømplëtë; \"__getattr__\" øþsçµrës tÿpë ërrørs før møðµlëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "sublistParamsIncompatible": "[582LE][นั้Sublist pæræmëtërs ærë ñøt sµppørtëð ïñ Pÿthøñ 3.xẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "superCallArgCount": "[iLYq6][นั้Ëxpëçtëð ñø mørë thæñ twø ærgµmëñts tø \"super\" çællẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "superCallFirstArg": "[HSEvD][นั้Ëxpëçtëð çlæss tÿpë æs fïrst ærgµmëñt tø \"super\" çæll þµt rëçëïvëð \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "superCallSecondArg": "[dKoHi][นั้§ëçøñð ærgµmëñt tø \"super\" çæll mµst þë øþjëçt ør çlæss thæt ðërïvës frøm \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "superCallZeroArgForm": "[0XO27][นั้Zërø-ærgµmëñt førm øf \"super\" çæll ïs vælïð øñlÿ wïthïñ æ mëthøðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "superCallZeroArgFormStaticMethod": "[9hJPB][นั้Zërø-ærgµmëñt førm øf \"super\" çæll ïs ñøt vælïð wïthïñ æ stætïç mëthøðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", "symbolIsPossiblyUnbound": "[cUgue][นั้\"{ñæmë}\" ïs pøssïþlÿ µñþøµñðẤğ倪İЂҰक्र्तिृนั้ढूँ]", "symbolIsUnbound": "[zhGl5][นั้\"{ñæmë}\" ïs µñþøµñðẤğ倪İЂҰक्นั้ढूँ]", "symbolIsUndefined": "[qCm6F][นั้\"{ñæmë}\" ïs ñøt ðëfïñëðẤğ倪İЂҰक्र्นั้ढूँ]", "symbolOverridden": "[JwRrv][นั้\"{ñæmë}\" øvërrïðës sÿmþøl øf sæmë ñæmë ïñ çlæss \"{çlæssÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "ternaryNotAllowed": "[5NH6C][นั้Tërñærÿ ëxprëssïøñ ñøt ælløwëð ïñ tÿpë æññøtætïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "totalOrderingMissingMethod": "[eYfjn][นั้Çlæss mµst ðëfïñë øñë øf \"__lt__\", \"__lë__\", \"__gt__\", ør \"__gë__\" tø µsë tøtæl_ørðërïñgẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "ternaryNotAllowed": "[5NH6C][นั้Tërñærÿ ëxprëssïøñ ñøt ælløwëð ïñ tÿpë ëxprëssïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "totalOrderingMissingMethod": "[eYfjn][นั้Çlæss mµst ðëfïñë øñë øf \"__lt__\", \"__le__\", \"__gt__\", ør \"__ge__\" tø µsë total_orderingẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "trailingCommaInFromImport": "[NcaZY][นั้Træïlïñg çømmæ ñøt ælløwëð wïthøµt sµrrøµñðïñg pærëñthësësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "tryWithoutExcept": "[6z9oA][นั้Trÿ stætëmëñt mµst hævë æt lëæst øñë ëxçëpt ør fïñællÿ çlæµsëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "tupleAssignmentMismatch": "[xySRW][นั้Ëxprëssïøñ wïth tÿpë \"{tÿpë}\" çæññøt þë æssïgñëð tø tærgët tµplëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "tupleInAnnotation": "[j2RAZ][นั้Tµplë ëxprëssïøñ ñøt ælløwëð ïñ tÿpë æññøtætïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "tryWithoutExcept": "[6z9oA][นั้Try stætëmëñt mµst hævë æt lëæst øñë except ør finally çlæµsëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "tupleAssignmentMismatch": "[xySRW][นั้Ëxprëssïøñ wïth tÿpë \"{tÿpë}\" çæññøt þë æssïgñëð tø tærgët tupleẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "tupleInAnnotation": "[j2RAZ][นั้Tuple ëxprëssïøñ ñøt ælløwëð ïñ tÿpë ëxprëssïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", "tupleIndexOutOfRange": "[aNqDv][นั้Ïñðëx {ïñðëx} ïs øµt øf ræñgë før tÿpë {tÿpë}Ấğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "typeAliasIllegalExpressionForm": "[4u4ay][นั้Ïñvælïð ëxprëssïøñ førm før tÿpë ælïæs ðëfïñïtïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "typeAliasIsRecursiveDirect": "[r8PyZ][นั้Tÿpë ælïæs \"{ñæmë}\" çæññøt µsë ïtsëlf ïñ ïts ðëfïñïtïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "typeAliasNotInModuleOrClass": "[iQpDJ][นั้Æ TÿpëÆlïæs çæñ þë ðëfïñëð øñlÿ wïthïñ æ møðµlë ør çlæss sçøpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "typeAliasRedeclared": "[P036x][นั้\"{ñæmë}\" ïs ðëçlærëð æs æ TÿpëÆlïæs æñð çæñ þë æssïgñëð øñlÿ øñçëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "typeAliasStatementBadScope": "[C24Up][นั้Æ tÿpë stætëmëñt çæñ þë µsëð øñlÿ wïthïñ æ møðµlë ør çlæss sçøpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "typeAliasNotInModuleOrClass": "[iQpDJ][นั้Æ TypeAlias çæñ þë ðëfïñëð øñlÿ wïthïñ æ møðµlë ør çlæss sçøpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "typeAliasRedeclared": "[P036x][นั้\"{ñæmë}\" ïs ðëçlærëð æs æ TypeAlias æñð çæñ þë æssïgñëð øñlÿ øñçëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "typeAliasStatementBadScope": "[C24Up][นั้Æ type stætëmëñt çæñ þë µsëð øñlÿ wïthïñ æ møðµlë ør çlæss sçøpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "typeAliasStatementIllegal": "[2EW0Q][นั้Tÿpë ælïæs stætëmëñt rëqµïrës Pÿthøñ 3.12 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "typeAliasTypeBaseClass": "[RIpMs][นั้Æ tÿpë ælïæs ðëfïñëð ïñ æ \"tÿpë\" stætëmëñt çæññøt þë µsëð æs æ þæsë çlæssẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "typeAliasTypeMustBeAssigned": "[aV4Nn][นั้TÿpëÆlïæsTÿpë mµst þë æssïgñëð tø æ værïæþlë wïth thë sæmë ñæmë æs thë tÿpë ælïæsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "typeAliasTypeNameArg": "[dUUf1][นั้Fïrst ærgµmëñt tø TÿpëÆlïæsTÿpë mµst þë æ strïñg lïtëræl rëprësëñtïñg thë ñæmë øf thë tÿpë ælïæsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "typeAliasTypeBaseClass": "[RIpMs][นั้Æ tÿpë ælïæs ðëfïñëð ïñ æ \"type\" stætëmëñt çæññøt þë µsëð æs æ þæsë çlæssẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "typeAliasTypeMustBeAssigned": "[aV4Nn][นั้TypeAliasType mµst þë æssïgñëð tø æ værïæþlë wïth thë sæmë ñæmë æs thë tÿpë ælïæsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "typeAliasTypeNameArg": "[dUUf1][นั้Fïrst ærgµmëñt tø TypeAliasType mµst þë æ strïñg lïtëræl rëprësëñtïñg thë ñæmë øf thë tÿpë ælïæsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "typeAliasTypeNameMismatch": "[jW1bQ][นั้Ñæmë øf tÿpë ælïæs mµst mætçh thë ñæmë øf thë værïæþlë tø whïçh ït ïs æssïgñëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "typeAliasTypeParamInvalid": "[RdHRE][นั้Tÿpë pæræmëtër lïst mµst þë æ tµplë çøñtæïñïñg øñlÿ TÿpëVær, TÿpëVærTµplë, ør Pæræm§pëçẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "typeAliasTypeParamInvalid": "[RdHRE][นั้Tÿpë pæræmëtër lïst mµst þë æ tuple çøñtæïñïñg øñlÿ TypeVar, TypeVarTuple, ør ParamSpecẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "typeAnnotationCall": "[7pNts][นั้Çæll ëxprëssïøñ ñøt ælløwëð ïñ tÿpë ëxprëssïøñẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "typeAnnotationVariable": "[GeXWQ][นั้Værïæþlë ñøt ælløwëð ïñ tÿpë ëxprëssïøñẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "typeAnnotationWithCallable": "[JJENJ][นั้Tÿpë ærgµmëñt før \"tÿpë\" mµst þë æ çlæss; çællæþlës ærë ñøt sµppørtëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "typeArgListExpected": "[2efoA][นั้Ëxpëçtëð Pæræm§pëç, ëllïpsïs, ør lïst øf tÿpësẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "typeArgListNotAllowed": "[oV7JF][นั้£ïst ëxprëssïøñ ñøt ælløwëð før thïs tÿpë ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "typeAnnotationWithCallable": "[JJENJ][นั้Tÿpë ærgµmëñt før \"type\" mµst þë æ çlæss; çællæþlës ærë ñøt sµppørtëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "typeArgListExpected": "[2efoA][นั้Ëxpëçtëð ParamSpec, ëllïpsïs, ør list øf tÿpësẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "typeArgListNotAllowed": "[oV7JF][นั้List ëxprëssïøñ ñøt ælløwëð før thïs tÿpë ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "typeArgsExpectingNone": "[faycH][นั้Ëxpëçtëð ñø tÿpë ærgµmëñts før çlæss \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "typeArgsMismatchOne": "[BBe1n][นั้Ëxpëçtëð øñë tÿpë ærgµmëñt þµt rëçëïvëð {rëçëïvëð}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "typeArgsMissingForAlias": "[hk8aw][นั้Ëxpëçtëð tÿpë ærgµmëñts før gëñërïç tÿpë ælïæs \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "typeArgsMissingForClass": "[SkdfG][นั้Ëxpëçtëð tÿpë ærgµmëñts før gëñërïç çlæss \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "typeArgsTooFew": "[6PAb0][นั้Tøø fëw tÿpë ærgµmëñts prøvïðëð før \"{ñæmë}\"; ëxpëçtëð {ëxpëçtëð} þµt rëçëïvëð {rëçëïvëð}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "typeArgsTooMany": "[NKF2Z][นั้Tøø mæñÿ tÿpë ærgµmëñts prøvïðëð før \"{ñæmë}\"; ëxpëçtëð {ëxpëçtëð} þµt rëçëïvëð {rëçëïvëð}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "typeAssignmentMismatch": "[wwjSP][นั้Ëxprëssïøñ øf tÿpë \"{søµrçëTÿpë}\" ïs ïñçømpætïþlë wïth ðëçlærëð tÿpë \"{ðëstTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "typeAssignmentMismatchWildcard": "[qdgVA][นั้Ïmpørt sÿmþøl \"{ñæmë}\" hæs tÿpë \"{søµrçëTÿpë}\", whïçh ïs ïñçømpætïþlë wïth ðëçlærëð tÿpë \"{ðëstTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "typeCallNotAllowed": "[OGMmG][นั้tÿpë() çæll shøµlð ñøt þë µsëð ïñ tÿpë æññøtætïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "typeCheckOnly": "[cSmKj][นั้\"{ñæmë}\" ïs mærkëð æs @tÿpë_çhëçk_øñlÿ æñð çæñ þë µsëð øñlÿ ïñ tÿpë æññøtætïøñsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "typeCommentDeprecated": "[SRhVz][นั้Üsë øf tÿpë çømmëñts ïs ðëprëçætëð; µsë tÿpë æññøtætïøñ ïñstëæðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "typeAssignmentMismatch": "[wwjSP][นั้Tÿpë \"{søµrçëTÿpë}\" ïs ñøt æssïgñæþlë tø ðëçlærëð tÿpë \"{ðëstTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "typeAssignmentMismatchWildcard": "[qdgVA][นั้Ïmpørt sÿmþøl \"{ñæmë}\" hæs tÿpë \"{søµrçëTÿpë}\", whïçh ïs ñøt æssïgñæþlë tø ðëçlærëð tÿpë \"{ðëstTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "typeCallNotAllowed": "[OGMmG][นั้type() çæll shøµlð ñøt þë µsëð ïñ tÿpë ëxprëssïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "typeCheckOnly": "[cSmKj][นั้\"{ñæmë}\" ïs mærkëð æs @type_check_only æñð çæñ þë µsëð øñlÿ ïñ tÿpë æññøtætïøñsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "typeCommentDeprecated": "[SRhVz][นั้Üsë øf type çømmëñts ïs ðëprëçætëð; µsë type æññøtætïøñ ïñstëæðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "typeExpectedClass": "[r0pdu][นั้Ëxpëçtëð çlæss þµt rëçëïvëð \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまนั้ढूँ]", - "typeGuardArgCount": "[Zl47K][นั้Ëxpëçtëð æ sïñglë tÿpë ærgµmëñt æftër \"TÿpëGµærð\" ør \"TÿpëÏs\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "typeFormArgs": "[ivrdh][นั้\"TypeForm\" æççëpts æ sïñglë pøsïtïøñæl ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "typeGuardArgCount": "[Zl47K][นั้Ëxpëçtëð æ sïñglë tÿpë ærgµmëñt æftër \"TypeGuard\" ør \"TypeIs\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "typeGuardParamCount": "[I3HUH][นั้Üsër-ðëfïñëð tÿpë gµærð fµñçtïøñs æñð mëthøðs mµst hævë æt lëæst øñë ïñpµt pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "typeIsReturnType": "[5bBbd][นั้Rëtµrñ tÿpë øf TÿpëÏs (\"{rëtµrñTÿpë}\") ïs ñøt çøñsïstëñt wïth vælµë pæræmëtër tÿpë (\"{tÿpë}\")Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "typeNotAwaitable": "[NZ9Yu][นั้\"{tÿpë}\" ïs ñøt æwæïtæþlëẤğ倪İЂҰक्र्นั้ढूँ]", + "typeIsReturnType": "[5bBbd][นั้Rëtµrñ tÿpë øf TypeIs (\"{rëtµrñTÿpë}\") ïs ñøt çøñsïstëñt wïth vælµë pæræmëtër tÿpë (\"{tÿpë}\")Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "typeNotAwaitable": "[NZ9Yu][นั้\"{tÿpë}\" ïs ñøt awaitableẤğ倪İЂҰक्र्นั้ढूँ]", "typeNotIntantiable": "[f3xEe][นั้\"{tÿpë}\" çæññøt þë ïñstæñtïætëðẤğ倪İЂҰक्र्तिृนั้ढूँ]", "typeNotIterable": "[XMDzF][นั้\"{tÿpë}\" ïs ñøt ïtëræþlëẤğ倪İЂҰक्र्นั้ढूँ]", "typeNotSpecializable": "[ZCsyD][นั้Çøµlð ñøt spëçïælïzë tÿpë \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまนั้ढूँ]", @@ -512,152 +514,152 @@ "typeNotSupportUnaryOperator": "[f2pEG][นั้Øpërætør \"{øpërætør}\" ñøt sµppørtëð før tÿpë \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "typeNotSupportUnaryOperatorBidirectional": "[Z51QN][นั้Øpërætør \"{øpërætør}\" ñøt sµppørtëð før tÿpë \"{tÿpë}\" whëñ ëxpëçtëð tÿpë ïs \"{ëxpëçtëðTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "typeNotUsableWith": "[R7VpZ][นั้Øþjëçt øf tÿpë \"{tÿpë}\" çæññøt þë µsëð wïth \"wïth\" þëçæµsë ït ðøës ñøt ïmplëmëñt {mëthøð}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "typeParameterBoundNotAllowed": "[iA0kz][นั้ßøµñð ør çøñstræïñt çæññøt þë µsëð wïth æ værïæðïç tÿpë pæræmëtër ør Pæræm§pëçẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "typeParameterBoundNotAllowed": "[iA0kz][นั้ßøµñð ør çøñstræïñt çæññøt þë µsëð wïth æ værïæðïç tÿpë pæræmëtër ør ParamSpecẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", "typeParameterConstraintTuple": "[8wa57][นั้Tÿpë pæræmëtër çøñstræïñt mµst þë æ tµplë øf twø ør mørë tÿpësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "typeParameterExistingTypeParameter": "[M2QXP][นั้Tÿpë pæræmëtër \"{ñæmë}\" ïs ælrëæðÿ ïñ µsëẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "typeParameterNotDeclared": "[WD9B6][นั้Tÿpë pæræmëtër \"{ñæmë}\" ïs ñøt ïñçlµðëð ïñ thë tÿpë pæræmëtër lïst før \"{çøñtæïñër}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "typeParametersMissing": "[7nPE2][นั้Æt lëæst øñë tÿpë pæræmëtër mµst þë spëçïfïëðẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "typePartiallyUnknown": "[K72xm][นั้Tÿpë øf \"{ñæmë}\" ïs pærtïællÿ µñkñøwñẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", "typeUnknown": "[flab2][นั้Tÿpë øf \"{ñæmë}\" ïs µñkñøwñẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "typeVarAssignedName": "[AnBke][นั้TÿpëVær mµst þë æssïgñëð tø æ værïæþlë ñæmëð \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "typeVarAssignedName": "[AnBke][นั้TypeVar mµst þë æssïgñëð tø æ værïæþlë ñæmëð \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "typeVarAssignmentMismatch": "[IYCuH][นั้Tÿpë \"{tÿpë}\" çæññøt þë æssïgñëð tø tÿpë værïæþlë \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "typeVarBoundAndConstrained": "[nSFES][นั้TÿpëVær çæññøt þë þøth þøµñð æñð çøñstræïñëðẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "typeVarBoundGeneric": "[scFkM][นั้TÿpëVær þøµñð tÿpë çæññøt þë gëñërïçẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "typeVarConstraintGeneric": "[k7N05][นั้TÿpëVær çøñstræïñt tÿpë çæññøt þë gëñërïçẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "typeVarDefaultBoundMismatch": "[knxtI][นั้TÿpëVær ðëfæµlt tÿpë mµst þë æ sµþtÿpë øf thë þøµñð tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "typeVarDefaultConstraintMismatch": "[BlQvu][นั้TÿpëVær ðëfæµlt tÿpë mµst þë øñë øf thë çøñstræïñëð tÿpësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "typeVarBoundAndConstrained": "[nSFES][นั้TypeVar çæññøt þë þøth þøµñð æñð çøñstræïñëðẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "typeVarBoundGeneric": "[scFkM][นั้TypeVar þøµñð tÿpë çæññøt þë gëñërïçẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "typeVarConstraintGeneric": "[k7N05][นั้TypeVar çøñstræïñt tÿpë çæññøt þë gëñërïçẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "typeVarDefaultBoundMismatch": "[knxtI][นั้TypeVar ðëfæµlt tÿpë mµst þë æ sµþtÿpë øf thë þøµñð tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "typeVarDefaultConstraintMismatch": "[BlQvu][นั้TypeVar ðëfæµlt tÿpë mµst þë øñë øf thë çøñstræïñëð tÿpësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "typeVarDefaultIllegal": "[Z5lrX][นั้Tÿpë værïæþlë ðëfæµlt tÿpës rëqµïrë Pÿthøñ 3.13 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "typeVarDefaultInvalidTypeVar": "[bOQ21][นั้Tÿpë pæræmëtër \"{ñæmë}\" hæs æ ðëfæµlt tÿpë thæt rëfërs tø øñë ør mørë tÿpë værïæþlës thæt ærë øµt øf sçøpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "typeVarFirstArg": "[XBVgA][นั้Ëxpëçtëð ñæmë øf TÿpëVær æs fïrst ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "typeVarFirstArg": "[XBVgA][นั้Ëxpëçtëð ñæmë øf TypeVar æs fïrst ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", "typeVarInvalidForMemberVariable": "[m45Yw][นั้Ættrïþµtë tÿpë çæññøt µsë tÿpë værïæþlë \"{ñæmë}\" sçøpëð tø løçæl mëthøðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "typeVarNoMember": "[Trelb][นั้TÿpëVær \"{tÿpë}\" hæs ñø ættrïþµtë \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "typeVarNotSubscriptable": "[3KoEm][นั้TÿpëVær \"{tÿpë}\" ïs ñøt sµþsçrïptæþlëẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "typeVarNoMember": "[Trelb][นั้TypeVar \"{tÿpë}\" hæs ñø ættrïþµtë \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "typeVarNotSubscriptable": "[3KoEm][นั้TypeVar \"{tÿpë}\" ïs ñøt sµþsçrïptæþlëẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", "typeVarNotUsedByOuterScope": "[on7uQ][นั้Tÿpë værïæþlë \"{ñæmë}\" hæs ñø mëæñïñg ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "typeVarPossiblyUnsolvable": "[PP5xz][นั้Tÿpë værïæþlë \"{ñæmë}\" mæÿ gø µñsølvëð ïf çællër sµpplïës ñø ærgµmëñt før pæræmëtër \"{pæræm}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "typeVarSingleConstraint": "[51MwX][นั้TÿpëVær mµst hævë æt lëæst twø çøñstræïñëð tÿpësẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "typeVarTupleConstraints": "[ouP8u][นั้TÿpëVærTµplë çæññøt hævë vælµë çøñstræïñtsẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "typeVarTupleContext": "[Q8vE2][นั้TÿpëVærTµplë ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "typeVarTupleDefaultNotUnpacked": "[S2joz][นั้TÿpëVærTµplë ðëfæµlt tÿpë mµst þë æñ µñpæçkëð tµplë ør TÿpëVærTµplëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "typeVarTupleMustBeUnpacked": "[TA5HX][นั้Üñpæçk øpërætør ïs rëqµïrëð før TÿpëVærTµplë vælµëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "typeVarTupleUnknownParam": "[fOW23][นั้\"{ñæmë}\" ïs µñkñøwñ pæræmëtër tø TÿpëVærTµplëẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "typeVarUnknownParam": "[veXvU][นั้\"{ñæmë}\" ïs µñkñøwñ pæræmëtër tø TÿpëVærẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "typeVarUsedByOuterScope": "[GJ5N3][นั้TÿpëVær \"{ñæmë}\" ïs ælrëæðÿ ïñ µsë þÿ æñ øµtër sçøpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "typeVarUsedOnlyOnce": "[vSn0W][นั้TÿpëVær \"{ñæmë}\" æppëærs øñlÿ øñçë ïñ gëñërïç fµñçtïøñ sïgñætµrëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "typeVarVariance": "[1Dxdn][นั้TÿpëVær çæññøt þë þøth çøværïæñt æñð çøñtræværïæñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "typeVarWithDefaultFollowsVariadic": "[h1V5a][นั้TÿpëVær \"{tÿpëVærÑæmë}\" hæs æ ðëfæµlt vælµë æñð çæññøt følløw TÿpëVærTµplë \"{værïæðïçÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "typeVarSingleConstraint": "[51MwX][นั้TypeVar mµst hævë æt lëæst twø çøñstræïñëð tÿpësẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "typeVarTupleConstraints": "[ouP8u][นั้TypeVarTuple çæññøt hævë vælµë çøñstræïñtsẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "typeVarTupleContext": "[Q8vE2][นั้TypeVarTuple ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "typeVarTupleDefaultNotUnpacked": "[S2joz][นั้TypeVarTuple ðëfæµlt tÿpë mµst þë æñ µñpæçkëð tuple ør TypeVarTupleẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "typeVarTupleMustBeUnpacked": "[TA5HX][นั้Üñpæçk øpërætør ïs rëqµïrëð før TypeVarTuple vælµëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "typeVarTupleUnknownParam": "[fOW23][นั้\"{ñæmë}\" ïs µñkñøwñ pæræmëtër tø TypeVarTupleẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "typeVarUnknownParam": "[veXvU][นั้\"{ñæmë}\" ïs µñkñøwñ pæræmëtër tø TypeVarẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "typeVarUsedByOuterScope": "[GJ5N3][นั้TypeVar \"{ñæmë}\" ïs ælrëæðÿ ïñ µsë þÿ æñ øµtër sçøpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "typeVarUsedOnlyOnce": "[vSn0W][นั้TypeVar \"{ñæmë}\" æppëærs øñlÿ øñçë ïñ gëñërïç fµñçtïøñ sïgñætµrëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "typeVarVariance": "[1Dxdn][นั้TypeVar çæññøt þë þøth çøværïæñt æñð çøñtræværïæñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "typeVarWithDefaultFollowsVariadic": "[h1V5a][นั้TypeVar \"{tÿpëVærÑæmë}\" hæs æ ðëfæµlt vælµë æñð çæññøt følløw TypeVarTuple \"{værïæðïçÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "typeVarWithoutDefault": "[w630R][นั้\"{ñæmë}\" çæññøt æppëær æftër \"{øthër}\" ïñ tÿpë pæræmëtër lïst þëçæµsë ït hæs ñø ðëfæµlt tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "typeVarsNotInGenericOrProtocol": "[ydmAV][นั้Gëñërïç[] ør Prøtøçøl[] mµst ïñçlµðë æll tÿpë værïæþlësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "typedDictAccess": "[55CCf][นั้Çøµlð ñøt æççëss ïtëm ïñ TÿpëðÐïçtẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "typedDictAssignedName": "[Dkf5M][นั้TÿpëðÐïçt mµst þë æssïgñëð tø æ værïæþlë ñæmëð \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "typedDictBadVar": "[OL8Ox][นั้TÿpëðÐïçt çlæssës çæñ çøñtæïñ øñlÿ tÿpë æññøtætïøñsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "typedDictBaseClass": "[HxyA2][นั้Æll þæsë çlæssës før TÿpëðÐïçt çlæssës mµst ælsø þë TÿpëðÐïçt çlæssësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "typedDictBoolParam": "[GALOD][นั้Ëxpëçtëð \"{ñæmë}\" pæræmëtër tø hævë æ vælµë øf Trµë ør FælsëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "typedDictClosedExtras": "[mlkJO][นั้ßæsë çlæss \"{ñæmë}\" ïs æ çløsëð TÿpëðÐïçt; ëxtræ ïtëms mµst þë tÿpë \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "typedDictClosedNoExtras": "[BCyXd][นั้ßæsë çlæss \"{ñæmë}\" ïs æ çløsëð TÿpëðÐïçt; ëxtræ ïtëms ærë ñøt ælløwëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "typedDictDelete": "[bdBu7][นั้Çøµlð ñøt ðëlëtë ïtëm ïñ TÿpëðÐïçtẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "typedDictEmptyName": "[h45e7][นั้Ñæmës wïthïñ æ TÿpëðÐïçt çæññøt þë ëmptÿẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "typeVarsNotInGenericOrProtocol": "[ydmAV][นั้Generic[] ør Protocol[] mµst ïñçlµðë æll tÿpë værïæþlësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "typedDictAccess": "[55CCf][นั้Çøµlð ñøt æççëss ïtëm ïñ TypedDictẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "typedDictAssignedName": "[Dkf5M][นั้TypedDict mµst þë æssïgñëð tø æ værïæþlë ñæmëð \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "typedDictBadVar": "[OL8Ox][นั้TypedDict çlæssës çæñ çøñtæïñ øñlÿ tÿpë æññøtætïøñsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "typedDictBaseClass": "[HxyA2][นั้Æll þæsë çlæssës før TypedDict çlæssës mµst ælsø þë TypedDict çlæssësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "typedDictBoolParam": "[GALOD][นั้Ëxpëçtëð \"{ñæmë}\" pæræmëtër tø hævë æ vælµë øf True ør FalseẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "typedDictClosedExtras": "[mlkJO][นั้ßæsë çlæss \"{ñæmë}\" ïs æ closed TypedDict; ëxtræ ïtëms mµst þë tÿpë \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "typedDictClosedNoExtras": "[BCyXd][นั้ßæsë çlæss \"{ñæmë}\" ïs æ closed TypedDict; ëxtræ ïtëms ærë ñøt ælløwëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "typedDictDelete": "[bdBu7][นั้Çøµlð ñøt ðëlëtë ïtëm ïñ TypedDictẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "typedDictEmptyName": "[h45e7][นั้Ñæmës wïthïñ æ TypedDict çæññøt þë ëmptÿẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "typedDictEntryName": "[NT4np][นั้Ëxpëçtëð strïñg lïtëræl før ðïçtïøñærÿ ëñtrÿ ñæmëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "typedDictEntryUnique": "[nWy0L][นั้Ñæmës wïthïñ æ ðïçtïøñærÿ mµst þë µñïqµëẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "typedDictExtraArgs": "[0gX32][นั้Ëxtræ TÿpëðÐïçt ærgµmëñts ñøt sµppørtëðẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "typedDictFieldNotRequiredRedefinition": "[rNYD1][นั้TÿpëðÐïçt ïtëm \"{ñæmë}\" çæññøt þë rëðëfïñëð æs ÑøtRëqµïrëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "typedDictFieldReadOnlyRedefinition": "[8IFAz][นั้TÿpëðÐïçt ïtëm \"{ñæmë}\" çæññøt þë rëðëfïñëð æs RëæðØñlÿẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "typedDictFieldRequiredRedefinition": "[lpw97][นั้TÿpëðÐïçt ïtëm \"{ñæmë}\" çæññøt þë rëðëfïñëð æs RëqµïrëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "typedDictFirstArg": "[OPlNk][นั้Ëxpëçtëð TÿpëðÐïçt çlæss ñæmë æs fïrst ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "typedDictInitsubclassParameter": "[HMpfK][นั้TÿpëðÐïçt ðøës ñøt sµppørt __ïñït_sµþçlæss__ pæræmëtër \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "typedDictNotAllowed": "[UWg4F][นั้\"TÿpëðÐïçt\" çæññøt þë µsëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "typedDictSecondArgDict": "[mwrv7][นั้Ëxpëçtëð ðïçt ør këÿwørð pæræmëtër æs sëçøñð pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "typedDictExtraArgs": "[0gX32][นั้Ëxtræ TypedDict ærgµmëñts ñøt sµppørtëðẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "typedDictFieldNotRequiredRedefinition": "[rNYD1][นั้TypedDict ïtëm \"{ñæmë}\" çæññøt þë rëðëfïñëð æs NotRequiredẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "typedDictFieldReadOnlyRedefinition": "[8IFAz][นั้TypedDict ïtëm \"{ñæmë}\" çæññøt þë rëðëfïñëð æs ReadOnlyẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "typedDictFieldRequiredRedefinition": "[lpw97][นั้TypedDict ïtëm \"{ñæmë}\" çæññøt þë rëðëfïñëð æs RequiredẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "typedDictFirstArg": "[OPlNk][นั้Ëxpëçtëð TypedDict çlæss ñæmë æs fïrst ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "typedDictInitsubclassParameter": "[HMpfK][นั้TypedDict ðøës ñøt sµppørt __init_subclass__ pæræmëtër \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "typedDictNotAllowed": "[UWg4F][นั้\"TypedDict\" çæññøt þë µsëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "typedDictSecondArgDict": "[mwrv7][นั้Ëxpëçtëð dict ør këÿwørð pæræmëtër æs sëçøñð pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "typedDictSecondArgDictEntry": "[oAT5Z][นั้Ëxpëçtëð sïmplë ðïçtïøñærÿ ëñtrÿẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "typedDictSet": "[30hTC][นั้Çøµlð ñøt æssïgñ ïtëm ïñ TÿpëðÐïçtẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "typedDictSet": "[30hTC][นั้Çøµlð ñøt æssïgñ ïtëm ïñ TypedDictẤğ倪İЂҰक्र्तिृまนั้ढूँ]", "unaccessedClass": "[dou8i][นั้Çlæss \"{ñæmë}\" ïs ñøt æççëssëðẤğ倪İЂҰक्र्तिृนั้ढूँ]", "unaccessedFunction": "[AdgDz][นั้Fµñçtïøñ \"{ñæmë}\" ïs ñøt æççëssëðẤğ倪İЂҰक्र्तिृนั้ढूँ]", "unaccessedImport": "[2a90g][นั้Ïmpørt \"{ñæmë}\" ïs ñøt æççëssëðẤğ倪İЂҰक्र्तिृนั้ढूँ]", "unaccessedSymbol": "[MmnM7][นั้\"{ñæmë}\" ïs ñøt æççëssëðẤğ倪İЂҰक्र्นั้ढूँ]", "unaccessedVariable": "[n5l1e][นั้Værïæþlë \"{ñæmë}\" ïs ñøt æççëssëðẤğ倪İЂҰक्र्तिृนั้ढूँ]", "unannotatedFunctionSkipped": "[Ovgyl][นั้Æñælÿsïs øf fµñçtïøñ \"{ñæmë}\" ïs skïppëð þëçæµsë ït ïs µñæññøtætëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "unaryOperationNotAllowed": "[2WB31][นั้Üñærÿ øpërætør ñøt ælløwëð ïñ tÿpë æññøtætïøñẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "unexpectedAsyncToken": "[fKSJb][นั้Ëxpëçtëð \"ðëf\", \"wïth\" ør \"før\" tø følløw \"æsÿñç\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "unaryOperationNotAllowed": "[2WB31][นั้Üñærÿ øpërætør ñøt ælløwëð ïñ tÿpë ëxprëssïøñẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "unexpectedAsyncToken": "[fKSJb][นั้Ëxpëçtëð \"def\", \"with\" ør \"for\" tø følløw \"async\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "unexpectedExprToken": "[MtBsu][นั้Üñëxpëçtëð tøkëñ æt ëñð øf ëxprëssïøñẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", "unexpectedIndent": "[uZUVS][นั้Üñëxpëçtëð ïñðëñtætïøñẤğ倪İЂҰक्र्นั้ढूँ]", "unexpectedUnindent": "[yqwy4][นั้Üñïñðëñt ñøt ëxpëçtëðẤğ倪İЂҰक्นั้ढूँ]", "unhashableDictKey": "[pIvHj][นั้Ðïçtïøñærÿ këÿ mµst þë hæshæþlëẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "unhashableSetEntry": "[rWf72][นั้§ët ëñtrÿ mµst þë hæshæþlëẤğ倪İЂҰक्र्นั้ढूँ]", - "uninitializedAbstractVariables": "[SpCPH][นั้Værïæþlës ðëfïñëð ïñ æþstræçt þæsë çlæss ærë ñøt ïñïtïælïzëð ïñ fïñæl çlæss \"{çlæssTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "uninitializedInstanceVariable": "[5pgFw][นั้Ïñstæñçë værïæþlë \"{ñæmë}\" ïs ñøt ïñïtïælïzëð ïñ thë çlæss þøðÿ ør __ïñït__ mëthøðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "unionForwardReferenceNotAllowed": "[MOLby][นั้Üñïøñ sÿñtæx çæññøt þë µsëð wïth strïñg øpëræñð; µsë qµøtës ærøµñð ëñtïrë ëxprëssïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "unhashableSetEntry": "[rWf72][นั้Set ëñtrÿ mµst þë hæshæþlëẤğ倪İЂҰक्र्นั้ढूँ]", + "uninitializedAbstractVariables": "[SpCPH][นั้Værïæþlës ðëfïñëð ïñ æþstræçt þæsë çlæss ærë ñøt ïñïtïælïzëð ïñ final çlæss \"{çlæssTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "uninitializedInstanceVariable": "[5pgFw][นั้Ïñstæñçë værïæþlë \"{ñæmë}\" ïs ñøt ïñïtïælïzëð ïñ thë çlæss þøðÿ ør __init__ mëthøðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "unionForwardReferenceNotAllowed": "[MOLby][นั้Union sÿñtæx çæññøt þë µsëð wïth strïñg øpëræñð; µsë qµøtës ærøµñð ëñtïrë ëxprëssïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "unionSyntaxIllegal": "[vbTDG][นั้Æltërñætïvë sÿñtæx før µñïøñs rëqµïrës Pÿthøñ 3.10 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "unionTypeArgCount": "[vc6vA][นั้Üñïøñ rëqµïrës twø ør mørë tÿpë ærgµmëñtsẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "unionUnpackedTuple": "[owRjE][นั้Üñïøñ çæññøt ïñçlµðë æñ µñpæçkëð tµplëẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "unionUnpackedTypeVarTuple": "[a6msY][นั้Üñïøñ çæññøt ïñçlµðë æñ µñpæçkëð TÿpëVærTµplëẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "unnecessaryCast": "[QgPoI][นั้Üññëçëssærÿ \"çæst\" çæll; tÿpë ïs ælrëæðÿ \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "unnecessaryIsInstanceAlways": "[gX4s7][นั้Üññëçëssærÿ ïsïñstæñçë çæll; \"{tëstTÿpë}\" ïs ælwæÿs æñ ïñstæñçë øf \"{çlæssTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "unnecessaryIsSubclassAlways": "[BzHtx][นั้Üññëçëssærÿ ïssµþçlæss çæll; \"{tëstTÿpë}\" ïs ælwæÿs æ sµþçlæss øf \"{çlæssTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "unnecessaryPyrightIgnore": "[7QhdX][นั้Üññëçëssærÿ \"# pÿrïght: ïgñørë\" çømmëñtẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "unnecessaryPyrightIgnoreRule": "[0ESoQ][นั้Üññëçëssærÿ \"# pÿrïght: ïgñørë\" rµlë: \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "unnecessaryTypeIgnore": "[IoWr9][นั้Üññëçëssærÿ \"# tÿpë: ïgñørë\" çømmëñtẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "unpackArgCount": "[bkAT1][นั้Ëxpëçtëð æ sïñglë tÿpë ærgµmëñt æftër \"Üñpæçk\"Ấğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "unpackExpectedTypeVarTuple": "[CWX8o][นั้Ëxpëçtëð TÿpëVærTµplë ør tµplë æs tÿpë ærgµmëñt før ÜñpæçkẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "unpackExpectedTypedDict": "[ha9qw][นั้Ëxpëçtëð TÿpëðÐïçt tÿpë ærgµmëñt før ÜñpæçkẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "unionTypeArgCount": "[vc6vA][นั้Union rëqµïrës twø ør mørë tÿpë ærgµmëñtsẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "unionUnpackedTuple": "[owRjE][นั้Union çæññøt ïñçlµðë æñ µñpæçkëð tupleẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "unionUnpackedTypeVarTuple": "[a6msY][นั้Union çæññøt ïñçlµðë æñ µñpæçkëð TypeVarTupleẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "unnecessaryCast": "[QgPoI][นั้Üññëçëssærÿ \"cast\" çæll; tÿpë ïs ælrëæðÿ \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "unnecessaryIsInstanceAlways": "[gX4s7][นั้Üññëçëssærÿ isinstance çæll; \"{tëstTÿpë}\" ïs ælwæÿs æñ ïñstæñçë øf \"{çlæssTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "unnecessaryIsSubclassAlways": "[BzHtx][นั้Üññëçëssærÿ issubclass çæll; \"{tëstTÿpë}\" ïs ælwæÿs æ sµþçlæss øf \"{çlæssTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "unnecessaryPyrightIgnore": "[7QhdX][นั้Üññëçëssærÿ \"# pyright: ignore\" çømmëñtẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "unnecessaryPyrightIgnoreRule": "[0ESoQ][นั้Üññëçëssærÿ \"# pyright: ignore\" rµlë: \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "unnecessaryTypeIgnore": "[IoWr9][นั้Üññëçëssærÿ \"# type: ignore\" çømmëñtẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "unpackArgCount": "[bkAT1][นั้Ëxpëçtëð æ sïñglë tÿpë ærgµmëñt æftër \"Unpack\"Ấğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "unpackExpectedTypeVarTuple": "[CWX8o][นั้Ëxpëçtëð TypeVarTuple ør tuple æs tÿpë ærgµmëñt før UnpackẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "unpackExpectedTypedDict": "[ha9qw][นั้Ëxpëçtëð TypedDict tÿpë ærgµmëñt før UnpackẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", "unpackIllegalInComprehension": "[7a4pV][นั้Üñpæçk øpërætïøñ ñøt ælløwëð ïñ çømprëhëñsïøñẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "unpackInAnnotation": "[6gqFu][นั้Üñpæçk øpërætør ñøt ælløwëð ïñ tÿpë æññøtætïøñẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "unpackInAnnotation": "[6gqFu][นั้Üñpæçk øpërætør ñøt ælløwëð ïñ tÿpë ëxprëssïøñẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "unpackInDict": "[eKn69][นั้Üñpæçk øpërætïøñ ñøt ælløwëð ïñ ðïçtïøñærïësẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "unpackInSet": "[lKyO0][นั้Üñpæçk øpërætør ñøt ælløwëð wïthïñ æ sëtẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "unpackNotAllowed": "[MZq6e][นั้Üñpæçk ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "unpackInSet": "[lKyO0][นั้Üñpæçk øpërætør ñøt ælløwëð wïthïñ æ setẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "unpackNotAllowed": "[MZq6e][นั้Unpack ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", "unpackOperatorNotAllowed": "[lMq2B][นั้Üñpæçk øpërætïøñ ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", "unpackTuplesIllegal": "[RJvzW][นั้Üñpæçk øpërætïøñ ñøt ælløwëð ïñ tµplës prïør tø Pÿthøñ 3.8Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "unpackedArgInTypeArgument": "[skxlo][นั้Üñpæçkëð ærgµmëñts çæññøt þë µsëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "unpackedArgWithVariadicParam": "[ZP3kP][นั้Üñpæçkëð ærgµmëñt çæññøt þë µsëð før TÿpëVærTµplë pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "unpackedArgWithVariadicParam": "[ZP3kP][นั้Üñpæçkëð ærgµmëñt çæññøt þë µsëð før TypeVarTuple pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "unpackedDictArgumentNotMapping": "[iSTnU][นั้Ærgµmëñt ëxprëssïøñ æftër ** mµst þë æ mæppïñg wïth æ \"str\" këÿ tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "unpackedDictSubscriptIllegal": "[slATr][นั้Ðïçtïøñærÿ µñpæçk øpërætør ïñ sµþsçrïpt ïs ñøt ælløwëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "unpackedSubscriptIllegal": "[2CpZz][นั้Üñpæçk øpërætør ïñ sµþsçrïpt rëqµïrës Pÿthøñ 3.11 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "unpackedTypeVarTupleExpected": "[tgdHs][นั้Ëxpëçtëð µñpæçkëð TÿpëVærTµplë; µsë Üñpæçk[{ñæmë1}] ør *{ñæmë2}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "unpackedTypedDictArgument": "[iCgjR][นั้Üñæþlë tø mætçh µñpæçkëð TÿpëðÐïçt ærgµmëñt tø pæræmëtërsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "unpackedTypeVarTupleExpected": "[tgdHs][นั้Ëxpëçtëð µñpæçkëð TypeVarTuple; µsë Unpack[{name1}] ør *{name2}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "unpackedTypedDictArgument": "[iCgjR][นั้Üñæþlë tø mætçh µñpæçkëð TypedDict ærgµmëñt tø pæræmëtërsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "unreachableCode": "[bpJSK][นั้Çøðë ïs µñrëæçhæþlëẤğ倪İЂҰक्นั้ढूँ]", "unreachableCodeType": "[v80nR][นั้Tÿpë æñælÿsïs ïñðïçætës çøðë ïs µñrëæçhæþlëẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "unreachableExcept": "[zFMWg][นั้Ëxçëpt çlæµsë ïs µñrëæçhæþlë þëçæµsë ëxçëptïøñ ïs ælrëæðÿ hæñðlëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "unsupportedDunderAllOperation": "[KsX0f][นั้Øpërætïøñ øñ \"__æll__\" ïs ñøt sµppørtëð, sø ëxpørtëð sÿmþøl lïst mæÿ þë ïñçørrëçtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "unreachableExcept": "[zFMWg][นั้Except çlæµsë ïs µñrëæçhæþlë þëçæµsë ëxçëptïøñ ïs ælrëæðÿ hæñðlëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "unsupportedDunderAllOperation": "[KsX0f][นั้Øpërætïøñ øñ \"__all__\" ïs ñøt sµppørtëð, sø ëxpørtëð sÿmþøl lïst mæÿ þë ïñçørrëçtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "unusedCallResult": "[9IsV5][นั้Rësµlt øf çæll ëxprëssïøñ ïs øf tÿpë \"{tÿpë}\" æñð ïs ñøt µsëð; æssïgñ tø værïæþlë \"_\" ïf thïs ïs ïñtëñtïøñælẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "unusedCoroutine": "[nQUJ2][นั้Rësµlt øf æsÿñç fµñçtïøñ çæll ïs ñøt µsëð; µsë \"æwæït\" ør æssïgñ rësµlt tø værïæþlëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "unusedCoroutine": "[nQUJ2][นั้Rësµlt øf async fµñçtïøñ çæll ïs ñøt µsëð; µsë \"æwæït\" ør æssïgñ rësµlt tø værïæþlëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", "unusedExpression": "[ghmaU][นั้Ëxprëssïøñ vælµë ïs µñµsëðẤğ倪İЂҰक्र्นั้ढूँ]", - "varAnnotationIllegal": "[v2cs9][นั้Tÿpë æññøtætïøñs før værïæþlës rëqµïrës Pÿthøñ 3.6 ør ñëwër; µsë tÿpë çømmëñt før çømpætïþïlïtÿ wïth prëvïøµs vërsïøñsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "variableFinalOverride": "[LcrNS][นั้Værïæþlë \"{ñæmë}\" ïs mærkëð Fïñæl æñð øvërrïðës ñøñ-Fïñæl værïæþlë øf sæmë ñæmë ïñ çlæss \"{çlæssÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "variadicTypeArgsTooMany": "[1QX0D][นั้Tÿpë ærgµmëñt lïst çæñ hævë æt møst øñë µñpæçkëð TÿpëVærTµplë ør tµplëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "variadicTypeParamTooManyAlias": "[43VIR][นั้Tÿpë ælïæs çæñ hævë æt møst øñë TÿpëVærTµplë tÿpë pæræmëtër þµt rëçëïvëð mµltïplë ({ñæmës})Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "variadicTypeParamTooManyClass": "[fboqC][นั้Gëñërïç çlæss çæñ hævë æt møst øñë TÿpëVærTµplë tÿpë pæræmëtër þµt rëçëïvëð mµltïplë ({ñæmës})Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "varAnnotationIllegal": "[v2cs9][นั้Tÿpë æññøtætïøñs før værïæþlës rëqµïrës Pÿthøñ 3.6 ør ñëwër; µsë type çømmëñt før çømpætïþïlïtÿ wïth prëvïøµs vërsïøñsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "variableFinalOverride": "[LcrNS][นั้Værïæþlë \"{ñæmë}\" ïs mærkëð Final æñð øvërrïðës ñøñ-Final værïæþlë øf sæmë ñæmë ïñ çlæss \"{çlæssÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "variadicTypeArgsTooMany": "[1QX0D][นั้Tÿpë ærgµmëñt lïst çæñ hævë æt møst øñë µñpæçkëð TypeVarTuple ør tupleẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "variadicTypeParamTooManyAlias": "[43VIR][นั้Tÿpë ælïæs çæñ hævë æt møst øñë TypeVarTuple tÿpë pæræmëtër þµt rëçëïvëð mµltïplë ({ñæmës})Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "variadicTypeParamTooManyClass": "[fboqC][นั้Gëñërïç çlæss çæñ hævë æt møst øñë TypeVarTuple tÿpë pæræmëtër þµt rëçëïvëð mµltïplë ({ñæmës})Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "walrusIllegal": "[iR3y3][นั้Øpërætør \":=\" rëqµïrës Pÿthøñ 3.8 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", "walrusNotAllowed": "[kdD5j][นั้Øpërætør \":=\" ïs ñøt ælløwëð ïñ thïs çøñtëxt wïthøµt sµrrøµñðïñg pærëñthësësẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "wildcardInFunction": "[NyGOv][นั้Wïlðçærð ïmpørt ñøt ælløwëð wïthïñ æ çlæss ør fµñçtïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "wildcardLibraryImport": "[Yk3ai][นั้Wïlðçærð ïmpørt frøm æ lïþrærÿ ñøt ælløwëðẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "wildcardInFunction": "[NyGOv][นั้Wïlðçærð import ñøt ælløwëð wïthïñ æ çlæss ør fµñçtïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "wildcardLibraryImport": "[Yk3ai][นั้Wïlðçærð import frøm æ lïþrærÿ ñøt ælløwëðẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", "wildcardPatternTypePartiallyUnknown": "[eRR5M][นั้Tÿpë çæptµrëð þÿ wïlðçærð pættërñ ïs pærtïællÿ µñkñøwñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "wildcardPatternTypeUnknown": "[Bo3gT][นั้Tÿpë çæptµrëð þÿ wïlðçærð pættërñ ïs µñkñøwñẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "yieldFromIllegal": "[DkXto][นั้Üsë øf \"ÿïëlð frøm\" rëqµïrës Pÿthøñ 3.3 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "yieldFromOutsideAsync": "[ZONEz][นั้\"ÿïëlð frøm\" ñøt ælløwëð ïñ æñ æsÿñç fµñçtïøñẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "yieldOutsideFunction": "[2lDBQ][นั้\"ÿïëlð\" ñøt ælløwëð øµtsïðë øf æ fµñçtïøñ ør læmþðæẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "yieldWithinComprehension": "[yALS5][นั้\"ÿïëlð\" ñøt ælløwëð ïñsïðë æ çømprëhëñsïøñẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "zeroCaseStatementsFound": "[ArU3j][นั้Mætçh stætëmëñt mµst ïñçlµðë æt lëæst øñë çæsë stætëmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "zeroLengthTupleNotAllowed": "[3gVpF][นั้Zërø-lëñgth tµplë ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]" + "yieldFromIllegal": "[DkXto][นั้Üsë øf \"yield from\" rëqµïrës Pÿthøñ 3.3 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "yieldFromOutsideAsync": "[ZONEz][นั้\"yield from\" ñøt ælløwëð ïñ æñ async fµñçtïøñẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "yieldOutsideFunction": "[2lDBQ][นั้\"yield\" ñøt ælløwëð øµtsïðë øf æ fµñçtïøñ ør læmþðæẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "yieldWithinComprehension": "[yALS5][นั้\"yield\" ñøt ælløwëð ïñsïðë æ çømprëhëñsïøñẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "zeroCaseStatementsFound": "[ArU3j][นั้Match stætëmëñt mµst ïñçlµðë æt lëæst øñë case stætëmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "zeroLengthTupleNotAllowed": "[3gVpF][นั้Zërø-lëñgth tuple ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]" }, "DiagnosticAddendum": { - "annotatedNotAllowed": "[Mws6g][นั้\"Æññøtætëð\" spëçïæl førm çæññøt þë µsëð wïth ïñstæñçë æñð çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "annotatedNotAllowed": "[Mws6g][นั้\"Annotated\" spëçïæl førm çæññøt þë µsëð wïth ïñstæñçë æñð çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", "argParam": "[nmvvb][นั้Ærgµmëñt çørrëspøñðs tø pæræmëtër \"{pæræmÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", "argParamFunction": "[7Xwg8][นั้Ærgµmëñt çørrëspøñðs tø pæræmëtër \"{pæræmÑæmë}\" ïñ fµñçtïøñ \"{fµñçtïøñÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "argsParamMissing": "[vg3b8][นั้Pæræmëtër \"*{pæræmÑæmë}\" hæs ñø çørrëspøñðïñg pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "argsPositionOnly": "[sNlU1][นั้Pøsïtïøñ-øñlÿ pæræmëtër mïsmætçh; ëxpëçtëð {ëxpëçtëð} þµt rëçëïvëð {rëçëïvëð}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", "argumentType": "[JJxeD][นั้Ærgµmëñt tÿpë ïs \"{tÿpë}\"Ấğ倪İЂҰक्र्นั้ढूँ]", "argumentTypes": "[Omlwm][นั้Ærgµmëñt tÿpës: ({tÿpës})Ấğ倪İЂҰक्र्นั้ढूँ]", - "assignToNone": "[z249G][นั้Tÿpë ïs ïñçømpætïþlë wïth \"Ñøñë\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]", - "asyncHelp": "[2nasS][นั้Ðïð ÿøµ mëæñ \"æsÿñç wïth\"?Ấğ倪İЂҰक्र्นั้ढूँ]", + "assignToNone": "[z249G][นั้Tÿpë ïs ñøt æssïgñæþlë tø \"None\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]", + "asyncHelp": "[2nasS][นั้Ðïð ÿøµ mëæñ \"async with\"?Ấğ倪İЂҰक्र्นั้ढूँ]", "baseClassIncompatible": "[oW6Ip][นั้ßæsë çlæss \"{þæsëÇlæss}\" ïs ïñçømpætïþlë wïth tÿpë \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "baseClassIncompatibleSubclass": "[mMUCH][นั้ßæsë çlæss \"{þæsëÇlæss}\" ðërïvës frøm \"{sµþçlæss}\" whïçh ïs ïñçømpætïþlë wïth tÿpë \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "baseClassOverriddenType": "[Hp8Sl][นั้ßæsë çlæss \"{þæsëÇlæss}\" prøvïðës tÿpë \"{tÿpë}\", whïçh ïs øvërrïððëñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "baseClassOverridesType": "[P7N4Y][นั้ßæsë çlæss \"{þæsëÇlæss}\" øvërrïðës wïth tÿpë \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "bytesTypePromotions": "[qIXYb][นั้§ët ðïsæþlëßÿtësTÿpëPrømøtïøñs tø fælsë tø ëñæþlë tÿpë prømøtïøñ þëhævïør før \"þÿtëærræÿ\" æñð \"mëmørÿvïëw\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "conditionalRequiresBool": "[k1G9a][นั้Mëthøð __þøøl__ før tÿpë \"{øpëræñðTÿpë}\" rëtµrñs tÿpë \"{þøølRëtµrñTÿpë}\" ræthër thæñ \"þøøl\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "bytesTypePromotions": "[qIXYb][นั้§ët disableBytesTypePromotions tø false tø ëñæþlë tÿpë prømøtïøñ þëhævïør før \"bytearray\" æñð \"memoryview\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "conditionalRequiresBool": "[k1G9a][นั้Mëthøð __bool__ før tÿpë \"{øpëræñðTÿpë}\" rëtµrñs tÿpë \"{þøølRëtµrñTÿpë}\" ræthër thæñ \"þøøl\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "dataClassFieldLocation": "[vQxtf][นั้Fïëlð ðëçlærætïøñẤğ倪İЂҰक्นั้ढूँ]", "dataClassFrozen": "[d4uiK][นั้\"{ñæmë}\" ïs frøzëñẤğ倪İЂҰक्นั้ढूँ]", "dataProtocolUnsupported": "[7gIT2][นั้\"{ñæmë}\" ïs æ ðætæ prøtøçølẤğ倪İЂҰक्र्तिृนั้ढूँ]", "descriptorAccessBindingFailed": "[RiEhE][นั้Fæïlëð tø þïñð mëthøð \"{ñæmë}\" før ðësçrïptør çlæss \"{çlæssÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "descriptorAccessCallFailed": "[8EXvg][นั้Fæïlëð tø çæll mëthøð \"{ñæmë}\" før ðësçrïptør çlæss \"{çlæssÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "finalMethod": "[zz1yN][นั้Fïñæl mëthøðẤğ倪İЂนั้ढूँ]", + "finalMethod": "[zz1yN][นั้Final mëthøðẤğ倪İЂนั้ढूँ]", "functionParamDefaultMissing": "[yWAIy][นั้Pæræmëtër \"{ñæmë}\" ïs mïssïñg ðëfæµlt ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "functionParamName": "[NrJqx][นั้Pæræmëtër ñæmë mïsmætçh: \"{ðëstÑæmë}\" vërsµs \"{srçÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "functionParamPositionOnly": "[XOhUP][นั้Pøsïtïøñ-øñlÿ pæræmëtër mïsmætçh; pæræmëtër \"{ñæmë}\" ïs ñøt pøsïtïøñ-øñlÿẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", @@ -665,15 +667,15 @@ "functionTooFewParams": "[575uy][นั้Fµñçtïøñ æççëpts tøø fëw pøsïtïøñæl pæræmëtërs; ëxpëçtëð {ëxpëçtëð} þµt rëçëïvëð {rëçëïvëð}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "functionTooManyParams": "[zj9vw][นั้Fµñçtïøñ æççëpts tøø mæñÿ pøsïtïøñæl pæræmëtërs; ëxpëçtëð {ëxpëçtëð} þµt rëçëïvëð {rëçëïvëð}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "genericClassNotAllowed": "[MDEt3][นั้Gëñërïç tÿpë wïth tÿpë ærgµmëñts ñøt ælløwëð før ïñstæñçë ør çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "incompatibleDeleter": "[LCJuj][นั้Prøpërtÿ ðëlëtër mëthøð ïs ïñçømpætïþlëẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "incompatibleGetter": "[yds2G][นั้Prøpërtÿ gëttër mëthøð ïs ïñçømpætïþlëẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "incompatibleSetter": "[GDoso][นั้Prøpërtÿ sëttër mëthøð ïs ïñçømpætïþlëẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "initMethodLocation": "[D4O2l][นั้Thë __ïñït__ mëthøð ïs ðëfïñëð ïñ çlæss \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "initMethodSignature": "[EULjB][นั้§ïgñætµrë øf __ïñït__ ïs \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]", - "initSubclassLocation": "[eEcCS][นั้Thë __ïñït_sµþçlæss__ mëthøð ïs ðëfïñëð ïñ çlæss \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "invariantSuggestionDict": "[OIoHo][นั้Çøñsïðër swïtçhïñg frøm \"ðïçt\" tø \"Mæppïñg\" whïçh ïs çøværïæñt ïñ thë vælµë tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "invariantSuggestionList": "[irYWI][นั้Çøñsïðër swïtçhïñg frøm \"lïst\" tø \"§ëqµëñçë\" whïçh ïs çøværïæñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "invariantSuggestionSet": "[64U47][นั้Çøñsïðër swïtçhïñg frøm \"sët\" tø \"Çøñtæïñër\" whïçh ïs çøværïæñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "incompatibleDeleter": "[LCJuj][นั้Property deleter mëthøð ïs ïñçømpætïþlëẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "incompatibleGetter": "[yds2G][นั้Property getter mëthøð ïs ïñçømpætïþlëẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "incompatibleSetter": "[GDoso][นั้Property setter mëthøð ïs ïñçømpætïþlëẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "initMethodLocation": "[D4O2l][นั้Thë __init__ mëthøð ïs ðëfïñëð ïñ çlæss \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "initMethodSignature": "[EULjB][นั้§ïgñætµrë øf __init__ ïs \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]", + "initSubclassLocation": "[eEcCS][นั้Thë __init_subclass__ mëthøð ïs ðëfïñëð ïñ çlæss \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "invariantSuggestionDict": "[OIoHo][นั้Çøñsïðër swïtçhïñg frøm \"dict\" tø \"Mapping\" whïçh ïs çøværïæñt ïñ thë vælµë tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "invariantSuggestionList": "[irYWI][นั้Çøñsïðër swïtçhïñg frøm \"list\" tø \"Sequence\" whïçh ïs çøværïæñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "invariantSuggestionSet": "[64U47][นั้Çøñsïðër swïtçhïñg frøm \"set\" tø \"Container\" whïçh ïs çøværïæñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "isinstanceClassNotSupported": "[uTDu4][นั้\"{tÿpë}\" ïs ñøt sµppørtëð før ïñstæñçë æñð çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "keyNotRequired": "[K1bDP][นั้\"{ñæmë}\" ïs ñøt æ rëqµïrëð këÿ ïñ \"{tÿpë}\", sø æççëss mæÿ rësµlt ïñ rµñtïmë ëxçëptïøñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "keyReadOnly": "[dhAH3][นั้\"{ñæmë}\" ïs æ rëæð-øñlÿ këÿ ïñ \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", @@ -681,36 +683,36 @@ "keyUndefined": "[6mQGu][นั้\"{ñæmë}\" ïs ñøt æ ðëfïñëð këÿ ïñ \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "kwargsParamMissing": "[KHgb2][นั้Pæræmëtër \"**{pæræmÑæmë}\" hæs ñø çørrëspøñðïñg pæræmëtërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "listAssignmentMismatch": "[fERKI][นั้Tÿpë \"{tÿpë}\" ïs ïñçømpætïþlë wïth tærgët lïstẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "literalAssignmentMismatch": "[17LiQ][นั้\"{søµrçëTÿpë}\" ïs ïñçømpætïþlë wïth tÿpë \"{ðëstTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "matchIsNotExhaustiveHint": "[3NR39][นั้Ïf ëxhæµstïvë hæñðlïñg ïs ñøt ïñtëñðëð, æðð \"çæsë _: pæss\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "literalAssignmentMismatch": "[17LiQ][นั้\"{søµrçëTÿpë}\" ïs ñøt æssïgñæþlë tø tÿpë \"{ðëstTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "matchIsNotExhaustiveHint": "[3NR39][นั้Ïf ëxhæµstïvë hæñðlïñg ïs ñøt ïñtëñðëð, æðð \"case _: pass\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "matchIsNotExhaustiveType": "[9RN1P][นั้Üñhæñðlëð tÿpë: \"{tÿpë}\"Ấğ倪İЂҰक्र्นั้ढूँ]", "memberAssignment": "[1WFCt][นั้Ëxprëssïøñ øf tÿpë \"{tÿpë}\" çæññøt þë æssïgñëð tø ættrïþµtë \"{ñæmë}\" øf çlæss \"{çlæssTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "memberIsAbstract": "[l912U][นั้\"{tÿpë}.{ñæmë}\" ïs ñøt ïmplëmëñtëðẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "memberIsAbstractMore": "[dgfwa][นั้æñð {çøµñt} mørë...Ấğ倪İЂҰक्นั้ढूँ]", - "memberIsClassVarInProtocol": "[ZZeb4][นั้\"{ñæmë}\" ïs ðëfïñëð æs æ ÇlæssVær ïñ prøtøçølẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "memberIsInitVar": "[0SGIB][นั้\"{ñæmë}\" ïs æñ ïñït-øñlÿ fïëlðẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "memberIsAbstractMore": "[dgfwa][นั้æñð {çøµñt} mørëẤğ倪İЂҰนั้ढूँ]...", + "memberIsClassVarInProtocol": "[ZZeb4][นั้\"{ñæmë}\" ïs ðëfïñëð æs æ ClassVar ïñ prøtøçølẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "memberIsInitVar": "[0SGIB][นั้\"{ñæmë}\" ïs æñ init-only fïëlðẤğ倪İЂҰक्र्तिृนั้ढूँ]", "memberIsInvariant": "[rBPX6][นั้\"{ñæmë}\" ïs ïñværïæñt þëçæµsë ït ïs mµtæþlëẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "memberIsNotClassVarInClass": "[bKhkE][นั้\"{ñæmë}\" mµst þë ðëfïñëð æs æ ÇlæssVær tø þë çømpætïþlë wïth prøtøçølẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "memberIsNotClassVarInProtocol": "[OAmE1][นั้\"{ñæmë}\" ïs ñøt ðëfïñëð æs æ ÇlæssVær ïñ prøtøçølẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "memberIsNotClassVarInClass": "[bKhkE][นั้\"{ñæmë}\" mµst þë ðëfïñëð æs æ ClassVar tø þë çømpætïþlë wïth prøtøçølẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "memberIsNotClassVarInProtocol": "[OAmE1][นั้\"{ñæmë}\" ïs ñøt ðëfïñëð æs æ ClassVar ïñ prøtøçølẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "memberIsNotReadOnlyInProtocol": "[TKk1U][นั้\"{ñæmë}\" ïs ñøt rëæð-øñlÿ ïñ prøtøçølẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", "memberIsReadOnlyInProtocol": "[xOSqy][นั้\"{ñæmë}\" ïs rëæð-øñlÿ ïñ prøtøçølẤğ倪İЂҰक्र्तिृนั้ढूँ]", "memberIsWritableInProtocol": "[x53Kg][นั้\"{ñæmë}\" ïs wrïtæþlë ïñ prøtøçølẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "memberSetClassVar": "[2pVfQ][นั้Ættrïþµtë \"{ñæmë}\" çæññøt þë æssïgñëð thrøµgh æ çlæss ïñstæñçë þëçæµsë ït ïs æ ÇlæssVærẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "memberSetClassVar": "[2pVfQ][นั้Ættrïþµtë \"{ñæmë}\" çæññøt þë æssïgñëð thrøµgh æ çlæss ïñstæñçë þëçæµsë ït ïs æ ClassVarẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "memberTypeMismatch": "[IHN4x][นั้\"{ñæmë}\" ïs æñ ïñçømpætïþlë tÿpëẤğ倪İЂҰक्र्तिृนั้ढूँ]", "memberUnknown": "[7kDIF][นั้Ættrïþµtë \"{ñæmë}\" ïs µñkñøwñẤğ倪İЂҰक्र्तिृนั้ढूँ]", "metaclassConflict": "[fjWW1][นั้Mëtæçlæss \"{mëtæçlæss1}\" çøñflïçts wïth \"{mëtæçlæss2}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "missingDeleter": "[5IVNI][นั้Prøpërtÿ ðëlëtër mëthøð ïs mïssïñgẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "missingGetter": "[Mzn4K][นั้Prøpërtÿ gëttër mëthøð ïs mïssïñgẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "missingSetter": "[goeIY][นั้Prøpërtÿ sëttër mëthøð ïs mïssïñgẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "missingDeleter": "[5IVNI][นั้Property deleter mëthøð ïs mïssïñgẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "missingGetter": "[Mzn4K][นั้Property getter mëthøð ïs mïssïñgẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "missingSetter": "[goeIY][นั้Property setter mëthøð ïs mïssïñgẤğ倪İЂҰक्र्तिृนั้ढूँ]", "namedParamMissingInDest": "[dc07X][นั้Ëxtræ pæræmëtër \"{ñæmë}\"Ấğ倪İЂҰक्र्นั้ढूँ]", "namedParamMissingInSource": "[N59fC][นั้Mïssïñg këÿwørð pæræmëtër \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまนั้ढूँ]", "namedParamTypeMismatch": "[9CAV6][นั้Këÿwørð pæræmëtër \"{ñæmë}\" øf tÿpë \"{søµrçëTÿpë}\" ïs ïñçømpætïþlë wïth tÿpë \"{ðëstTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "namedTupleNotAllowed": "[gAlSp][นั้ÑæmëðTµplë çæññøt þë µsëð før ïñstæñçë ør çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "newMethodLocation": "[n0dxL][นั้Thë __ñëw__ mëthøð ïs ðëfïñëð ïñ çlæss \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "newMethodSignature": "[NeWKO][นั้§ïgñætµrë øf __ñëw__ ïs \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]", - "newTypeClassNotAllowed": "[JQmcY][นั้Çlæss çrëætëð wïth ÑëwTÿpë çæññøt þë µsëð wïth ïñstæñçë æñð çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "namedTupleNotAllowed": "[gAlSp][นั้NamedTuple çæññøt þë µsëð før ïñstæñçë ør çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "newMethodLocation": "[n0dxL][นั้Thë __new__ mëthøð ïs ðëfïñëð ïñ çlæss \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "newMethodSignature": "[NeWKO][นั้§ïgñætµrë øf __new__ ïs \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]", + "newTypeClassNotAllowed": "[JQmcY][นั้Çlæss çrëætëð wïth NewType çæññøt þë µsëð wïth ïñstæñçë æñð çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", "noOverloadAssignable": "[FJ88c][นั้Ñø øvërløæðëð fµñçtïøñ mætçhës tÿpë \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "noneNotAllowed": "[Yn8Lx][นั้Ñøñë çæññøt þë µsëð før ïñstæñçë ør çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "noneNotAllowed": "[Yn8Lx][นั้None çæññøt þë µsëð før ïñstæñçë ør çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", "orPatternMissingName": "[kgiPM][นั้Mïssïñg ñæmës: {ñæmë}Ấğ倪İЂҰक्นั้ढूँ]", "overloadIndex": "[vNPxL][นั้Øvërløæð {ïñðëx} ïs thë çløsëst mætçhẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", "overloadNotAssignable": "[BA2kK][นั้Øñë ør mørë øvërløæðs øf \"{ñæmë}\" ïs ñøt æssïgñæþlëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", @@ -720,9 +722,9 @@ "overrideInvariantMismatch": "[uODzM][นั้Øvërrïðë tÿpë \"{øvërrïðëTÿpë}\" ïs ñøt thë sæmë æs þæsë tÿpë \"{þæsëTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", "overrideIsInvariant": "[j45KZ][นั้Værïæþlë ïs mµtæþlë sø ïts tÿpë ïs ïñværïæñtẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", "overrideNoOverloadMatches": "[vG14w][นั้Ñø øvërløæð sïgñætµrë ïñ øvërrïðë ïs çømpætïþlë wïth þæsë mëthøðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "overrideNotClassMethod": "[t5OaH][นั้ßæsë mëthøð ïs ðëçlærëð æs æ çlæssmëthøð þµt øvërrïðë ïs ñøtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "overrideNotClassMethod": "[t5OaH][นั้ßæsë mëthøð ïs ðëçlærëð æs æ classmethod þµt øvërrïðë ïs ñøtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "overrideNotInstanceMethod": "[e2Xo5][นั้ßæsë mëthøð ïs ðëçlærëð æs æñ ïñstæñçë mëthøð þµt øvërrïðë ïs ñøtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "overrideNotStaticMethod": "[Eu8Oy][นั้ßæsë mëthøð ïs ðëçlærëð æs æ stætïçmëthøð þµt øvërrïðë ïs ñøtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "overrideNotStaticMethod": "[Eu8Oy][นั้ßæsë mëthøð ïs ðëçlærëð æs æ staticmethod þµt øvërrïðë ïs ñøtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "overrideOverloadNoMatch": "[smVSW][นั้Øvërrïðë ðøës ñøt hæñðlë æll øvërløæðs øf þæsë mëthøðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "overrideOverloadOrder": "[HrUeN][นั้Øvërløæðs før øvërrïðë mëthøð mµst þë ïñ thë sæmë ørðër æs thë þæsë mëthøðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "overrideParamKeywordNoDefault": "[yIoa8][นั้Këÿwørð pæræmëtër \"{ñæmë}\" mïsmætçh: þæsë pæræmëtër hæs ðëfæµlt ærgµmëñt vælµë, øvërrïðë pæræmëtër ðøës ñøtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", @@ -737,20 +739,20 @@ "overrideReturnType": "[mdPwX][นั้Rëtµrñ tÿpë mïsmætçh: þæsë mëthøð rëtµrñs tÿpë \"{þæsëTÿpë}\", øvërrïðë rëtµrñs tÿpë \"{øvërrïðëTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", "overrideType": "[ryAgb][นั้ßæsë çlæss ðëfïñës tÿpë æs \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまนั้ढूँ]", "paramAssignment": "[HGg7D][นั้Pæræmëtër {ïñðëx}: tÿpë \"{søµrçëTÿpë}\" ïs ïñçømpætïþlë wïth tÿpë \"{ðëstTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "paramSpecMissingInOverride": "[AUge7][นั้Pæræm§pëç pæræmëtërs ærë mïssïñg ïñ øvërrïðë mëthøðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "paramSpecMissingInOverride": "[AUge7][นั้ParamSpec pæræmëtërs ærë mïssïñg ïñ øvërrïðë mëthøðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "paramType": "[hHLAX][นั้Pæræmëtër tÿpë ïs \"{pæræmTÿpë}\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]", "privateImportFromPyTypedSource": "[8gX6u][นั้Ïmpørt frøm \"{møðµlë}\" ïñstëæðẤğ倪İЂҰक्र्तिृนั้ढूँ]", "propertyAccessFromProtocolClass": "[h75EJ][นั้Æ prøpërtÿ ðëfïñëð wïthïñ æ prøtøçøl çlæss çæññøt þë æççëssëð æs æ çlæss værïæþlëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "propertyMethodIncompatible": "[dWDwG][นั้Prøpërtÿ mëthøð \"{ñæmë}\" ïs ïñçømpætïþlëẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "propertyMethodMissing": "[xWlRK][นั้Prøpërtÿ mëthøð \"{ñæmë}\" ïs mïssïñg ïñ øvërrïðëẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "propertyMissingDeleter": "[r2oGK][นั้Prøpërtÿ \"{ñæmë}\" hæs ñø ðëfïñëð ðëlëtërẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "propertyMissingSetter": "[Sr1R9][นั้Prøpërtÿ \"{ñæmë}\" hæs ñø ðëfïñëð sëttërẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "propertyMethodIncompatible": "[dWDwG][นั้Property mëthøð \"{ñæmë}\" ïs ïñçømpætïþlëẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "propertyMethodMissing": "[xWlRK][นั้Property mëthøð \"{ñæmë}\" ïs mïssïñg ïñ øvërrïðëẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "propertyMissingDeleter": "[r2oGK][นั้Property \"{ñæmë}\" hæs ñø ðëfïñëð deleterẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "propertyMissingSetter": "[Sr1R9][นั้Property \"{ñæmë}\" hæs ñø ðëfïñëð setterẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "protocolIncompatible": "[4uTqc][นั้\"{søµrçëTÿpë}\" ïs ïñçømpætïþlë wïth prøtøçøl \"{ðëstTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "protocolMemberMissing": "[Ad9PZ][นั้\"{ñæmë}\" ïs ñøt prësëñtẤğ倪İЂҰक्र्นั้ढूँ]", - "protocolRequiresRuntimeCheckable": "[c9ewn][นั้Prøtøçøl çlæss mµst þë @rµñtïmë_çhëçkæþlë tø þë µsëð wïth ïñstæñçë æñð çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "protocolRequiresRuntimeCheckable": "[c9ewn][นั้Protocol çlæss mµst þë @runtime_checkable tø þë µsëð wïth ïñstæñçë æñð çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", "protocolSourceIsNotConcrete": "[DnLrN][นั้\"{søµrçëTÿpë}\" ïs ñøt æ çøñçrëtë çlæss tÿpë æñð çæññøt þë æssïgñëð tø tÿpë \"{ðëstTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "protocolUnsafeOverlap": "[fKiUM][นั้Ættrïþµtës øf \"{ñæmë}\" hævë thë sæmë ñæmës æs thë prøtøçølẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "pyrightCommentIgnoreTip": "[raFZN][นั้Üsë \"# pÿrïght: ïgñørë[<ðïægñøstïç rµlës>] tø sµpprëss ðïægñøstïçs før æ sïñglë lïñëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "pyrightCommentIgnoreTip": "[raFZN][นั้Üsë \"# pyright: ignore[]\" tø sµpprëss ðïægñøstïçs før æ sïñglë lïñëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "readOnlyAttribute": "[k9waY][นั้Ættrïþµtë \"{ñæmë}\" ïs rëæð-øñlÿẤğ倪İЂҰक्र्तिृนั้ढूँ]", "seeClassDeclaration": "[8sx7n][นั้§ëë çlæss ðëçlærætïøñẤğ倪İЂҰक्นั้ढूँ]", "seeDeclaration": "[K0X6p][นั้§ëë ðëçlærætïøñẤğ倪İЂҰนั้ढूँ]", @@ -759,54 +761,54 @@ "seeParameterDeclaration": "[mBEpT][นั้§ëë pæræmëtër ðëçlærætïøñẤğ倪İЂҰक्र्นั้ढूँ]", "seeTypeAliasDeclaration": "[Pjnb8][นั้§ëë tÿpë ælïæs ðëçlærætïøñẤğ倪İЂҰक्र्นั้ढूँ]", "seeVariableDeclaration": "[M3EiY][นั้§ëë værïæþlë ðëçlærætïøñẤğ倪İЂҰक्र्นั้ढूँ]", - "tupleAssignmentMismatch": "[aLGep][นั้Tÿpë \"{tÿpë}\" ïs ïñçømpætïþlë wïth tærgët tµplëẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "tupleEntryTypeMismatch": "[ny8Sn][นั้Tµplë ëñtrÿ {ëñtrÿ} ïs ïñçørrëçt tÿpëẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "tupleSizeIndeterminateSrc": "[EnNiw][นั้Tµplë sïzë mïsmætçh; ëxpëçtëð {ëxpëçtëð} þµt rëçëïvëð ïñðëtërmïñætëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "tupleSizeIndeterminateSrcDest": "[lrxYh][นั้Tµplë sïzë mïsmætçh; ëxpëçtëð {ëxpëçtëð} ør mørë þµt rëçëïvëð ïñðëtërmïñætëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", - "tupleSizeMismatch": "[F2Yc7][นั้Tµplë sïzë mïsmætçh; ëxpëçtëð {ëxpëçtëð} þµt rëçëïvëð {rëçëïvëð}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "tupleSizeMismatchIndeterminateDest": "[6vxdi][นั้Tµplë sïzë mïsmætçh; ëxpëçtëð {ëxpëçtëð} ør mørë þµt rëçëïvëð {rëçëïvëð}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", - "typeAliasInstanceCheck": "[29G7K][นั้Tÿpë ælïæs çrëætëð wïth \"tÿpë\" stætëmëñt çæññøt þë µsëð wïth ïñstæñçë æñð çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "typeAssignmentMismatch": "[VF9B4][นั้Tÿpë \"{søµrçëTÿpë}\" ïs ïñçømpætïþlë wïth tÿpë \"{ðëstTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", - "typeBound": "[AIZri][นั้Tÿpë \"{søµrçëTÿpë}\" ïs ïñçømpætïþlë wïth þøµñð tÿpë \"{ðëstTÿpë}\" før tÿpë værïæþlë \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "typeConstrainedTypeVar": "[qHztb][นั้Tÿpë \"{tÿpë}\" ïs ïñçømpætïþlë wïth çøñstræïñëð tÿpë værïæþlë \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", - "typeIncompatible": "[L3llJ][นั้\"{søµrçëTÿpë}\" ïs ïñçømpætïþlë wïth \"{ðëstTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "tupleAssignmentMismatch": "[aLGep][นั้Tÿpë \"{tÿpë}\" ïs ïñçømpætïþlë wïth tærgët tupleẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "tupleEntryTypeMismatch": "[ny8Sn][นั้Tuple ëñtrÿ {ëñtrÿ} ïs ïñçørrëçt tÿpëẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "tupleSizeIndeterminateSrc": "[EnNiw][นั้Tuple sïzë mïsmætçh; ëxpëçtëð {ëxpëçtëð} þµt rëçëïvëð ïñðëtërmïñætëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "tupleSizeIndeterminateSrcDest": "[lrxYh][นั้Tuple sïzë mïsmætçh; ëxpëçtëð {ëxpëçtëð} ør mørë þµt rëçëïvëð ïñðëtërmïñætëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "tupleSizeMismatch": "[F2Yc7][นั้Tuple sïzë mïsmætçh; ëxpëçtëð {ëxpëçtëð} þµt rëçëïvëð {rëçëïvëð}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "tupleSizeMismatchIndeterminateDest": "[6vxdi][นั้Tuple sïzë mïsmætçh; ëxpëçtëð {ëxpëçtëð} ør mørë þµt rëçëïvëð {rëçëïvëð}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", + "typeAliasInstanceCheck": "[29G7K][นั้Tÿpë ælïæs çrëætëð wïth \"type\" stætëmëñt çæññøt þë µsëð wïth ïñstæñçë æñð çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", + "typeAssignmentMismatch": "[VF9B4][นั้Tÿpë \"{søµrçëTÿpë}\" ïs ñøt æssïgñæþlë tø tÿpë \"{ðëstTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "typeBound": "[AIZri][นั้Tÿpë \"{søµrçëTÿpë}\" ïs ñøt æssïgñæþlë tø µppër þøµñð \"{ðëstTÿpë}\" før tÿpë værïæþlë \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "typeConstrainedTypeVar": "[qHztb][นั้Tÿpë \"{tÿpë}\" ïs ñøt æssïgñæþlë tø çøñstræïñëð tÿpë værïæþlë \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]", + "typeIncompatible": "[L3llJ][นั้\"{søµrçëTÿpë}\" ïs ñøt æssïgñæþlë tø \"{ðëstTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", "typeNotClass": "[DTm1E][นั้\"{tÿpë}\" ïs ñøt æ çlæssẤğ倪İЂҰक्र्นั้ढूँ]", "typeNotStringLiteral": "[D7UY3][นั้\"{tÿpë}\" ïs ñøt æ strïñg lïtërælẤğ倪İЂҰक्र्तिृนั้ढूँ]", "typeOfSymbol": "[qlRHN][นั้Tÿpë øf \"{ñæmë}\" ïs \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]", - "typeParamSpec": "[m23b5][นั้Tÿpë \"{tÿpë}\" ïs ïñçømpætïþlë wïth Pæræm§pëç \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "typeParamSpec": "[m23b5][นั้Tÿpë \"{tÿpë}\" ïs ïñçømpætïþlë wïth ParamSpec \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "typeUnsupported": "[Dx3Cx][นั้Tÿpë \"{tÿpë}\" ïs µñsµppørtëðẤğ倪İЂҰक्र्तिृนั้ढूँ]", "typeVarDefaultOutOfScope": "[05ALy][นั้Tÿpë værïæþlë \"{ñæmë}\" ïs ñøt ïñ sçøpëẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]", "typeVarIsContravariant": "[kup2Y][นั้Tÿpë pæræmëtër \"{ñæmë}\" ïs çøñtræværïæñt, þµt \"{søµrçëTÿpë}\" ïs ñøt æ sµpërtÿpë øf \"{ðëstTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "typeVarIsCovariant": "[EeRng][นั้Tÿpë pæræmëtër \"{ñæmë}\" ïs çøværïæñt, þµt \"{søµrçëTÿpë}\" ïs ñøt æ sµþtÿpë øf \"{ðëstTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "typeVarIsInvariant": "[WLZaN][นั้Tÿpë pæræmëtër \"{ñæmë}\" ïs ïñværïæñt, þµt \"{søµrçëTÿpë}\" ïs ñøt thë sæmë æs \"{ðëstTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "typeVarNotAllowed": "[37OGF][นั้TÿpëVær ñøt ælløwëð før ïñstæñçë ør çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", - "typeVarTupleRequiresKnownLength": "[GGttd][นั้TÿpëVærTµplë çæññøt þë þøµñð tø æ tµplë øf µñkñøwñ lëñgthẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", + "typeVarNotAllowed": "[37OGF][นั้TypeVar ñøt ælløwëð før ïñstæñçë ør çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", + "typeVarTupleRequiresKnownLength": "[GGttd][นั้TypeVarTuple çæññøt þë þøµñð tø æ tuple øf µñkñøwñ lëñgthẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "typeVarUnnecessarySuggestion": "[k0XTd][นั้Üsë {tÿpë} ïñstëæðẤğ倪İЂҰक्นั้ढूँ]", "typeVarUnsolvableRemedy": "[PaRa7][นั้Prøvïðë æñ øvërløæð thæt spëçïfïës thë rëtµrñ tÿpë whëñ thë ærgµmëñt ïs ñøt sµpplïëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", "typeVarsMissing": "[R1SEV][นั้Mïssïñg tÿpë værïæþlës: {ñæmës}Ấğ倪İЂҰक्र्तिृนั้ढूँ]", - "typedDictBaseClass": "[Zv6vP][นั้Çlæss \"{tÿpë}\" ïs ñøt æ TÿpëðÐïçtẤğ倪İЂҰक्र्तिृนั้ढूँ]", - "typedDictClassNotAllowed": "[Vgl7x][นั้TÿpëðÐïçt çlæss ñøt ælløwëð før ïñstæñçë ør çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "typedDictBaseClass": "[Zv6vP][นั้Çlæss \"{tÿpë}\" ïs ñøt æ TypedDictẤğ倪İЂҰक्र्तिृนั้ढूँ]", + "typedDictClassNotAllowed": "[Vgl7x][นั้TypedDict çlæss ñøt ælløwëð før ïñstæñçë ør çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "typedDictClosedExtraNotAllowed": "[zT7Rm][นั้Çæññøt æðð ïtëm \"{ñæmë}\"Ấğ倪İЂҰक्र्นั้ढूँ]", "typedDictClosedExtraTypeMismatch": "[blC1e][นั้Çæññøt æðð ïtëm \"{ñæmë}\" wïth tÿpë \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "typedDictClosedFieldNotRequired": "[6rtDR][นั้Çæññøt æðð ïtëm \"{ñæmë}\" þëçæµsë ït mµst þë ÑøtRëqµïrëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "typedDictClosedFieldNotRequired": "[6rtDR][นั้Çæññøt æðð ïtëm \"{ñæmë}\" þëçæµsë ït mµst þë NotRequiredẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "typedDictExtraFieldNotAllowed": "[kFDh9][นั้\"{ñæmë}\" ïs ñøt prësëñt ïñ \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまนั้ढूँ]", - "typedDictExtraFieldTypeMismatch": "[DnAhM][นั้Tÿpë øf \"{ñæmë}\" ïs ïñçømpætïþlë wïth tÿpë øf \"__ëxtræ_ïtëms__\" ïñ \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", + "typedDictExtraFieldTypeMismatch": "[DnAhM][นั้Tÿpë øf \"{ñæmë}\" ïs ïñçømpætïþlë wïth tÿpë øf \"__extra_items__\" ïñ \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]", "typedDictFieldMissing": "[rNzn7][นั้\"{ñæmë}\" ïs mïssïñg frøm \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]", "typedDictFieldNotReadOnly": "[BJy1V][นั้\"{ñæmë}\" ïs ñøt rëæð-øñlÿ ïñ \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤนั้ढूँ]", "typedDictFieldNotRequired": "[eqatW][นั้\"{ñæmë}\" ïs ñøt rëqµïrëð ïñ \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまนั้ढूँ]", "typedDictFieldRequired": "[ckyH4][นั้\"{ñæmë}\" ïs rëqµïrëð ïñ \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]", "typedDictFieldTypeMismatch": "[XYIBH][นั้Tÿpë \"{tÿpë}\" ïs ñøt æssïgñæþlë tø ïtëm \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]", "typedDictFieldUndefined": "[UsDC9][นั้\"{ñæmë}\" ïs æñ µñðëfïñëð ïtëm ïñ tÿpë \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "typedDictFinalMismatch": "[tFb04][นั้\"{søµrçëTÿpë}\" ïs ïñçømpætïþlë wïth \"{ðëstTÿpë}\" þëçæµsë øf æ @fïñæl mïsmætçhẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "typedDictKeyAccess": "[67DLq][นั้Üsë [\"{ñæmë}\"] tø rëfërëñçë ïtëm ïñ TÿpëðÐïçtẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "typedDictNotAllowed": "[eTsPP][นั้TÿpëðÐïçt çæññøt þë µsëð før ïñstæñçë ør çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "typedDictFinalMismatch": "[tFb04][นั้\"{søµrçëTÿpë}\" ïs ïñçømpætïþlë wïth \"{ðëstTÿpë}\" þëçæµsë øf æ @final mïsmætçhẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "typedDictKeyAccess": "[67DLq][นั้Üsë [\"{ñæmë}\"] tø rëfërëñçë ïtëm ïñ TypedDictẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "typedDictNotAllowed": "[eTsPP][นั้TypedDict çæññøt þë µsëð før ïñstæñçë ør çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "unhashableType": "[IJEeq][นั้Tÿpë \"{tÿpë}\" ïs ñøt hæshæþlëẤğ倪İЂҰक्र्तिृนั้ढूँ]", "uninitializedAbstractVariable": "[uDuHt][นั้Ïñstæñçë værïæþlë \"{ñæmë}\" ïs ðëfïñëð ïñ æþstræçt þæsë çlæss \"{çlæssTÿpë}\" þµt ñøt ïñïtïælïzëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]", "unreachableExcept": "[3CSUL][นั้\"{ëxçëptïøñTÿpë}\" ïs æ sµþçlæss øf \"{pærëñtTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]", - "useDictInstead": "[LReB5][นั้Üsë Ðïçt[T1, T2] tø ïñðïçætë æ ðïçtïøñærÿ tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", - "useListInstead": "[RPu0E][นั้Üsë £ïst[T] tø ïñðïçætë æ lïst tÿpë ør Üñïøñ[T1, T2] tø ïñðïçætë æ µñïøñ tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", - "useTupleInstead": "[jaFqC][นั้Üsë tµplë[T1, ..., Tñ] tø ïñðïçætë æ tµplë tÿpë ør Üñïøñ[T1, T2] tø ïñðïçætë æ µñïøñ tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", - "useTypeInstead": "[Zig8D][นั้Üsë Tÿpë[T] ïñstëæðẤğ倪İЂҰक्นั้ढूँ]", + "useDictInstead": "[LReB5][นั้Üsë Dict[T1, T2] tø ïñðïçætë æ ðïçtïøñærÿ tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]", + "useListInstead": "[RPu0E][นั้Üsë List[T] tø ïñðïçætë æ list tÿpë ør Union[T1, T2] tø ïñðïçætë æ union tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]", + "useTupleInstead": "[jaFqC][นั้Üsë tuple[T1, ..., Tn] tø ïñðïçætë æ tuple tÿpë ør Union[T1, T2] tø ïñðïçætë æ union tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", + "useTypeInstead": "[Zig8D][นั้Üsë Type[T] ïñstëæðẤğ倪İЂҰक्นั้ढूँ]", "varianceMismatchForClass": "[fqhIl][นั้Værïæñçë øf tÿpë ærgµmëñt \"{tÿpëVærÑæmë}\" ïs ïñçømpætïþlë wïth þæsë çlæss \"{çlæssÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]", "varianceMismatchForTypeAlias": "[YSiVx][นั้Værïæñçë øf tÿpë ærgµmëñt \"{tÿpëVærÑæmë}\" ïs ïñçømpætïþlë wïth \"{tÿpëÆlïæsPæræm}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]" }, diff --git a/packages/pyright-internal/src/localization/package.nls.ru.json b/packages/pyright-internal/src/localization/package.nls.ru.json index 13c3d92b4..83886159e 100644 --- a/packages/pyright-internal/src/localization/package.nls.ru.json +++ b/packages/pyright-internal/src/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,20 +576,20 @@ "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}\"", "unnecessaryIsSubclassAlways": "Ненужный вызов issubclass. \"{testType}\" всегда является подклассом \"{classType}\"", @@ -595,13 +597,13 @@ "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 +618,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 +667,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 +683,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 +701,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 +712,7 @@ "newMethodSignature": "Сигнатура метода __new__ требует \"{type}\"", "newTypeClassNotAllowed": "Класс, созданный с NewType, нельзя использовать с проверками экземпляров и классов", "noOverloadAssignable": "Нет перегруженной функции, соответствующей типу \"{type}\"", - "noneNotAllowed": "Их невозможно использовать для проверок экземпляров или классов", + "noneNotAllowed": "None невозможно использовать для проверок экземпляров или классов", "orPatternMissingName": "Отсутствуют имена: {name}", "overloadIndex": "Наилучшее совпадение: {index} перегрузки", "overloadNotAssignable": "Одна или несколько перегрузок \"{name}\" не подлежат присвоению", @@ -722,7 +724,7 @@ "overrideNoOverloadMatches": "В переопределении нет сигнатуры перегрузки, совместимой с базовым методом", "overrideNotClassMethod": "Базовый метод объявлен как classmethod, а его переопределение — нет", "overrideNotInstanceMethod": "Базовый метод объявлен как метод экземпляра, а его переопределение — нет", - "overrideNotStaticMethod": "Базовый метод объявлен как статический, а его переопределение — нет", + "overrideNotStaticMethod": "Базовый метод объявлен как staticmethod, а его переопределение — нет", "overrideOverloadNoMatch": "Переопределение не обрабатывает все перегрузки базового метода", "overrideOverloadOrder": "Перегрузки в методе переопределения должны располагаться в том же порядке, что и в базовом методе", "overrideParamKeywordNoDefault": "Несоответствие параметра ключевого слова \"{name}\": базовый параметр содержит значение аргумента по умолчанию, параметр переопределения — нет", @@ -741,16 +743,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[]\"", "readOnlyAttribute": "Атрибут \"{name}\" доступен только для чтения", "seeClassDeclaration": "См. объявление класса", "seeDeclaration": "См. объявление", @@ -759,17 +761,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 +782,7 @@ "typeVarIsCovariant": "Параметр типа \"{name}\" является ковариантным, но \"{sourceType}\" не является подтипом \"{destType}\"", "typeVarIsInvariant": "Параметр типа \"{name}\" является инвариантным, но \"{sourceType}\" не совпадает с \"{destType}\"", "typeVarNotAllowed": "TypeVar не допускается для проверок экземпляров или классов", - "typeVarTupleRequiresKnownLength": "TypeVarTuple не может граничить с кортежем неизвестной длины", + "typeVarTupleRequiresKnownLength": "TypeVarTuple не может граничить с tuple неизвестной длины", "typeVarUnnecessarySuggestion": "Вместо этого используйте {type}", "typeVarUnsolvableRemedy": "Укажите перегрузку, которая указывает тип возвращаемого значения, если аргумент не передается", "typeVarsMissing": "Отсутствуют переменные типа: {names}", @@ -788,7 +790,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 +799,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}\"" diff --git a/packages/pyright-internal/src/localization/package.nls.tr.json b/packages/pyright-internal/src/localization/package.nls.tr.json index b3926da65..b42e81f8f 100644 --- a/packages/pyright-internal/src/localization/package.nls.tr.json +++ b/packages/pyright-internal/src/localization/package.nls.tr.json @@ -1,7 +1,7 @@ { "CodeAction": { - "createTypeStub": "Tür Saplaması Oluştur", - "createTypeStubFor": "\"{moduleName}\" için Tür Saplaması Oluştur", + "createTypeStub": "Tür Stub Oluştur", + "createTypeStubFor": "\"{moduleName}\" için Tür Stub Oluştur", "executingCommand": "Komut yürütülüyor", "filesToAnalyzeCount": "analiz edilecek {count} dosya var", "filesToAnalyzeOne": "Analiz edilecek 1 dosya", @@ -18,12 +18,12 @@ "annotatedMetadataInconsistent": "\"{metadataType}\" not eklenmiş meta veri türü \"{type}\" türüyle uyumlu değil", "annotatedParamCountMismatch": "Parametre ek açıklama sayısı uyuşmazlığı: {expected} bekleniyordu ancak {received} alındı", "annotatedTypeArgMissing": "\"Annotated\" için bir tür bağımsız değişkeni ve bir veya daha fazla ek açıklama bekleniyordu", - "annotationBytesString": "Tür ek açıklamaları bayt sabit değerli dizeleri kullanamaz", - "annotationFormatString": "Tür ek açıklamaları biçim dizesi sabit değerlerini (f-strings) kullanamaz", + "annotationBytesString": "Tür ifadeleri bayt sabit değerli dizeleri kullanamaz", + "annotationFormatString": "Tür ifadeleri biçim dizesi sabit değerlerini (f-strings) kullanamaz", "annotationNotSupported": "Tür ek açıklaması bu deyim için desteklenmiyor", - "annotationRawString": "Tür ek açıklamaları ham sabit değerli dizeleri kullanamaz", - "annotationSpansStrings": "Tür ek açıklamaları birden çok dize sabit değerine yayılamaz", - "annotationStringEscape": "Tür ek açıklamaları kaçış karakterleri içeremez", + "annotationRawString": "Tür ifadeleri ham dize sabit değerlerini kullanamaz", + "annotationSpansStrings": "Tür ifadeleri birden çok dize sabit değerine yayılamaz", + "annotationStringEscape": "Tür ifadeleri kaçış karakterleri içeremez", "argAssignment": "\"{argType}\" türünde bağımsız değişken, \"{paramType}\" türündeki parametreye atanamaz", "argAssignmentFunction": "\"{argType}\" türünde bağımsız değişken, \"{functionName}\" işlevi içinde \"{paramType}\" türündeki parametreye atanamaz", "argAssignmentParam": "\"{argType}\" türünde bağımsız değişken, \"{paramName}\" türündeki \"{paramType}\" parametresine atanamaz", @@ -43,12 +43,12 @@ "assignmentExprComprehension": "\"{name}\" atama ifadesi hedefi, hedef için anlama ile aynı adı kullanamaz", "assignmentExprContext": "Atama ifadesi modül, işlev veya lambda içinde olmalıdır", "assignmentExprInSubscript": "Bir alt simge içindeki atama ifadeleri yalnızca Python 3.10 ve daha yeni sürümlerinde desteklenir", - "assignmentInProtocol": "Protokol sınıfı içindeki örnek veya sınıf değişkenleri sınıf gövdesi içinde açıkça bildirilmelidir", + "assignmentInProtocol": "Instance or class variables within a Protocol class must be explicitly declared within the class body", "assignmentTargetExpr": "İfade, atama hedefi olamaz", - "asyncNotInAsyncFunction": "Zaman uyumsuz işlevin dışında \"async\" kullanımına izin verilmez", + "asyncNotInAsyncFunction": "Use of \"async\" not allowed outside of async function", "awaitIllegal": "\"await\" kullanımı için Python 3.5 veya daha yeni bir sürümü gerekiyor", - "awaitNotAllowed": "Tür ek açıklamaları \"await\" kullanamaz", - "awaitNotInAsync": "\"await\" öğesi yalnızca zaman uyumsuz işlev içinde kullanılabilir", + "awaitNotAllowed": "Tür ifadeleri \"await\" kullanamaz", + "awaitNotInAsync": "\"await\" öğesi yalnızca async işlev içinde kullanılabilir", "backticksIllegal": "Eski kesme işaretleri arasında yer almayan ifadeler Python3.x’de desteklenmiyor; bunun yerine repr kullanın", "baseClassCircular": "Sınıf kendi türevi olamaz", "baseClassFinal": "\"{type}\" temel sınıfı final olarak işaretlendi ve alt sınıf olamaz", @@ -57,7 +57,7 @@ "baseClassMethodTypeIncompatible": "\"{classType}\" sınıfına ait temel sınıflar, \"{name}\" metodunu uyumsuz bir şekilde tanımlıyor", "baseClassUnknown": "Temel sınıf türü bilinmiyor, türetilmiş sınıfı gizliyor", "baseClassVariableTypeIncompatible": "\"{classType}\" sınıfı için temel sınıflar, \"{name}\" değişkenini uyumsuz bir şekilde tanımlıyor", - "binaryOperationNotAllowed": "Tür ek açıklamasında ikili işleç kullanılamaz", + "binaryOperationNotAllowed": "Tür ifadesinde ikili işleç kullanılamaz", "bindTypeMismatch": "\"{type}\", \"{paramName}\" parametresine atanamadığından \"{methodName}\" metodu bağlanamadı", "breakOutsideLoop": "\"break\" yalnızca bir döngü içinde kullanılabilir", "callableExtraArgs": "\"Callable\" için yalnızca iki tür bağımsız değişkeni bekleniyordu", @@ -70,7 +70,7 @@ "classDefinitionCycle": "\"{name}\" için sınıf tanımı kendisine bağımlı", "classGetItemClsParam": "__class_getitem__ geçersiz kılması bir \"cls\" parametresi almalı", "classMethodClsParam": "Sınıf metotları bir \"cls\" parametresi almalıdır", - "classNotRuntimeSubscriptable": "\"{name}\" sınıfına ait alt simge çalışma zamanı özel durumunu oluşturur; tür ek açıklamalarını tırnak içine alın", + "classNotRuntimeSubscriptable": "\"{name}\" sınıfına ait alt simge çalışma zamanı özel durumunu oluşturur; tür ifadelerini tırnak içine alın", "classPatternBuiltInArgPositional": "Sınıf deseni yalnızca konumsal alt desen kabul eder", "classPatternPositionalArgCount": "\"{type}\" sınıfı için çok fazla konumsal desen var; {expected} bekleniyordu ancak {received} alındı", "classPatternTypeAlias": "\"{type}\" özel bir tür diğer adı olduğundan sınıf deseninde kullanılamaz", @@ -87,10 +87,10 @@ "comparisonAlwaysFalse": "\"{leftType}\" türleri ve \"{rightType}\" türleri çakışmadığından koşul her zaman False olarak değerlendirilir", "comparisonAlwaysTrue": "\"{leftType}\" ve \"{rightType}\" türleri çakışmadığından ifade her zaman True olarak değerlendirilir", "comprehensionInDict": "Anlama diğer küme girdileri ile kullanılamaz", - "comprehensionInSet": "Anlama diğer küme girdileri ile kullanılamaz", + "comprehensionInSet": "Anlama diğer set ile kullanılamaz", "concatenateContext": "Bu bağlamda \"Concatenate\" kullanılamaz", "concatenateParamSpecMissing": "\"Concatenate\" için son tür bağımsız değişkeni bir ParamSpec veya \"...\" olmalıdır", - "concatenateTypeArgsMissing": "\"Birleştirme\" en az iki tür bağımsız değişken gerektirir", + "concatenateTypeArgsMissing": "\"Concatenate\" en az iki tür bağımsız değişken gerektirir", "conditionalOperandInvalid": "\"{type}\" türündeki koşullu işlenen geçersiz", "constantRedefinition": "\"{name}\" sabit (büyük harf olduğundan) ve yeniden tanımlanamaz", "constructorParametersMismatch": "\"{classType}\" sınıfındaki __new__ ve __init__ imzaları arasında uyuşmazlık var", @@ -111,7 +111,7 @@ "dataClassPostInitType": "Veri sınıfı __post_init__ metodu parametre türü ile \"{fieldName}\" alanı uyuşmuyor", "dataClassSlotsOverwrite": "__slots__ zaten sınıfta tanımlı", "dataClassTransformExpectedBoolLiteral": "Statik olarak True veya False olarak değerlendirilen ifade bekleniyordu", - "dataClassTransformFieldSpecifier": "Sınıfların veya işlevlerin demeti bekleniyordu ancak \"{type}\" türü alındı", + "dataClassTransformFieldSpecifier": "Sınıfların veya işlevlerin tuple bekleniyordu ancak \"{type}\" türü alındı", "dataClassTransformPositionalParam": "\"dataclass_transform\" için tüm bağımsız değişkenlerin anahtar sözcük bağımsız değişkenleri olması gerekiyor", "dataClassTransformUnknownArgument": "\"{name}\" bağımsız değişkeni, dataclass_transform tarafından desteklenmiyor", "dataProtocolInSubclassCheck": "issubclass çağrılarında veri protokollerine (yöntem dışı öznitelikler dahil) izin verilmez", @@ -127,12 +127,12 @@ "deprecatedDescriptorSetter": "\"{name}\" tanımlayıcısı için \"__set__\" yöntemi kullanım dışı", "deprecatedFunction": "\"{name}\" işlevi kullanım dışı", "deprecatedMethod": "\"{className}\" sınıfındaki \"{name}\" yöntemi kullanım dışı", - "deprecatedPropertyDeleter": "\"{name}\" özelliği silicisi kullanım dışı", - "deprecatedPropertyGetter": "\"{name}\" özelliği alıcısı kullanım dışı", - "deprecatedPropertySetter": "\"{name}\" özelliği ayarlayıcısı kullanım dışı", + "deprecatedPropertyDeleter": "\"{name}\" property deleter kullanım dışı", + "deprecatedPropertyGetter": "\"{name}\" property getter kullanım dışı", + "deprecatedPropertySetter": "\"{name}\" property setter kullanım dışı", "deprecatedType": "Bu tür Python {version} sürümünden itibaren kullanım dışı; bunun yerine \"{replacement}\" kullanın", "dictExpandIllegalInComprehension": "Sözlük genişletmeye anlamada izin verilmiyor", - "dictInAnnotation": "Tür ek açıklamasında sözlük ifadesi kullanılamaz", + "dictInAnnotation": "Tür ifadesinde sözlük ifadesi kullanılamaz", "dictKeyValuePairs": "Sözlük girdileri anahtar/değer çiftleri içermelidir", "dictUnpackIsNotMapping": "Sözlük açma işleci için eşleme bekleniyordu", "dunderAllSymbolNotPresent": "\"{name}\" __all__ ile belirtildi ancak modülde yok", @@ -140,8 +140,8 @@ "duplicateBaseClass": "Yinelenen temel sınıfa izin verilmiyor", "duplicateCapturePatternTarget": "\"{name}\" yakalama hedefi, aynı desen içinde birden çok kez bulunamaz", "duplicateCatchAll": "Yalnızca bir catch-all except yan tümcesine izin verilir", - "duplicateEnumMember": "\"{name}\" sabit listesi üyesi zaten bildirildi", - "duplicateGenericAndProtocolBase": "Yalnızca bir Genel[...] veya Protocol[...] temel sınıfı kullanılabilir", + "duplicateEnumMember": "Enum member \"{name}\" is already declared", + "duplicateGenericAndProtocolBase": "Yalnızca bir Generic[...] veya Protocol[...] temel sınıfı kullanılabilir", "duplicateImport": "\"{importName}\" birden çok kez içeri aktarıldı", "duplicateKeywordOnly": "Yalnızca bir \"*\" ayırıcısı kullanılabilir", "duplicateKwargsParam": "Yalnızca bir \"**\" parametresine izin verilir", @@ -149,14 +149,14 @@ "duplicatePositionOnly": "Yalnızca bir \"/\" parametresine izin verilir", "duplicateStarPattern": "Desen dizisinde yalnızca bir \"*\" desenine izin verilir", "duplicateStarStarPattern": "Yalnızca bir \"**\" girdisine izin verilir", - "duplicateUnpack": "Listede yalnızca bir paket açma işlemine izin veriliyor", + "duplicateUnpack": "Only one unpack operation allowed in list", "ellipsisAfterUnpacked": "\"...\" paketlenmemiş TypeVarTuple veya tuple ile kullanılamaz", "ellipsisContext": "\"...\" kullanımına bu bağlamda izin verilmiyor", "ellipsisSecondArg": "\"...\" yalnızca iki bağımsız değişkenin ikincisi olarak kullanılabilir", - "enumClassOverride": "\"{name}\" sabit listesi sınıfı final niteliğinde ve alt sınıf olamaz", - "enumMemberDelete": "Sabit liste üyesi \"{name}\" silinemiyor", - "enumMemberSet": "Sabit liste üyesi \"{name}\" atanamıyor", - "enumMemberTypeAnnotation": "Sabit listesi üyeleri için tür ek açıklamalarına izin verilmiyor", + "enumClassOverride": "Enum class \"{name}\" is final and cannot be subclassed", + "enumMemberDelete": "Enum üyesi \"{name}\" silinemiyor", + "enumMemberSet": "Enum üyesi \"{name}\" atanamıyor", + "enumMemberTypeAnnotation": "Type annotations are not allowed for enum members", "exceptionGroupIncompatible": "Özel durum grubu söz dizimi (\"except*\") için Python 3.11 veya daha yeni bir sürümü gerekiyor", "exceptionGroupTypeIncorrect": "except* altındaki özel durum türü BaseGroupException değerinden türetilemiyor", "exceptionTypeIncorrect": "\"{type}\", BaseException türevi değil", @@ -189,7 +189,7 @@ "expectedIdentifier": "Tanımlayıcı bekleniyordu", "expectedImport": "\"import\" bekleniyordu", "expectedImportAlias": "\"as\" sonrasında sembol bekleniyordu", - "expectedImportSymbols": "İçeri aktarmadan sonra bir veya daha fazla sembol adı bekleniyordu", + "expectedImportSymbols": "\"import\" sonrasında bir veya daha fazla sembol adı bekleniyordu", "expectedIn": "\"in\" bekleniyordu", "expectedInExpr": "\"in\" sonrasında ifade bekleniyordu", "expectedIndentedBlock": "Girintili blok bekleniyordu", @@ -208,13 +208,13 @@ "expectedSliceIndex": "Dizin veya dilim ifadesi bekleniyordu", "expectedTypeNotString": "Tür bekleniyordu ancak sabit değerli dize alındı", "expectedTypeParameterName": "Beklenen tür parametresi adı", - "expectedYieldExpr": "Yield deyiminde ifade bekleniyordu", - "finalClassIsAbstract": "\"{type}\" sınıfı son olarak işaretlendi ve tüm soyut sembolleri uygulamalıdır", + "expectedYieldExpr": "Expected expression in yield statement", + "finalClassIsAbstract": "\"{type}\" sınıfı final olarak işaretlendi ve tüm soyut sembolleri uygulamalıdır", "finalContext": "Bu bağlamda \"Final\" kullanılamaz", - "finalInLoop": "Bir döngü içinde “Son” değişkeni atanamaz", + "finalInLoop": "Bir döngü içinde “Final” değişkeni atanamaz", "finalMethodOverride": "\"{name}\" yöntemi \"{className}\" sınıfı içinde tanımlanan final metodu geçersiz kılamaz", "finalNonMethod": "\"{name}\" işlevi bir yöntem olmadığından @final olarak işaretlenemez", - "finalReassigned": "\"{name}\" Son olarak bildirildi ve yeniden atanamaz", + "finalReassigned": "\"{name}\" Final olarak bildirildi ve yeniden atanamaz", "finalRedeclaration": "\"{name}\" daha önce Final olarak bildirildi", "finalRedeclarationBySubclass": "\"{name}\", \"{className}\" sınıf adı bu adı Final olarak bildirdiğinden yeniden bildirilemez", "finalTooManyArgs": "\"Final\" sonrasında tek bir tür bağımsız değişken bekleniyordu", @@ -234,7 +234,7 @@ "functionInConditionalExpression": "Koşullu ifade, her zaman True olarak değerlendirilen işleve başvurur", "functionTypeParametersIllegal": "İşlev türü parametre sözdizimi Python 3.12 veya daha yeni bir sürüm gerektirir", "futureImportLocationNotAllowed": "__future__ içeri aktarmaları dosyanın başında olmalıdır", - "generatorAsyncReturnType": "Zaman uyumsuz oluşturucu işlevinin dönüş türü \"AsyncGenerator[{yieldType}, Any]\" ile uyumlu olmalıdır", + "generatorAsyncReturnType": "Return type of async generator function must be compatible with \"AsyncGenerator[{yieldType}, Any]\"", "generatorNotParenthesized": "Tek bağımsız değişken olmadıklarında oluşturucu ifadeleri ayraç içine alınmalıdır", "generatorSyncReturnType": "Oluşturucu işlevinin dönüş türü \"Generator[{yieldType}, Any, Any]\" ile uyumlu olmalıdır", "genericBaseClassNotAllowed": "\"Generic\" temel sınıfı, tür parametresi sözdizimiyle kullanılamaz", @@ -246,8 +246,8 @@ "genericTypeArgMissing": "\"Generic\" en az bir tür bağımsız değişkeni gerektirir", "genericTypeArgTypeVar": "\"Generic\" için tür bağımsız değişkeni bir tür değişkeni olmalıdır", "genericTypeArgUnique": "\"Generic\" için tür bağımsız değişkenleri benzersiz olmalıdır", - "globalReassignment": "\"{name}\" genel bildirimden önce atanmış", - "globalRedefinition": "\"{name}\" zaten genel olarak bildirildi", + "globalReassignment": "\"{name}\" is assigned before global declaration", + "globalRedefinition": "\"{name}\" zaten global olarak bildirildi", "implicitStringConcat": "Örtük dize birleştirmesine izin verilmiyor", "importCycleDetected": "İçeri aktarma zincirinde döngü algılandı", "importDepthExceeded": "İçeri aktarma zinciri derinliği {depth} sınırını aştı", @@ -265,16 +265,16 @@ "instanceMethodSelfParam": "Örnek metotları bir \"self\" parametresi almalıdır", "instanceVarOverridesClassVar": "\"{name}\" örnek değişkeni \"{className}\" sınıfındaki aynı ada sahip sınıf değişkenini geçersiz kılıyor", "instantiateAbstract": "\"{type}\" soyut sınıfı örneği oluşturulamıyor", - "instantiateProtocol": "\"{type}\" protokol sınıfının örneği oluşturulamıyor", + "instantiateProtocol": "\"{type}\" Protocol sınıfının örneği oluşturulamıyor", "internalBindError": "\"{file}\" dosyası bağlanırken dahili bir hata oluştu: {message}", "internalParseError": "\"{file}\" dosyası ayrıştırılırken dahili bir hata oluştu: {message}", "internalTypeCheckingError": "\"{file}\" dosyası tür denetimi gerçekleştirilirken dahili bir hata oluştu: {message}", "invalidIdentifierChar": "Tanımlayıcıda geçersiz karakter", - "invalidStubStatement": "Deyim, bir tür saplama dosyası içinde anlamsız", + "invalidStubStatement": "Deyim, bir tür stub dosyası içinde anlamsız", "invalidTokenChars": "Belirteçte geçersiz \"{text}\" karakteri var", - "isInstanceInvalidType": "\"isinstance\" için ikinci bağımsız değişken bir sınıf veya sınıf demeti olmalıdır", - "isSubclassInvalidType": "\"issubclass\" için ikinci bağımsız değişken bir sınıf veya sınıflar demeti olmalıdır", - "keyValueInSet": "Küme içinde anahtar/değer çiftlerine izin verilmiyor", + "isInstanceInvalidType": "\"isinstance\" için ikinci bağımsız değişken bir sınıf veya sınıf dtuple olmalıdır", + "isSubclassInvalidType": "\"issubclass\" için ikinci bağımsız değişken bir sınıf veya sınıflar tuple olmalıdır", + "keyValueInSet": "Key/value pairs are not allowed within a set", "keywordArgInTypeArgument": "Anahtar sözcük bağımsız değişkenleri tür bağımsız değişken listelerinde kullanılamaz", "keywordArgShortcutIllegal": "Anahtar sözcük bağımsız değişkeni kısayolu için Python 3.14 veya daha yenisini gereklidir.", "keywordOnlyAfterArgs": "\"*\" parametresinden sonra keyword-only bağımsız değişken ayırıcısı kullanılamaz", @@ -283,14 +283,14 @@ "lambdaReturnTypePartiallyUnknown": "Lambdanın \"{returnType}\" dönüş türü kısmen bilinmiyor", "lambdaReturnTypeUnknown": "Lambdanın dönüş türü bilinmiyor", "listAssignmentMismatch": "\"{type}\" türündeki ifade hedef listesine atanamaz", - "listInAnnotation": "Tür ek açıklamasında liste ifadesi kullanılamaz", + "listInAnnotation": "List expression not allowed in type expression", "literalEmptyArgs": "\"Literal\" sonrasında bir veya daha fazla tür bağımsız değişkeni bekleniyordu", - "literalNamedUnicodeEscape": "Adlandırılmış unicode kaçış sıraları “Değişmez” dize ek açıklamalarında desteklenmiyor", - "literalNotAllowed": "\"Değişmez değer\" bir tür bağımsız değişken olmadan bu bağlamda kullanılamaz", - "literalNotCallable": "Değişmez tür örneği oluşturulamıyor", - "literalUnsupportedType": "\"Literal\" için tür bağımsız değişkenleri None, bir sabit değer (int, bool, str veya bytes) veya bir sabit listesi değeri olmalıdır", - "matchIncompatible": "Eşleme deyimleri için Python 3.10 veya daha yeni bir sürümü gerekiyor", - "matchIsNotExhaustive": "Eşleme deyimindeki durumlar değerlerin tümünü karşılayamıyor", + "literalNamedUnicodeEscape": "Adlandırılmış unicode kaçış sıraları “Literal” dize ek açıklamalarında desteklenmiyor", + "literalNotAllowed": "\"Literal\" bir tür bağımsız değişken olmadan bu bağlamda kullanılamaz", + "literalNotCallable": "Literal type cannot be instantiated", + "literalUnsupportedType": "\"Literal\" için tür bağımsız değişkenleri None, bir sabit değer (int, bool, str veya bytes) veya bir enum değeri olmalıdır", + "matchIncompatible": "Match deyimleri için Python 3.10 veya daha yeni bir sürümü gerekiyor", + "matchIsNotExhaustive": "Cases within match statement do not exhaustively handle all values", "maxParseDepthExceeded": "Maksimum ayrıştırma derinliği aşıldı; ifadeyi daha küçük alt ifadelere bölün", "memberAccess": "Sınıf \"{type}\" için \"{name}\" özniteliğine erişilemiyor", "memberDelete": "Sınıf \"{type}\" için \"{name}\" özniteliği silinemiyor", @@ -304,20 +304,21 @@ "methodOverridden": "\"{name}\", uyumsuz \"{type}\" türüne sahip \"{className}\" sınıfında aynı ad metodunu geçersiz kılar", "methodReturnsNonObject": "\"{name}\" metodu bir nesne döndürmez", "missingSuperCall": "\"{methodName}\" metodu üst sınıftaki aynı ada sahip metodu çağıramaz", + "mixingBytesAndStr": "Bytes ve str değerleri birleştirilemez", "moduleAsType": "Modül tür olarak kullanılamaz", "moduleNotCallable": "Modül çağrılabilir değil", "moduleUnknownMember": "\"{memberName}\", \"{moduleName}\" modülünün bilinen bir özniteliği değil", "namedExceptAfterCatchAll": "Adlandırılmış except yan tümcesi, catch-all except yan tümcesinden sonra gelemez", "namedParamAfterParamSpecArgs": "\"{name}\" anahtar sözcük parametresi ParamSpec args parametresinden sonra imzada yer alamaz", - "namedTupleEmptyName": "Adlandırılmış demet içindeki adlar boş olamaz", - "namedTupleEntryRedeclared": "Üst sınıf \"{name}\" adlandırılmış bir demet olduğundan \"{className}\" geçersiz kılınamıyor", - "namedTupleFirstArg": "İlk bağımsız değişken olarak adlandırılmış demet sınıf adı bekleniyordu", + "namedTupleEmptyName": "Adlandırılmış tuple içindeki adlar boş olamaz", + "namedTupleEntryRedeclared": "Üst sınıf \"{name}\" adlandırılmış bir tuple olduğundan \"{className}\" geçersiz kılınamıyor", + "namedTupleFirstArg": "İlk bağımsız değişken olarak adlandırılmış tuple sınıf adı bekleniyordu", "namedTupleMultipleInheritance": "NamedTuple bulunan birden çok devralma desteklenmiyor", "namedTupleNameKeyword": "Alan adları anahtar sözcük olamaz", - "namedTupleNameType": "Girdi adını ve türünü belirten iki girdili demet bekleniyordu", - "namedTupleNameUnique": "Adlandırılmış demet içindeki adlar benzersiz olmalıdır", + "namedTupleNameType": "Girdi adını ve türünü belirten iki girdili tuple bekleniyordu", + "namedTupleNameUnique": "Adlandırılmış tuple içindeki adlar benzersiz olmalıdır", "namedTupleNoTypes": "\"namedtuple\" demet girdileri için tür sağlamaz; bunun yerine \"NamedTuple\" kullanın", - "namedTupleSecondArg": "İkinci bağımsız değişken olarak adlandırılmış demet girdi listesi bekleniyordu", + "namedTupleSecondArg": "İkinci bağımsız değişken olarak adlandırılmış tuple girdi listesi bekleniyordu", "newClsParam": "__new__ geçersiz kılması bir \"cls\" parametresi almalı", "newTypeAnyOrUnknown": "NewType'ın ikinci bağımsız değişkeni Any veya Unknown değil, bilinen bir sınıf olmalıdır", "newTypeBadName": "NewType için ilk bağımsız değişken bir sabit değerli dize olmalıdır", @@ -325,20 +326,20 @@ "newTypeNameMismatch": "NewType, aynı ada sahip bir değişkene atanmalıdır", "newTypeNotAClass": "NewType için ikinci bağımsız değişken olarak sınıf bekleniyordu", "newTypeParamCount": "NewType için iki konumsal bağımsız değişken gerekiyor", - "newTypeProtocolClass": "NewType yapısal türle (protokol veya TypedDict sınıfı) kullanılamaz", + "newTypeProtocolClass": "NewType yapısal türle (Protocol veya TypedDict sınıfı) kullanılamaz", "noOverload": "\"{name}\" için aşırı yüklemelerin hiçbiri sağlanan bağımsız değişkenlerle eşleşmiyor", - "noReturnContainsReturn": "Bildirilen dönüş türü \"NoReturn\" olan işlev bir return deyimi içeremez", + "noReturnContainsReturn": "Function with declared return type \"NoReturn\" cannot include a return statement", "noReturnContainsYield": "Bildirilen dönüş türü \"NoReturn\" olan işlev bir yield deyimi içeremez", "noReturnReturnsNone": "Bildirilen \"NoReturn\" döndürme türüne sahip işlev \"None\" döndüremez", "nonDefaultAfterDefault": "Varsayılan olmayan bağımsız değişken varsayılan bağımsız değişkeni izler", - "nonLocalInModule": "Modül düzeyinde yerel olmayan bildirim kullanılamaz", - "nonLocalNoBinding": "Yerel olmayan \"{name}\" öğesi için bağlama bulunamadı", - "nonLocalReassignment": "\"{name}\" yerel olmayan bildirimden önce atanmış", - "nonLocalRedefinition": "\"{name}\" zaten yerel olmayan olarak bildirildi", + "nonLocalInModule": "Modül düzeyinde nonlocal bildirim kullanılamaz", + "nonLocalNoBinding": "No binding for nonlocal \"{name}\" found", + "nonLocalReassignment": "\"{name}\" nonlocal bildirimden önce atanmış", + "nonLocalRedefinition": "\"{name}\" zaten nonlocal olarak bildirildi", "noneNotCallable": "\"None\" türündeki nesne çağrılamaz", "noneNotIterable": "\"None\" türündeki nesne, yeniden kullanılabilir değer olarak kullanılamaz", "noneNotSubscriptable": "\"None\" türündeki nesne alt simgeleştirilebilir değil", - "noneNotUsableWith": "\"None\" türündeki nesne \"with\" ile kullanılamaz", + "noneNotUsableWith": "Object of type \"None\" cannot be used with \"with\"", "noneOperator": "\"{operator}\" işleci \"None\" için desteklenmiyor", "noneUnknownMember": "\"{name}\" bilinen bir \"None\" özniteliği değil", "notRequiredArgCount": "\"NotRequired\" sonrasında tek bir tür bağımsız değişken bekleniyordu", @@ -351,7 +352,7 @@ "obscuredTypeAliasDeclaration": "\"{name}\" tür diğer ad bildirimi aynı ada sahip bir bildirim tarafından etkisiz kılındı", "obscuredVariableDeclaration": "\"{name}\" bildirimi aynı ada sahip bir bildirim tarafından gizlendi", "operatorLessOrGreaterDeprecated": "\"<>\" işleci Python 3'de desteklenmiyor; bunun yerine \"!=\" kullanın", - "optionalExtraArgs": "\"optional\" sonrasında bir tür bağımsız değişkeni bekleniyordu", + "optionalExtraArgs": "Expected one type argument after \"Optional\"", "orPatternIrrefutable": "Reddedilemez desene yalnızca \"or\" deseninde son alt desen olarak izin verilir", "orPatternMissingName": "Bir \"or\" deseni içindeki tüm alt desenlerde aynı adlar hedeflenmeli", "overlappingKeywordArgs": "Türü belirlenmiş sözlük anahtar sözcük parametresiyle çakışıyor: {names}", @@ -364,9 +365,9 @@ "overloadImplementationMismatch": "Aşırı yüklenmiş uygulama, {index} aşırı yükleme imzası ile tutarlı değil", "overloadReturnTypeMismatch": "\"{name}\" için {prevIndex} aşırı yüklemesi {newIndex} aşırı yüklemesi ile çakışıyor ve uyumsuz bir tür döndürüyor", "overloadStaticMethodInconsistent": "\"{name}\" için aşırı yüklemeler, @staticmethod yöntemini tutarsız kullanıyor", - "overloadWithoutImplementation": "\"{name}\" aşırı yük olarak işaretlendi, ancak uygulama sağlanmadı", - "overriddenMethodNotFound": "\"{name}\" metodu geçersiz kılma olarak işaretlendi, ancak aynı ada sahip bir temel metot yok", - "overrideDecoratorMissing": "\"{name}\" metodu geçersiz kılma olarak işaretlenmedi ancak \"{className}\" sınıfındaki bir metodu geçersiz kılıyor", + "overloadWithoutImplementation": "\"{name}\" overload olarak işaretlendi, ancak uygulama sağlanmadı", + "overriddenMethodNotFound": "\"{name}\" metodu override olarak işaretlendi, ancak aynı ada sahip bir temel metot yok", + "overrideDecoratorMissing": "Method \"{name}\" is not marked as override but is overriding a method in class \"{className}\"", "paramAfterKwargsParam": "Parametre \"**\" parametresini izleyemez", "paramAlreadyAssigned": "\"{name}\" parametresi zaten atanmış", "paramAnnotationMissing": "\"{name}\" parametresi için tür ek açıklaması eksik", @@ -377,7 +378,7 @@ "paramSpecArgsUsage": "ParamSpec'in \"args\" özniteliği yalnızca *args parametresiyle kullanıldığında geçerlidir", "paramSpecAssignedName": "ParamSpec, \"{name}\" adlı bir değişkene atanmalı", "paramSpecContext": "ParamSpec bu bağlamda kullanılamaz", - "paramSpecDefaultNotTuple": "ParamSpec varsayılan değeri için üç nokta, demet ifadesi veya ParamSpec bekleniyordu", + "paramSpecDefaultNotTuple": "ParamSpec varsayılan değeri için üç nokta, tuple ifadesi veya ParamSpec bekleniyordu", "paramSpecFirstArg": "İlk bağımsız değişken olarak ParamSpec adı bekleniyordu", "paramSpecKwargsUsage": "ParamSpec'in \"kwargs\" özniteliği yalnızca **kwargs parametresiyle kullanıldığında geçerlidir", "paramSpecNotUsedByOuterScope": "\"{name}\" adlı ParamSpec bu bağlamda bir anlam ifade etmiyor", @@ -387,7 +388,7 @@ "paramTypeCovariant": "Kovaryant türü değişkeni parametre türünde kullanılamaz", "paramTypePartiallyUnknown": "\"{paramName}\" parametresinin türü kısmen bilinmiyor", "paramTypeUnknown": "\"{paramName}\" parametresinin türü bilinmiyor", - "parenthesizedContextManagerIllegal": "\"with\" deyimindeki parantezler Python 3.9 veya daha yeni bir sürüm gerektirir", + "parenthesizedContextManagerIllegal": "Parentheses within \"with\" statement requires Python 3.9 or newer", "patternNeverMatches": "Desen, \"{type}\" konu türü ile hiçbir zaman eşleşmez", "positionArgAfterNamedArg": "Konumsal bağımsız değişken anahtar sözcük bağımsız değişkenlerden sonra gelemez", "positionOnlyAfterArgs": "\"*\" parametresinden sonra yalnızca konum parametre ayırıcısı kullanılamaz", @@ -398,22 +399,22 @@ "privateImportFromPyTypedModule": "\"{name}\" \"{module}\" modülünden dışarı aktarılamadı", "privateUsedOutsideOfClass": "\"{name}\" özeldir ve bildirildiği sınıfın dışında kullanılır", "privateUsedOutsideOfModule": "\"{name}\" özeldir ve bildirildiği modülün dışında kullanılır", - "propertyOverridden": "\"{name}\", \"{className}\" sınıfında aynı ad özelliğini geçersiz kılar", - "propertyStaticMethod": "Static metotlar özellik alıcı, ayarlayıcı veya silici için kullanılamaz", + "propertyOverridden": "\"{name}\" incorrectly overrides property of same name in class \"{className}\"", + "propertyStaticMethod": "Static methods not allowed for property getter, setter or deleter", "protectedUsedOutsideOfClass": "\"{name}\" korumalıdır ve içinde bildirildiği sınıfın dışında kullanılır", - "protocolBaseClass": "Protokol sınıfı \"{classType}\", protokol olmayan \"{baseType}\" sınıfı türevi olamaz", - "protocolBaseClassWithTypeArgs": "Tür parametresi söz dizimi kullanılırken, tür bağımsız değişkenlerinin Protokol sınıfıyla kullanılmasına izin verilmez", + "protocolBaseClass": "\"{classType}\" Protocol sınıfı, Protocol olmayan \"{baseType}\" sınıfının türevi olamaz", + "protocolBaseClassWithTypeArgs": "Type arguments are not allowed with Protocol class when using type parameter syntax", "protocolIllegal": "\"Protocol\" kullanımı için Python 3.7 veya daha yeni bir sürümü gerekiyor", - "protocolNotAllowed": "\"Protokol\" bu bağlamda kullanılamaz", - "protocolTypeArgMustBeTypeParam": "“Protokol” için tür bağımsız değişkeni bir tür parametresi olmalıdır", + "protocolNotAllowed": "\"Protocol\" bu bağlamda kullanılamaz", + "protocolTypeArgMustBeTypeParam": "“Protocol” için tür bağımsız değişkeni bir tür parametresi olmalıdır", "protocolUnsafeOverlap": "Sınıf, \"{name}\" ile güvenli olmayan bir şekilde çakışıyor ve çalışma zamanında bir eşleşme üretebilir", - "protocolVarianceContravariant": "\"{class}\" genel protokolünde kullanılan \"{variable}\" tür değişkeni, değişken karşıtı olmalıdır", - "protocolVarianceCovariant": "\"{class}\" genel protokolünde kullanılan \"{variable}\" tür değişkeni birlikte değişen olmalıdır", - "protocolVarianceInvariant": "\"{class}\" genel protokolünde kullanılan \"{variable}\" tür değişkeni sabit olmalıdır", + "protocolVarianceContravariant": "Genel Protocol \"{class}\" için kullanılan \"{variable}\" tür değişkeni, değişken karşıtı olmalıdır", + "protocolVarianceCovariant": "Genel Protocol \"{class}\" için kullanılan \"{variable}\" tür değişkeni, birlikte değişen olmalıdır", + "protocolVarianceInvariant": "Genel Protocol \"{class}\" için kullanılan \"{variable}\" tür değişkeni sabit olmalıdır", "pyrightCommentInvalidDiagnosticBoolValue": "Pyright açıklama yönergesinden sonra \"=\" ve true veya false değeri olmalıdır", "pyrightCommentInvalidDiagnosticSeverityValue": "Pyright açıklama yönergesinden sonra \"=\" ve true, false, error, warning, information veya none değeri girilmelidir", - "pyrightCommentMissingDirective": "Pyright açıklaması sonrasında bir yönerge (temel veya katı) veya tanılama kuralı gelmelidir", - "pyrightCommentNotOnOwnLine": "Dosya düzeyi ayarları kontrol etmek için kullanılan pyright açıklamaları kendi satırlarında görünmelidir", + "pyrightCommentMissingDirective": "Pyright comment must be followed by a directive (basic or strict) or a diagnostic rule", + "pyrightCommentNotOnOwnLine": "Pyright comments used to control file-level settings must appear on their own line", "pyrightCommentUnknownDiagnosticRule": "\"{rule}\", pyright açıklaması için bilinmeyen bir tanılama kuralı", "pyrightCommentUnknownDiagnosticSeverityValue": "\"{value}\" pyright açıklaması için geçersiz değer; true, false, error, warning, information veya none bekleniyordu", "pyrightCommentUnknownDirective": "\"{directive}\", pyright açıklaması için bilinmeyen bir yönergedir; \"strict\" veya \"basic\" bekleniyordu", @@ -423,15 +424,15 @@ "relativeImportNotAllowed": "Göreli içeri aktarmalar \"import .a\" formuyla kullanılamaz; bunun yerine \"from . import a\" kullanın", "requiredArgCount": "\"Required\" sonrasında tek bir tür bağımsız değişken bekleniyordu", "requiredNotInTypedDict": "Bu bağlamda \"Required\" kullanımına izin verilmiyor", - "returnInAsyncGenerator": "Zaman uyumsuz oluşturucuda değer içeren dönüş deyimine izin verilmez", + "returnInAsyncGenerator": "Return statement with value is not allowed in async generator", "returnMissing": "Bildirilen \"{returnType}\" döndürme türüne sahip işlev, tüm kod yollarında değer döndürmelidir", "returnOutsideFunction": "\"return\" yalnızca bir işlev içinde kullanılabilir", "returnTypeContravariant": "Değişken karşıtı tür değişkeni dönüş türünde kullanılamaz", - "returnTypeMismatch": "\"{exprType}\" türünün ifadesi, \"{returnType}\" dönüş türüyle uyumsuz", + "returnTypeMismatch": "\"{exprType}\" türü \"{returnType}\" dönüş türüne atanamaz", "returnTypePartiallyUnknown": "\"{returnType}\" dönüş türü kısmen bilinmiyor", "returnTypeUnknown": "Dönüş türü bilinmiyor", "revealLocalsArgs": "\"reveal_locals\" çağrısı için bağımsız değişken beklenmiyordu", - "revealLocalsNone": "Bu kapsamda yerel öğe yok", + "revealLocalsNone": "No locals in this scope", "revealTypeArgs": "\"reveal_type\" çağrısı için tek bir konumsal bağımsız değişken bekleniyordu", "revealTypeExpectedTextArg": "\"reveal_type\" bağımsız değişkeni için \"expected_text\" argümanı bir str sabit değeri olmalıdır", "revealTypeExpectedTextMismatch": "Tür uyuşmazlığı; \"{expected}\" bekleniyordu ancak \"{received}\" alındı", @@ -439,7 +440,7 @@ "selfTypeContext": "\"Self\" bu bağlamda geçerli değil", "selfTypeMetaclass": "\"Self\" bir meta sınıfı (\"type\" alt sınıfı) içinde kullanılamaz", "selfTypeWithTypedSelfOrCls": "\"Self\", \"Self\" dışında bir tür ek açıklamasına sahip bir `self` veya `cls` parametresine sahip bir işlevde kullanılamaz", - "setterGetterTypeMismatch": "Özellik ayarlayıcısı değer türü alıcı dönüş türüne atanamaz", + "setterGetterTypeMismatch": "Property setter value type is not assignable to the getter return type", "singleOverload": "\"{name}\" aşırı yükleme olarak işaretlenmiş, ancak ek aşırı yüklemeler eksik", "slotsAttributeError": "\"{name}\", __slots__ içinde belirtilmedi", "slotsClassVarConflict": "\"{name}\", __slots__ içinde bildirilen örnek değişkenle çakışıyor", @@ -449,12 +450,12 @@ "staticClsSelfParam": "Static metotları \"self\" veya \"cls\" parametresi almamalıdır", "stdlibModuleOverridden": "\"{path}\", \"{name}\" stdlib modülünü geçersiz kılıyor", "stringNonAsciiBytes": "ASCII olmayan karaktere bayt sabit değerli dizesinde izin verilmez", - "stringNotSubscriptable": "Tür ek açıklamasında dize ifadesi alt simge olarak belirtilemez; ek açıklamanın tamamını tırnak içine alın", + "stringNotSubscriptable": "Tür ifadesinde dize ifadesi alt simge olarak belirtilemez; ifadenin tamamını tırnak içine alın", "stringUnsupportedEscape": "Dize sabit değerinde desteklenmeyen kaçış dizisi", "stringUnterminated": "Sabit değerli dize sonlandırılmamış", - "stubFileMissing": "\"{importName}\" için saplama dosyası bulunamadı", - "stubUsesGetAttr": "Tür saplama dosyası eksik; \"__getattr__\" modül için tür hatalarını gizliyor", - "sublistParamsIncompatible": "Alt liste parametreleri Python 3.x'te desteklenmez", + "stubFileMissing": "\"{importName}\" için stub dosyası bulunamadı", + "stubUsesGetAttr": "Tür stub dosyası eksik; \"__getattr__\" modül için tür hatalarını gizliyor", + "sublistParamsIncompatible": "Sublist parametreleri Python 3.x'te desteklenmez", "superCallArgCount": "\"super\" çağrısı için ikiden fazla bağımsız değişken beklenmiyordu", "superCallFirstArg": "\"super\" çağrısının ilk bağımsız değişkeni olarak sınıf türü bekleniyordu ancak \"{type}\" alındı", "superCallSecondArg": "\"super\" çağrısının ikinci bağımsız değişkeni, \"{type}\" türünden türetilen nesne veya sınıf olmalıdır", @@ -464,27 +465,27 @@ "symbolIsUnbound": "\"{name}\" bağlı değil", "symbolIsUndefined": "\"{name}\" tanımlanmadı", "symbolOverridden": "\"{name}\", \"{className}\" sınıfında aynı ada sahip sembolü geçersiz kılar", - "ternaryNotAllowed": "Tür ek açıklamasında üçlü ifade kullanılamaz", + "ternaryNotAllowed": "Tür ifadesinde üçlü ifade kullanılamaz", "totalOrderingMissingMethod": "total_ordering kullanmak için sınıfta \"__lt__\", \"__le__\", \"__gt__\" veya \"__ge__\" metotlarından biri tanımlanmalıdır", "trailingCommaInFromImport": "Çevreleyen parantezler olmadan sondaki virgüle izin verilmez", "tryWithoutExcept": "Try deyimi en az bir except veya finally yan tümcesi içermelidir", - "tupleAssignmentMismatch": "\"{type}\" türündeki ifade hedef demetine atanamaz", - "tupleInAnnotation": "Tür ek açıklamasında demet ifadesine izin verilmiyor", + "tupleAssignmentMismatch": "\"{type}\" türündeki ifade hedef tupleine atanamaz", + "tupleInAnnotation": "Tür ifadesinde tanımlama tuple ifadesi kullanılamaz", "tupleIndexOutOfRange": "{index} dizini {type} türü için aralık dışında", "typeAliasIllegalExpressionForm": "Tür diğer ad tanımı için geçersiz ifade form", "typeAliasIsRecursiveDirect": "Tür diğer adı \"{name}\", tanımında kendisini kullanamaz", "typeAliasNotInModuleOrClass": "TypeAlias yalnızca bir modül veya sınıf kapsamında tanımlanabilir", "typeAliasRedeclared": "\"{name}\" bir TypeAlias olarak bildirilmiş ve yalnızca bir kez atanabilir", - "typeAliasStatementBadScope": "Tür deyimi, yalnızca bir modül veya sınıf kapsamında kullanılabilir", + "typeAliasStatementBadScope": "A type statement can be used only within a module or class scope", "typeAliasStatementIllegal": "Tür diğer adı deyimi için Python 3.12 veya daha yeni bir sürümü gerekiyor", - "typeAliasTypeBaseClass": "Bir “type” deyiminde tanımlanan tür diğer adı temel sınıf olarak kullanılamaz", + "typeAliasTypeBaseClass": "Bir \"type\" deyiminde tanımlanan type diğer adı temel sınıf olarak kullanılamaz", "typeAliasTypeMustBeAssigned": "TypeAliasType, tür diğer adıyla aynı ada sahip bir değişkene atanmalıdır", "typeAliasTypeNameArg": "TypeAliasType için ilk bağımsız değişken, tür diğer adının adını temsil eden bir sabit değerli dize olmalıdır", "typeAliasTypeNameMismatch": "Tür diğer adının atandığı değişkenin adıyla eşleşmesi gerekiyor", - "typeAliasTypeParamInvalid": "Tür parametresi listesi yalnızca TypeVar, TypeVarTuple veya ParamSpec içeren bir demet olmalıdır", + "typeAliasTypeParamInvalid": "Tür parametresi listesi yalnızca TypeVar, TypeVarTuple veya ParamSpec içeren bir tuple olmalıdır", "typeAnnotationCall": "Tür ifadesinde çağrı ifadesine izin verilmiyor", "typeAnnotationVariable": "Tür ifadesinde değişkene izin verilmiyor", - "typeAnnotationWithCallable": "“Tür” için tür bağımsız değişkeni bir sınıf olmalıdır; çağrılabilir öğeler desteklenmiyor", + "typeAnnotationWithCallable": "Type argument for \"type\" must be a class; callables are not supported", "typeArgListExpected": "ParamSpec, üç nokta veya tür listesi bekleniyordu", "typeArgListNotAllowed": "Bu tür bağımsız değişkeni için liste ifadesine izin verilmiyor", "typeArgsExpectingNone": "\"{name}\" sınıfı için tür bağımsız değişkeni beklenmiyordu", @@ -493,16 +494,17 @@ "typeArgsMissingForClass": "\"{name}\" genel sınıf adı için tür bağımsız değişkenleri bekleniyordu", "typeArgsTooFew": "\"{name}\" için çok az tür bağımsız değişkeni sağlandı; {expected} bekleniyordu ancak {received} alındı", "typeArgsTooMany": "\"{name}\" için çok fazla tür bağımsız değişkeni sağlandı; {expected} bekleniyordu ancak {received} alındı", - "typeAssignmentMismatch": "\"{sourceType}\" türünün ifadesi, bildirilen tür \"{destType}\" ile uyumsuz", - "typeAssignmentMismatchWildcard": "İçeri aktarma sembolü \"{name}\", bildirilen \"{destType}\" türüyle uyumsuz olan \"{sourceType}\" türüne sahip", - "typeCallNotAllowed": "Tür ek açıklamasında type() çağrısı kullanılmamalıdır", + "typeAssignmentMismatch": "\"{sourceType}\" türü \"{destType}\" bildirilen türüne atanamaz", + "typeAssignmentMismatchWildcard": "\"{name}\" içeri aktarma sembolü \"{sourceType}\" türüne sahip ve bu tür \"{destType}\" bildirilen türüne atanamaz", + "typeCallNotAllowed": "Tür ifadesinde type() çağrısı kullanılmamalıdır", "typeCheckOnly": "\"{name}\", @type_check_only olarak işaretlendi ve yalnızca tür ek açıklamalarında kullanılabilir", - "typeCommentDeprecated": "Tür açıklamalarının kullanımı kullanım dışı; bunun yerine tür ek açıklaması kullanın", + "typeCommentDeprecated": "Use of type comments is deprecated; use type annotation instead", "typeExpectedClass": "Sınıf bekleniyordu ancak \"{type}\" alındı", - "typeGuardArgCount": "\"TypeGuard\" veya \"Typels\" sonrasında tek bir tür bağımsız değişken bekleniyordu", + "typeFormArgs": "\"TypeForm\" tek bir konumsal bağımsız değişkeni kabul eder", + "typeGuardArgCount": "Expected a single type argument after \"TypeGuard\" or \"TypeIs\"", "typeGuardParamCount": "Kullanıcı tanımlı tür koruma işlevleri ve metotlarında en az bir giriş parametresi olmalıdır", "typeIsReturnType": "TypeIs dönüş türü (\"{returnType}\"), değer parametresi türü (\"{type}\") ile tutarlı değil", - "typeNotAwaitable": "\"{type}\" beklenemez", + "typeNotAwaitable": "\"{type}\" is not awaitable", "typeNotIntantiable": "\"{type}\" örneği oluşturulamıyor", "typeNotIterable": "\"{type}\" yeniden kullanılamaz", "typeNotSpecializable": "\"{type}\" türü özelleştirilemedi", @@ -537,9 +539,9 @@ "typeVarSingleConstraint": "TypeVar en az iki kısıtlanmış türe sahip olmalıdır", "typeVarTupleConstraints": "TypeVarTuple değer kısıtlamalarına sahip olamaz", "typeVarTupleContext": "TypeVarTuple bu bağlamda kullanılamaz", - "typeVarTupleDefaultNotUnpacked": "TypeVarTuple varsayılan türü, paketlenmemiş bir demet veya TypeVarTuple olmalıdır", + "typeVarTupleDefaultNotUnpacked": "TypeVarTuple varsayılan türü, paketlenmemiş bir tuple veya TypeVarTuple olmalıdır", "typeVarTupleMustBeUnpacked": "TypeVarTuple değeri için Paket açma işleci gereklidir", - "typeVarTupleUnknownParam": "\"{name}\", TypeVar için bilinmeyen bir parametre", + "typeVarTupleUnknownParam": "\"{name}\", TypeVarTuple için bilinmeyen bir parametre", "typeVarUnknownParam": "\"{name}\", TypeVar için bilinmeyen bir parametre", "typeVarUsedByOuterScope": "TypeVar \"{name}\" zaten bir dış kapsam tarafından kullanılıyor", "typeVarUsedOnlyOnce": "TypeVar \"{name}\" genel işlev imzasında yalnızca bir kez görünür", @@ -552,8 +554,8 @@ "typedDictBadVar": "TypedDict sınıfları yalnızca tür ek açıklamaları içerebilir", "typedDictBaseClass": "TypedDict sınıfları için tüm temel sınıflar da TypedDict sınıfları olmalıdır", "typedDictBoolParam": "True veya False değeri olması için \"{name}\" parametresi bekleniyordu", - "typedDictClosedExtras": "\"{name}\" temel sınıfı kapalı bir TypedDict öğesidir; ek öğeler \"{type}\" türünde olmalıdır", - "typedDictClosedNoExtras": "\"{name}\" temel sınıfı kapalı bir TypedDict öğesidir; ek öğelere izin verilmiyor", + "typedDictClosedExtras": "\"{name}\" temel sınıfı closed bir TypedDict öğesidir; ek öğeler \"{type}\" türünde olmalıdır", + "typedDictClosedNoExtras": "\"{name}\" temel sınıfı closed bir TypedDict öğesidir; ek öğelere izin verilmiyor", "typedDictDelete": "TypedDict'da öğe silinemedi", "typedDictEmptyName": "TypedDict içindeki adlar boş olamaz", "typedDictEntryName": "Sözlük girdisi adı için sabit değerli dize bekleniyordu", @@ -565,7 +567,7 @@ "typedDictFirstArg": "Birinci bağımsız değişken olarak TypedDict sınıf adı bekleniyordu", "typedDictInitsubclassParameter": "TypedDict, \"{name}\" __init_subclass__ parametresini desteklemez", "typedDictNotAllowed": "\"TypedDict\" bu bağlamda kullanılamaz", - "typedDictSecondArgDict": "İkinci parametre olarak sözlük veya anahtar sözcük parametresi bekleniyordu", + "typedDictSecondArgDict": "İkinci parametre olarak dict veya anahtar sözcük parametresi bekleniyordu", "typedDictSecondArgDictEntry": "Basit sözlük girişi bekleniyordu", "typedDictSet": "TypedDict içinde öğe atanamadı", "unaccessedClass": "\"{name}\" sınıfına erişilemiyor", @@ -574,34 +576,34 @@ "unaccessedSymbol": "\"{name}\" öğesine erişilemiyor", "unaccessedVariable": "\"{name}\" değişkenine erişilemiyor", "unannotatedFunctionSkipped": "\"{name}\" işlevinin analizi, açıklanmadığından atlandı", - "unaryOperationNotAllowed": "Tür ek açıklamasında birli işleç kullanılamaz", + "unaryOperationNotAllowed": "Tür ifadesinde birli işleç kullanılamaz", "unexpectedAsyncToken": "\"async\" öğesinin ardından \"def\", \"with\" veya \"for\" bekleniyordu", "unexpectedExprToken": "İfadenin sonunda beklenmeyen belirteç", "unexpectedIndent": "Beklenmeyen girinti", "unexpectedUnindent": "Girintiyi kaldırma beklenmiyordu", "unhashableDictKey": "Sözlük anahtarı karmalanabilir olmalıdır", - "unhashableSetEntry": "Küme girdisi karmalanabilir olmalıdır", + "unhashableSetEntry": "Set girdisi karmalanabilir olmalıdır", "uninitializedAbstractVariables": "Soyut temel sınıfta tanımlanan değişkenler \"{classType}\" final sınıfında başlatılmaz", "uninitializedInstanceVariable": "\"{name}\" örnek değişkeni sınıf gövdesinde veya __init__ metodunda başlatılmadı", "unionForwardReferenceNotAllowed": "Union söz dizimi dize işleneni ile kullanılamaz; ifadenin tamamını tırnak içine alın", "unionSyntaxIllegal": "Union işlemlerinde alternatif söz dizimi kullanılabilmesi için Python 3.10 veya daha yeni bir sürümü gerekiyor", "unionTypeArgCount": "Union için iki veya daha fazla tür bağımsız değişkeni gerekiyor", - "unionUnpackedTuple": "Birleşim, paketlenmemiş bir demet içeremez", - "unionUnpackedTypeVarTuple": "Birleşim, paketlenmemiş bir TypeVarTuple içeremez", + "unionUnpackedTuple": "Union, paketlenmemiş bir tuple içeremez", + "unionUnpackedTypeVarTuple": "Union, paketlenmemiş bir TypeVarTuple içeremez", "unnecessaryCast": "Gereksiz \"cast\" çağrısı; tür zaten \"{type}\"", "unnecessaryIsInstanceAlways": "Gereksiz isinstance çağrısı; \"{testType}\" her zaman bir \"{classType}\" örneğidir", "unnecessaryIsSubclassAlways": "Gereksiz issubclass çağrısı; \"{testType}\" her zaman \"{classType}\" sınıf türünün bir alt sınıfıdır", "unnecessaryPyrightIgnore": "Gereksiz \"# pyright: ignore\" açıklaması", "unnecessaryPyrightIgnoreRule": "\"# pyright: ignore\" rule: \"{name}\" gereksiz", - "unnecessaryTypeIgnore": "Gereksiz \"# type: yoksay\" açıklaması", + "unnecessaryTypeIgnore": "Gereksiz \"# type: ignore\" açıklaması", "unpackArgCount": "\"Unpack\" sonrasında tek bir tür bağımsız değişken bekleniyordu", "unpackExpectedTypeVarTuple": "Unpack için tür bağımsız değişkeni olarak TypeVarTuple veya tuple bekleniyordu", "unpackExpectedTypedDict": "Unpack için TypedDict tür bağımsız değişkeni bekleniyordu", "unpackIllegalInComprehension": "Anlamada paket açma işlemi kullanılamaz", - "unpackInAnnotation": "Tür ek açıklamasında paket açma işlecine izin verilmiyor", + "unpackInAnnotation": "Tür ifadesinde paket açma işleci kullanılamaz", "unpackInDict": "Sözlüklerde paket açma işlemi kullanılamaz", - "unpackInSet": "Paket açma işlecine küme içinde izin verilmiyor", - "unpackNotAllowed": "Bu bağlamda paketi açma işlemine izin verilmiyor", + "unpackInSet": "Paket açma işlecine set içinde izin verilmiyor", + "unpackNotAllowed": "Unpack is not allowed in this context", "unpackOperatorNotAllowed": "Bu bağlamda paket açma işlemi kullanılamaz", "unpackTuplesIllegal": "Python 3.8'den önceki demetler içinde paket açma işlemi kullanılamıyor", "unpackedArgInTypeArgument": "Paketlenmemiş bağımsız değişkenler bu bağlamda kullanılamaz", @@ -613,38 +615,38 @@ "unpackedTypedDictArgument": "Paketlenmemiş TypedDict bağımsız değişkeni parametrelerle eşlenemiyor", "unreachableCode": "Koda ulaşılamıyor", "unreachableCodeType": "Tür analizi koda erişilemediğini gösteriyor", - "unreachableExcept": "Özel durum zaten işlenmiş olduğundan özel durum yan tümcesi erişilebilir değil", + "unreachableExcept": "Except clause is unreachable because exception is already handled", "unsupportedDunderAllOperation": "\"__all__\" üzerinde işlem desteklenmiyor, bu nedenle dışarı aktarılan sembol listesi yanlış olabilir", "unusedCallResult": "Çağrı ifadesinin sonucu \"{type}\" türünde ve kullanılmıyor; bilerek yapıldıysa \"_\" değişkenine atayın", - "unusedCoroutine": "Zaman uyumsuz işlev çağrısının sonucu kullanılmıyor; \"await\" kullanın veya sonucu değişkene atayın", + "unusedCoroutine": "Result of async function call is not used; use \"await\" or assign result to variable", "unusedExpression": "İfade değeri kullanılmadı", - "varAnnotationIllegal": "Değişkenler için tür ek açıklamaları Python 3.6 veya daha yeni bir sürümünü gerektiriyor; önceki sürümlerle uyumluluk için tür açıklaması kullanın", + "varAnnotationIllegal": "Değişkenler için type ek açıklamaları Python 3.6 veya daha yeni bir sürümünü gerektiriyor; önceki sürümlerle uyumluluk için tür açıklaması kullanın", "variableFinalOverride": "\"{name}\" değişkeni Final olarak işaretlendi ve \"{className}\" sınıfı içinde aynı ada sahip Final olmayan değişkeni geçersiz kılıyor", "variadicTypeArgsTooMany": "Tür bağımsız değişkeni listesinde en fazla bir paketlenmemiş TypeVarTuple veya tuple olabilir", "variadicTypeParamTooManyAlias": "Tür diğer adı en fazla bir TypeVarTuple tür parametresine sahip olabilir ancak birden fazlası {names}) alındı", "variadicTypeParamTooManyClass": "Genel sınıf en fazla bir TypeVarTuple tür parametresine sahip olabilir ancak birden fazlası {names}) alındı", "walrusIllegal": "\":=\" işleci için Python 3.8 veya daha yeni bir sürümü gerekiyor", "walrusNotAllowed": "Çevreleyen parantezler olmadan bu bağlamda \":=\" işlecine izin verilmiyor", - "wildcardInFunction": "Bir sınıf veya işlev içinde joker karakteri içeri aktarmaya izin verilmiyor", - "wildcardLibraryImport": "Kitaplıktan joker karakter aktarmaya izin verilmiyor", + "wildcardInFunction": "Bir sınıf veya işlev içinde joker karakteri import izin verilmiyor", + "wildcardLibraryImport": "Kitaplıktan joker karakter import verilmiyor", "wildcardPatternTypePartiallyUnknown": "Joker karakter deseni tarafından yakalanan tür kısmen bilinmiyor", "wildcardPatternTypeUnknown": "Joker karakter deseni tarafından yakalanan tür bilinmiyor", "yieldFromIllegal": "\"yield from\" kullanımı için Python 3.3 veya daha yeni bir sürümü gerekiyor", - "yieldFromOutsideAsync": "Zaman uyumsuz bir işlevde \"yield from\" öğesine izin verilmez", + "yieldFromOutsideAsync": "\"yield from\" not allowed in an async function", "yieldOutsideFunction": "\"yield\", işlev veya lambda dışında kullanılamaz", "yieldWithinComprehension": "Bir anlama içinde “yield” kullanılamaz", "zeroCaseStatementsFound": "Match deyimi en az bir case deyimi içermeli", - "zeroLengthTupleNotAllowed": "Bu bağlamda sıfır uzunluklu demete izin verilmiyor" + "zeroLengthTupleNotAllowed": "Bu bağlamda sıfır uzunluklu tuple izin verilmiyor" }, "DiagnosticAddendum": { - "annotatedNotAllowed": "“Not eklenmiş” özel biçimi, örnek ve sınıf denetimleriyle kullanılamaz", + "annotatedNotAllowed": "“Annotated” özel biçimi, örnek ve sınıf denetimleriyle kullanılamaz", "argParam": "Bağımsız değişken \"{paramName}\" parametresine karşılık gelir", "argParamFunction": "Bağımsız değişken, \"{functionName}\" işlevinde \"{paramName}\" parametresine karşılık gelir", "argsParamMissing": "\"*{paramName}\" parametresine karşılık gelen bir parametre yok", "argsPositionOnly": "Yalnızca konum parametresi uyuşmazlığı; {expected} bekleniyordu ancak {received} alındı", "argumentType": "Bağımsız değişken türü \"{type}\"", "argumentTypes": "Bağımsız değişken türleri: ({types})", - "assignToNone": "Tür \"None\" ile uyumsuz", + "assignToNone": "Tür \"None\" öğesine atanamaz", "asyncHelp": "\"async with\" mi demek istediniz?", "baseClassIncompatible": "\"{baseClass}\" temel sınıfı \"{type}\" türüyle uyumlu değil", "baseClassIncompatibleSubclass": "\"{baseClass}\" temel sınıfı, \"{type}\" türüyle uyumlu olmayan \"{subclass}\" alt sınıfından türetiliyor", @@ -665,15 +667,15 @@ "functionTooFewParams": "İşlev çok az konumsal parametre kabul ediyor; {expected} bekleniyordu ancak {received} alındı", "functionTooManyParams": "İşlev çok fazla konumsal parametre kabul ediyor; {expected} bekleniyordu ancak {received} alındı", "genericClassNotAllowed": "Örnek veya sınıf denetimleri için tür bağımsız değişkenlerine sahip genel türe izin verilmiyor", - "incompatibleDeleter": "Özellik silici metodu uyumsuz", - "incompatibleGetter": "Özellik alıcısı metodu uyumsuz", - "incompatibleSetter": "Özellik ayarlayıcı metodu uyumsuz", + "incompatibleDeleter": "Property deleter method is incompatible", + "incompatibleGetter": "Property getter method is incompatible", + "incompatibleSetter": "Property setter method is incompatible", "initMethodLocation": "\"{type}\" sınıfı içinde __init__ metodu tanımlandı", "initMethodSignature": "__init__ imzası \"{type}\"", "initSubclassLocation": "__init_subclass__ yöntemi \"{name}\" sınıfı içinde tanımlandı", "invariantSuggestionDict": "“dict” öğesinden değer türünde eş değişken olan “Mapping” öğesine geçmeyi deneyin", "invariantSuggestionList": "“list” öğesinden eş değişken olan “Sequence” öğesine geçmeyi deneyin", - "invariantSuggestionSet": "“Küme” öğesinden eş değişken olan “Kapsayıcı” öğesine geçmeyi deneyin", + "invariantSuggestionSet": "Consider switching from \"set\" to \"Container\" which is covariant", "isinstanceClassNotSupported": "\"{type}\", örnek ve sınıf denetimleri için desteklenmiyor", "keyNotRequired": "\"{name}\", \"{type}\" türünde gerekli bir anahtar olmadığından çalışma zamanı özel durumuna neden olabilir", "keyReadOnly": "\"{name}\", \"{type}\" içinde salt okunur", @@ -681,14 +683,14 @@ "keyUndefined": "\"{name}\", \"{type}\" içinde tanımlı bir anahtar değil", "kwargsParamMissing": "\"**{paramName}\" parametresine karşılık gelen bir parametre yok", "listAssignmentMismatch": "\"{type}\" türü hedef listeyle uyumsuz", - "literalAssignmentMismatch": "\"{sourceType}\", \"{destType}\" türüyle uyumsuz", + "literalAssignmentMismatch": "\"{sourceType}\" \"{destType}\" türüne atanamaz", "matchIsNotExhaustiveHint": "Tümlemeli işleme amaçlanmadıysa \"case _: pass\" ekleyin", "matchIsNotExhaustiveType": "\"{type}\" türü işlenmemiş", "memberAssignment": "\"{type}\" türündeki ifade, \"{classType}\" sınıfının \"{name}\" özniteliğine atanamaz", "memberIsAbstract": "\"{type}.{name}\" uygulanmadı", "memberIsAbstractMore": "ve +{count} tane daha...", "memberIsClassVarInProtocol": "\"{name}\", protokolde ClassVar olarak tanımlandı", - "memberIsInitVar": "\"{name}\" üyesi bir yalnızca init alanıdır", + "memberIsInitVar": "\"{name}\" üyesi bir init-only alanıdır", "memberIsInvariant": "\"{name}\" değiştirilebilir olduğundan sabit ayarlanır", "memberIsNotClassVarInClass": "\"{name}\" protokolle uyumlu olması için ClassVar olarak tanımlanmalıdır", "memberIsNotClassVarInProtocol": "\"{name}\" protokolde ClassVar olarak tanımlanmadı", @@ -699,9 +701,9 @@ "memberTypeMismatch": "\"{name}\" uyumsuz bir tür", "memberUnknown": "\"{name}\" özniteliği bilinmiyor", "metaclassConflict": "Metaclass \"{metaclass1}\", \"{metaclass2}\" ile çakışıyor", - "missingDeleter": "Özellik silici metodu eksik", - "missingGetter": "Özellik alıcı metodu eksik", - "missingSetter": "Özellik ayarlayıcı metodu eksik", + "missingDeleter": "Property deleter method is missing", + "missingGetter": "Property getter method is missing", + "missingSetter": "Property setter method is missing", "namedParamMissingInDest": "\"{name}\" ek parametresi", "namedParamMissingInSource": "\"{name}\" eksik anahtar sözcük parametresi", "namedParamTypeMismatch": "\"{sourceType}\" türündeki \"{name}\" anahtar sözcük parametresi, \"{destType}\" türüyle uyumsuz", @@ -710,7 +712,7 @@ "newMethodSignature": "__new__ imzası \"{type}\"", "newTypeClassNotAllowed": "NewType ile oluşturulan sınıf, örnek ve sınıf denetimleriyle kullanılamaz", "noOverloadAssignable": "Aşırı yüklenmiş işlevlerden hiçbiri \"{type}\" türüyle uyuşmuyor", - "noneNotAllowed": "Örnek veya sınıf denetimleri için hiçbiri kullanılamaz", + "noneNotAllowed": "Örnek veya sınıf denetimleri için None kullanılamaz", "orPatternMissingName": "Eksik adlar: {name}", "overloadIndex": "Aşırı yükleme {index} en yakın eşleşmedir", "overloadNotAssignable": "Bir veya daha fazla \"{name}\" aşırı yüklemesi atanabilir değil", @@ -720,7 +722,7 @@ "overrideInvariantMismatch": "\"{overrideType}\" geçersiz kılma türü \"{baseType}\" temel türüyle aynı değil", "overrideIsInvariant": "Değişken değişebilir, bu nedenle türü sabit", "overrideNoOverloadMatches": "Geçersiz kılmadaki hiçbir aşırı yükleme imzası temel metotla uyumlu değil", - "overrideNotClassMethod": "Temel metot bir örnek metodu olarak bildirilir, ancak geçersiz kılma bu şekilde bildirilmez", + "overrideNotClassMethod": "Base method is declared as a classmethod but override is not", "overrideNotInstanceMethod": "Temel metot bir örnek metodu olarak bildirilir, ancak geçersiz kılma bu şekilde bildirilmez", "overrideNotStaticMethod": "Temel metot bir staticmethod olarak bildirilir, ancak geçersiz kılma bu şekilde bildirilmez", "overrideOverloadNoMatch": "Geçersiz kılma temel yöntemin tüm aşırı yüklemelerini işlemez", @@ -741,16 +743,16 @@ "paramType": "Parametre türü \"{paramType}\"", "privateImportFromPyTypedSource": "Bunun yerine \"{module}\" üzerinden içeri aktarın", "propertyAccessFromProtocolClass": "Protokol sınıfı içinde tanımlanan bir özelliğe sınıf değişkeni olarak erişilemez", - "propertyMethodIncompatible": "\"{name}\" özellik metodu uyumsuz", - "propertyMethodMissing": "Geçersiz kılmada \"{name}\" özellik metodu eksik", - "propertyMissingDeleter": "\"{name}\" özelliği tanımlı bir siliciye sahip değil", - "propertyMissingSetter": "\"{name}\" özelliği tanımlı bir ayarlayıcıya sahip değil", + "propertyMethodIncompatible": "Property method \"{name}\" is incompatible", + "propertyMethodMissing": "Property method \"{name}\" is missing in override", + "propertyMissingDeleter": "Property \"{name}\" has no defined deleter", + "propertyMissingSetter": "Property \"{name}\" has no defined setter", "protocolIncompatible": "\"{sourceType}\", \"{destType}\" protokol ayarlarıyla uyumsuz", "protocolMemberMissing": "\"{name}\" yok", - "protocolRequiresRuntimeCheckable": "Protokol sınıfının örnekle ve sınıf denetimleriyle birlikte kullanılabilmesi için @runtime_checkable olması gerekir", + "protocolRequiresRuntimeCheckable": "Protocol sınıfının örnekle ve sınıf denetimleriyle birlikte kullanılabilmesi için @runtime_checkable olması gerekir", "protocolSourceIsNotConcrete": "\"{sourceType}\" somut bir sınıf türü değil ve \"{destType}\" türüne atanamaz", "protocolUnsafeOverlap": "\"{name}\" öznitelikleri protokolle aynı adlara sahip", - "pyrightCommentIgnoreTip": "Tek bir satır için tanılamayı durdurmak için \"# pyright: ignore[] kullanın", + "pyrightCommentIgnoreTip": "Tek bir satırda tanılamayı durdurmak için \"# pyright: ignore[]\" kullanın", "readOnlyAttribute": "\"{name}\" özniteliği salt okunur", "seeClassDeclaration": "Sınıf bildirimine bakın", "seeDeclaration": "Bildirime bakın", @@ -759,17 +761,17 @@ "seeParameterDeclaration": "Parametre bildirimine bakın", "seeTypeAliasDeclaration": "Tür diğer adı bildirimine bakın", "seeVariableDeclaration": "Değişken bildirimine bakın", - "tupleAssignmentMismatch": "\"{type}\" türü hedef demet ile uyumsuz", - "tupleEntryTypeMismatch": "{entry} demet girdisi doğru türde değil", - "tupleSizeIndeterminateSrc": "Demet boyutu uyuşmuyor; {expected} bekleniyordu ancak indeterminate alındı", - "tupleSizeIndeterminateSrcDest": "Demet boyutu uyuşmuyor; {expected} veya daha büyük bir değer bekleniyordu ancak belirsiz bir değer alındı", - "tupleSizeMismatch": "Demet boyutu uyuşmuyor; {expected} bekleniyordu ancak {received} alındı", - "tupleSizeMismatchIndeterminateDest": "Demet boyutu uyuşmuyor; {expected} veya daha büyük bir değer bekleniyordu ancak {received} alındı", - "typeAliasInstanceCheck": "“Type” deyimi ile oluşturulan tür diğer adı örnek ve sınıf denetimleri kullanılamaz", - "typeAssignmentMismatch": "\"{sourceType}\" türü, \"{destType}\" türüyle uyumsuz", - "typeBound": "\"{sourceType}\" türü, \"{name}\" tür değişkeni için \"{destType}\" bağlı türü ile uyumlu değil", - "typeConstrainedTypeVar": "\"{type}\" türü, \"{name}\" kısıtlanmış tür değişkeni değişkeniyle uyumlu değil", - "typeIncompatible": "\"{sourceType}\", \"{destType}\" ile uyumlu değil", + "tupleAssignmentMismatch": "\"{type}\" türü hedef tuple ile uyumsuz", + "tupleEntryTypeMismatch": "{entry} tuple girdisi doğru türde değil", + "tupleSizeIndeterminateSrc": "Tuple boyutu uyuşmuyor; {expected} bekleniyordu ancak indeterminate alındı", + "tupleSizeIndeterminateSrcDest": "Tuple boyutu uyuşmuyor; {expected} veya daha büyük bir değer bekleniyordu ancak belirsiz bir değer alındı", + "tupleSizeMismatch": "Tuple boyutu uyuşmuyor; {expected} bekleniyordu ancak {received} alındı", + "tupleSizeMismatchIndeterminateDest": "Tuple boyutu uyuşmuyor; {expected} veya daha büyük bir değer bekleniyordu ancak {received} alındı", + "typeAliasInstanceCheck": "“Type” deyimi ile oluşturulan type diğer adı örnek ve sınıf denetimleri kullanılamaz", + "typeAssignmentMismatch": "\"{sourceType}\" türü \"{destType}\" türüne atanamaz", + "typeBound": "\"{sourceType}\" türü \"{name}\" tür değişkeni için \"{destType}\" üst sınırına atanamaz", + "typeConstrainedTypeVar": "\"{type}\" türü \"{name}\" kısıtlanmış tür değişkenine atanamaz", + "typeIncompatible": "\"{sourceType}\" \"{destType}\" öğesine atanamaz", "typeNotClass": "\"{type}\" bir sınıf değil", "typeNotStringLiteral": "\"{type}\" bir sabit değeri dize değil", "typeOfSymbol": "\"{name}\" türü \"{type}\"", @@ -780,7 +782,7 @@ "typeVarIsCovariant": "\"{name}\" tür parametresi bir eşdeğişken ancak \"{sourceType}\", \"{destType}\" öğesinin bir alt türü değil", "typeVarIsInvariant": "\"{name}\" tür parametresi bir değişmez değer ancak \"{sourceType}\", \"{destType}\" ile aynı değil", "typeVarNotAllowed": "Örnek veya sınıf denetimleri için TypeVar'a izin verilmiyor", - "typeVarTupleRequiresKnownLength": "TypeVarTuple, uzunluğu bilinmeyen bir demete bağlanamaz", + "typeVarTupleRequiresKnownLength": "TypeVarTuple, uzunluğu bilinmeyen bir tuple bağlanamaz", "typeVarUnnecessarySuggestion": "Bunun yerine {type} kullanın", "typeVarUnsolvableRemedy": "Bağımsız değişken sağlanmamışken dönüş türünü belirten bir aşırı yükleme belirtin", "typeVarsMissing": "Eksik tür değişkenleri: {names}", @@ -804,8 +806,8 @@ "uninitializedAbstractVariable": "\"{name}\" örnek değişkeni, \"{classType}\" soyut temel sınıfında tanımlandı ancak başlatılmadı", "unreachableExcept": "\"{exceptionType}\", \"{parentType}\" üst öğesinin bir alt sınıfı", "useDictInstead": "Sözlük türünü belirtmek için Dict[T1, T2] kullanın", - "useListInstead": "Liste türü belirtmek için List[T] veya birleşim türü belirtmek için Union[T1, T2] kullanın", - "useTupleInstead": "Demet türünü belirtmek için Tuple[T1, ..., Tn] veya birleşim türünü belirtmek için Union[T1, T2] kullanın", + "useListInstead": "Use List[T] to indicate a list type or Union[T1, T2] to indicate a union type", + "useTupleInstead": "Use tuple[T1, ..., Tn] to indicate a tuple type or Union[T1, T2] to indicate a union type", "useTypeInstead": "Bunun yerine Type[T] kullanın", "varianceMismatchForClass": "\"{typeVarName}\" tür bağımsız değişkeni \"{className}\" taban sınıfıyla uyumsuz", "varianceMismatchForTypeAlias": "\"{typeVarName}\" tür bağımsız değişkeninin varyansı, \"{typeAliasParam}\" ile uyumsuz" diff --git a/packages/pyright-internal/src/localization/package.nls.zh-cn.json b/packages/pyright-internal/src/localization/package.nls.zh-cn.json index e941a676b..36e3cd6c3 100644 --- a/packages/pyright-internal/src/localization/package.nls.zh-cn.json +++ b/packages/pyright-internal/src/localization/package.nls.zh-cn.json @@ -1,7 +1,7 @@ { "CodeAction": { - "createTypeStub": "创建类型存根", - "createTypeStubFor": "为“{moduleName}”创建类型存根", + "createTypeStub": "创建类型 Stub", + "createTypeStubFor": "为 \"{moduleName}\" 创建类型 Stub", "executingCommand": "正在执行命令", "filesToAnalyzeCount": "要分析的 {count} 个文件", "filesToAnalyzeOne": "1 个要分析的文件", @@ -18,12 +18,12 @@ "annotatedMetadataInconsistent": "带批注的元数据类型“{metadataType}”与类型“{type}”不兼容", "annotatedParamCountMismatch": "参数批注计数不匹配: 应为 {expected}，但收到 {received}", "annotatedTypeArgMissing": "“Annotated”应为一个类型参数和一个或多个批注", - "annotationBytesString": "类型批注不能使用字节字符串文本", - "annotationFormatString": "类型批注不能使用格式字符串文本 (f 字符串)", + "annotationBytesString": "类型表达式不能使用字节字符串文本", + "annotationFormatString": "类型表达式不能使用格式字符串文本(f-string)", "annotationNotSupported": "此语句不支持类型批注", - "annotationRawString": "类型批注不能使用原始字符串文本", - "annotationSpansStrings": "类型批注不能跨越多个字符串文本", - "annotationStringEscape": "类型批注不能包含转义字符", + "annotationRawString": "类型表达式不能使用原始字符串文本", + "annotationSpansStrings": "类型表达式不能跨越多个字符串文本", + "annotationStringEscape": "类型表达式不能包含转义字符", "argAssignment": "无法将“{argType}”类型的参数分配给“{paramType}”类型的参数", "argAssignmentFunction": "无法将\"{argType}\"类型的参数分配给函数\"{functionName}\"中的\"{paramType}\"类型参数", "argAssignmentParam": "无法将“{argType}”类型的参数分配给“{paramType}”类型的参数“{paramName}”", @@ -43,21 +43,21 @@ "assignmentExprComprehension": "赋值表达式目标“{name}”不能使用与目标理解相同的名称", "assignmentExprContext": "赋值表达式必须在模块、函数或 lambda 中", "assignmentExprInSubscript": "仅在 Python 3.10 和更高版本中支持下标中的赋值表达式", - "assignmentInProtocol": "协议类中的实例或类变量必须在类主体内显式声明", + "assignmentInProtocol": "Protocol 类中的实例或类变量必须在类主体内显式声明", "assignmentTargetExpr": "表达式不能是赋值目标", - "asyncNotInAsyncFunction": "异步函数之外不允许使用“async”", + "asyncNotInAsyncFunction": "不允许在 async 函数之外使用 \"async\"", "awaitIllegal": "使用 “await” 需要 Python 3.5 或更高版本", - "awaitNotAllowed": "类型注释不能使用“await”", - "awaitNotInAsync": "仅允许在异步函数内使用“await”", + "awaitNotAllowed": "类型表达式不能使用 \"await\"", + "awaitNotInAsync": "仅允许在 async 函数内使用 \"await\"", "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}”，因为它是专用类型别名", @@ -87,7 +87,7 @@ "comparisonAlwaysFalse": "条件的计算结果始终为 False，因为类型“{leftType}”和“{rightType}”没有重叠", "comparisonAlwaysTrue": "条件的计算结果始终为 True，因为类型“{leftType}”和“{rightType}”没有重叠", "comprehensionInDict": "理解不能与其他字典条目一起使用", - "comprehensionInSet": "理解不能与其他集条目一起使用", + "comprehensionInSet": "推导式不能与其他 set 条目一起使用", "concatenateContext": "此上下文中不允许使用“Concatenate”", "concatenateParamSpecMissing": "“Concatenate”的最后一个类型参数必须是 ParamSpec 或 \"...\"", "concatenateTypeArgsMissing": "“Concatenate” 至少需要两个类型参数", @@ -111,7 +111,7 @@ "dataClassPostInitType": "数据类__post_init__方法参数类型不匹配 \"{fieldName}\"字段", "dataClassSlotsOverwrite": "__slots__已在类中定义", "dataClassTransformExpectedBoolLiteral": "静态计算结果为 True 或 False 的预期表达式", - "dataClassTransformFieldSpecifier": "应为类或函数的元组，但收到的类型\"{type}\"", + "dataClassTransformFieldSpecifier": "应为类或函数的 tuple，但收到类型 \"{type}\"", "dataClassTransformPositionalParam": "“dataclass_transform”的所有参数都必须是关键字参数", "dataClassTransformUnknownArgument": "dataclass_transform不支持参数“{name}”", "dataProtocolInSubclassCheck": "issubclass 调用中不允许使用数据协议(包括非方法属性)", @@ -127,12 +127,12 @@ "deprecatedDescriptorSetter": "已弃用描述符“{name}”的“__set__”方法", "deprecatedFunction": "函数“{name}”已弃用", "deprecatedMethod": "类“{className}”中的“{name}”方法已弃用", - "deprecatedPropertyDeleter": "已弃用属性“{name}”的删除程序", - "deprecatedPropertyGetter": "已弃用属性“{name}”的 getter", - "deprecatedPropertySetter": "已弃用属性“{name}”的资源库", + "deprecatedPropertyDeleter": "已弃用 property \"{name}\" 的 deleter", + "deprecatedPropertyGetter": "已弃用 property \"{name}\" 的 getter", + "deprecatedPropertySetter": "已弃用 property \"{name}\" 的 setter", "deprecatedType": "自 Python {version} 起，此类型已弃用；请改用“{replacement}”", "dictExpandIllegalInComprehension": "理解中不允许字典扩展", - "dictInAnnotation": "类型批注中不允许使用字典表达式", + "dictInAnnotation": "类型表达式中不允许使用字典表达式", "dictKeyValuePairs": "字典条目必须包含键/值对", "dictUnpackIsNotMapping": "字典解包运算符的预期映射", "dunderAllSymbolNotPresent": "\"{name}\"已在__all__中指定，但在模块中不存在", @@ -140,8 +140,8 @@ "duplicateBaseClass": "不允许重复的基类", "duplicateCapturePatternTarget": "捕获目标“{name}”不能在同一模式中出现多次", "duplicateCatchAll": "仅允许一个 catch-all except 子句", - "duplicateEnumMember": "枚举成员\"{name}\"已声明", - "duplicateGenericAndProtocolBase": "只允许一个泛型[...]或协议[...]基类", + "duplicateEnumMember": "Enum 成员 \"{name}\" 已声明", + "duplicateGenericAndProtocolBase": "只允许一个 Generic[...] 或 Protocol[...] 基类", "duplicateImport": "已多次导入“{importName}”", "duplicateKeywordOnly": "只允许一个“*”分隔符", "duplicateKwargsParam": "仅允许一个 “**” 参数", @@ -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,13 +212,13 @@ "finalClassIsAbstract": "类“{type}”被标记为 final，并且必须实现所有抽象符号", "finalContext": "不允许在此上下文中使用 \"Final\"", "finalInLoop": "无法在循环中分配 \"Final\" 变量", - "finalMethodOverride": "方法\"{name}\"无法替代在类\"{className}\"中定义的最终方法", + "finalMethodOverride": "方法 \"{name}\" 无法替代在类 \"{className}\" 中定义的 final 方法", "finalNonMethod": "不能将函数“{name}”标记为 @final，因为它不是方法", "finalReassigned": "\"{name}\"声明为 Final，无法重新分配", "finalRedeclaration": "\"{name}\"以前声明为 Final", "finalRedeclarationBySubclass": "无法重新声明“{name}”，因为父类“{className}”将其声明为 Final", "finalTooManyArgs": "“Final”后应为单个类型参数", - "finalUnassigned": "“{name}”声明为“最终”，但未分配值", + "finalUnassigned": "\"{name}\" 被声明为 Final，但未分配值", "formatStringBrace": "f 字符串文本中不允许使用单个右大括号；使用双右大括号", "formatStringBytes": "格式字符串文本(f 字符串)不能为二进制", "formatStringDebuggingIllegal": "F 字符串调试说明符“=”需要 Python 3.8 或更高版本", @@ -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": "lambda 的返回类型“{returnType}”部分未知", "lambdaReturnTypeUnknown": "lambda 的返回类型未知", "listAssignmentMismatch": "无法将 \"{type}\" 类型的表达式分配给目标列表", - "listInAnnotation": "类型批注中不允许使用列表表达式", + "listInAnnotation": "类型表达式中不允许使用 List 表达式", "literalEmptyArgs": "“Literal”后应有一个或多个类型参数", - "literalNamedUnicodeEscape": "“文本”字符串批注不支持已命名的 unicode 转义序列", + "literalNamedUnicodeEscape": "\"Literal\" 字符串批注不支持已命名的 unicode 转义序列", "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": "match 语句中的事例不会彻底处理所有值", "maxParseDepthExceeded": "超出最大分析深度;将表达式分解为较小的子表达式", "memberAccess": "无法访问类“{type}”的属性“{name}”", @@ -304,41 +304,42 @@ "methodOverridden": "“{name}”在类型“{type}”不兼容的类“{className}”中替代同名的方法", "methodReturnsNonObject": "“{name}”方法不返回对象", "missingSuperCall": "方法“{methodName}”在父类中不调用同名方法", + "mixingBytesAndStr": "Bytes 和 str 值无法串联", "moduleAsType": "模块不能用作类型", "moduleNotCallable": "模块不可调用", "moduleUnknownMember": "“{memberName}”不是模块“{moduleName}”的已知属性", - "namedExceptAfterCatchAll": "在 catch-all(除子句外)后不能出现命名的 except 子句", + "namedExceptAfterCatchAll": "命名的 except 子句不能出现在 catch-all except 子句后", "namedParamAfterParamSpecArgs": "关键字参数“{name}”不能出现在 ParamSpec args 参数之后的签名中", - "namedTupleEmptyName": "命名元组中的名称不能为空", - "namedTupleEntryRedeclared": "无法重写“{name}”，因为父类“{className}”是命名的元组", - "namedTupleFirstArg": "应将命名元组类名称作为第一个参数", + "namedTupleEmptyName": "命名 tuple 中的名称不能为空", + "namedTupleEntryRedeclared": "无法替代 \"{name}\"，因为父类 \"{className}\" 是命名的 tuple", + "namedTupleFirstArg": "应将命名的 tuple 类名作为第一个参数", "namedTupleMultipleInheritance": "不支持使用 NamedTuple 进行多个继承", "namedTupleNameKeyword": "字段名称不能是关键字", - "namedTupleNameType": "应为指定条目名称和类型的双条目元组", - "namedTupleNameUnique": "命名元组中的名称必须唯一", + "namedTupleNameType": "应为指定条目名称和类型的双条目 tuple", + "namedTupleNameUnique": "命名的 tuple 中的名称必须唯一", "namedTupleNoTypes": "“namedtuple”不提供元组条目的类型；请改用“NamedTuple”", - "namedTupleSecondArg": "应将命名元组条目列表作为第二个参数", + "namedTupleSecondArg": "应将命名的 tuple 条目 list 作为第二个参数", "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": "“None”不支持运算符\"{operator}\"", "noneUnknownMember": "“{name}”不是 \"None\" 的已知属性", "notRequiredArgCount": "“NotRequired” 之后应为单个类型参数", @@ -364,9 +365,9 @@ "overloadImplementationMismatch": "重载实现与重载 {index} 的签名不一致", "overloadReturnTypeMismatch": "“{name}”的重载 {prevIndex} 与重载 {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,7 +378,7 @@ "paramSpecArgsUsage": "ParamSpec 的 \"args\" 属性仅在与 *args 参数一起使用时有效", "paramSpecAssignedName": "必须将 ParamSpec 分配给名为“{name}”的变量", "paramSpecContext": "此上下文中不允许使用 ParamSpec", - "paramSpecDefaultNotTuple": "ParamSpec 的默认值应为省略号、元组表达式或 ParamSpec", + "paramSpecDefaultNotTuple": "ParamSpec 的默认值应为省略号、tuple 表达式或 ParamSpec", "paramSpecFirstArg": "ParamSpec 作为第一个参数的预期名称", "paramSpecKwargsUsage": "ParamSpec 的 \"kwargs\" 属性仅在与 **kwargs 参数一起使用时有效", "paramSpecNotUsedByOuterScope": "ParamSpec“{name}”在此上下文中没有意义", @@ -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": "未从模块“{module}”导出“{name}”", "privateUsedOutsideOfClass": "\"{name}\"是专用的，在声明它的类之外使用", "privateUsedOutsideOfModule": "“{name}”是专用的，在声明它的模块外部使用", - "propertyOverridden": "“{name}”错误地替代类“{className}”中同名的属性", - "propertyStaticMethod": "属性 getter、setter 或 deleter 不允许使用静态方法", + "propertyOverridden": "\"{name}\" 错误地替代了类 \"{className}\" 中同名的 property", + "propertyStaticMethod": "property getter、setter 或 deleter 不允许使用静态方法", "protectedUsedOutsideOfClass": "“{name}”在声明它的类之外受到保护并被使用", - "protocolBaseClass": "协议类“{classType}”不能派生自非协议类“{baseType}”", - "protocolBaseClassWithTypeArgs": "使用类型参数语法时，协议类不允许使用类型参数", + "protocolBaseClass": "Protocol 类 \"{classType}\" 不能派生自非 Protocol 类 \"{baseType}\"", + "protocolBaseClassWithTypeArgs": "使用类型参数语法时，Protocol 类不允许使用类型参数", "protocolIllegal": "使用 \"Protocol\" 需要 Python 3.7 或更高版本", "protocolNotAllowed": "\"Protocol\" 不能用于此上下文", - "protocolTypeArgMustBeTypeParam": "“协议”的类型参数必须是类型参数", + "protocolTypeArgMustBeTypeParam": "\"Protocol\" 的类型参数必须是类型参数", "protocolUnsafeOverlap": "类与“{name}”不安全地重叠，并且可能在运行时生成匹配项", - "protocolVarianceContravariant": "泛型协议“{class}”中使用的类型变量“{variable}”应为逆变", - "protocolVarianceCovariant": "泛型协议“{class}”中使用的类型变量“{variable}”应为协变", - "protocolVarianceInvariant": "泛型协议“{class}”中使用的类型变量“{variable}”应为固定变量", + "protocolVarianceContravariant": "泛型 Protocol \"{class}\" 中使用的类型变量 \"{variable}\" 应为反变量", + "protocolVarianceCovariant": "泛型 Protocol \"{class}\" 中使用的类型变量 \"{variable}\" 应为共变量", + "protocolVarianceInvariant": "泛型 Protocol \"{class}\" 中使用的类型变量 \"{variable}\" 应为固定变量", "pyrightCommentInvalidDiagnosticBoolValue": "Pyright 注释指令后面必须跟有“=”和 true 或 false 值", "pyrightCommentInvalidDiagnosticSeverityValue": "Pyright 注释指令后面必须跟有“=”，并且值为 true、false、error、warning、information 或 none", - "pyrightCommentMissingDirective": "Pyright 注释后面必须是指令(基本或严格)或诊断规则", + "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": "异步生成器中不允许返回值为值的语句", + "returnInAsyncGenerator": "async 生成器中不允许使用具有值的 return 语句", "returnMissing": "所声明的返回类型为“{returnType}”的函数必须在所有代码路径上返回值", "returnOutsideFunction": "“return”只能在函数中使用", "returnTypeContravariant": "逆变类型变量不能用于返回类型", - "returnTypeMismatch": "类型“{exprType}”的表达式与返回类型“{returnType}”不兼容", + "returnTypeMismatch": "类型“{exprType}”不可分配给返回类型“{returnType}”", "returnTypePartiallyUnknown": "返回类型“{returnType}”部分未知", "returnTypeUnknown": "返回类型未知", "revealLocalsArgs": "“reveal_locals”调用应没有参数", - "revealLocalsNone": "此范围内没有局部变量", + "revealLocalsNone": "此范围内没有 locals 变量", "revealTypeArgs": "“reveal_type”调用应为单个位置参数", "revealTypeExpectedTextArg": "函数“reveal_type”的“expected_text”参数必须是 str 文本值", "revealTypeExpectedTextMismatch": "类型文本不匹配；应为\"{expected}\"但收到\"{received}\"", @@ -439,7 +440,7 @@ "selfTypeContext": "“Self”在此上下文中无效", "selfTypeMetaclass": "“Self”不能在元类(“type”的子类)中使用", "selfTypeWithTypedSelfOrCls": "“Self”不能在具有“self”或“cls”参数的函数中使用，该参数的类型批注不是“Self”", - "setterGetterTypeMismatch": "属性资源库值类型不可分配给 getter 返回类型", + "setterGetterTypeMismatch": "Property setter 值类型不可分配给 getter 返回类型", "singleOverload": "“{name}”被标记为重载，但缺少其他重载", "slotsAttributeError": "未在__slots__中指定“{name}”", "slotsClassVarConflict": "\"{name}\"与__slots__中声明的实例变量冲突", @@ -449,27 +450,27 @@ "staticClsSelfParam": "静态方法不应采用“self”或“cls”参数", "stdlibModuleOverridden": "\"{path}\"正在替代 stdlib 模块\"{name}\"", "stringNonAsciiBytes": "不允许使用非 ASCII 字符(以字节为单位)字符串文本", - "stringNotSubscriptable": "字符串表达式不能在类型批注中下标；将整个批注括在引号中", + "stringNotSubscriptable": "字符串表达式不能在类型表达式中使用下标; 请将整个表达式括在引号中", "stringUnsupportedEscape": "字符串文本中不受支持的转义序列", "stringUnterminated": "字符串文本未终止", - "stubFileMissing": "找不到“{importName}”的存根文件", - "stubUsesGetAttr": "类型存根文件不完整；“__getattr__”会遮盖模块的类型错误", - "sublistParamsIncompatible": "Python 3.x 不支持子列表参数", + "stubFileMissing": "找不到 \"{importName}\" 的 Stub 文件", + "stubUsesGetAttr": "类型 stub 文件不完整; \"__getattr__\" 遮盖了模块的类型错误", + "sublistParamsIncompatible": "Python 3.x 不支持 Sublist 参数", "superCallArgCount": "“super” 调用应不超过两个参数", "superCallFirstArg": "应将类类型作为“super”调用的第一个参数，但收到“{type}”", "superCallSecondArg": "“super”调用的第二个参数必须是派生自“{type}”的对象或类", - "superCallZeroArgForm": "“Super”调用的零参数形式仅在方法中有效", + "superCallZeroArgForm": "\"super\" 调用的零参数形式仅在方法中有效", "superCallZeroArgFormStaticMethod": "“super”调用的零参数形式在静态方法中无效", "symbolIsPossiblyUnbound": "“{name}”可能未绑定", "symbolIsUnbound": "“{name}”未绑定", "symbolIsUndefined": "未定义“{name}”", "symbolOverridden": "“{name}”替代类“{className}”中的同名符号", - "ternaryNotAllowed": "类型注释中不允许使用三元表达式", + "ternaryNotAllowed": "类型表达式中不允许使用三元表达式", "totalOrderingMissingMethod": "类必须定义“__lt__”、“__le__”、“__gt__”或“__ge__”之一才能使用total_ordering", "trailingCommaInFromImport": "不允许使用尾随逗号，没有括号", "tryWithoutExcept": "Try 语句必须至少有一个 except 或 finally 子句", - "tupleAssignmentMismatch": "无法将类型为“{type}”的表达式分配给目标元组", - "tupleInAnnotation": "类型批注中不允许元组表达式", + "tupleAssignmentMismatch": "无法将类型为 \"{type}\" 的表达式分配给目标 tuple", + "tupleInAnnotation": "类型表达式中不允许使用 tuple 表达式", "tupleIndexOutOfRange": "类型 {type} 的索引 {index} 超出范围", "typeAliasIllegalExpressionForm": "类型别名定义的表达式形式无效", "typeAliasIsRecursiveDirect": "类型别名“{name}”不能在其定义中使用自身", @@ -481,28 +482,29 @@ "typeAliasTypeMustBeAssigned": "必须将 TypeAliasType 分配给与类型别名同名的变量", "typeAliasTypeNameArg": "TypeAliasType 的第一个参数必须是表示类型别名名称的字符串文本", "typeAliasTypeNameMismatch": "类型别名的名称必须与分配到的变量的名称匹配", - "typeAliasTypeParamInvalid": "类型参数列表必须是仅包含 TypeVar、TypeVarTuple 或 ParamSpec 的元组", + "typeAliasTypeParamInvalid": "类型参数列表必须是仅包含 TypeVar、TypeVarTuple 或 ParamSpec 的 tuple", "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,10 +539,10 @@ "typeVarSingleConstraint": "TypeVar 必须至少有两种约束类型", "typeVarTupleConstraints": "TypeVarTuple 不能有值约束", "typeVarTupleContext": "此上下文中不允许使用 TypeVarTuple", - "typeVarTupleDefaultNotUnpacked": "TypeVarTuple 默认类型必须是未打包的元组或 TypeVarTuple", + "typeVarTupleDefaultNotUnpacked": "TypeVarTuple 默认类型必须是未打包的 tuple 或 TypeVarTuple", "typeVarTupleMustBeUnpacked": "TypeVarTuple 值需要解包运算符", "typeVarTupleUnknownParam": "“{name}”是 TypeVarTuple 的未知参数", - "typeVarUnknownParam": "typeVar 的\"{name}\"是未知参数", + "typeVarUnknownParam": "\"{name}\" 是 TypeVar 的未知参数", "typeVarUsedByOuterScope": "TypeVar“{name}”已被外部作用域使用", "typeVarUsedOnlyOnce": "TypeVar \"{name}\" 在泛型函数签名中仅显示一次", "typeVarVariance": "TypeVar 不能同时为协变和逆变", @@ -552,8 +554,8 @@ "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": "字典条目名称的预期字符串文本", @@ -574,20 +576,20 @@ "unaccessedSymbol": "未存取“{name}”", "unaccessedVariable": "无法存取变量“{name}”", "unannotatedFunctionSkipped": "已跳过对函数“{name}”的分析，因为它未被批注", - "unaryOperationNotAllowed": "类型注释中不允许使用一元运算符", + "unaryOperationNotAllowed": "类型表达式中不允许使用一元运算符", "unexpectedAsyncToken": "“def”、“with” 或 “for” 应跟随 “async”", "unexpectedExprToken": "表达式末尾出现意外标记", "unexpectedIndent": "意外缩进", "unexpectedUnindent": "不应取消缩进", "unhashableDictKey": "字典密钥必须可哈希", - "unhashableSetEntry": "设置条目必须是可哈希", - "uninitializedAbstractVariables": "抽象基类中定义的变量未在最终类“{classType}”中初始化", + "unhashableSetEntry": "Set 条目必须是可哈希的", + "uninitializedAbstractVariables": "抽象基类中定义的变量未在 final 类 \"{classType}\" 中初始化", "uninitializedInstanceVariable": "未在类体或__init__方法中初始化实例变量“{name}”", - "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}”的实例", "unnecessaryIsSubclassAlways": "不必要的 issubclass 调用；“{testType}”始终是“{classType}”的子类", @@ -595,13 +597,13 @@ "unnecessaryPyrightIgnoreRule": "不必要的 \"# pyright: ignore\"规则: \"{name}\"", "unnecessaryTypeIgnore": "不必要的 \"# type: ignore\" 注释", "unpackArgCount": "\"Unpack\"后应为单个类型参数", - "unpackExpectedTypeVarTuple": "需要 TypeVarTuple 或元组作为 Unpack 的类型参数", - "unpackExpectedTypedDict": "解包的预期 TypedDict 类型参数", + "unpackExpectedTypeVarTuple": "Unpack 预期接收 TypeVarTuple 或 tuple 作为类型参数", + "unpackExpectedTypedDict": "Unpack 预期接收 TypedDict 类型参数", "unpackIllegalInComprehension": "在理解中不允许解包操作", - "unpackInAnnotation": "类型批注中不允许解压缩运算符", + "unpackInAnnotation": "类型表达式中不允许使用解包运算符", "unpackInDict": "字典中不允许解压缩操作", - "unpackInSet": "集内不允许解包运算符", - "unpackNotAllowed": "此上下文中不允许解包", + "unpackInSet": "set 内不允许使用解包运算符", + "unpackNotAllowed": "此上下文中不允许 Unpack", "unpackOperatorNotAllowed": "此上下文中不允许解压缩操作", "unpackTuplesIllegal": "Python 3.8 之前的元组中不允许解包操作", "unpackedArgInTypeArgument": "未打包的参数不能用于此上下文", @@ -616,35 +618,35 @@ "unreachableExcept": "无法访问 Except 子句，因为已处理异常", "unsupportedDunderAllOperation": "不支持对“__all__”执行操作，因此导出的符号列表可能不正确", "unusedCallResult": "调用表达式的结果类型为 \"{type}\" 且未使用；如果这是有意为之，则分配给变量 “_”", - "unusedCoroutine": "未使用异步函数调用的结果；使用 “await” 或将结果分配给变量", + "unusedCoroutine": "未使用 async 函数调用的结果; 请使用 \"await\" 或将结果分配给变量", "unusedExpression": "表达式值未使用", - "varAnnotationIllegal": "变量的类型批注需要 Python 3.6 或更高版本；使用类型注释与以前的版本兼容", + "varAnnotationIllegal": "变量的 Type 批注需要 Python 3.6 或更高版本; 请使用 type 注释以与以前的版本兼容", "variableFinalOverride": "变量\"{name}\"被标记为 Final，并替代类\"{className}\"中同名的非 Final 变量", - "variadicTypeArgsTooMany": "类型参数列表最多可以有一个未打包的 TypeVarTuple 或元组", + "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”", + "yieldFromOutsideAsync": "async 函数中不允许使用 \"yield from\"", "yieldOutsideFunction": "不允许在函数或 lambda 之外使用“yield”", "yieldWithinComprehension": "不允许在理解中使用 \"yield\"", "zeroCaseStatementsFound": "Match 语句必须至少包含一个 case 语句", - "zeroLengthTupleNotAllowed": "此上下文中不允许使用零长度元组" + "zeroLengthTupleNotAllowed": "此上下文中不允许使用零长度 tuple" }, "DiagnosticAddendum": { - "annotatedNotAllowed": "“已批注”特殊窗体不能与实例和类检查一起使用", + "annotatedNotAllowed": "\"Annotated\" 特殊形式不能与实例和类检查一起使用", "argParam": "参数对应于参数“{paramName}”", "argParamFunction": "参数对应于函数“{functionName}”中的参数“{paramName}”", "argsParamMissing": "参数“*{paramName}”没有相应的参数", "argsPositionOnly": "仅位置参数不匹配；应为 {expected}，但收到 {received}", "argumentType": "参数类型为“{type}”", "argumentTypes": "参数类型:({types})", - "assignToNone": "类型与 \"None\" 不兼容", + "assignToNone": "类型不可分配给“None”", "asyncHelp": "是否表示“async with”?", "baseClassIncompatible": "基类“{baseClass}”与类型“{type}”不兼容", "baseClassIncompatibleSubclass": "基类“{baseClass}”派生自与类型“{type}”不兼容的“{subclass}”", @@ -665,9 +667,9 @@ "functionTooFewParams": "函数接受的位置参数太少；应为 {expected}，但收到 {received}", "functionTooManyParams": "函数接受太多位置参数；应为 {expected}，但收到 {received}", "genericClassNotAllowed": "不允许对实例或类检查使用具有类型参数的泛型类型", - "incompatibleDeleter": "属性deleter 方法不兼容", - "incompatibleGetter": "属性 getter 方法不兼容", - "incompatibleSetter": "属性 setter 方法不兼容", + "incompatibleDeleter": "Property deleter 方法不兼容", + "incompatibleGetter": "Property getter 方法不兼容", + "incompatibleSetter": "Property setter 方法不兼容", "initMethodLocation": "__init__方法已在类“{type}”中定义", "initMethodSignature": "__init__的签名为“{type}”", "initSubclassLocation": "__init_subclass__ 方法在类“{name}”中定义", @@ -681,14 +683,14 @@ "keyUndefined": "“{name}”不是“{type}”中定义的密钥", "kwargsParamMissing": "参数“**{paramName}”没有相应的参数", "listAssignmentMismatch": "类型“{type}”与目标列表不兼容", - "literalAssignmentMismatch": "“{sourceType}”与类型“{destType}”不兼容", + "literalAssignmentMismatch": "“{sourceType}”不可分配给类型“{destType}”", "matchIsNotExhaustiveHint": "如果未进行详尽处理，请添加\"case _: pass\"", "matchIsNotExhaustiveType": "未处理的类型: \"{type}\"", "memberAssignment": "无法将类型“{type}”的表达式分配给类“{classType}”的属性“{name}”", "memberIsAbstract": "未实现“{type}.{name}”", "memberIsAbstractMore": "还有 {count} 个...", "memberIsClassVarInProtocol": "“{name}”在协议中定义为 ClassVar", - "memberIsInitVar": "“{name}”是仅限 init 的字段", + "memberIsInitVar": "\"{name}\" 是 init-only 的字段", "memberIsInvariant": "“{name}”是固定的，因为它是可变的", "memberIsNotClassVarInClass": "“{name}”必须定义为 ClassVar 才能与协议兼容", "memberIsNotClassVarInProtocol": "“{name}”未在协议中定义为 ClassVar", @@ -699,9 +701,9 @@ "memberTypeMismatch": "\"{name}\"是不兼容的类型", "memberUnknown": "属性“{name}”未知", "metaclassConflict": "元类“{metaclass1}”与“{metaclass2}”存在冲突", - "missingDeleter": "缺少属性 deleter方法", - "missingGetter": "缺少属性 getter 方法", - "missingSetter": "缺少属性 setter 方法", + "missingDeleter": "缺少 Property deleter 方法", + "missingGetter": "缺少 Property getter 方法", + "missingSetter": "缺少 Property setter 方法", "namedParamMissingInDest": "额外参数“{name}”", "namedParamMissingInSource": "缺少关键字参数“{name}”", "namedParamTypeMismatch": "类型为“{sourceType}”的关键字参数“{name}”与类型“{destType}”不兼容", @@ -741,16 +743,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[]\" 抑制单行诊断", "readOnlyAttribute": "属性“{name}”为只读", "seeClassDeclaration": "查看类声明", "seeDeclaration": "参见声明", @@ -759,17 +761,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}”不可分配给类型变量“{name}”的上限“{destType}”", + "typeConstrainedTypeVar": "类型“{type}”不可分配给受约束的类型变量“{name}”", + "typeIncompatible": "“{sourceType}”不可分配给“{destType}”", "typeNotClass": "“{type}”不是类", "typeNotStringLiteral": "“{type}”不是字符串文本", "typeOfSymbol": "“{name}”的类型为“{type}”", @@ -780,7 +782,7 @@ "typeVarIsCovariant": "类型参数 \"{name}\" 是协变的，但 \"{sourceType}\" 不是 \"{destType}\" 的子类型", "typeVarIsInvariant": "类型参数 \"{name}\" 是固定的，但 \"{sourceType}\" 与 \"{destType}\" 不同", "typeVarNotAllowed": "不允许对实例或类检查使用 TypeVar", - "typeVarTupleRequiresKnownLength": "TypeVarTuple 不能绑定到长度未知的元组", + "typeVarTupleRequiresKnownLength": "TypeVarTuple 不能绑定到长度未知的 tuple", "typeVarUnnecessarySuggestion": "请改用 {type}", "typeVarUnsolvableRemedy": "提供一个重载，该重载指定未提供参数时的返回类型", "typeVarsMissing": "缺少类型变量: {names}", @@ -804,9 +806,9 @@ "uninitializedAbstractVariable": "实例变量“{name}”在抽象基类“{classType}”中定义，但未初始化", "unreachableExcept": "“{exceptionType}”是“{parentType}”的子类", "useDictInstead": "使用 Dict[T1, T2] 指示字典类型", - "useListInstead": "使用 List[T] 指示列表类型或 Union[T1, T2] 以指示联合类型", - "useTupleInstead": "使用 tuple[T1, ..., Tn] 指示元组类型或使用 Union[T1, T2] 指示联合类型", - "useTypeInstead": "改用类型[T]", + "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}\"不兼容" }, diff --git a/packages/pyright-internal/src/localization/package.nls.zh-tw.json b/packages/pyright-internal/src/localization/package.nls.zh-tw.json index b33c9a24f..5f6cd0966 100644 --- a/packages/pyright-internal/src/localization/package.nls.zh-tw.json +++ b/packages/pyright-internal/src/localization/package.nls.zh-tw.json @@ -1,7 +1,7 @@ { "CodeAction": { - "createTypeStub": "建立類型虛設常式", - "createTypeStubFor": "建立 \"{moduleName}\" 的類型虛設常式", + "createTypeStub": "建立類型 Stub", + "createTypeStubFor": "建立 \"{moduleName}\" 的類型 Stub", "executingCommand": "執行命令", "filesToAnalyzeCount": "要分析的 {count} 個檔案", "filesToAnalyzeOne": "1 個要分析的檔案", @@ -18,12 +18,12 @@ "annotatedMetadataInconsistent": "標註的中繼資料類型 \"{metadataType}\" 與類型 \"{type}\" 不相容", "annotatedParamCountMismatch": "參數註釋計數不符: 應為 {expected}，但收到 {received}", "annotatedTypeArgMissing": "預期 \"Annotated\" 有一個類型引數和一或多個註釋", - "annotationBytesString": "類型註釋無法使用位元組字串常值", - "annotationFormatString": "類型註釋不能使用格式字串常值 (f-strings)", + "annotationBytesString": "類型運算式無法使用位元組字串常值", + "annotationFormatString": "類型運算式不能使用格式字串常值 (f-strings)", "annotationNotSupported": "此陳述式不支援類型註釋", - "annotationRawString": "類型註釋無法使用原始字串常值", - "annotationSpansStrings": "型別註釋無法跨越多個字串常值", - "annotationStringEscape": "型別註釋不可包含逸出字元", + "annotationRawString": "類型運算式無法使用原始字串常值", + "annotationSpansStrings": "型別運算式無法跨越多個字串常值", + "annotationStringEscape": "型別運算式不可包含逸出字元", "argAssignment": "類型 \"{argType}\" 的引數不能指派至類型 \"{paramType}\" 的參數", "argAssignmentFunction": "類型 \"{argType}\" 的引數不能指派至函式 \"{functionName}\" 中類型 \"{paramType}\" 的參數", "argAssignmentParam": "類型 \"{argType}\" 的引數不能指派至類型 \"{paramType}\" 的參數 \"{paramName}\"", @@ -43,21 +43,21 @@ "assignmentExprComprehension": "指派運算式目標 \"{name}\" 不能使用與目標 comprehension 相同的名稱", "assignmentExprContext": "Assignment 運算式必須在模組、函式或 Lambda 內", "assignmentExprInSubscript": "下標內的 Assignment 運算式僅在 Python 3.10 和更新版本中支援", - "assignmentInProtocol": "必須在類別主體內明確宣告通訊協定類別內的執行個體或類別變數", + "assignmentInProtocol": "必須在類別主體內明確宣告 Protocol 類別內的執行個體或類別變數", "assignmentTargetExpr": "運算式不能是指派目標", - "asyncNotInAsyncFunction": "不允許在非同步函式之外使用 \"async\"", + "asyncNotInAsyncFunction": "不允許在非 async 之外使用 \"async\"", "awaitIllegal": "使用 \"await\" 需要 Python 3.5 或更新版本", - "awaitNotAllowed": "類型註釋不能使用 “await”", - "awaitNotInAsync": "只在非同步函式內允許 \"await\"", + "awaitNotAllowed": "類型運算式不能使用 \"await\"", + "awaitNotInAsync": "只在 async 函式內允許 \"await\"", "backticksIllegal": "Python 3.x 中不支援以反引號括住的運算式; 請改為使用 repr", "baseClassCircular": "類別無法從本身衍生", - "baseClassFinal": "基底類別 \"{type}\" 標示為 Final，且不能設為子類別", + "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}\"，因為它是特殊的型別別名", @@ -87,7 +87,7 @@ "comparisonAlwaysFalse": "條件一律會評估為 False，因為類型 \"{leftType}\" 和 \"{rightType}\" 沒有重疊", "comparisonAlwaysTrue": "條件一律會評估為 True，因為類型 \"{leftType}\" 和 \"{rightType}\" 沒有重疊", "comprehensionInDict": "理解不能與其他字典項目搭配使用", - "comprehensionInSet": "Comprehension 無法與其他集合輸入項目一起使用", + "comprehensionInSet": "Comprehension 無法與其他 set 輸入項目一起使用", "concatenateContext": "此內容中不允許 \"Concatenate\"", "concatenateParamSpecMissing": "\"Concatenate\" 的最後一個類型引數必須是 ParamSpec 或 \"...\"", "concatenateTypeArgsMissing": "\"Concatenate\" 至少需要兩個型別引數", @@ -111,7 +111,7 @@ "dataClassPostInitType": "欄位 \"{fieldName}\" 的 Dataclass __post_init__ 方法參數類型不符", "dataClassSlotsOverwrite": "__slots__已定義在類別中", "dataClassTransformExpectedBoolLiteral": "應為靜態評估為 True 或 False 的運算式", - "dataClassTransformFieldSpecifier": "應為類別或函式的元組，但收到的型別為 \"{type}\"", + "dataClassTransformFieldSpecifier": "應為類別或函式的 tuple，但收到的類別為 \"{type}\"", "dataClassTransformPositionalParam": "\"dataclass_transform\" 的所有引數都必須是關鍵字引數", "dataClassTransformUnknownArgument": "dataclass_transform 不支援引數 \"{name}\"", "dataProtocolInSubclassCheck": "issubclass 呼叫中不允許資料通訊協定 (包含非方法屬性)", @@ -127,20 +127,20 @@ "deprecatedDescriptorSetter": "描述項 \"{name}\" 的 \"__set__\" 方法已被取代", "deprecatedFunction": "函式 \"{name}\" 已取代", "deprecatedMethod": "類別 \"{className}\" 中的方法 \"{name}\" 已取代", - "deprecatedPropertyDeleter": "屬性 \"{name}\" 的 deleter 已被取代", - "deprecatedPropertyGetter": "屬性 \"{name}\" 的 getter 已被取代", - "deprecatedPropertySetter": "屬性 \"{name}\" 的 setter 已被取代", + "deprecatedPropertyDeleter": "The deleter for property \"{name}\" is deprecated", + "deprecatedPropertyGetter": "The getter for property \"{name}\" is deprecated", + "deprecatedPropertySetter": "The setter for property \"{name}\" is deprecated", "deprecatedType": "此類型已隨著 Python {version} 取代; 請改為使用 \"{replacement}\"", "dictExpandIllegalInComprehension": "理解中不允許字典擴充", - "dictInAnnotation": "類型註釋中不允許字典運算式", + "dictInAnnotation": "類型運算式中不允許字典運算式", "dictKeyValuePairs": "字典項目必須包含金鑰/值組", "dictUnpackIsNotMapping": "預期為字典解壓縮運算子的對應", "dunderAllSymbolNotPresent": "\"{name}\" 已在 __all__ 中指定，但在模組中不存在", "duplicateArgsParam": "只允許一個 \"*\" 參數", "duplicateBaseClass": "不允許重複的基底類別", "duplicateCapturePatternTarget": "擷取目標 \"{name}\" 不能在相同模式中出現一次以上", - "duplicateCatchAll": "只允許一個 catch-all 例外子句", - "duplicateEnumMember": "已宣告列舉成員 \"{name}\"", + "duplicateCatchAll": "只允許一個 catch-all except 子句", + "duplicateEnumMember": "已宣告 Enum 成員 \"{name}\"", "duplicateGenericAndProtocolBase": "只允許一個 Generic[...] 或 Protocol[...] 基底類別", "duplicateImport": "\"{importName}\" 已匯入多次", "duplicateKeywordOnly": "只允許一個 \"*\" 分隔符號", @@ -149,14 +149,14 @@ "duplicatePositionOnly": "僅允許一個 \"/\" 參數", "duplicateStarPattern": "模式序列中僅允許一個 \"*\" 模式", "duplicateStarStarPattern": "僅允許輸入一個 \"**\"", - "duplicateUnpack": "清單中僅允許一個解除封裝作業", + "duplicateUnpack": "list 中僅允許一個解除封裝作業", "ellipsisAfterUnpacked": "\"...\" 不能與解壓縮的 TypeVarTuple 或 tuple 一起使用", "ellipsisContext": "此內容中不允許 \"...\"", "ellipsisSecondArg": "\"...\" 只允許做為兩個引數的第二個", - "enumClassOverride": "列舉類別 \"{name}\" 為 Final，且不能設為子類別", - "enumMemberDelete": "無法刪除列舉成員 \"{name}\"", - "enumMemberSet": "無法指派列舉成員 \"{name}\"", - "enumMemberTypeAnnotation": "列舉成員不允許類型註釋", + "enumClassOverride": "Enum 類別 \"{name}\" 為 final，且不能設為子類別", + "enumMemberDelete": "Enum member \"{name}\" cannot be deleted", + "enumMemberSet": "Enum member \"{name}\" cannot be assigned", + "enumMemberTypeAnnotation": "Type annotations are not allowed for enum members", "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": "預期為縮排區塊", @@ -209,10 +209,10 @@ "expectedTypeNotString": "預期為類型，但收到字串常值", "expectedTypeParameterName": "應為型別參數名稱", "expectedYieldExpr": "yield 陳述式中應有運算式", - "finalClassIsAbstract": "類別 \"{type}\" 標示為 Final，且必須實作所有抽象符號", + "finalClassIsAbstract": "類別 \"{type}\" 標示為 final，且必須實作所有抽象符號", "finalContext": "此內容中不允許 \"Final\"", "finalInLoop": "無法在迴圈內指派 \"Final\" 變數", - "finalMethodOverride": "方法 \"{name}\" 不能覆寫類別 \"{className}\" 中定義的 Final 方法", + "finalMethodOverride": "方法 \"{name}\" 不能覆寫類別 \"{className}\" 中定義的 final 方法", "finalNonMethod": "無法將函式 \"{name}\" 標示為 @final，因為它不是方法", "finalReassigned": "\"{name}\" 已宣告為 Final，因此無法重新指派", "finalRedeclaration": "\"{name}\" 先前已宣告為 Final", @@ -234,7 +234,7 @@ "functionInConditionalExpression": "條件運算式參考函式，一律評估為 True", "functionTypeParametersIllegal": "函式型別參數語法需要 Python 3.12 或較新的版本", "futureImportLocationNotAllowed": "來自 __future__ 的匯入必須位於檔案的開頭", - "generatorAsyncReturnType": "非同步產生器函式的傳回類型必須與 \"AsyncGenerator[{yieldType}, Any]\" 相容", + "generatorAsyncReturnType": "Return type of async generator function must be compatible with \"AsyncGenerator[{yieldType}, Any]\"", "generatorNotParenthesized": "如果不是唯一引數，則必須將產生器運算式用括弧括住", "generatorSyncReturnType": "產生器函式的傳回類型必須與 \"Generator[{yieldType}, Any, Any]\" 相容", "genericBaseClassNotAllowed": "\"Generic\" 基底類別不能與型別參數語法一起使用", @@ -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\" 的第二個引數必須是類別的類別或 Tuple", - "keyValueInSet": "組合內不允許金鑰/值組", + "isInstanceInvalidType": "\"isinstance\" 的第二個引數必須是類別或類別的tuple", + "isSubclassInvalidType": "\"issubclass\" 的第二個引數必須是類別的類別或 tuple", + "keyValueInSet": "set 內不允許金鑰/值組", "keywordArgInTypeArgument": "關鍵字引數無法用於型別引數清單", "keywordArgShortcutIllegal": "關鍵字引數快速鍵需要 Python 3.14 或更新版本", "keywordOnlyAfterArgs": "\"*\" 參數之後不允許僅限關鍵字的引數分隔符號", @@ -283,13 +283,13 @@ "lambdaReturnTypePartiallyUnknown": "Lambda 的傳回類型 \"{returnType}\" 部分未知", "lambdaReturnTypeUnknown": "Lambda 的傳回類型未知", "listAssignmentMismatch": "類型 \"{type}\" 的運算式不能指派至目標清單", - "listInAnnotation": "類型註釋中不允許清單運算式", + "listInAnnotation": "型別運算式中不允許 List 運算式", "literalEmptyArgs": "\"Literal\" 後面應有一或多個型別引數", "literalNamedUnicodeEscape": "\"Literal\" 字串常值中不支援具名 Unicode 逸出序列", "literalNotAllowed": "沒有類型參數，\"Literal\" 不能在此內容中使用", - "literalNotCallable": "常值類型不能具現化", - "literalUnsupportedType": "\"Literal\" 的類型引數必須是 None、常值 (int、bool、str 或 bytes) 或列舉值", - "matchIncompatible": "比對陳述式需要 Python 3.10 或更新版本", + "literalNotCallable": "Literal 類型不能具現化", + "literalUnsupportedType": "\"Literal\" 的類型引數必須是 None、literal (int、bool、str 或 bytes) 或 enum 值", + "matchIncompatible": "Match 陳述式需要 Python 3.10 或更新版本", "matchIsNotExhaustive": "match 陳述式內的案例並未完整處理所有值", "maxParseDepthExceeded": "超過剖析深度上限; 將運算式分成較小的子運算式", "memberAccess": "無法存取類別 \"{type}\" 的屬性 \"{name}\"", @@ -304,30 +304,31 @@ "methodOverridden": "\"{name}\" 以不相容型別 \"{type}\" 覆寫類別 \"{className}\" 中具有相同名稱的方法", "methodReturnsNonObject": "\"{name}\" 方法未傳回物件", "missingSuperCall": "方法 \"{methodName}\" 未呼叫父類別中相同名稱的方法", + "mixingBytesAndStr": "無法串連 Bytes 和 str 值", "moduleAsType": "模組不能當作型別來使用", "moduleNotCallable": "模組無法呼叫", "moduleUnknownMember": "\"{memberName}\" 不是模組 \"{moduleName}\" 的已知屬性", "namedExceptAfterCatchAll": "catch-all except 子句後面不能出現具名 except 子句", "namedParamAfterParamSpecArgs": "關鍵字參數 \"{name}\" 不能在簽章中出現在 ParamSpec args 參數之後", - "namedTupleEmptyName": "具名元組內的名稱不可為空白", - "namedTupleEntryRedeclared": "無法覆寫 \"{name}\"，因為父代類別 \"{className}\" 是具名的 Tuple", - "namedTupleFirstArg": "預期為具名 Tuple 類別名稱作為第一個引數", + "namedTupleEmptyName": "具名 tuple 內的名稱不可為空白", + "namedTupleEntryRedeclared": "無法覆寫 \"{name}\"，因為父代類別 \"{className}\" 是具名的 tuple", + "namedTupleFirstArg": "預期為具名 tuple 類別名稱作為第一個引數", "namedTupleMultipleInheritance": "不支援使用 NamedTuple 的多重繼承", "namedTupleNameKeyword": "欄位名稱不能是關鍵字", - "namedTupleNameType": "指定項目名稱和類型預期有兩個項目 Tuple", - "namedTupleNameUnique": "具名 Tuple 內的名稱必須是唯一的", + "namedTupleNameType": "指定輸入項目名稱和類型預期有兩個輸入項目 tuple", + "namedTupleNameUnique": "具名 tuple 內的名稱必須是唯一的", "namedTupleNoTypes": "\"namedtuple\" 未提供 Tuple 項目的類型; 請改為使用 \"NamedTuple\"", - "namedTupleSecondArg": "預期為具名 Tuple 項目清單作為第二個引數", + "namedTupleSecondArg": "預期為具名 tuple 項目 list 作為第二個引數", "newClsParam": "__new__ 覆寫應接受 \"cls\" 參數", "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": "非預設引數遵循預設引數", @@ -338,7 +339,7 @@ "noneNotCallable": "無法呼叫型別 \"None\" 的物件", "noneNotIterable": "類型 \"None\" 的物件不能作為可疊代的值", "noneNotSubscriptable": "型別 \"None\" 的物件不能下標", - "noneNotUsableWith": "類型 \"None\" 的物件不能與 \"with\" 搭配使用", + "noneNotUsableWith": "Object of type \"None\" cannot be used with \"with\"", "noneOperator": "\"None\" 不支援運算子 \"{operator}\"", "noneUnknownMember": "\"{name}\" 不是 \"None\" 的已知屬性", "notRequiredArgCount": "預期 \"NotRequired\" 之後為單一類型引數", @@ -364,9 +365,9 @@ "overloadImplementationMismatch": "多載的實作與多載 {index} 的簽章不一致", "overloadReturnTypeMismatch": "\"{name}\" 的多載 {prevIndex} 與多載 {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,7 +378,7 @@ "paramSpecArgsUsage": "只有搭配 *args 參數使用時，ParamSpec 的 \"args\" 屬性才有效", "paramSpecAssignedName": "ParamSpec 必須指派至名為 \"{name}\" 的變數", "paramSpecContext": "此內容中不允許 ParamSpec", - "paramSpecDefaultNotTuple": "ParamSpec 的預設值必須是省略符號、元組運算式或 ParamSpec", + "paramSpecDefaultNotTuple": "ParamSpec 的預設值必須是省略符號、tuple 運算式或 ParamSpec", "paramSpecFirstArg": "應以 ParamSpec 的名稱作為第一個引數", "paramSpecKwargsUsage": "只有搭配 **kwargs 參數使用時，ParamSpec 的 \"kwargs\" 屬性才有效", "paramSpecNotUsedByOuterScope": "ParamSpec \"{name}\" 在此內容中沒有意義", @@ -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": "\"*\" 參數之後不允許 Position-only 參數分隔符號", @@ -398,18 +399,18 @@ "privateImportFromPyTypedModule": "\"{name}\" 未從模組 \"{module}\" 匯出", "privateUsedOutsideOfClass": "\"{name}\" 為私人，並用於宣告其所在的類別之外", "privateUsedOutsideOfModule": "\"{name}\" 為私人，並用於宣告其所在的模組之外", - "propertyOverridden": "\"{name}\" 不正確地覆寫了類別 \"{className}\" 中相同名稱的屬性", - "propertyStaticMethod": "屬性 getter、setter 或 deleter 不允許靜態方法", + "propertyOverridden": "\"{name}\" 不正確地覆寫了類別 \"{className}\" 中相同名稱的 property", + "propertyStaticMethod": "Static methods not allowed for property getter, setter or deleter", "protectedUsedOutsideOfClass": "\"{name}\" 受到保護，並用於其宣告所在的類別之外", - "protocolBaseClass": "通訊協定類別 \"{classType}\" 不能衍生自非通訊協定類別 \"{baseType}\"", - "protocolBaseClassWithTypeArgs": "使用型別參數語法時，通訊協定類別不允許使用型別引數", + "protocolBaseClass": "Protocol 類別 \"{classType}\" 不能衍生自非 Protocol 類別 \"{baseType}\"", + "protocolBaseClassWithTypeArgs": "使用型別參數語法時，Protocol 類別不允許使用型別引數", "protocolIllegal": "使用 \"Protocol\" 需要 Python 3.7 或更新版本", "protocolNotAllowed": "\"Protocol\" 不能用在此內容中", "protocolTypeArgMustBeTypeParam": "“Protocol” 的型別引數必須是型別參數", "protocolUnsafeOverlap": "類別以不安全方式重疊 \"{name}\"，且可能會在運行時間產生相符專案", - "protocolVarianceContravariant": "一般通訊協定 \"{class}\" 中使用的型別變數 \"{variable}\" 必須為逆變數", - "protocolVarianceCovariant": "一般通訊協定 \"{class}\" 中使用的型別變數 \"{variable}\" 必須為共變數", - "protocolVarianceInvariant": "一般通訊協定 \"{class}\" 中使用的型別變數 \"{variable}\" 必須為不變數", + "protocolVarianceContravariant": "一般 Protocol \"{class}\" 中使用的類別變數 \"{variable}\" 必須為逆變數", + "protocolVarianceCovariant": "一般 Protocol \"{class}\" 中使用的類型變數 \"{variable}\" 必須為共變數", + "protocolVarianceInvariant": "一般 Protocol \"{class}\" 中使用的類別變數 \"{variable}\" 必須為不變數", "pyrightCommentInvalidDiagnosticBoolValue": "Pyright 註解指示詞後面必須接著 \"=\"，且值為 true 或 false", "pyrightCommentInvalidDiagnosticSeverityValue": "Pyright 註解指示詞後面必須接著 \"=\"，且值為 true、false、error、warning、information 或 none", "pyrightCommentMissingDirective": "Pyright 註解後面必須接著指示詞 (basic 或 strict) 或診斷規則", @@ -423,11 +424,11 @@ "relativeImportNotAllowed": "相對匯入不能與 \"import .a\" 格式搭配使用; 請改為使用 \"from . import a\"", "requiredArgCount": "\"Required\" 後面應有單一型別引數", "requiredNotInTypedDict": "此內容中不允許 \"Required\"", - "returnInAsyncGenerator": "非同步產生器中不允許具有值的 return 陳述式", + "returnInAsyncGenerator": "Return statement with value is not allowed in async generator", "returnMissing": "宣告類型為 \"{returnType}\" 的函式必須在所有程式碼路徑上傳回值", "returnOutsideFunction": "\"return\" 只能在函式內使用", "returnTypeContravariant": "逆變數型別變數不能用在傳回型別中", - "returnTypeMismatch": "類型 \"{exprType}\" 的運算式與傳回型別 \"{returnType}\" 不相容", + "returnTypeMismatch": "型別 \"{exprType}\" 無法指派給傳回型別 \"{returnType}\"", "returnTypePartiallyUnknown": "傳回類型 \"{returnType}\" 部分未知", "returnTypeUnknown": "傳回類型未知", "revealLocalsArgs": "\"reveal_locals\" 呼叫不應有任何引數", @@ -439,7 +440,7 @@ "selfTypeContext": "\"Self\" 在此內容中無效", "selfTypeMetaclass": "“Self” 不能用於 Metaclass 内 (“type” 的子類別)", "selfTypeWithTypedSelfOrCls": "\"Self\" 不能用在具有 `self` 或 `cls` 參數的函式中，其類型註釋不是 \"Self\"", - "setterGetterTypeMismatch": "屬性 setter 數值類型不能指派至 getter 傳回類型", + "setterGetterTypeMismatch": "Property setter 數值類型不能指派至 getter 傳回類型", "singleOverload": "\"{name}\" 標示為多載，但遺失其他多載", "slotsAttributeError": "未在__slots__中指定 \"{name}\"", "slotsClassVarConflict": "\"{name}\" 與在 __slots__ 中宣告的執行個體變數衝突", @@ -449,12 +450,12 @@ "staticClsSelfParam": "靜態方法不應採用 \"self\" 或 \"cls\" 參數", "stdlibModuleOverridden": "\"{path}\" 正在覆寫 stdlib 模組 \"{name}\"", "stringNonAsciiBytes": "位元組字串常值中不允許非 ASCII 字元", - "stringNotSubscriptable": "字串運算式不能在類型註釋中下標; 以引號括住整個註釋", + "stringNotSubscriptable": "字串運算式不能在類型運算式中下標; 以引號括住整個運算式", "stringUnsupportedEscape": "字串常值中不支援的逸出序列", "stringUnterminated": "字串常值未結束", - "stubFileMissing": "找不到 \"{importName}\" 的虛設常式檔案", - "stubUsesGetAttr": "類型虛設常式檔案不完整; \"__getattr__\" 會遮蔽模組的類型錯誤", - "sublistParamsIncompatible": "Python 3.x 不支援子清單參數", + "stubFileMissing": "找不到 \"{importName}\" 的 stub 檔案", + "stubUsesGetAttr": "類型 stub 檔案不完整; \"__getattr__\" 會遮蔽模組的類型錯誤", + "sublistParamsIncompatible": "Python 3.x 不支援 sublist 參數", "superCallArgCount": "\"super\" 呼叫不應有兩個以上的引數", "superCallFirstArg": "預期的類別類型為 \"super\" 呼叫的第一個引數，但收到 \"{type}\"", "superCallSecondArg": "\"super\" 呼叫的第二個引數必須是衍生自 \"{type}\" 的物件或類別", @@ -464,45 +465,46 @@ "symbolIsUnbound": "\"{name}\" 未繫結", "symbolIsUndefined": "\"{name}\" 未定義", "symbolOverridden": "\"{name}\" 會覆寫類別 \"{className}\" 中相同名稱的符號", - "ternaryNotAllowed": "類型註釋中不允許三元運算式", + "ternaryNotAllowed": "類型運算式中不允許三元運算式", "totalOrderingMissingMethod": "類別必須定義 \"__lt__\"、\"__le__\"、\"__gt__\" 或 \"__ge__\" 其中一個，才能使用 total_ordering", "trailingCommaInFromImport": "後置逗號不允許未使用括弧", "tryWithoutExcept": "Try 陳述式必須至少有一個 except 或 finally 子句", - "tupleAssignmentMismatch": "無法將型別 \"{type}\" 的運算式指派至目標元組", - "tupleInAnnotation": "型別註釋中不允許元組運算式", + "tupleAssignmentMismatch": "無法將型別 \"{type}\" 的運算式指派至目標 tuple", + "tupleInAnnotation": "型別運算式中不允許 Tuple 運算式", "tupleIndexOutOfRange": "索引 {index} 超過類型 {type} 的範圍", "typeAliasIllegalExpressionForm": "類型別名定義無效的運算式格式", "typeAliasIsRecursiveDirect": "型別別名 \"{name}\" 無法在其定義中使用它自己", "typeAliasNotInModuleOrClass": "TypeAlias 只能在模組或類別範圍內定義", "typeAliasRedeclared": "\"{name}\" 宣告為 TypeAlias，且只能指派一次", - "typeAliasStatementBadScope": "類型陳述式只能在模組或類別範圍內使用", + "typeAliasStatementBadScope": "A type statement can be used only within a module or class scope", "typeAliasStatementIllegal": "類型別名陳述式需要 Python 3.12 或更新版本", "typeAliasTypeBaseClass": "\"type\" 陳述式中定義的類型別名不能做為基底類別使用", "typeAliasTypeMustBeAssigned": "TypeAliasType 必須指派給與型別別名相同的變數", "typeAliasTypeNameArg": "TypeAliasType 的第一個引數必須是代表型別別名名稱的字串常值", "typeAliasTypeNameMismatch": "類型別名的名稱必須與指派它的變數名稱相符", - "typeAliasTypeParamInvalid": "型別參數清單必須是只包含 TypeVar、TypeVarTuple 或 ParamSpec 的元組", + "typeAliasTypeParamInvalid": "型別參數清單必須是只包含 TypeVar、TypeVarTuple 或 ParamSpec 的 tuple", "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,7 +539,7 @@ "typeVarSingleConstraint": "TypeVar 至少必須有兩個限制類型", "typeVarTupleConstraints": "TypeVarTuple 不能有值條件約束", "typeVarTupleContext": "此內容中不允許 TypeVarTuple", - "typeVarTupleDefaultNotUnpacked": "TypeVarTuple 預設型別必須是未封裝的元組或 TypeVarTuple", + "typeVarTupleDefaultNotUnpacked": "TypeVarTuple 預設型別必須是未封裝的 tuple 或 TypeVarTuple", "typeVarTupleMustBeUnpacked": "TypeVarTuple 值需要解除封裝運算子", "typeVarTupleUnknownParam": "\"{name}\" 是 TypeVarTuple 的未知參數", "typeVarUnknownParam": "\"{name}\" 對 TypeVar 是未知的參數", @@ -552,8 +554,8 @@ "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": "字典項目名稱預期為字串常值", @@ -565,7 +567,7 @@ "typedDictFirstArg": "預期 TypedDict 類別名稱作為第一個引數", "typedDictInitsubclassParameter": "TypedDict 不支援__init_subclass__參數 \"{name}\"", "typedDictNotAllowed": "\"TypedDict\" 不能用在此內容中", - "typedDictSecondArgDict": "預期為字典或關鍵字參數作為第二個參數", + "typedDictSecondArgDict": "預期為 dict 或關鍵字參數作為第二個參數", "typedDictSecondArgDictEntry": "應為簡單字典輸入項目", "typedDictSet": "無法在 TypedDict 中指派項目", "unaccessedClass": "未存取類別 \"{name}\"", @@ -574,20 +576,20 @@ "unaccessedSymbol": "未存取 \"{name}\"", "unaccessedVariable": "未存取變數 \"{name}\"", "unannotatedFunctionSkipped": "因為未標註函式 \"{name}\"，所以略過其分析", - "unaryOperationNotAllowed": "類型註釋中不允許一元運算子", + "unaryOperationNotAllowed": "類型運算式中不允許一元運算子", "unexpectedAsyncToken": "預期為 \"def\"、\"with\" 或 \"for\" 來追蹤 \"async\"", "unexpectedExprToken": "運算式結尾未預期的權杖", "unexpectedIndent": "未預期的縮排", "unexpectedUnindent": "取消縮排未預期", "unhashableDictKey": "字典索引鍵必須是可雜湊的", - "unhashableSetEntry": "設定項目必須是可雜湊", - "uninitializedAbstractVariables": "抽象基底類別中定義的變數未在 Final 類別 \"{classType}\" 中初始化", + "unhashableSetEntry": "Set 項目必須是可雜湊", + "uninitializedAbstractVariables": "抽象基底類別中定義的變數未在 final 類別 \"{classType}\" 中初始化", "uninitializedInstanceVariable": "執行個體變數 \"{name}\" 未在類別本文或 __init__ 方法上初始化", - "unionForwardReferenceNotAllowed": "聯集語法不能與字串運算元搭配使用; 使用引號括住整個運算式", + "unionForwardReferenceNotAllowed": "Union 語法不能與字串運算元搭配使用; 使用引號括住整個運算式", "unionSyntaxIllegal": "聯集的替代語法需要 Python 3.10 或更新版本", - "unionTypeArgCount": "聯集需要兩個或多個類型引數", - "unionUnpackedTuple": "集合聯集不能包含未封裝的 Tuple", - "unionUnpackedTypeVarTuple": "集合聯集不能包含未封裝的 TypeVarTuple", + "unionTypeArgCount": "Union 需要兩個或多個類型引數", + "unionUnpackedTuple": "Union 不能包含未封裝的 tuple", + "unionUnpackedTypeVarTuple": "Union 不能包含未封裝的 TypeVarTuple", "unnecessaryCast": "不必要的 \"cast\" 呼叫; 型別已是 \"{type}\"", "unnecessaryIsInstanceAlways": "不必要的 isinstance 呼叫; \"{testType}\" 一律是 \"{classType}\" 的執行個體", "unnecessaryIsSubclassAlways": "不必要的 issubclass 呼叫; \"{testType}\"永遠是 \"{classType}\" 的子類別", @@ -596,12 +598,12 @@ "unnecessaryTypeIgnore": "不必要的 \"# type: ignore\" 註解", "unpackArgCount": "\"Unpack\" 後面應為單一型別引數", "unpackExpectedTypeVarTuple": "預期 TypeVarTuple 或 tuple 作為 Unpack 的類型引數", - "unpackExpectedTypedDict": "應為解除封裝的 TypedDict 型別引數", + "unpackExpectedTypedDict": "應為 Unpack 的 TypedDict 型別引數", "unpackIllegalInComprehension": "理解中不允許解壓縮作業", - "unpackInAnnotation": "類型註釋中不允許解壓縮運算子", + "unpackInAnnotation": "類型運算式中不允許解壓縮運算子", "unpackInDict": "字典中不允許解壓縮作業", - "unpackInSet": "集合內不允許將運算子解除封裝", - "unpackNotAllowed": "此內容中不允許解壓縮", + "unpackInSet": "Unpack operator not allowed within a set", + "unpackNotAllowed": "此內容中不允許 Unpack", "unpackOperatorNotAllowed": "此內容中不允許解壓縮作業", "unpackTuplesIllegal": "Python 3.8 之前的 Tuple 中不允許解壓縮作業", "unpackedArgInTypeArgument": "無法在此內容中使用未封裝的引數", @@ -616,35 +618,35 @@ "unreachableExcept": "無法連接 Except 子句，因為例外已處理", "unsupportedDunderAllOperation": "不支援 \"__all__\" 上的作業，因此匯出的符號清單可能不正確", "unusedCallResult": "呼叫運算式的結果是 \"{type}\" 型別，而且未使用; 如果這是刻意的，則指派給變數 \"_\"", - "unusedCoroutine": "未使用非同步函式呼叫的結果; 使用 \"await\" 或指派結果至變數", + "unusedCoroutine": "未使用 async 函式呼叫的結果; 使用 \"await\" 或指派結果至變數", "unusedExpression": "未使用運算式值", - "varAnnotationIllegal": "變數的類型註釋需要 Python 3.6 或更新版本; 使用類型註解以獲得與先前版本的相容性", + "varAnnotationIllegal": "變數的 type 註釋需要 Python 3.6 或更新版本; 使用類型註解以獲得與先前版本的相容性", "variableFinalOverride": "變數 \"{name}\" 標示為 Final，且會覆寫類別 \"{className}\" 中相同名稱的非 Final 變數", "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\"", + "yieldFromOutsideAsync": "\"yield from\" not allowed in an async function", "yieldOutsideFunction": "在函式或 lambda 外部不允許 \"yield\"", "yieldWithinComprehension": "理解內不允許 \"yield\"", "zeroCaseStatementsFound": "Match 陳述式必須至少包含一個 case 陳述式", - "zeroLengthTupleNotAllowed": "此內容中不允許零長度 Tuple" + "zeroLengthTupleNotAllowed": "此內容中不允許零長度 tuple" }, "DiagnosticAddendum": { - "annotatedNotAllowed": "[已標註] 特殊表單不可與執行個體和類別檢查一起使用", + "annotatedNotAllowed": "[Annotated] 特殊表單不可與執行個體和類別檢查一起使用", "argParam": "引數對應至參數 \"{paramName}\"", "argParamFunction": "引數對應至函式 \"{functionName}\" 中的參數 \"{paramName}\"", "argsParamMissing": "參數 \"*{paramName}\" 沒有對應的參數", "argsPositionOnly": "僅限位置的參數不符; 應為 {expected}，但收到 {received}", "argumentType": "引數類型為 \"{type}\"", "argumentTypes": "引數型別: ({types})", - "assignToNone": "類型與 \"None\" 不相容", + "assignToNone": "型別無法指派給「None」", "asyncHelp": "您是指 \"async with\" 嗎?", "baseClassIncompatible": "基底類別 \"{baseClass}\" 與類型 \"{type}\" 不相容", "baseClassIncompatibleSubclass": "基底類別 \"{baseClass}\" 衍生自與類型 \"{type}\" 不相容的 \"{subclass}\"", @@ -657,7 +659,7 @@ "dataProtocolUnsupported": "\"{name}\" 是個資料通訊協定", "descriptorAccessBindingFailed": "無法為描述項類別 \"{className}\" 繫結方法 \"{name}\"", "descriptorAccessCallFailed": "無法呼叫描述項類別 \"{className}\" 的方法 \"{name}\"", - "finalMethod": "最終方法", + "finalMethod": "Final 方法", "functionParamDefaultMissing": "參數 \"{name}\" 遺漏了預設引數", "functionParamName": "參數名稱不符: \"{destName}\" 與 \"{srcName}\"", "functionParamPositionOnly": "僅位置參數不符；參數 \"{name}\" 不是僅限位置", @@ -665,9 +667,9 @@ "functionTooFewParams": "函式接受太少位置參數; 預期 {expected}，但收到 {received}", "functionTooManyParams": "函式接受太多位置參數; 預期 {expected}，但收到 {received}", "genericClassNotAllowed": "執行個體或類別檢查不允許具有類型引數的泛型類型", - "incompatibleDeleter": "屬性 deleter 方法不相容", - "incompatibleGetter": "屬性 getter 方法不相容", - "incompatibleSetter": "屬性 setter 方法不相容", + "incompatibleDeleter": "Property deleter 方法不相容", + "incompatibleGetter": "Property getter 方法不相容", + "incompatibleSetter": "Property setter 方法不相容", "initMethodLocation": "__init__ 方法於類別 \"{type}\" 中定義", "initMethodSignature": "__init__ 的簽章為 \"{type}\"", "initSubclassLocation": "__init_subclass__ 方法已於類別 \"{name}\" 中定義", @@ -681,14 +683,14 @@ "keyUndefined": "\"{name}\" 不是 \"{type}\" 中定義的金鑰", "kwargsParamMissing": "參數 \"**{paramName}\" 沒有對應的參數", "listAssignmentMismatch": "類型 \"{type}\" 與目標清單不相容", - "literalAssignmentMismatch": "\"{sourceType}\" 與類型 \"{destType}\" 不相容", + "literalAssignmentMismatch": "\"{sourceType}\" 無法指派給型別 \"{destType}\"", "matchIsNotExhaustiveHint": "如果不需要徹底處理，請新增 \"case _: pass\"", "matchIsNotExhaustiveType": "未處理的類型: \"{type}\"", "memberAssignment": "無法將型別 \"{type}\" 的運算式指派給類別 \"{classType}\" 的屬性 \"{name}\"", "memberIsAbstract": "\"{type}.{name}\" 未實作", "memberIsAbstractMore": "和其他 {count} 人...", "memberIsClassVarInProtocol": "\"{name}\" 定義為通訊協定中的 ClassVar", - "memberIsInitVar": "\"{name}\" 是僅限初始化的欄位", + "memberIsInitVar": "\"{name}\" 是 init-only 的欄位", "memberIsInvariant": "\"{name}\" 為不變數，因為它可變動", "memberIsNotClassVarInClass": "\"{name}\" 必須定義為 ClassVar，才能與通訊協定相容", "memberIsNotClassVarInProtocol": "\"{name}\" 未定義為通訊協定中的 ClassVar", @@ -699,9 +701,9 @@ "memberTypeMismatch": "\"{name}\" 是不相容的類型", "memberUnknown": "屬性 \"{name}\" 不明", "metaclassConflict": "Metaclass「{metaclass1}」與「{metaclass2}」衝突", - "missingDeleter": "屬性 deleter 方法遺失", - "missingGetter": "屬性 getter 方法遺失", - "missingSetter": "遺漏了屬性 setter 方法", + "missingDeleter": "Property deleter 方法遺失", + "missingGetter": "Property getter 方法遺失", + "missingSetter": "遺漏了 property setter 方法", "namedParamMissingInDest": "額外參數 \"{name}\"", "namedParamMissingInSource": "遺失關鍵詞參數 \"{name}\"", "namedParamTypeMismatch": "類型 \"{sourceType}\" 的關鍵字參數 \"{name}\" 與類型 \"{destType}\" 不相容", @@ -741,13 +743,13 @@ "paramType": "參數類型為 \"{paramType}\"", "privateImportFromPyTypedSource": "改為從 \"{module}\" 匯入", "propertyAccessFromProtocolClass": "通訊協定類別中定義的屬性無法存取為類別變數", - "propertyMethodIncompatible": "屬性方法 \"{name}\" 不相容", - "propertyMethodMissing": "覆寫中遺漏了屬性方法 \"{name}\"", - "propertyMissingDeleter": "屬性 \"{name}\" 沒有定義的 deleter", - "propertyMissingSetter": "屬性 \"{name}\" 沒有定義的 setter", + "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[]\" 來隱藏單行的診斷", @@ -759,17 +761,17 @@ "seeParameterDeclaration": "請參閱參數宣告", "seeTypeAliasDeclaration": "請參閱類型別名宣告", "seeVariableDeclaration": "請參閱變數宣告", - "tupleAssignmentMismatch": "型別 \"{type}\" 與目標元組不相容", + "tupleAssignmentMismatch": "型別 \"{type}\" 與目標 tuple 不相容", "tupleEntryTypeMismatch": "Tuple 項目 {entry} 的類型不正確", - "tupleSizeIndeterminateSrc": "元組大小不符; 預期為 {expected}，但收到不確定的大小", - "tupleSizeIndeterminateSrcDest": "元組大小不符; 預期為 {expected} 或其他，但收到不確定的大小", - "tupleSizeMismatch": "元組大小不符; 預期為 {expected}，但收到 {received}", - "tupleSizeMismatchIndeterminateDest": "元組大小不符; 預期為 {expected} 或其他，但收到 {received}", + "tupleSizeIndeterminateSrc": "Tuple 大小不符; 預期為 {expected}，但收到不確定的大小", + "tupleSizeIndeterminateSrcDest": "Tuple 大小不符; 預期為 {expected} 或其他，但收到不確定的大小", + "tupleSizeMismatch": "Tuple 大小不符; 預期為 {expected}，但收到 {received}", + "tupleSizeMismatchIndeterminateDest": "Tuple 大小不符; 預期為 {expected} 或其他，但收到 {received}", "typeAliasInstanceCheck": "使用 \"type\" 陳述式建立的類型別名不能搭配執行個體和類別檢查使用", - "typeAssignmentMismatch": "類型 \"{sourceType}\" 與類型 \"{destType}\" 不相容", - "typeBound": "類型 \"{sourceType}\" 與類型變數 \"{name}\" 的繫結類型 \"{destType}\" 不相容", - "typeConstrainedTypeVar": "類型 \"{type}\" 與限制類型變數 \"{name}\" 不相容", - "typeIncompatible": "\"{sourceType}\" 與 \"{destType}\" 不相容", + "typeAssignmentMismatch": "型別 \"{sourceType}\" 無法指派給型別 \"{destType}\"", + "typeBound": "型別 \"{sourceType}\" 無法指派給型別變數 \"{name}\" 的上限 \"{destType}\"", + "typeConstrainedTypeVar": "型別 \"{type}\" 無法指派給限制型別變數 \"{name}\"", + "typeIncompatible": "\"{sourceType}\" 無法指派給 \"{destType}\"", "typeNotClass": "\"{type}\" 不是類別", "typeNotStringLiteral": "\"{type}\" 不是字串常值", "typeOfSymbol": "\"{name}\" 的型別為 \"{type}\"", @@ -780,7 +782,7 @@ "typeVarIsCovariant": "型別參數 \"{name}\" 具有共變性，但 \"{sourceType}\" 不是 \"{destType}\" 的子型別", "typeVarIsInvariant": "型別參數 \"{name}\" 具有不變性，但 \"{sourceType}\" 與 \"{destType}\" 不同", "typeVarNotAllowed": "執行個體或類別檢查不允許 TypeVar", - "typeVarTupleRequiresKnownLength": "TypeVarTuple 無法繫結至長度不明的元組", + "typeVarTupleRequiresKnownLength": "TypeVarTuple 無法繫結至長度不明的 tuple", "typeVarUnnecessarySuggestion": "改用 {type}", "typeVarUnsolvableRemedy": "提供多載，其指定未提供引數時的傳回類型", "typeVarsMissing": "遺失類型變數: {names}", @@ -803,9 +805,9 @@ "unhashableType": "型別 \"{type}\" 無法雜湊", "uninitializedAbstractVariable": "執行個體變數 \"{name}\" 在抽象基底類別 \"{classType}\" 中定義，但未初始化", "unreachableExcept": "\"{exceptionType}\" 是 \"{parentType}\" 的子類別", - "useDictInstead": "使用 Dict[T1，T2] 來表示字典型別", - "useListInstead": "使用 List[T] 來表示清單型別，或使用 Union [T1, T2] 來表示等位型別", - "useTupleInstead": "使用 tuple[T1, ..., Tn] 來指出 Tuple 類型或 Union[T1, T2] 來指出聯集類型", + "useDictInstead": "使用 Dict[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}\" 不相容" diff --git a/packages/pyright-internal/src/tests/envVarUtils.test.ts b/packages/pyright-internal/src/tests/envVarUtils.test.ts index 12b6b89f3..4eefb3c04 100644 --- a/packages/pyright-internal/src/tests/envVarUtils.test.ts +++ b/packages/pyright-internal/src/tests/envVarUtils.test.ts @@ -11,7 +11,7 @@ import * as os from 'os'; import assert from 'assert'; import { expandPathVariables, resolvePathWithEnvVariables } from '../common/envVarUtils'; -import { WellKnownWorkspaceKinds, Workspace, WorkspacePythonPathKind, createInitStatus } from '../workspaceFactory'; +import { WellKnownWorkspaceKinds, Workspace, createInitStatus } from '../workspaceFactory'; import { UriEx } from '../common/uri/uriUtils'; import { Uri } from '../common/uri/uri'; import { AnalyzerService } from '../analyzer/service'; @@ -210,8 +210,6 @@ function createWorkspace(rootUri: Uri | undefined) { return { workspaceName: '', rootUri, - pythonPath: undefined, - pythonPathKind: WorkspacePythonPathKind.Mutable, kinds: [WellKnownWorkspaceKinds.Test], service: new AnalyzerService('test service', createServiceProvider(fs), { console: new NullConsole(), @@ -225,6 +223,5 @@ function createWorkspace(rootUri: Uri | undefined) { disableWorkspaceSymbol: false, isInitialized: createInitStatus(), searchPathsToWatch: [], - pythonEnvironmentName: undefined, }; } diff --git a/packages/pyright-internal/src/tests/harness/fourslash/testLanguageService.ts b/packages/pyright-internal/src/tests/harness/fourslash/testLanguageService.ts index d1845884d..e70e052ca 100644 --- a/packages/pyright-internal/src/tests/harness/fourslash/testLanguageService.ts +++ b/packages/pyright-internal/src/tests/harness/fourslash/testLanguageService.ts @@ -31,12 +31,7 @@ import { WindowInterface, } from '../../../common/languageServerInterface'; import { CodeActionProvider } from '../../../languageService/codeActionProvider'; -import { - WellKnownWorkspaceKinds, - Workspace, - WorkspacePythonPathKind, - createInitStatus, -} from '../../../workspaceFactory'; +import { WellKnownWorkspaceKinds, Workspace, createInitStatus } from '../../../workspaceFactory'; import { TestAccessHost } from '../testAccessHost'; import { HostSpecificFeatures } from './testState'; @@ -98,8 +93,6 @@ export class TestLanguageService implements LanguageServerInterface { this._defaultWorkspace = { workspaceName: '', rootUri: undefined, - pythonPath: undefined, - pythonPathKind: WorkspacePythonPathKind.Mutable, kinds: [WellKnownWorkspaceKinds.Test], service: new AnalyzerService( 'test service', @@ -118,7 +111,6 @@ export class TestLanguageService implements LanguageServerInterface { disableWorkspaceSymbol: false, isInitialized: createInitStatus(), searchPathsToWatch: [], - pythonEnvironmentName: undefined, }; } diff --git a/packages/pyright-internal/src/tests/harness/fourslash/testState.ts b/packages/pyright-internal/src/tests/harness/fourslash/testState.ts index 955976826..e7ba6cc96 100644 --- a/packages/pyright-internal/src/tests/harness/fourslash/testState.ts +++ b/packages/pyright-internal/src/tests/harness/fourslash/testState.ts @@ -73,13 +73,7 @@ import { ParseNode } from '../../../parser/parseNodes'; import { ParseFileResults } from '../../../parser/parser'; import { Tokenizer } from '../../../parser/tokenizer'; import { PyrightFileSystem } from '../../../pyrightFileSystem'; -import { - NormalWorkspace, - WellKnownWorkspaceKinds, - Workspace, - WorkspacePythonPathKind, - createInitStatus, -} from '../../../workspaceFactory'; +import { NormalWorkspace, WellKnownWorkspaceKinds, Workspace, createInitStatus } from '../../../workspaceFactory'; import { TestAccessHost } from '../testAccessHost'; import * as host from '../testHost'; import { stringify } from '../utils'; @@ -97,7 +91,13 @@ import { TestCancellationToken, } from './fourSlashTypes'; import { TestFeatures, TestLanguageService } from './testLanguageService'; -import { createVfsInfoFromFourSlashData, getMarkerByName, getMarkerName, getMarkerNames } from './testStateUtils'; +import { + createVfsInfoFromFourSlashData, + getMarkerByName, + getMarkerName, + getMarkerNames, + getRangeByMarkerName, +} from './testStateUtils'; import { verifyWorkspaceEdit } from './workspaceEditTestUtils'; export interface TextChange { @@ -199,8 +199,6 @@ export class TestState { this.workspace = { workspaceName: 'test workspace', rootUri: Uri.file(vfsInfo.projectRoot, this.serviceProvider), - pythonPath: undefined, - pythonPathKind: WorkspacePythonPathKind.Mutable, kinds: [WellKnownWorkspaceKinds.Test], service: service, disableLanguageServices: false, @@ -209,7 +207,6 @@ export class TestState { disableWorkspaceSymbol: false, isInitialized: createInitStatus(), searchPathsToWatch: [], - pythonEnvironmentName: undefined, }; const indexer = toBoolean(testData.globalOptions[GlobalMetadataOptionNames.indexer]); @@ -433,8 +430,7 @@ export class TestState { } getRangeByMarkerName(markerName: string): Range | undefined { - const marker = this.getMarkerByName(markerName); - return this.getRanges().find((r) => r.marker === marker); + return getRangeByMarkerName(this.testData, markerName); } goToBOF() { @@ -1958,6 +1954,7 @@ export class TestState { backgroundAnalysisProgramFactory, configOptions, fileSystem: this.fs, + libraryReanalysisTimeProvider: () => 0, }); // directly set files to track rather than using fileSpec from config diff --git a/packages/pyright-internal/src/tests/harness/fourslash/testStateUtils.ts b/packages/pyright-internal/src/tests/harness/fourslash/testStateUtils.ts index 688b142b3..1a37068e3 100644 --- a/packages/pyright-internal/src/tests/harness/fourslash/testStateUtils.ts +++ b/packages/pyright-internal/src/tests/harness/fourslash/testStateUtils.ts @@ -74,6 +74,11 @@ export function getMarkerNames(testData: FourSlashData): string[] { return [...testData.markerPositions.keys()]; } +export function getRangeByMarkerName(testData: FourSlashData, markerName: string) { + const marker = getMarkerByName(testData, markerName); + return testData.ranges.find((r) => r.marker === marker); +} + function isConfig(file: FourSlashFile, ignoreCase: boolean): boolean { const comparer = getStringComparer(ignoreCase); return comparer(getBaseFileName(file.fileName), configFileName) === Comparison.EqualTo; diff --git a/packages/pyright-internal/src/tests/harness/vfs/filesystem.ts b/packages/pyright-internal/src/tests/harness/vfs/filesystem.ts index b0ae59a3a..5fd2c6900 100644 --- a/packages/pyright-internal/src/tests/harness/vfs/filesystem.ts +++ b/packages/pyright-internal/src/tests/harness/vfs/filesystem.ts @@ -30,13 +30,13 @@ export interface DiffOptions { } export class TestFileSystemWatcher implements FileWatcher { - constructor(private _paths: Uri[], private _listener: FileWatcherEventHandler) {} + constructor(readonly paths: Uri[], private _listener: FileWatcherEventHandler) {} close() { // Do nothing. } fireFileChange(path: Uri, eventType: FileWatcherEventType): boolean { - if (this._paths.some((p) => path.startsWith(p))) { + if (this.paths.some((p) => path.startsWith(p))) { this._listener(eventType, path.getFilePath()); return true; } @@ -133,6 +133,10 @@ export class TestFileSystem implements FileSystem, TempFile, CaseSensitivityDete return this._shadowRoot; } + get fileWatchers() { + return this._watchers; + } + /** * Makes the file system read-only. */ diff --git a/packages/pyright-internal/src/tests/service.test.ts b/packages/pyright-internal/src/tests/service.test.ts index 3f8ff7475..d27b8294d 100644 --- a/packages/pyright-internal/src/tests/service.test.ts +++ b/packages/pyright-internal/src/tests/service.test.ts @@ -8,9 +8,12 @@ import assert from 'assert'; import { CancellationToken } from 'vscode-jsonrpc'; import { IPythonMode } from '../analyzer/sourceFile'; -import { combinePaths, getDirectoryPath } from '../common/pathUtils'; -import { parseAndGetTestState } from './harness/fourslash/testState'; +import { combinePaths, getDirectoryPath, normalizeSlashes } from '../common/pathUtils'; +import { parseAndGetTestState, TestState } from './harness/fourslash/testState'; import { Uri } from '../common/uri/uri'; +import { CommandLineOptions } from '../common/commandLineOptions'; +import { parseTestData } from './harness/fourslash/fourSlashParser'; +import { UriEx } from '../common/uri/uriUtils'; test('random library file changed', () => { const state = parseAndGetTestState('', '/projectRoot').state; @@ -298,6 +301,27 @@ test('folder that contains no file but whose parent has __init__ has changed', ( testSourceFileWatchChange(code, /* expected */ true, /* isFile */ false); }); +test('library file watching for extra path under workspace', () => { + const watchers = getRegisteredLibraryFileWatchers('/src', ['extraPath'], ['extraPath/**']); + assert(watchers.some((w) => w.paths.some((p) => p.equals(UriEx.file('/src/extraPath'))))); +}); + +test('user file watching as extra path under workspace', () => { + // Sometimes, this trick is used to make sub-modules to top-level modules. + const watchers = getRegisteredLibraryFileWatchers('/src', ['extraPath']); + + // This shouldn't be recognized as library file. + assert(!watchers.some((w) => w.paths.some((p) => p.equals(UriEx.file('/src/extraPath'))))); +}); + +test('library file watching another workspace root using extra path', () => { + // The extra path for a different workspace root will be initially added as a relative path, + // but when it reaches the service layer, it will be normalized to an absolute path. + // That's why it is used as an absolute path here. + const watchers = getRegisteredLibraryFileWatchers('/root1', ['/root2']); + assert(watchers.some((w) => w.paths.some((p) => p.equals(UriEx.file('/root2'))))); +}); + test('program containsSourceFileIn', () => { const code = ` // @ignoreCase: true @@ -388,3 +412,19 @@ function testSourceFileWatchChange(code: string, expected = true, isFile = true) expected ); } + +function getRegisteredLibraryFileWatchers(root: string, extraPaths: string[], excludes: string[] = []) { + root = normalizeSlashes(root); + + const data = parseTestData(root, '', ''); + const state = new TestState(root, data); + + const options = new CommandLineOptions(state.workspace.rootUri, false); + options.languageServerSettings.watchForLibraryChanges = true; + options.configSettings.extraPaths = extraPaths; + options.configSettings.excludeFileSpecs = excludes; + + state.workspace.service.setOptions(options); + + return state.testFS.fileWatchers; +} diff --git a/packages/pyright-internal/src/workspaceFactory.ts b/packages/pyright-internal/src/workspaceFactory.ts index 48baba9b4..4d0bf394f 100644 --- a/packages/pyright-internal/src/workspaceFactory.ts +++ b/packages/pyright-internal/src/workspaceFactory.ts @@ -13,8 +13,8 @@ import { import { AnalyzerService } from './analyzer/service'; import { ConsoleInterface } from './common/console'; import { createDeferred } from './common/deferred'; -import { Uri } from './common/uri/uri'; import { ServiceProvider } from './common/serviceProvider'; +import { Uri } from './common/uri/uri'; let WorkspaceFactoryIdCounter = 0; @@ -26,11 +26,6 @@ export enum WellKnownWorkspaceKinds { Test = 'test', } -export enum WorkspacePythonPathKind { - Immutable = 'immutable', - Mutable = 'mutable', -} - export interface InitStatus { resolve(): void; reset(): InitStatus; @@ -92,9 +87,6 @@ export interface Workspace extends WorkspaceFolder { disableWorkspaceSymbol: boolean; isInitialized: InitStatus; searchPathsToWatch: Uri[]; - pythonPath: Uri | undefined; - pythonPathKind: WorkspacePythonPathKind; - pythonEnvironmentName: string | undefined; } export interface NormalWorkspace extends Workspace { @@ -106,21 +98,7 @@ export function renameWorkspace(workspace: Workspace, name: string) { workspace.service.setServiceName(name); } -export interface IWorkspaceFactory { - handleInitialize(params: InitializeParams): void; - handleWorkspaceFoldersChanged(params: WorkspaceFoldersChangeEvent, workspaces: lspWorkspaceFolder[] | null): void; - - getWorkspaceForFile(uri: Uri, pythonPath: Uri | undefined): Promise; - getContainingWorkspacesForFile(filePath: Uri): Promise; - - applyPythonPath(workspace: Workspace, newPythonPath: Uri | undefined): Uri | undefined; - getNonDefaultWorkspaces(kind?: string): NormalWorkspace[]; - - clear(): void; - items(): AllWorkspace[]; -} - -export class WorkspaceFactory implements IWorkspaceFactory { +export class WorkspaceFactory { private _defaultWorkspacePath = ''; private _map = new Map(); private _id = WorkspaceFactoryIdCounter++; @@ -139,14 +117,10 @@ export class WorkspaceFactory implements IWorkspaceFactory { // Create a service instance for each of the workspace folders. if (params.workspaceFolders) { params.workspaceFolders.forEach((folder) => { - this._add(Uri.parse(folder.uri, this._serviceProvider), folder.name, undefined, [ - WellKnownWorkspaceKinds.Regular, - ]); + this._add(Uri.parse(folder.uri, this._serviceProvider), folder.name, [WellKnownWorkspaceKinds.Regular]); }); } else if (params.rootPath) { - this._add(Uri.file(params.rootPath, this._serviceProvider), '', undefined, [ - WellKnownWorkspaceKinds.Regular, - ]); + this._add(Uri.file(params.rootPath, this._serviceProvider), '', [WellKnownWorkspaceKinds.Regular]); } } @@ -164,7 +138,7 @@ export class WorkspaceFactory implements IWorkspaceFactory { const uri = Uri.parse(workspaceInfo.uri, this._serviceProvider); // Add the new workspace. - this._add(uri, workspaceInfo.name, undefined, [WellKnownWorkspaceKinds.Regular]); + this._add(uri, workspaceInfo.name, [WellKnownWorkspaceKinds.Regular]); }); // Ensure name changes are also reflected. @@ -187,25 +161,6 @@ export class WorkspaceFactory implements IWorkspaceFactory { return Array.from(this._map.values()); } - applyPythonPath(workspace: Workspace, newPythonPath: Uri | undefined): Uri | undefined { - // See if were allowed to apply the new python path - if (workspace.pythonPathKind === WorkspacePythonPathKind.Mutable && !Uri.isEmpty(newPythonPath)) { - workspace.pythonPath = newPythonPath; - - // This may not be the workspace in our map. Update the workspace in the map too. - // This can happen during startup were the Initialize creates a workspace and then - // onDidChangeConfiguration is called right away. - const key = this._getWorkspaceKey(workspace); - const workspaceInMap = this._map.get(key); - if (workspaceInMap) { - workspaceInMap.pythonPath = newPythonPath; - } - } - - // Return the python path that should be used (whether hardcoded or configured) - return workspace.pythonPath; - } - clear() { this._map.forEach((workspace) => { workspace.isInitialized.resolve(); @@ -236,8 +191,7 @@ export class WorkspaceFactory implements IWorkspaceFactory { getContainingWorkspace(filePath: Uri, pythonPath?: Uri): NormalWorkspace | undefined { return this._getBestRegularWorkspace( - this.getNonDefaultWorkspaces(WellKnownWorkspaceKinds.Regular).filter((w) => filePath.startsWith(w.rootUri)), - pythonPath + this.getNonDefaultWorkspaces(WellKnownWorkspaceKinds.Regular).filter((w) => filePath.startsWith(w.rootUri)) ); } @@ -266,7 +220,7 @@ export class WorkspaceFactory implements IWorkspaceFactory { await Promise.all(this.items().map((w) => w.isInitialized.promise)); // Find or create best match. - const workspace = await this._getOrCreateBestWorkspaceForFile(uri, pythonPath); + const workspace = await this._getOrCreateBestWorkspaceForFile(uri); // The workspace may have just been created. Wait for it to be initialized before returning it. await workspace.isInitialized.promise; @@ -285,7 +239,7 @@ export class WorkspaceFactory implements IWorkspaceFactory { // If that list is empty, get the best workspace if (workspaces.length === 0) { - workspaces.push(this._getBestWorkspaceForFile(filePath, undefined)); + workspaces.push(this._getBestWorkspaceForFile(filePath)); } // The workspaces may have just been created, wait for them all to be initialized @@ -297,7 +251,6 @@ export class WorkspaceFactory implements IWorkspaceFactory { private _add( rootUri: T, name: string, - pythonPath: Uri | undefined, kinds: string[] ): ConditionalWorkspaceReturnType { const uri = rootUri ?? Uri.empty(); @@ -312,8 +265,6 @@ export class WorkspaceFactory implements IWorkspaceFactory { workspaceName: name, rootUri, kinds, - pythonPath, - pythonPathKind: WorkspacePythonPathKind.Mutable, service: this._createService(name, uri, kinds), disableLanguageServices: false, disableTaggedHints: false, @@ -321,7 +272,6 @@ export class WorkspaceFactory implements IWorkspaceFactory { disableWorkspaceSymbol: false, isInitialized: createInitStatus(), searchPathsToWatch: [], - pythonEnvironmentName: pythonPath?.toString(), }; // Stick in our map @@ -370,9 +320,9 @@ export class WorkspaceFactory implements IWorkspaceFactory { return `${value.rootUri}`; } - private async _getOrCreateBestWorkspaceForFile(uri: Uri, pythonPath: Uri | undefined): Promise { + private async _getOrCreateBestWorkspaceForFile(uri: Uri): Promise { // Find the current best workspace (without creating a new one) - const bestInstance = this._getBestWorkspaceForFile(uri, pythonPath); + const bestInstance = this._getBestWorkspaceForFile(uri); // Make sure the best instance is initialized so that it has its pythonPath. await bestInstance.isInitialized.promise; @@ -380,7 +330,7 @@ export class WorkspaceFactory implements IWorkspaceFactory { return bestInstance; } - private _getBestWorkspaceForFile(uri: Uri, pythonPath: Uri | undefined): Workspace { + private _getBestWorkspaceForFile(uri: Uri): Workspace { let bestInstance: Workspace | undefined; // The order of how we find the best matching workspace for the given file is @@ -399,7 +349,7 @@ export class WorkspaceFactory implements IWorkspaceFactory { .filter(isNormalWorkspace); // Then find the best in all of those that actually matches the pythonPath. - bestInstance = this._getBestRegularWorkspace(trackingWorkspaces, pythonPath); + bestInstance = this._getBestRegularWorkspace(trackingWorkspaces); const regularWorkspaces = this.getNonDefaultWorkspaces(WellKnownWorkspaceKinds.Regular); @@ -414,36 +364,33 @@ export class WorkspaceFactory implements IWorkspaceFactory { w.rootUri.equals(regularWorkspaces[0].rootUri) ) ) { - bestInstance = this._getBestRegularWorkspace(regularWorkspaces, pythonPath); + bestInstance = this._getBestRegularWorkspace(regularWorkspaces); } // If the regular workspaces don't all have the same length or they don't // actually match on the python path, then try the workspaces that already have the file open or scanned. - if (bestInstance === undefined || !bestInstance.pythonPath?.equals(pythonPath)) { + if (bestInstance === undefined) { bestInstance = this._getBestRegularWorkspace( - regularWorkspaces.filter((w) => w.service.hasSourceFile(uri) && w.rootUri.scheme === uri.scheme), - pythonPath + regularWorkspaces.filter((w) => w.service.hasSourceFile(uri) && w.rootUri.scheme === uri.scheme) ) || bestInstance; } // If that still didn't work, that must mean we don't have a workspace. Create a default one. if (bestInstance === undefined) { - bestInstance = this._getOrCreateDefaultWorkspace(pythonPath); + bestInstance = this._getOrCreateDefaultWorkspace(); } return bestInstance; } - private _getOrCreateDefaultWorkspace(pythonPath: Uri | undefined): DefaultWorkspace { + private _getOrCreateDefaultWorkspace(): DefaultWorkspace { // Default key depends upon the pythonPath let defaultWorkspace = this._map.get(this._getDefaultWorkspaceKey()) as DefaultWorkspace; if (!defaultWorkspace) { // Create a default workspace for files that are outside // of all workspaces. - defaultWorkspace = this._add(undefined, this._defaultWorkspacePath, pythonPath, [ - WellKnownWorkspaceKinds.Default, - ]); + defaultWorkspace = this._add(undefined, this._defaultWorkspacePath, [WellKnownWorkspaceKinds.Default]); } return defaultWorkspace; @@ -463,7 +410,7 @@ export class WorkspaceFactory implements IWorkspaceFactory { return workspaces.find((w) => w.rootUri.equals(longestPath))!; } - private _getBestRegularWorkspace(workspaces: NormalWorkspace[], pythonPath?: Uri): NormalWorkspace | undefined { + private _getBestRegularWorkspace(workspaces: NormalWorkspace[]): NormalWorkspace | undefined { if (workspaces.length === 0) { return undefined; } @@ -473,14 +420,6 @@ export class WorkspaceFactory implements IWorkspaceFactory { return workspaces[0]; } - // If there's any that match the python path, take the one with the longest path from those. - if (!Uri.isEmpty(pythonPath)) { - const matchingWorkspaces = workspaces.filter((w) => Uri.equals(w.pythonPath, pythonPath)); - if (matchingWorkspaces.length > 0) { - return this._getLongestPathWorkspace(matchingWorkspaces); - } - } - // Otherwise, just take the longest path. return this._getLongestPathWorkspace(workspaces); } From dd3ba0a96ac51494015bcd47bf835ca95e257472 Mon Sep 17 00:00:00 2001 From: Eric Traut Date: Thu, 12 Sep 2024 12:49:41 -0700 Subject: [PATCH 03/27] Fixed recent regression that results in a false positive error when attempting to assign the expression `type(Any)` to type `type[Any]`. This addresses #8973. (#8976) --- .../src/analyzer/typeEvaluator.ts | 6 +++++- .../pyright-internal/src/tests/samples/any1.py | 15 +++++++++++---- .../src/tests/typeEvaluator7.test.ts | 2 +- 3 files changed, 17 insertions(+), 6 deletions(-) diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts index bc3efaa29..372bfbf24 100644 --- a/packages/pyright-internal/src/analyzer/typeEvaluator.ts +++ b/packages/pyright-internal/src/analyzer/typeEvaluator.ts @@ -24193,7 +24193,11 @@ export function createTypeEvaluator( if (isClassInstance(destType)) { if (ClassType.isBuiltIn(destType, 'type')) { - if (isInstantiableClass(srcType) && isSpecialFormClass(srcType, flags)) { + if ( + isInstantiableClass(srcType) && + isSpecialFormClass(srcType, flags) && + TypeBase.getInstantiableDepth(srcType) === 0 + ) { return false; } diff --git a/packages/pyright-internal/src/tests/samples/any1.py b/packages/pyright-internal/src/tests/samples/any1.py index c43cede1f..4b0a1f389 100644 --- a/packages/pyright-internal/src/tests/samples/any1.py +++ b/packages/pyright-internal/src/tests/samples/any1.py @@ -13,12 +13,10 @@ v2 = cast(typing.Any, 0) -class A(Any): - ... +class A(Any): ... -class B(typing.Any): - ... +class B(typing.Any): ... # This should generate an error because Any is not callable. @@ -36,3 +34,12 @@ def func1() -> int: def func2() -> int: # This should generate an error because Any cannot be used as a value. return typing.Any + + +v3: type[Any] = type(Any) + +# This should generate an error. +v4: type[type] = type(Any) + +# This should generate an error. +v5: type = Any diff --git a/packages/pyright-internal/src/tests/typeEvaluator7.test.ts b/packages/pyright-internal/src/tests/typeEvaluator7.test.ts index c31dd17d3..bf4c1109a 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator7.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator7.test.ts @@ -962,7 +962,7 @@ test('Del2', () => { test('Any1', () => { const analysisResults = TestUtils.typeAnalyzeSampleFiles(['any1.py']); - TestUtils.validateResults(analysisResults, 6); + TestUtils.validateResults(analysisResults, 8); }); test('Type1', () => { From 10b372d77784c56d220cdb96712f4002f874d358 Mon Sep 17 00:00:00 2001 From: Eric Traut Date: Thu, 12 Sep 2024 19:08:35 -0700 Subject: [PATCH 04/27] Fixed a bug that results in incorrect evaluation of a variable in a doubly-nested loop that is assigned a value in an assignment expression. This addresses #8979. (#8980) --- .../pyright-internal/src/analyzer/typeGuards.ts | 8 +------- .../pyright-internal/src/tests/samples/loop49.py | 13 +++++++++++++ .../src/tests/typeEvaluator3.test.ts | 6 ++++++ 3 files changed, 20 insertions(+), 7 deletions(-) create mode 100644 packages/pyright-internal/src/tests/samples/loop49.py diff --git a/packages/pyright-internal/src/analyzer/typeGuards.ts b/packages/pyright-internal/src/analyzer/typeGuards.ts index 4d481a2db..4d5a0b2c1 100644 --- a/packages/pyright-internal/src/analyzer/typeGuards.ts +++ b/packages/pyright-internal/src/analyzer/typeGuards.ts @@ -346,13 +346,7 @@ export function getTypeNarrowingCallback( testExpression.d.operator === OperatorType.Equals ? isPositiveTest : !isPositiveTest; if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr)) { - // Use speculative mode here to avoid polluting the type cache. This is - // important in cases where evaluation of the right expression creates - // a false dependency on another variable. - const rightTypeResult = evaluator.useSpeculativeMode(testExpression.d.rightExpr, () => { - return evaluator.getTypeOfExpression(testExpression.d.rightExpr); - }); - + const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr); const rightType = rightTypeResult.type; if (isClassInstance(rightType) && rightType.priv.literalValue !== undefined) { diff --git a/packages/pyright-internal/src/tests/samples/loop49.py b/packages/pyright-internal/src/tests/samples/loop49.py new file mode 100644 index 000000000..ffe050ec2 --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/loop49.py @@ -0,0 +1,13 @@ +# This sample tests a doubly-nested loop that was incorrectly evaluated. + +a = b = c = 0 + +while True: + if a < 0: + c += b - 1 + a = b + + while a != (d := a + 1): + b = max(b, d) + c += abs(a - d) + a = d diff --git a/packages/pyright-internal/src/tests/typeEvaluator3.test.ts b/packages/pyright-internal/src/tests/typeEvaluator3.test.ts index 12c6cc4e0..3173de03b 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator3.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator3.test.ts @@ -467,6 +467,12 @@ test('Loop48', () => { TestUtils.validateResults(analysisResults, 0); }); +test('Loop49', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['loop49.py']); + + TestUtils.validateResults(analysisResults, 0); +}); + test('ForLoop1', () => { const analysisResults = TestUtils.typeAnalyzeSampleFiles(['forLoop1.py']); From c3580db83279388f8523f54afc71318d5e680caa Mon Sep 17 00:00:00 2001 From: Eric Traut Date: Thu, 12 Sep 2024 22:31:55 -0700 Subject: [PATCH 05/27] Fixed a bug that results in incorrect narrowing of types for `TypeIs` user-defined type guard in certain cases when variable type is a union. This addresses #8966. (#8981) --- .../src/analyzer/typeGuards.ts | 24 +++++++---- .../src/tests/samples/typeIs1.py | 42 ++++++++++++------- .../src/tests/samples/typeIs3.py | 10 ----- .../src/tests/typeEvaluator6.test.ts | 2 +- 4 files changed, 42 insertions(+), 36 deletions(-) diff --git a/packages/pyright-internal/src/analyzer/typeGuards.ts b/packages/pyright-internal/src/analyzer/typeGuards.ts index 4d5a0b2c1..8d38868dd 100644 --- a/packages/pyright-internal/src/analyzer/typeGuards.ts +++ b/packages/pyright-internal/src/analyzer/typeGuards.ts @@ -1497,16 +1497,22 @@ function narrowTypeForInstance( filteredTypes.push(addConditionToType(specializedFilterType, conditions)); } else if (ClassType.isSameGenericClass(concreteVarType, concreteFilterType)) { - // Don't attempt to narrow in this case. - if ( - concreteVarType.priv?.literalValue === undefined && - concreteFilterType.priv?.literalValue === undefined - ) { - const intersection = intersectSameClassType(evaluator, concreteVarType, concreteFilterType); - filteredTypes.push(intersection ?? varType); + if (!isTypeIsCheck) { + // Don't attempt to narrow in this case. + if ( + concreteVarType.priv?.literalValue === undefined && + concreteFilterType.priv?.literalValue === undefined + ) { + const intersection = intersectSameClassType( + evaluator, + concreteVarType, + concreteFilterType + ); + filteredTypes.push(intersection ?? varType); - // Don't attempt to narrow in the negative direction. - isClassRelationshipIndeterminate = true; + // Don't attempt to narrow in the negative direction. + isClassRelationshipIndeterminate = true; + } } } else if ( allowIntersections && diff --git a/packages/pyright-internal/src/tests/samples/typeIs1.py b/packages/pyright-internal/src/tests/samples/typeIs1.py index d6bedd7e0..d98c5854b 100644 --- a/packages/pyright-internal/src/tests/samples/typeIs1.py +++ b/packages/pyright-internal/src/tests/samples/typeIs1.py @@ -28,8 +28,7 @@ def func1(val: Union[str, int]): reveal_type(val, expected_text="int") -def is_true(o: object) -> TypeIs[Literal[True]]: - ... +def is_true(o: object) -> TypeIs[Literal[True]]: ... def func2(val: bool): @@ -85,16 +84,13 @@ def func6(direction: Literal["NW", "E"]): reveal_type(direction, expected_text="Literal['NW']") -class Animal: - ... +class Animal: ... -class Kangaroo(Animal): - ... +class Kangaroo(Animal): ... -class Koala(Animal): - ... +class Koala(Animal): ... T = TypeVar("T") @@ -138,8 +134,7 @@ def func7(names: tuple[str, ...]): reveal_type(names, expected_text="tuple[str, ...]") -def is_int(obj: type) -> TypeIs[type[int]]: - ... +def is_int(obj: type) -> TypeIs[type[int]]: ... def func8(x: type) -> None: @@ -159,22 +154,37 @@ def func9(val: Collection[object]) -> None: @overload -def func10(v: tuple[int | str, ...], b: Literal[False]) -> TypeIs[tuple[str, ...]]: - ... +def func10(v: tuple[int | str, ...], b: Literal[False]) -> TypeIs[tuple[str, ...]]: ... @overload def func10( v: tuple[int | str, ...], b: Literal[True] = True -) -> TypeIs[tuple[int, ...]]: - ... +) -> TypeIs[tuple[int, ...]]: ... -def func10(v: tuple[int | str, ...], b: bool = True) -> bool: - ... +def func10(v: tuple[int | str, ...], b: bool = True) -> bool: ... v0 = is_int(int) v1: bool = v0 v2: int = v0 v3 = v0 & v0 + + +def is_sequence_of_int(sequence: Sequence) -> TypeIs[Sequence[int]]: + return all(isinstance(x, int) for x in sequence) + + +def func11(v: Sequence[int] | Sequence[str]): + if is_sequence_of_int(v): + reveal_type(v, expected_text="Sequence[int]") + else: + reveal_type(v, expected_text="Sequence[str]") + + +def func12(v: Sequence[int | str] | Sequence[list[Any]]): + if is_sequence_of_int(v): + reveal_type(v, expected_text="Sequence[int]") + else: + reveal_type(v, expected_text="Sequence[int | str] | Sequence[list[Any]]") diff --git a/packages/pyright-internal/src/tests/samples/typeIs3.py b/packages/pyright-internal/src/tests/samples/typeIs3.py index 65722fc02..a15c61f40 100644 --- a/packages/pyright-internal/src/tests/samples/typeIs3.py +++ b/packages/pyright-internal/src/tests/samples/typeIs3.py @@ -11,8 +11,6 @@ def is_tuple_of_strings(v: tuple[int | str, ...]) -> TypeIs[tuple[str, ...]]: def test1(t: tuple[int]) -> None: if is_tuple_of_strings(t): - # This will fail currently because pyright lacks - # the logic to narrow tuples in this manner. reveal_type(t, expected_text="Never") else: reveal_type(t, expected_text="tuple[int]") @@ -20,8 +18,6 @@ def test1(t: tuple[int]) -> None: def test2(t: tuple[str, int]) -> None: if is_tuple_of_strings(t): - # This will fail currently because pyright lacks - # the logic to narrow tuples in this manner. reveal_type(t, expected_text="Never") else: reveal_type(t, expected_text="tuple[str, int]") @@ -29,8 +25,6 @@ def test2(t: tuple[str, int]) -> None: def test3(t: tuple[int | str]) -> None: if is_tuple_of_strings(t): - # This will fail currently because pyright lacks - # the logic to narrow tuples in this manner. reveal_type(t, expected_text="tuple[str]") else: reveal_type(t, expected_text="tuple[int | str]") @@ -38,8 +32,6 @@ def test3(t: tuple[int | str]) -> None: def test4(t: tuple[int | str, int | str]) -> None: if is_tuple_of_strings(t): - # This will fail currently because pyright lacks - # the logic to narrow tuples in this manner. reveal_type(t, expected_text="tuple[str, str]") else: reveal_type(t, expected_text="tuple[int | str, int | str]") @@ -54,8 +46,6 @@ def test5(t: tuple[int | str, ...]) -> None: def test6(t: tuple[str, *tuple[int | str, ...], str]) -> None: if is_tuple_of_strings(t): - # This will fail currently because pyright lacks - # the logic to narrow tuples in this manner. reveal_type(t, expected_text="tuple[str, *tuple[str, ...], str]") else: reveal_type(t, expected_text="tuple[str, *tuple[int | str, ...], str]") diff --git a/packages/pyright-internal/src/tests/typeEvaluator6.test.ts b/packages/pyright-internal/src/tests/typeEvaluator6.test.ts index 74a327c91..98fcbffd2 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator6.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator6.test.ts @@ -140,7 +140,7 @@ test('TypeIs2', () => { test('TypeIs3', () => { const analysisResults = TestUtils.typeAnalyzeSampleFiles(['typeIs3.py']); - TestUtils.validateResults(analysisResults, 5); + TestUtils.validateResults(analysisResults, 0); }); test('TypeIs4', () => { From edaeab2bc2e7c5b4e5310ea02bc342c7d72eeef0 Mon Sep 17 00:00:00 2001 From: Daniel Colascione Date: Fri, 13 Sep 2024 12:58:56 -0400 Subject: [PATCH 06/27] Mutate sourceFile imports list whenever it changes (#8986) This change fixes a bug in which module imports stop resolving after file edits that change the set of modules a file imports. Previously, in _updateSourceFileImports, we would mutate the import list of the source file we were updating only if the new imports list was longer than the old list or any element mismatched between the old and new lists. This behavior led to a situation in which, potentially due to buffer editing, if the new import list was a prefix of the old list, we would fail to call sourceFileInfo.mutate(). Consequently, when those imports came back (perhaps due to further buffer editing) we would skip adding them to the sourceFileInfo import list (because, as we didn't call sourceFileInfo.mutate(), we falsely believe we still had the imports). Because we skipped the addition logic, we would not add the importing buffer to the importedBy lists of the imported SourceFileInfo. If not updating the importedBy list ended up leaving it empty, we regarded the imported source files as "not needed", didn't parse them, and consequently failed to resolve symbols imported from these modules. Now, we call sourceFileInfo.mutate() when the old and new import lists differ in any way, restoring correct behavior under buffer edits that remove imports. --- packages/pyright-internal/src/analyzer/program.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/pyright-internal/src/analyzer/program.ts b/packages/pyright-internal/src/analyzer/program.ts index f1e169914..68ea46da1 100644 --- a/packages/pyright-internal/src/analyzer/program.ts +++ b/packages/pyright-internal/src/analyzer/program.ts @@ -1492,7 +1492,7 @@ export class Program { // Only mutate if absolutely necessary otherwise we // can end up rebinding a lot of files we don't need to. if ( - newImports.length > sourceFileInfo.imports.length || + newImports.length !== sourceFileInfo.imports.length || !newImports.every((i) => sourceFileInfo.imports.includes(i)) ) { sourceFileInfo.mutate((s) => (s.imports = newImports)); From 9ea762f416d28e9246c183ca2bfcc7c325da1d29 Mon Sep 17 00:00:00 2001 From: Eric Traut Date: Fri, 13 Sep 2024 10:00:16 -0700 Subject: [PATCH 07/27] Improved comment for clarity. --- packages/pyright-internal/src/analyzer/program.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/pyright-internal/src/analyzer/program.ts b/packages/pyright-internal/src/analyzer/program.ts index 68ea46da1..138cefb02 100644 --- a/packages/pyright-internal/src/analyzer/program.ts +++ b/packages/pyright-internal/src/analyzer/program.ts @@ -1489,8 +1489,8 @@ export class Program { newImports.push(newImport); } }); - // Only mutate if absolutely necessary otherwise we - // can end up rebinding a lot of files we don't need to. + + // Mutate only when necessary to avoid extra binding operations. if ( newImports.length !== sourceFileInfo.imports.length || !newImports.every((i) => sourceFileInfo.imports.includes(i)) From d3821e9e5d8161d55a9ebe7ebddfbc35cc06bcc7 Mon Sep 17 00:00:00 2001 From: Eric Traut Date: Fri, 13 Sep 2024 15:35:05 -0700 Subject: [PATCH 08/27] Made adjustments to `TypeForm` behaviors based on feedback on draft PEP 747. (#8989) --- .../src/analyzer/typeEvaluator.ts | 141 +++++++----- .../src/analyzer/typePrinter.ts | 42 ---- .../src/tests/samples/typeForm1.py | 8 +- .../src/tests/samples/typeForm2.py | 217 +++++++++--------- .../src/tests/samples/typeForm4.py | 7 +- .../src/tests/samples/typeForm5.py | 10 +- .../src/tests/samples/typeForm6.py | 33 +++ .../src/tests/typeEvaluator8.test.ts | 4 +- 8 files changed, 237 insertions(+), 225 deletions(-) diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts index 372bfbf24..c820af6de 100644 --- a/packages/pyright-internal/src/analyzer/typeEvaluator.ts +++ b/packages/pyright-internal/src/analyzer/typeEvaluator.ts @@ -1118,6 +1118,11 @@ export function createTypeEvaluator( } } + if (inferenceContext) { + // Handle TypeForm assignments. + typeResult.type = convertToTypeFormType(inferenceContext.expectedType, typeResult.type); + } + // Don't allow speculative caching for assignment expressions because // the target name node won't have a corresponding type cached speculatively. const allowSpeculativeCaching = node.nodeType !== ParseNodeType.AssignmentExpression; @@ -4715,10 +4720,12 @@ export function createTypeEvaluator( } if (type.props?.typeAliasInfo && TypeBase.isInstantiable(type)) { - type = TypeBase.cloneWithTypeForm( - type, - convertToInstance(specializeTypeAliasWithDefaults(type, /* errorNode */ undefined)) - ); + let typeFormType = type; + if ((flags & EvalFlags.NoSpecialize) === 0) { + typeFormType = specializeTypeAliasWithDefaults(typeFormType, /* errorNode */ undefined); + } + + type = TypeBase.cloneWithTypeForm(type, convertToInstance(typeFormType)); } return type; @@ -5351,6 +5358,9 @@ export function createTypeEvaluator( // Detect, report, and fill in missing type arguments if appropriate. typeResult.type = reportMissingTypeArgs(node, typeResult.type, flags); + + // Add TypeForm details if appropriate. + typeResult.type = addTypeFormForSymbol(node, typeResult.type, flags, /* includesVarDecl */ false); } if (baseTypeResult.isIncomplete) { @@ -6958,13 +6968,20 @@ export function createTypeEvaluator( baseType: Type, flags: EvalFlags ): TypeResultWithNode | undefined { - const aliasInfo = baseType.props?.typeAliasInfo; + let aliasInfo = baseType.props?.typeAliasInfo; + let aliasBaseType = baseType; + + if (!aliasInfo && baseType.props?.typeForm) { + aliasInfo = baseType.props.typeForm?.props?.typeAliasInfo; + aliasBaseType = convertToInstantiable(baseType.props.typeForm); + } + if (!aliasInfo?.typeParams || (aliasInfo.typeParams.length === 0 && aliasInfo.typeArgs)) { return undefined; } // If this is not instantiable, then the index expression isn't a specialization. - if (!TypeBase.isInstantiable(baseType)) { + if (!TypeBase.isInstantiable(aliasBaseType)) { return undefined; } @@ -7007,7 +7024,7 @@ export function createTypeEvaluator( addDiagnostic( DiagnosticRule.reportInvalidTypeForm, LocMessage.typeArgsTooMany().format({ - name: printType(baseType), + name: printType(aliasBaseType), expected: typeParams.length, received: typeArgs.length, }), @@ -7018,7 +7035,7 @@ export function createTypeEvaluator( addDiagnostic( DiagnosticRule.reportInvalidTypeForm, LocMessage.typeArgsTooFew().format({ - name: printType(baseType), + name: printType(aliasBaseType), expected: typeParams.length, received: typeArgs.length, }), @@ -7029,8 +7046,8 @@ export function createTypeEvaluator( // Handle the mypy_extensions.FlexibleAlias type specially. if ( - isInstantiableClass(baseType) && - baseType.shared.fullName === 'mypy_extensions.FlexibleAlias' && + isInstantiableClass(aliasBaseType) && + aliasBaseType.shared.fullName === 'mypy_extensions.FlexibleAlias' && typeArgs.length >= 1 ) { return { node, type: typeArgs[0].type }; @@ -7156,7 +7173,7 @@ export function createTypeEvaluator( } if ((flags & EvalFlags.EnforceVarianceConsistency) !== 0) { - const usageVariances = inferVarianceForTypeAlias(baseType); + const usageVariances = inferVarianceForTypeAlias(aliasBaseType); if (usageVariances && index < usageVariances.length) { const usageVariance = usageVariances[index]; @@ -7194,7 +7211,7 @@ export function createTypeEvaluator( if (!diag.isEmpty()) { addDiagnostic( DiagnosticRule.reportInvalidTypeForm, - LocMessage.typeNotSpecializable().format({ type: printType(baseType) }) + diag.getString(), + LocMessage.typeNotSpecializable().format({ type: printType(aliasBaseType) }) + diag.getString(), node, diag.getEffectiveTextRange() ?? node ); @@ -7216,7 +7233,7 @@ export function createTypeEvaluator( aliasTypeArgs.push(typeVarType); }); - let type = TypeBase.cloneForTypeAlias(solveAndApplyConstraints(baseType, constraints), { + let type = TypeBase.cloneForTypeAlias(solveAndApplyConstraints(aliasBaseType, constraints), { ...aliasInfo, typeArgs: aliasTypeArgs, }); @@ -7225,7 +7242,11 @@ export function createTypeEvaluator( type = TypeBase.cloneWithTypeForm(type, reportedError ? undefined : convertToInstance(type)); } - return { type, node }; + if (baseType.props?.typeAliasInfo) { + return { type, node }; + } + + return { type: TypeBase.cloneWithTypeForm(baseType, convertToInstance(type)), node }; } function getTypeOfIndexWithBaseType( @@ -8314,7 +8335,7 @@ export function createTypeEvaluator( typeResult = getTypeOfAssertType(node, inferenceContext); } else if (isClass(baseTypeResult.type) && ClassType.isBuiltIn(baseTypeResult.type, 'TypeForm')) { // Handle the "typing.TypeForm" call. - typeResult = getTypeOfTypeForm(node); + typeResult = getTypeOfTypeForm(node, baseTypeResult.type); } else if ( isAnyOrUnknown(baseTypeResult.type) && node.d.leftExpr.nodeType === ParseNodeType.Name && @@ -8452,7 +8473,7 @@ export function createTypeEvaluator( return typeResult; } - function getTypeOfTypeForm(node: CallNode): TypeResult { + function getTypeOfTypeForm(node: CallNode, typeFormClass: ClassType): TypeResult { if ( node.d.args.length !== 1 || node.d.args[0].d.argCategory !== ArgCategory.Simple || @@ -8462,11 +8483,19 @@ export function createTypeEvaluator( return { type: UnknownType.create() }; } - return getTypeOfArgExpectingType(convertNodeToArg(node.d.args[0]), { + const typeFormResult = getTypeOfArgExpectingType(convertNodeToArg(node.d.args[0]), { typeFormArg: isTypeFormSupported(node), noNonTypeSpecialForms: true, typeExpression: true, }); + + if (!typeFormResult.typeErrors && typeFormResult.type.props?.typeForm) { + typeFormResult.type = convertToInstance( + ClassType.specialize(typeFormClass, [convertToInstance(typeFormResult.type.props.typeForm)]) + ); + } + + return typeFormResult; } function getTypeOfAssertType(node: CallNode, inferenceContext: InferenceContext | undefined): TypeResult { @@ -8497,29 +8526,12 @@ export function createTypeEvaluator( // what mypy does -- and what various library authors expect. const arg0Type = stripTypeGuard(arg0TypeResult.type); - let assertSuccess = isTypeSame(assertedType, arg0Type, { - treatAnySameAsUnknown: true, - ignorePseudoGeneric: true, - }); - - // Handle TypeForm types specially. if ( - !assertSuccess && - arg0Type.props?.typeForm && - isClassInstance(assertedType) && - ClassType.isBuiltIn(assertedType, 'TypeForm') - ) { - const typeFormType = - assertedType.priv.typeArgs && assertedType.priv.typeArgs.length >= 1 - ? assertedType.priv.typeArgs[0] - : UnknownType.create(); - assertSuccess = isTypeSame(arg0Type.props.typeForm, typeFormType, { + !isTypeSame(assertedType, arg0Type, { treatAnySameAsUnknown: true, ignorePseudoGeneric: true, - }); - } - - if (!assertSuccess) { + }) + ) { const srcDestTypes = printSrcDestTypes(arg0TypeResult.type, assertedType, { expandTypeAlias: true }); addDiagnostic( @@ -23678,6 +23690,11 @@ export function createTypeEvaluator( includeDiagAddendum = false; } + // Special-case TypeForm to retain literals when solving TypeVars. + if (ClassType.isBuiltIn(destType, 'TypeForm')) { + effectiveFlags |= AssignTypeFlags.RetainLiteralsForTypeVar; + } + if ( !assignType( variance === Variance.Contravariant ? srcTypeArg : destTypeArg, @@ -23864,11 +23881,6 @@ export function createTypeEvaluator( return true; } - // Handle TypeForm assignments. - if (assignToTypeFormType(destType, srcType, constraints, flags, recursionCount)) { - return true; - } - if (isTypeVar(destType)) { if (isTypeVarSame(destType, srcType)) { return true; @@ -24565,25 +24577,15 @@ export function createTypeEvaluator( return false; } - // If the destination type is an explicit TypeForm type, see if the source - // type has an implicit TypeForm type that can be assigned to it. Also see - // of the source is a type[T] type that is assignable. - function assignToTypeFormType( - destType: Type, - srcType: Type, - constraints: ConstraintTracker | undefined, - flags: AssignTypeFlags, - recursionCount: number - ): boolean { - if (!isClassInstance(destType) || !ClassType.isBuiltIn(destType, 'TypeForm')) { - return false; + // If the expected type is an explicit TypeForm type, see if the source + // type has an implicit TypeForm type that can be assigned to it. If so, + // convert to an explicit TypeForm type. + function convertToTypeFormType(expectedType: Type, srcType: Type): Type { + // Is the source is a TypeForm type? + if (!srcType.props?.typeForm) { + return srcType; } - const destTypeFormType = - destType.priv.typeArgs && destType.priv.typeArgs.length > 0 - ? destType.priv.typeArgs[0] - : UnknownType.create(); - let srcTypeFormType: Type | undefined; // Is the source is a TypeForm type? @@ -24607,10 +24609,27 @@ export function createTypeEvaluator( } if (!srcTypeFormType) { - return false; + return srcType; } - return assignType(destTypeFormType, srcTypeFormType, /* diag */ undefined, constraints, flags, recursionCount); + let resultType: Type | undefined; + + doForEachSubtype(expectedType, (subtype) => { + if (resultType || !isClassInstance(subtype) || !ClassType.isBuiltIn(subtype, 'TypeForm')) { + return; + } + + const destTypeFormType = + subtype.priv.typeArgs && subtype.priv.typeArgs.length > 0 + ? subtype.priv.typeArgs[0] + : UnknownType.create(); + + if (assignType(destTypeFormType, srcTypeFormType)) { + resultType = ClassType.specialize(subtype, [srcTypeFormType]); + } + }); + + return resultType ?? srcType; } function assignFromUnionType( diff --git a/packages/pyright-internal/src/analyzer/typePrinter.ts b/packages/pyright-internal/src/analyzer/typePrinter.ts index 425477aa5..cc488337e 100644 --- a/packages/pyright-internal/src/analyzer/typePrinter.ts +++ b/packages/pyright-internal/src/analyzer/typePrinter.ts @@ -86,9 +86,6 @@ export const enum PrintTypeFlags { // Use the fully-qualified name of classes, type aliases, modules, // and functions rather than short names. UseFullyQualifiedNames = 1 << 12, - - // Omit the "& TypeForm[T]" on the end of the type. - OmitTypeForm = 1 << 13, } export type FunctionReturnTypeCallback = (type: FunctionType) => Type; @@ -199,45 +196,6 @@ function printTypeInternal( } recursionCount++; - // Does this type have a typeForm associated with it? - if ( - type.props?.typeForm && - (printTypeFlags & PrintTypeFlags.OmitTypeForm) === 0 && - (printTypeFlags & PrintTypeFlags.PythonSyntax) === 0 - ) { - const actualTypeText = printTypeInternal( - type, - printTypeFlags | PrintTypeFlags.OmitTypeForm | PrintTypeFlags.ParenthesizeUnion, - returnTypeCallback, - uniqueNameMap, - recursionTypes, - recursionCount - ); - - const typeFormText = printTypeInternal( - type.props.typeForm, - (printTypeFlags | PrintTypeFlags.OmitTypeForm) & ~PrintTypeFlags.ExpandTypeAlias, - returnTypeCallback, - uniqueNameMap, - recursionTypes, - recursionCount - ); - - // Don't include the TypeForm portion if this is a simple type[T] - // type because this information is redundant. - if (actualTypeText === `type[${typeFormText}]`) { - return actualTypeText; - } - - // Don't include the TypeForm portion if this is a None type because - // this is redundant. - if (isNoneInstance(type)) { - return actualTypeText; - } - - return `${actualTypeText} & TypeForm[${typeFormText}]`; - } - const originalPrintTypeFlags = printTypeFlags; const parenthesizeUnion = (printTypeFlags & PrintTypeFlags.ParenthesizeUnion) !== 0; printTypeFlags &= ~(PrintTypeFlags.ParenthesizeUnion | PrintTypeFlags.ParenthesizeCallable); diff --git a/packages/pyright-internal/src/tests/samples/typeForm1.py b/packages/pyright-internal/src/tests/samples/typeForm1.py index 84707acc0..d4dc78dc6 100644 --- a/packages/pyright-internal/src/tests/samples/typeForm1.py +++ b/packages/pyright-internal/src/tests/samples/typeForm1.py @@ -20,13 +20,13 @@ s1 = TypeForm(int) -reveal_type(s1, expected_text="type[int]") +reveal_type(s1, expected_text="TypeForm[int]") s2 = TypeForm("int | str") -reveal_type(s2, expected_text="Literal['int | str'] & TypeForm[int | str]") +reveal_type(s2, expected_text="TypeForm[int | str]") s3 = TypeForm(list["str"]) -reveal_type(s3, expected_text="type[list[str]]") +reveal_type(s3, expected_text="TypeForm[list[str]]") s4 = TypeForm(Annotated[int, "meta"]) -reveal_type(s4, expected_text="Annotated & TypeForm[int]") +reveal_type(s4, expected_text="TypeForm[int]") diff --git a/packages/pyright-internal/src/tests/samples/typeForm2.py b/packages/pyright-internal/src/tests/samples/typeForm2.py index 7af4eda47..7c2b23cd3 100644 --- a/packages/pyright-internal/src/tests/samples/typeForm2.py +++ b/packages/pyright-internal/src/tests/samples/typeForm2.py @@ -32,177 +32,182 @@ type TA5[T] = int -def func1(): - t1 = int - reveal_type(t1, expected_text="type[int]") +def tf[T](x: TypeForm[T]) -> TypeForm[T]: ... + - t2 = int | str - reveal_type(t2, expected_text="UnionType & TypeForm[int | str]") +def func1(): + t1 = tf(int) + reveal_type(t1, expected_text="TypeForm[int]") - t3 = "int | str" - reveal_type(t3, expected_text="Literal['int | str'] & TypeForm[int | str]") + t2 = tf(int | str) + reveal_type(t2, expected_text="TypeForm[int | str]") - t4 = "int | 1" - reveal_type(t4, expected_text="Literal['int | 1']") + t3 = tf("int | str") + reveal_type(t3, expected_text="TypeForm[int | str]") - t5 = Annotated[int, "meta"] - reveal_type(t5, expected_text="Annotated & TypeForm[int]") + t5 = tf(Annotated[int, "meta"]) + reveal_type(t5, expected_text="TypeForm[int]") - t5_alt1 = tp.Annotated[int, "meta"] - reveal_type(t5_alt1, expected_text="Annotated & TypeForm[int]") + t5_alt1 = tf(tp.Annotated[int, "meta"]) + reveal_type(t5_alt1, expected_text="TypeForm[int]") - t6 = Any - reveal_type(t6, expected_text="type[Any]") + t6 = tf(Any) + reveal_type(t6, expected_text="TypeForm[Any]") - t6_alt1 = tp.Any - reveal_type(t6_alt1, expected_text="type[Any]") + t6_alt1 = tf(tp.Any) + reveal_type(t6_alt1, expected_text="TypeForm[Any]") - t7 = type[int] - reveal_type(t7, expected_text="type[type[int]]") + t7 = tf(type[int]) + reveal_type(t7, expected_text="TypeForm[type[int]]") - t7_alt = type - reveal_type(t7_alt, expected_text="type[type]") + t7_alt = tf(type) + reveal_type(t7_alt, expected_text="TypeForm[type]") - t8 = TA1 - reveal_type(t8, expected_text="TypeAliasType & TypeForm[TA1]") + t8 = tf(TA1) + reveal_type(t8, expected_text="TypeForm[int | str]") - t9 = TA2[str] - reveal_type(t9, expected_text="TypeAliasType & TypeForm[TA2[str]]") + t9 = tf(TA2[str]) + reveal_type(t9, expected_text="TypeForm[list[str] | str]") - t9_alt = TA2 - reveal_type(t9_alt, expected_text="TypeAliasType & TypeForm[TA2[Unknown]]") + t9_alt = tf(TA2) + reveal_type(t9_alt, expected_text="TypeForm[list[T@TA2] | T@TA2]") - t10 = TA3 - reveal_type(t10, expected_text="Annotated & TypeForm[TA3]") + t10 = tf(TA3) + reveal_type(t10, expected_text="TypeForm[int]") - t11 = TA4 - reveal_type(t11, expected_text="UnionType & TypeForm[TA4]") + t11 = tf(TA4) + reveal_type(t11, expected_text="TypeForm[int | str]") - t12 = Literal[1, 2, 3] - reveal_type(t12, expected_text="UnionType & TypeForm[Literal[1, 2, 3]]") + t12 = tf(Literal[1, 2, 3]) + reveal_type(t12, expected_text="TypeForm[Literal[1, 2, 3]]") - t12_alt1 = tp.Literal[1, 2, 3] - reveal_type(t12_alt1, expected_text="UnionType & TypeForm[Literal[1, 2, 3]]") + t12_alt1 = tf(tp.Literal[1, 2, 3]) + reveal_type(t12_alt1, expected_text="TypeForm[Literal[1, 2, 3]]") - t13 = Optional[str] - reveal_type(t13, expected_text="UnionType & TypeForm[str | None]") + t13 = tf(Optional[str]) + reveal_type(t13, expected_text="TypeForm[str | None]") - t13_alt1 = tp.Optional[str] - reveal_type(t13_alt1, expected_text="UnionType & TypeForm[str | None]") + t13_alt1 = tf(tp.Optional[str]) + reveal_type(t13_alt1, expected_text="TypeForm[str | None]") - t14 = Union[list[int], str] - reveal_type(t14, expected_text="UnionType & TypeForm[list[int] | str]") + t14 = tf(Union[list[int], str]) + reveal_type(t14, expected_text="TypeForm[list[int] | str]") - t14_alt1 = tp.Union[list[int], str] - reveal_type(t14_alt1, expected_text="UnionType & TypeForm[list[int] | str]") + t14_alt1 = tf(tp.Union[list[int], str]) + reveal_type(t14_alt1, expected_text="TypeForm[list[int] | str]") - t15 = TypeGuard[int] - reveal_type(t15, expected_text="type[TypeGuard[int]]") + t15 = tf(TypeGuard[int]) + reveal_type(t15, expected_text="TypeForm[TypeGuard[int]]") - t15_alt1 = tp.TypeGuard[int] - reveal_type(t15_alt1, expected_text="type[TypeGuard[int]]") + t15_alt1 = tf(tp.TypeGuard[int]) + reveal_type(t15_alt1, expected_text="TypeForm[TypeGuard[int]]") - t16 = TypeIs[str] - reveal_type(t16, expected_text="type[TypeIs[str]]") + t16 = tf(TypeIs[str]) + reveal_type(t16, expected_text="TypeForm[TypeIs[str]]") - t17 = Callable[[int], None] - reveal_type(t17, expected_text="Callable & TypeForm[(int) -> None]") + t17 = tf(Callable[[int], None]) + reveal_type(t17, expected_text="TypeForm[(int) -> None]") - t17_alt1 = tp.Callable[[int], None] - reveal_type(t17_alt1, expected_text="Callable & TypeForm[(int) -> None]") + t17_alt1 = tf(tp.Callable[[int], None]) + reveal_type(t17_alt1, expected_text="TypeForm[(int) -> None]") t18 = list - reveal_type(t18, expected_text="type[list[Unknown]]") - reveal_type(t18[int], expected_text="type[list[int]]") + reveal_type(tf(t18), expected_text="TypeForm[list[Unknown]]") + reveal_type(tf(t18[int]), expected_text="TypeForm[list[int]]") - t19 = list | dict + t19 = tf(list | dict) reveal_type( t19, - expected_text="UnionType & TypeForm[list[Unknown] | dict[Unknown, Unknown]]", + expected_text="TypeForm[list[Unknown] | dict[Unknown, Unknown]]", ) t20 = tuple - reveal_type(t20, expected_text="type[tuple[Unknown, ...]]") - reveal_type(t20[()], expected_text="type[tuple[()]]") - reveal_type(t20[int, ...], expected_text="type[tuple[int, ...]]") + reveal_type(tf(t20), expected_text="TypeForm[tuple[Unknown, ...]]") + reveal_type(tf(t20[()]), expected_text="TypeForm[tuple[()]]") + reveal_type(tf(t20[int, ...]), expected_text="TypeForm[tuple[int, ...]]") - t21 = tuple[()] - reveal_type(t21, expected_text="type[tuple[()]]") + t21 = tf(tuple[()]) + reveal_type(t21, expected_text="TypeForm[tuple[()]]") - t22 = tuple[int, *tuple[str, ...], int] - reveal_type(t22, expected_text="type[tuple[int, *tuple[str, ...], int]]") + t22 = tf(tuple[int, *tuple[str, ...], int]) + reveal_type(t22, expected_text="TypeForm[tuple[int, *tuple[str, ...], int]]") - t23 = TA5 - reveal_type(t23, expected_text="TypeAliasType & TypeForm[TA5[Unknown]]") + t23 = tf(TA5) + reveal_type(t23, expected_text="TypeForm[int]") - t24 = str | None - reveal_type(t24, expected_text="UnionType & TypeForm[str | None]") + t24 = tf(str | None) + reveal_type(t24, expected_text="TypeForm[str | None]") - t25 = None - reveal_type(t25, expected_text="None") + t25 = tf(None) + reveal_type(t25, expected_text="TypeForm[None]") + + t26 = tf(LiteralString) + reveal_type(t26, expected_text="TypeForm[LiteralString]") def func2[T](x: T) -> T: - t1 = str | T - reveal_type(t1, expected_text="UnionType & TypeForm[str | T@func2]") + t1 = tf(str | T) + reveal_type(t1, expected_text="TypeForm[str | T@func2]") - t2 = type[T] - reveal_type(t2, expected_text="type[type[T@func2]]") + t2 = tf(type[T]) + reveal_type(t2, expected_text="TypeForm[type[T@func2]]") return x def func3[**P, R](x: Callable[P, R]) -> Callable[P, R]: - t1 = Callable[Concatenate[int, P], R] - reveal_type(t1, expected_text="Callable & TypeForm[(int, **P@func3) -> R@func3]") + t1 = tf(Callable[Concatenate[int, P], R]) + reveal_type(t1, expected_text="TypeForm[(int, **P@func3) -> R@func3]") return x def func4(): - t1 = Never - reveal_type(t1, expected_text="type[Never]") + t1 = tf(Never) + reveal_type(t1, expected_text="TypeForm[Never]") - t1_alt1 = tp.Never - reveal_type(t1_alt1, expected_text="type[Never]") + t1_alt1 = tf(tp.Never) + reveal_type(t1_alt1, expected_text="TypeForm[Never]") - t2 = NoReturn - reveal_type(t2, expected_text="type[NoReturn]") + t2 = tf(NoReturn) + reveal_type(t2, expected_text="TypeForm[NoReturn]") - t3 = Type[int] - reveal_type(t3, expected_text="type[Type[int]] & TypeForm[type[int]]") + t3 = tf(Type[int]) + reveal_type(t3, expected_text="TypeForm[type[int]]") - t3_alt1 = tp.Type[int] - reveal_type(t3_alt1, expected_text="type[Type[int]] & TypeForm[type[int]]") + t3_alt1 = tf(tp.Type[int]) + reveal_type(t3_alt1, expected_text="TypeForm[type[int]]") def func5(): - t1 = Generic - reveal_type(t1, expected_text="type[Generic]") + t1 = tf(TypeForm[int | str]) + reveal_type(t1, expected_text="TypeForm[TypeForm[int | str]]") + + t2 = tf(TypeForm[TypeForm[int | str]]) + reveal_type(t2, expected_text="TypeForm[TypeForm[TypeForm[int | str]]]") - t2 = Final - reveal_type(t2, expected_text="type[Final]") - t3 = Final[int] - reveal_type(t3, expected_text="type[Final]") +def func6(): + # This should generate an error. + t1 = tf(Generic) - t4 = Concatenate[int] - reveal_type(t4, expected_text="type[Concatenate]") + # This should generate an error. + t2 = tf(Final) - t5 = Unpack[int] - reveal_type(t5, expected_text="type[Unpack]") + # This should generate an error. + t3 = tf(Final[int]) - t6 = Required[int] - reveal_type(t6, expected_text="type[Required]") + # This should generate an error. + t4 = tf(Concatenate[int]) - t7 = NotRequired[int] - reveal_type(t7, expected_text="type[NotRequired]") + # This should generate an error. + t5 = tf(Unpack[int]) - t8 = ReadOnly[int] - reveal_type(t8, expected_text="type[ReadOnly]") + # This should generate an error. + t6 = tf(Required[int]) - t9 = LiteralString - reveal_type(t9, expected_text="type[LiteralString]") + # This should generate an error. + t7 = tf(NotRequired[int]) - t10 = TypeForm[int | str] - reveal_type(t10, expected_text="type[TypeForm[int | str]]") + # This should generate an error. + t8 = tf(ReadOnly[int]) diff --git a/packages/pyright-internal/src/tests/samples/typeForm4.py b/packages/pyright-internal/src/tests/samples/typeForm4.py index 297faf7bc..2dee7d0e4 100644 --- a/packages/pyright-internal/src/tests/samples/typeForm4.py +++ b/packages/pyright-internal/src/tests/samples/typeForm4.py @@ -68,13 +68,10 @@ def func1(): t21: TypeForm[Callable] = Callable[[int], None] t22: TypeForm[list[Any]] = list - t23: TypeForm[list[int]] = t22[int] t24: TypeForm = list | dict t25: TypeForm = tuple - t26: TypeForm = t25[()] - t27: TypeForm = t25[int, ...] t28: TypeForm = tuple[()] @@ -84,7 +81,7 @@ def func1(): t31: TypeForm = None t32: TypeForm = None | str - def get_type() -> type[int]: + def get_type() -> TypeForm[int]: return int t33: TypeForm = get_type() @@ -204,7 +201,7 @@ def func7(): t4: TypeForm[int] = type[int] -def func8[S, T: type](p1: type[Any], p2: type[int | str], p3: type[S]): +def func8[S, T: type](p1: TypeForm[Any], p2: TypeForm[int | str], p3: TypeForm[S]): t1: TypeForm = p1 t2: TypeForm = p2 t3: TypeForm = p3 diff --git a/packages/pyright-internal/src/tests/samples/typeForm5.py b/packages/pyright-internal/src/tests/samples/typeForm5.py index 76e8b6c39..e4cb9017b 100644 --- a/packages/pyright-internal/src/tests/samples/typeForm5.py +++ b/packages/pyright-internal/src/tests/samples/typeForm5.py @@ -2,7 +2,7 @@ # pyright: reportMissingModuleSource=false -from typing import Literal, LiteralString, Optional, TypeGuard +from typing import Literal, LiteralString, TypeGuard, Optional from typing_extensions import TypeForm, TypeIs @@ -15,7 +15,7 @@ def func2[S](x: TypeForm[S | None]) -> S: ... def func3[S, T](x: TypeForm[S | T]) -> S: ... -def func4[T](x: TypeForm[T]) -> TypeIs[T]: ... +def func4[T](x: object, t: TypeForm[T]) -> TypeIs[T]: ... def func5[T](x: TypeForm[T]) -> TypeGuard[type[T]]: ... @@ -28,10 +28,10 @@ def func5[T](x: TypeForm[T]) -> TypeGuard[type[T]]: ... reveal_type(v2, expected_text="int | str") v3 = func1(LiteralString) -reveal_type(v3, expected_text="str") +reveal_type(v3, expected_text="LiteralString") v4 = func1(Literal[1, 2, 3]) -reveal_type(v4, expected_text="int") +reveal_type(v4, expected_text="Literal[1, 2, 3]") v5 = func2("Optional[str]") reveal_type(v5, expected_text="str") @@ -42,7 +42,7 @@ def func5[T](x: TypeForm[T]) -> TypeGuard[type[T]]: ... v7 = func3(int | str | None) reveal_type(v7, expected_text="int | str | None") -v8 = func4(int | str | None) +v8 = func4(1, int | str | None) reveal_type(v8, expected_text="TypeIs[int | str | None]") v9 = func5(int | str | None) diff --git a/packages/pyright-internal/src/tests/samples/typeForm6.py b/packages/pyright-internal/src/tests/samples/typeForm6.py index 5fc739c8c..bf679f0b9 100644 --- a/packages/pyright-internal/src/tests/samples/typeForm6.py +++ b/packages/pyright-internal/src/tests/samples/typeForm6.py @@ -10,6 +10,8 @@ def func1[T](x: T) -> T: v1 = str assert_type(v1, type[str]) + + # This should generate an error. assert_type(v1, TypeForm[str]) # This should generate an error. @@ -18,12 +20,43 @@ def func1[T](x: T) -> T: # This should generate an error. assert_type(v1, TypeForm[str | int]) + v1_tf: TypeForm[str | int] = str + assert_type(v1_tf, TypeForm[str]) + + # This should generate an error. + assert_type(v1_tf, type[str]) + + return x + + +def func2[T](x: T) -> T: v2 = str | T assert_type(v2, UnionType) + + # This should generate an error. assert_type(v2, TypeForm[str | T]) + v2_tf: TypeForm[object] = str | T + + # This should generate an error. + assert_type(v2_tf, UnionType) + + assert_type(v2_tf, TypeForm[str | T]) + + return x + + +def func3[T](x: T) -> T: v3 = list["str | T"] | T assert_type(v3, UnionType) + + # This should generate an error. assert_type(v3, TypeForm[list[str | T] | T]) + v3_tf: TypeForm[object] = list["str | T"] | T + # This should generate an error. + assert_type(v3_tf, UnionType) + + assert_type(v3_tf, TypeForm[list[str | T] | T]) + return x diff --git a/packages/pyright-internal/src/tests/typeEvaluator8.test.ts b/packages/pyright-internal/src/tests/typeEvaluator8.test.ts index 707c3b6a9..fb4a353ca 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator8.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator8.test.ts @@ -930,7 +930,7 @@ test('TypeForm2', () => { configOptions.diagnosticRuleSet.enableExperimentalFeatures = true; const analysisResults = TestUtils.typeAnalyzeSampleFiles(['typeForm2.py'], configOptions); - TestUtils.validateResults(analysisResults, 0); + TestUtils.validateResults(analysisResults, 8); }); test('TypeForm3', () => { @@ -962,5 +962,5 @@ test('TypeForm6', () => { configOptions.diagnosticRuleSet.enableExperimentalFeatures = true; const analysisResults = TestUtils.typeAnalyzeSampleFiles(['typeForm6.py'], configOptions); - TestUtils.validateResults(analysisResults, 2); + TestUtils.validateResults(analysisResults, 8); }); From 171f05214d6232d193e6d51dcbbc9e5cb4527796 Mon Sep 17 00:00:00 2001 From: Eric Traut Date: Fri, 13 Sep 2024 17:01:33 -0700 Subject: [PATCH 09/27] Fixed recent regression that results in incorrect type narrowing for `isinstance` in the negative case when using `type` as a filter. This addresses #8963 and #8988. (#8990) --- .../pyright-internal/src/analyzer/typeGuards.ts | 7 ++++++- packages/pyright-internal/src/analyzer/types.ts | 9 +++++++++ .../tests/samples/typeNarrowingIsinstance1.py | 16 ++++++++++------ 3 files changed, 25 insertions(+), 7 deletions(-) diff --git a/packages/pyright-internal/src/analyzer/typeGuards.ts b/packages/pyright-internal/src/analyzer/typeGuards.ts index 8d38868dd..3c6dc3168 100644 --- a/packages/pyright-internal/src/analyzer/typeGuards.ts +++ b/packages/pyright-internal/src/analyzer/typeGuards.ts @@ -1496,7 +1496,12 @@ function narrowTypeForInstance( } filteredTypes.push(addConditionToType(specializedFilterType, conditions)); - } else if (ClassType.isSameGenericClass(concreteVarType, concreteFilterType)) { + } else if ( + ClassType.isSameGenericClass( + ClassType.cloneAsInstance(concreteVarType), + ClassType.cloneAsInstance(concreteFilterType) + ) + ) { if (!isTypeIsCheck) { // Don't attempt to narrow in this case. if ( diff --git a/packages/pyright-internal/src/analyzer/types.ts b/packages/pyright-internal/src/analyzer/types.ts index 8b267ced6..1d69346c3 100644 --- a/packages/pyright-internal/src/analyzer/types.ts +++ b/packages/pyright-internal/src/analyzer/types.ts @@ -1301,6 +1301,15 @@ export namespace ClassType { return false; } + // Handle type[] specially. + if (TypeBase.getInstantiableDepth(classType) > 0) { + return TypeBase.isInstantiable(type2) || ClassType.isBuiltIn(type2, 'type'); + } + + if (TypeBase.getInstantiableDepth(type2) > 0) { + return TypeBase.isInstantiable(classType) || ClassType.isBuiltIn(classType, 'type'); + } + const class1Details = classType.shared; const class2Details = type2.shared; diff --git a/packages/pyright-internal/src/tests/samples/typeNarrowingIsinstance1.py b/packages/pyright-internal/src/tests/samples/typeNarrowingIsinstance1.py index d5df2abd7..a735e1d4c 100644 --- a/packages/pyright-internal/src/tests/samples/typeNarrowingIsinstance1.py +++ b/packages/pyright-internal/src/tests/samples/typeNarrowingIsinstance1.py @@ -128,6 +128,13 @@ def func6(ty: type[T]) -> type[T]: return ty +def func6_2(ty: type[int] | int): + if isinstance(ty, type): + reveal_type(ty, expected_text="type[int]") + else: + reveal_type(ty, expected_text="int") + + # Test the handling of protocol classes that support runtime checking. def func7(a: Union[list[int], int]): if isinstance(a, Sized): @@ -140,8 +147,7 @@ def func7(a: Union[list[int], int]): # on isinstance checks. -class Base1: - ... +class Base1: ... class Sub1_1(Base1): @@ -207,14 +213,12 @@ def func10(val: Sub2[str] | Base2[str, float]): @runtime_checkable class Proto1(Protocol): - def f0(self, /) -> None: - ... + def f0(self, /) -> None: ... @runtime_checkable class Proto2(Proto1, Protocol): - def f1(self, /) -> None: - ... + def f1(self, /) -> None: ... def func11(x: Proto1): From 63c7c30c59488d802a74876f29e0936ced5dda77 Mon Sep 17 00:00:00 2001 From: Eric Traut Date: Sat, 14 Sep 2024 09:07:37 -0700 Subject: [PATCH 10/27] Expanded `reportUnnecessaryIsinstance` check to report cases where an `isinstance` or `issubclass` call always evaluates to `False`. This addresses #8961. (#8992) --- docs/configuration.md | 2 +- .../pyright-internal/src/analyzer/checker.ts | 35 +++++++++++++------ .../src/localization/localize.ts | 8 +++++ .../src/localization/package.nls.en-us.json | 8 +++++ .../src/tests/checker.test.ts | 12 +++++++ .../tests/samples/unnecessaryIsInstance1.py | 2 +- .../tests/samples/unnecessaryIsInstance2.py | 35 +++++++++++++++++++ .../tests/samples/unnecessaryIsSubclass1.py | 2 +- packages/vscode-pyright/package.json | 2 +- .../schemas/pyrightconfig.schema.json | 2 +- 10 files changed, 93 insertions(+), 15 deletions(-) create mode 100644 packages/pyright-internal/src/tests/samples/unnecessaryIsInstance2.py diff --git a/docs/configuration.md b/docs/configuration.md index 19d521f90..a48eb694b 100644 --- a/docs/configuration.md +++ b/docs/configuration.md @@ -195,7 +195,7 @@ The following settings allow more fine grained control over the **typeCheckingMo - **reportCallInDefaultInitializer** [boolean or string, optional]: Generate or suppress diagnostics for function calls, list expressions, set expressions, or dictionary expressions within a default value initialization expression. Such calls can mask expensive operations that are performed at module initialization time. The default value for this setting is `"none"`. -- **reportUnnecessaryIsInstance** [boolean or string, optional]: Generate or suppress diagnostics for `isinstance` or `issubclass` calls where the result is statically determined to be always true. Such calls are often indicative of a programming error. The default value for this setting is `"none"`. +- **reportUnnecessaryIsInstance** [boolean or string, optional]: Generate or suppress diagnostics for `isinstance` or `issubclass` calls where the result is statically determined to be always true or always false. Such calls are often indicative of a programming error. The default value for this setting is `"none"`. - **reportUnnecessaryCast** [boolean or string, optional]: Generate or suppress diagnostics for `cast` calls that are statically determined to be unnecessary. Such calls are sometimes indicative of a programming error. The default value for this setting is `"none"`. diff --git a/packages/pyright-internal/src/analyzer/checker.ts b/packages/pyright-internal/src/analyzer/checker.ts index 1661f1395..2e73a0893 100644 --- a/packages/pyright-internal/src/analyzer/checker.ts +++ b/packages/pyright-internal/src/analyzer/checker.ts @@ -3918,20 +3918,35 @@ export class Checker extends ParseTreeWalker { node ); - if (isNever(narrowedTypeNegative)) { + const narrowedTypePositive = narrowTypeForInstanceOrSubclass( + this._evaluator, + arg0Type, + classTypeList, + isInstanceCheck, + /* isTypeIsCheck */ false, + /* isPositiveTest */ true, + node + ); + + const isAlwaysTrue = isNever(narrowedTypeNegative); + const isNeverTrue = isNever(narrowedTypePositive); + + if (isAlwaysTrue || isNeverTrue) { const classType = combineTypes(classTypeList.map((t) => convertToInstance(t))); + const messageTemplate = isAlwaysTrue + ? isInstanceCheck + ? LocMessage.unnecessaryIsInstanceAlways() + : LocMessage.unnecessaryIsSubclassAlways() + : isInstanceCheck + ? LocMessage.unnecessaryIsInstanceNever() + : LocMessage.unnecessaryIsSubclassNever(); this._evaluator.addDiagnostic( DiagnosticRule.reportUnnecessaryIsInstance, - isInstanceCheck - ? LocMessage.unnecessaryIsInstanceAlways().format({ - testType: this._evaluator.printType(arg0Type), - classType: this._evaluator.printType(classType), - }) - : LocMessage.unnecessaryIsSubclassAlways().format({ - testType: this._evaluator.printType(arg0Type), - classType: this._evaluator.printType(classType), - }), + messageTemplate.format({ + testType: this._evaluator.printType(arg0Type), + classType: this._evaluator.printType(classType), + }), node ); } diff --git a/packages/pyright-internal/src/localization/localize.ts b/packages/pyright-internal/src/localization/localize.ts index 7a5c89bc6..1c0afa3fd 100644 --- a/packages/pyright-internal/src/localization/localize.ts +++ b/packages/pyright-internal/src/localization/localize.ts @@ -1134,6 +1134,14 @@ export namespace Localizer { new ParameterizedString<{ testType: string; classType: string }>( getRawString('Diagnostic.unnecessaryIsSubclassAlways') ); + export const unnecessaryIsInstanceNever = () => + new ParameterizedString<{ testType: string; classType: string }>( + getRawString('Diagnostic.unnecessaryIsInstanceNever') + ); + export const unnecessaryIsSubclassNever = () => + new ParameterizedString<{ testType: string; classType: string }>( + getRawString('Diagnostic.unnecessaryIsSubclassNever') + ); export const unnecessaryPyrightIgnore = () => getRawString('Diagnostic.unnecessaryPyrightIgnore'); export const unnecessaryPyrightIgnoreRule = () => new ParameterizedString<{ name: string }>(getRawString('Diagnostic.unnecessaryPyrightIgnoreRule')); diff --git a/packages/pyright-internal/src/localization/package.nls.en-us.json b/packages/pyright-internal/src/localization/package.nls.en-us.json index 13cee259b..64512495f 100644 --- a/packages/pyright-internal/src/localization/package.nls.en-us.json +++ b/packages/pyright-internal/src/localization/package.nls.en-us.json @@ -1544,6 +1544,14 @@ "message": "Unnecessary issubclass call; \"{testType}\" is always a subclass of \"{classType}\"", "comment": "{Locked='issubclass'}" }, + "unnecessaryIsInstanceNever": { + "message": "Unnecessary isinstance call; \"{testType}\" is never an instance of \"{classType}\"", + "comment": "{Locked='isinstance'}" + }, + "unnecessaryIsSubclassNever": { + "message": "Unnecessary issubclass call; \"{testType}\" is never a subclass of \"{classType}\"", + "comment": "{Locked='issubclass'}" + }, "unnecessaryPyrightIgnore": { "message": "Unnecessary \"# pyright: ignore\" comment", "comment": "{Locked='# pyright: ignore'}" diff --git a/packages/pyright-internal/src/tests/checker.test.ts b/packages/pyright-internal/src/tests/checker.test.ts index 71536e386..3168cf280 100644 --- a/packages/pyright-internal/src/tests/checker.test.ts +++ b/packages/pyright-internal/src/tests/checker.test.ts @@ -247,6 +247,18 @@ test('UnnecessaryIsInstance1', () => { TestUtils.validateResults(analysisResults, 5); }); +test('UnnecessaryIsInstance2', () => { + const configOptions = new ConfigOptions(Uri.empty()); + + let analysisResults = TestUtils.typeAnalyzeSampleFiles(['unnecessaryIsInstance2.py'], configOptions); + TestUtils.validateResults(analysisResults, 0); + + // Turn on errors. + configOptions.diagnosticRuleSet.reportUnnecessaryIsInstance = 'error'; + analysisResults = TestUtils.typeAnalyzeSampleFiles(['unnecessaryIsInstance2.py'], configOptions); + TestUtils.validateResults(analysisResults, 2); +}); + test('UnnecessaryIsSubclass1', () => { const configOptions = new ConfigOptions(Uri.empty()); diff --git a/packages/pyright-internal/src/tests/samples/unnecessaryIsInstance1.py b/packages/pyright-internal/src/tests/samples/unnecessaryIsInstance1.py index 3dc3ada74..5b72dcfbf 100644 --- a/packages/pyright-internal/src/tests/samples/unnecessaryIsInstance1.py +++ b/packages/pyright-internal/src/tests/samples/unnecessaryIsInstance1.py @@ -1,4 +1,4 @@ -# This sample tests unnecessary isinstance error reporting. +# This sample tests for isinstance calls that always evaluate to true. from typing import ClassVar, Protocol, TypedDict, runtime_checkable from unknown_import import CustomClass1 diff --git a/packages/pyright-internal/src/tests/samples/unnecessaryIsInstance2.py b/packages/pyright-internal/src/tests/samples/unnecessaryIsInstance2.py new file mode 100644 index 000000000..d1c938fbc --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/unnecessaryIsInstance2.py @@ -0,0 +1,35 @@ +# This sample tests for isinstance calls that never evaluate to true. + +from typing import final + + +class ABase: ... + + +@final +class AFinal(ABase): ... + + +class BBase: ... + + +@final +class BFinal(BBase): ... + + +def func1(a: AFinal, b: BFinal): + # This should generate an error if reportUnnecessaryIsinstance is true. + if isinstance(a, BBase): + reveal_type(a) + + # This should generate an error if reportUnnecessaryIsinstance is true. + if isinstance(a, BBase): + reveal_type(a) + + +def func2(a: ABase, b: BBase): + if isinstance(a, BBase): + reveal_type(a) + + if isinstance(b, ABase): + reveal_type(b) diff --git a/packages/pyright-internal/src/tests/samples/unnecessaryIsSubclass1.py b/packages/pyright-internal/src/tests/samples/unnecessaryIsSubclass1.py index 524406088..2bb543674 100644 --- a/packages/pyright-internal/src/tests/samples/unnecessaryIsSubclass1.py +++ b/packages/pyright-internal/src/tests/samples/unnecessaryIsSubclass1.py @@ -1,4 +1,4 @@ -# This sample tests unnecessary issubclass error reporting. +# This sample tests issubclass calls that always evaluate to true. def func1(p1: type[int], p2: type[int] | type[str]): diff --git a/packages/vscode-pyright/package.json b/packages/vscode-pyright/package.json index 5c947e8c6..fd4639f58 100644 --- a/packages/vscode-pyright/package.json +++ b/packages/vscode-pyright/package.json @@ -1156,7 +1156,7 @@ "string", "boolean" ], - "description": "Diagnostics for 'isinstance' or 'issubclass' calls where the result is statically determined to be always true. Such calls are often indicative of a programming error.", + "description": "Diagnostics for 'isinstance' or 'issubclass' calls where the result is statically determined to be always (or never) true. Such calls are often indicative of a programming error.", "default": "none", "enum": [ "none", diff --git a/packages/vscode-pyright/schemas/pyrightconfig.schema.json b/packages/vscode-pyright/schemas/pyrightconfig.schema.json index adbfd433e..d1135fe2d 100644 --- a/packages/vscode-pyright/schemas/pyrightconfig.schema.json +++ b/packages/vscode-pyright/schemas/pyrightconfig.schema.json @@ -401,7 +401,7 @@ }, "reportUnnecessaryIsInstance": { "$ref": "#/definitions/diagnostic", - "title": "Controls reporting calls to 'isinstance' or 'issubclass' where the result is statically determined to be always true", + "title": "Controls reporting calls to 'isinstance' or 'issubclass' where the result is statically determined to be always (or never) true", "default": "none" }, "reportUnnecessaryCast": { From 7eb358a8e82ac51630a3dce79e61598784ace9ec Mon Sep 17 00:00:00 2001 From: Eric Traut Date: Sat, 14 Sep 2024 16:14:26 -0700 Subject: [PATCH 11/27] Fixed bug that results in incorrect reporting of the Python version in a deprecation diagnostic message. --- packages/pyright-internal/src/analyzer/checker.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/pyright-internal/src/analyzer/checker.ts b/packages/pyright-internal/src/analyzer/checker.ts index 2e73a0893..3b1fa784a 100644 --- a/packages/pyright-internal/src/analyzer/checker.ts +++ b/packages/pyright-internal/src/analyzer/checker.ts @@ -4298,7 +4298,7 @@ export class Checker extends ParseTreeWalker { this._reportDeprecatedDiagnostic( node, LocMessage.deprecatedType().format({ - version: deprecatedForm.version.toString(), + version: PythonVersion.toString(deprecatedForm.version), replacement: deprecatedForm.replacementText, }) ); From ecdab9371cb88c5f5415dee73789c98eb2d24195 Mon Sep 17 00:00:00 2001 From: Eric Traut Date: Sat, 14 Sep 2024 20:38:09 -0700 Subject: [PATCH 12/27] Improved error message for type violation in assignment statement where the LHS is an instance variable reference. This addresses #8943. (#8994) --- packages/pyright-internal/src/analyzer/typeEvaluator.ts | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts index c820af6de..e8f0353a4 100644 --- a/packages/pyright-internal/src/analyzer/typeEvaluator.ts +++ b/packages/pyright-internal/src/analyzer/typeEvaluator.ts @@ -5421,6 +5421,10 @@ export function createTypeEvaluator( const isNotRequired = false; let memberAccessDeprecationInfo: MemberAccessDeprecationInfo | undefined; + if (usage?.setType?.isIncomplete) { + isIncomplete = true; + } + // If the base type was incomplete and unbound, don't proceed // because false positive errors will be generated. if (baseTypeResult.isIncomplete && isUnbound(baseType)) { @@ -24074,7 +24078,7 @@ export function createTypeEvaluator( // If both the source and dest are unions, use assignFromUnionType which has // special-case logic to handle this case. if (isUnion(srcType)) { - return assignFromUnionType(destType, srcType, /* diag */ undefined, constraints, flags, recursionCount); + return assignFromUnionType(destType, srcType, diag, constraints, flags, recursionCount); } const clonedConstraints = constraints?.clone(); From 6c2812306c50ec1768c30e8f3dcf98fc18c23e24 Mon Sep 17 00:00:00 2001 From: Eric Traut Date: Sat, 14 Sep 2024 22:43:52 -0700 Subject: [PATCH 13/27] Fixed bug that results in incorrect code flow involving a call to a `NoReturn` callable with a function decorator applied. This addresses https://github.com/microsoft/pylance-release/issues/6391. (#8996) --- packages/pyright-internal/src/analyzer/codeFlowEngine.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/pyright-internal/src/analyzer/codeFlowEngine.ts b/packages/pyright-internal/src/analyzer/codeFlowEngine.ts index d34573578..454924357 100644 --- a/packages/pyright-internal/src/analyzer/codeFlowEngine.ts +++ b/packages/pyright-internal/src/analyzer/codeFlowEngine.ts @@ -1821,7 +1821,7 @@ export function getCodeFlowEngine( } function isFunctionNoReturn(functionType: FunctionType, isCallAwaited: boolean) { - const returnType = functionType.shared.declaredReturnType; + const returnType = FunctionType.getEffectiveReturnType(functionType, /* includeInferred */ false); if (returnType) { if ( isClassInstance(returnType) && From fb5cc8c30c4c75746fc026577189362685785fe5 Mon Sep 17 00:00:00 2001 From: Eric Traut Date: Sun, 15 Sep 2024 08:14:52 -0700 Subject: [PATCH 14/27] Fixed bug that results in a spurious "symbol refers to itself" error under very specific conditions. This addresses #4513. (#8997) --- packages/pyright-internal/src/analyzer/typeEvaluator.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts index e8f0353a4..5bd1ac115 100644 --- a/packages/pyright-internal/src/analyzer/typeEvaluator.ts +++ b/packages/pyright-internal/src/analyzer/typeEvaluator.ts @@ -22311,7 +22311,7 @@ export function createTypeEvaluator( includesVariableDecl: includesVariableTypeDecl(typedDecls), includesIllegalTypeAliasDecl: !typedDecls.every((decl) => isPossibleTypeAliasDeclaration(decl)), includesSpeculativeResult: false, - isRecursiveDefinition: !declaredType, + isRecursiveDefinition: !declaredType && !speculativeTypeTracker.isSpeculative(/* node */ undefined), }; return result; From c799d9e71859c6f05f86d5bbdce9da5e78a532b3 Mon Sep 17 00:00:00 2001 From: Eric Traut Date: Sun, 15 Sep 2024 17:59:18 -0700 Subject: [PATCH 15/27] Fixed bug that can theoretically result in spurious errors when evaluating expressions that involve parameter symbols. (#8999) --- .../pyright-internal/src/analyzer/typeEvaluator.ts | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts index 5bd1ac115..9f08607ce 100644 --- a/packages/pyright-internal/src/analyzer/typeEvaluator.ts +++ b/packages/pyright-internal/src/analyzer/typeEvaluator.ts @@ -20181,10 +20181,10 @@ export function createTypeEvaluator( if (typeAnnotation) { const param = functionNode.d.params[paramIndex]; - const annotatedType = getTypeOfParamAnnotation( - typeAnnotation, - functionNode.d.params[paramIndex].d.category - ); + let annotatedType = getTypeOfParamAnnotation(typeAnnotation, functionNode.d.params[paramIndex].d.category); + + const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(param); + annotatedType = makeTypeVarsBound(annotatedType, liveTypeVarScopes); const adjType = transformVariadicParamType( node, @@ -21728,7 +21728,7 @@ export function createTypeEvaluator( } case DeclarationType.Param: { - let typeAnnotationNode = declaration.node.d.annotation || declaration.node.d.annotationComment; + let typeAnnotationNode = declaration.node.d.annotation ?? declaration.node.d.annotationComment; // If there wasn't an annotation, see if the parent function // has a function-level annotation comment that provides @@ -21750,7 +21750,6 @@ export function createTypeEvaluator( let declaredType = getTypeOfParamAnnotation(typeAnnotationNode, declaration.node.d.category); const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(declaration.node); - declaredType = makeTypeVarsBound(declaredType, liveTypeVarScopes); return { From f3ed4990d367e618df54160450a7e45b4ebf5282 Mon Sep 17 00:00:00 2001 From: Eric Traut Date: Mon, 16 Sep 2024 09:22:51 -0700 Subject: [PATCH 16/27] Fixed bug that results in incorrect type narrowing when `TypeIs` intersects `type[A]` with `type[B]`. Previously, pyright was producing `` but now produces `type[]`. This addresses #9002 and #9003. (#9005) --- .../src/analyzer/typeEvaluator.ts | 15 +++++++++ .../src/analyzer/typeGuards.ts | 4 +-- .../samples/typeNarrowingIsinstance21.py | 31 +++++++++++++++++++ 3 files changed, 47 insertions(+), 3 deletions(-) diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts index 9f08607ce..1cd4e3456 100644 --- a/packages/pyright-internal/src/analyzer/typeEvaluator.ts +++ b/packages/pyright-internal/src/analyzer/typeEvaluator.ts @@ -16870,6 +16870,16 @@ export function createTypeEvaluator( // Creates a new class type that is a subclass of two other specified classes. function createSubclass(errorNode: ExpressionNode, type1: ClassType, type2: ClassType): ClassType { assert(isInstantiableClass(type1) && isInstantiableClass(type2)); + + // If both classes are class objects (type[A] and type[B]), create a new + // class object (type[A & B]) rather than "type[A] & type[B]". + let createClassObject = false; + if (TypeBase.getInstantiableDepth(type1) > 0 && TypeBase.getInstantiableDepth(type2) > 0) { + type1 = ClassType.cloneAsInstance(type1); + type2 = ClassType.cloneAsInstance(type2); + createClassObject = true; + } + const className = ``; @@ -16894,12 +16904,17 @@ export function createTypeEvaluator( effectiveMetaclass, type1.shared.docString ); + newClassType.shared.baseClasses = [type1, type2]; computeMroLinearization(newClassType); newClassType = addConditionToType(newClassType, type1.props?.condition); newClassType = addConditionToType(newClassType, type2.props?.condition); + if (createClassObject) { + newClassType = ClassType.cloneAsInstantiable(newClassType); + } + return newClassType; } diff --git a/packages/pyright-internal/src/analyzer/typeGuards.ts b/packages/pyright-internal/src/analyzer/typeGuards.ts index 3c6dc3168..bab116f6a 100644 --- a/packages/pyright-internal/src/analyzer/typeGuards.ts +++ b/packages/pyright-internal/src/analyzer/typeGuards.ts @@ -1534,9 +1534,7 @@ function narrowTypeForInstance( newClassType = addConditionToType(newClassType, [{ typeVar: varType, constraintIndex: 0 }]); } - let newClassObjType = ClassType.cloneAsInstance(newClassType); - newClassObjType = addConditionToType(newClassObjType, concreteVarType.props?.condition); - filteredTypes.push(newClassObjType); + filteredTypes.push(addConditionToType(newClassType, concreteVarType.props?.condition)); } } else { if (isAnyOrUnknown(varType)) { diff --git a/packages/pyright-internal/src/tests/samples/typeNarrowingIsinstance21.py b/packages/pyright-internal/src/tests/samples/typeNarrowingIsinstance21.py index 497d7421f..dd3fbb389 100644 --- a/packages/pyright-internal/src/tests/samples/typeNarrowingIsinstance21.py +++ b/packages/pyright-internal/src/tests/samples/typeNarrowingIsinstance21.py @@ -2,6 +2,7 @@ # pyright: reportMissingModuleSource=false +from typing import Any from typing_extensions import TypeIs @@ -33,3 +34,33 @@ def func1(v: Sentinel | type[Sentinel]): reveal_type(v, expected_text="Sentinel") else: reveal_type(v, expected_text="type[Sentinel]") + + +class A: + pass + + +class B: + pass + + +def guard3(t: type[Any]) -> TypeIs[type[A]]: + return True + + +def func3(t: type[B]): + if guard3(t): + reveal_type(t, expected_text="type[]") + else: + reveal_type(t, expected_text="type[B]") + + +def guard4(t: Any) -> TypeIs[type[A]]: + return True + + +def func4(t: B): + if guard4(t): + reveal_type(t, expected_text="") + else: + reveal_type(t, expected_text="B") From e94fa867c53b4776324b3580a33975bfbe957538 Mon Sep 17 00:00:00 2001 From: Rich Chiodo Date: Mon, 16 Sep 2024 10:19:25 -0700 Subject: [PATCH 17/27] Allow venvPath to be set in settings.json (#9007) * Allow venvPath to be set on command line or in settings whether or not it's set in config file * Fix setting the venvPath in the extension --- .../pyright-internal/src/analyzer/service.ts | 22 +++++---- .../src/common/commandLineOptions.ts | 3 ++ .../analyzerServiceExecutor.ts | 2 +- .../pyright-internal/src/tests/config.test.ts | 45 ++++++++++++++++++- 4 files changed, 60 insertions(+), 12 deletions(-) diff --git a/packages/pyright-internal/src/analyzer/service.ts b/packages/pyright-internal/src/analyzer/service.ts index 295596e3b..cf94c298e 100644 --- a/packages/pyright-internal/src/analyzer/service.ts +++ b/packages/pyright-internal/src/analyzer/service.ts @@ -36,8 +36,8 @@ import { Range } from '../common/textRange'; import { timingStats } from '../common/timing'; import { Uri } from '../common/uri/uri'; import { - deduplicateFolders, FileSpec, + deduplicateFolders, getFileSpec, getFileSystemEntries, hasPythonExtension, @@ -689,7 +689,7 @@ export class AnalyzerService { // Apply the command line options that are not in the config file. These settings // only apply to the language server. - this._applyLanguageServerOptions(configOptions, commandLineOptions.languageServerSettings); + this._applyLanguageServerOptions(configOptions, projectRoot, commandLineOptions.languageServerSettings); // Ensure that if no command line or config options were applied, we have some defaults. this._ensureDefaultOptions(host, configOptions, projectRoot, executionRoot, commandLineOptions); @@ -859,6 +859,7 @@ export class AnalyzerService { private _applyLanguageServerOptions( configOptions: ConfigOptions, + projectRoot: Uri, languageServerOptions: CommandLineLanguageServerOptions ) { configOptions.disableTaggedHints = !!languageServerOptions.disableTaggedHints; @@ -888,6 +889,11 @@ export class AnalyzerService { Uri.file(languageServerOptions.pythonPath, this.serviceProvider, /* checkRelative */ true) ); } + if (languageServerOptions.venvPath) { + if (!configOptions.venvPath) { + configOptions.venvPath = projectRoot.resolvePaths(languageServerOptions.venvPath); + } + } } private _applyCommandLineOverrides( @@ -962,6 +968,11 @@ export class AnalyzerService { }); } + // Override the venvPath based on the command-line setting. + if (commandLineOptions.venvPath) { + configOptions.venvPath = projectRoot.resolvePaths(commandLineOptions.venvPath); + } + const reportDuplicateSetting = (settingName: string, configValue: number | string | boolean) => { const settingSource = fromLanguageServer ? 'the client settings' : 'a command-line option'; this._console.warn( @@ -974,13 +985,6 @@ export class AnalyzerService { // Apply the command-line options if the corresponding // item wasn't already set in the config file. Report any // duplicates. - if (commandLineOptions.venvPath) { - if (!configOptions.venvPath) { - configOptions.venvPath = projectRoot.resolvePaths(commandLineOptions.venvPath); - } else { - reportDuplicateSetting('venvPath', configOptions.venvPath.toUserVisibleString()); - } - } if (commandLineOptions.typeshedPath) { if (!configOptions.typeshedPath) { diff --git a/packages/pyright-internal/src/common/commandLineOptions.ts b/packages/pyright-internal/src/common/commandLineOptions.ts index e18cc466b..588ae97c3 100644 --- a/packages/pyright-internal/src/common/commandLineOptions.ts +++ b/packages/pyright-internal/src/common/commandLineOptions.ts @@ -146,6 +146,9 @@ export class CommandLineLanguageServerOptions { // Path to python interpreter. This is used when the language server // gets the python path from the client. pythonPath?: string | undefined; + + // Virtual environments directory. + venvPath?: string | undefined; } // Some options can be specified from a source other than the pyright config file. diff --git a/packages/pyright-internal/src/languageService/analyzerServiceExecutor.ts b/packages/pyright-internal/src/languageService/analyzerServiceExecutor.ts index 0bd96b706..6b270ccc8 100644 --- a/packages/pyright-internal/src/languageService/analyzerServiceExecutor.ts +++ b/packages/pyright-internal/src/languageService/analyzerServiceExecutor.ts @@ -116,7 +116,7 @@ function getEffectiveCommandLineOptions( } if (serverSettings.venvPath) { - commandLineOptions.configSettings.venvPath = serverSettings.venvPath.getFilePath(); + commandLineOptions.languageServerSettings.venvPath = serverSettings.venvPath.getFilePath(); } if (serverSettings.pythonPath) { diff --git a/packages/pyright-internal/src/tests/config.test.ts b/packages/pyright-internal/src/tests/config.test.ts index 2f4efb197..c02e6b18c 100644 --- a/packages/pyright-internal/src/tests/config.test.ts +++ b/packages/pyright-internal/src/tests/config.test.ts @@ -489,8 +489,8 @@ test('Command line options can override config but only when not using extension defaultOptions.executionEnvironments[0].extraPaths, overriddenOptions.executionEnvironments[0].extraPaths ); - // Venv, typeshed and stub path are an exception, it should just be reported as a dupe. - assert.deepStrictEqual(defaultOptions.venvPath, overriddenOptions.venvPath); + assert.notDeepStrictEqual(defaultOptions.venvPath, overriddenOptions.venvPath); + // Typeshed and stub path are an exception, it should just be reported as a dupe. assert.deepStrictEqual(defaultOptions.typeshedPath, overriddenOptions.typeshedPath); assert.deepStrictEqual(defaultOptions.stubPath, overriddenOptions.stubPath); @@ -501,6 +501,43 @@ test('Command line options can override config but only when not using extension assert.deepStrictEqual(defaultOptions, overriddenOptions2); }); +test('Config venvPath take precedences over language server settings', () => { + const cwd = normalizePath(combinePaths(process.cwd(), 'src/tests/samples/project_with_all_config')); + const service = createAnalyzer(); + const commandLineOptions = new CommandLineOptions(cwd, /* fromLanguageServer */ true); + commandLineOptions.languageServerSettings.venvPath = 'test_from_language_server'; + service.setOptions(commandLineOptions); + + // Verify language server options don't override + const options = service.test_getConfigOptions(commandLineOptions); + assert.equal(options.venvPath?.pathIncludes('from_language_server'), false); +}); + +test('Command line venvPath take precedences over everything else', () => { + const cwd = normalizePath(combinePaths(process.cwd(), 'src/tests/samples/project_with_all_config')); + const service = createAnalyzer(); + const commandLineOptions = new CommandLineOptions(cwd, /* fromLanguageServer */ false); + commandLineOptions.configSettings.venvPath = 'test_from_command_line'; + commandLineOptions.languageServerSettings.venvPath = 'test_from_language_server'; + service.setOptions(commandLineOptions); + + // Verify command line overrides everything + const options = service.test_getConfigOptions(commandLineOptions); + assert.ok(options.venvPath?.pathIncludes('test_from_command_line')); +}); + +test('Config empty venvPath does not take precedences over language server settings', () => { + const cwd = normalizePath(combinePaths(process.cwd(), 'src/tests/samples/project_src_with_config_extra_paths')); + const service = createAnalyzer(); + const commandLineOptions = new CommandLineOptions(cwd, /* fromLanguageServer */ true); + commandLineOptions.languageServerSettings.venvPath = 'test_from_language_server'; + service.setOptions(commandLineOptions); + + // Verify language server options don't override + const options = service.test_getConfigOptions(commandLineOptions); + assert.ok(options.venvPath?.pathIncludes('from_language_server')); +}); + test('Language server specific settings are set whether or not there is a pyproject.toml', () => { const cwd = normalizePath(combinePaths(process.cwd(), 'src/tests/samples/project_with_all_config')); const service = createAnalyzer(); @@ -532,6 +569,7 @@ test('Language server specific settings are set whether or not there is a pyproj // Test with language server set to true to make sure they are still set. commandLineOptions.fromLanguageServer = true; + commandLineOptions.languageServerSettings.venvPath = 'test_venv_path'; service.setOptions(commandLineOptions); options = service.test_getConfigOptions(commandLineOptions); assert.strictEqual(options.autoImportCompletions, true); @@ -541,4 +579,7 @@ test('Language server specific settings are set whether or not there is a pyproj assert.strictEqual(options.typeEvaluationTimeThreshold, 1); assert.strictEqual(options.disableTaggedHints, true); assert.ok(options.pythonPath?.pathIncludes('test_python_path')); + + // Verify language server options don't override the config setting. Only command line should + assert.equal(options.venvPath?.pathIncludes('test_venv_path'), false); }); From a203953bfea64dc3e1a3569a317ba4f75b826640 Mon Sep 17 00:00:00 2001 From: Eric Traut Date: Mon, 16 Sep 2024 15:28:13 -0700 Subject: [PATCH 18/27] Fixed bug that results in a confusing error message extension referencing a missing `__set__` method when assigning to a class variable that is not a descriptor object. This addresses #9011. (#9014) --- packages/pyright-internal/src/analyzer/typeEvaluator.ts | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts index 1cd4e3456..9d158b0db 100644 --- a/packages/pyright-internal/src/analyzer/typeEvaluator.ts +++ b/packages/pyright-internal/src/analyzer/typeEvaluator.ts @@ -6217,12 +6217,14 @@ export function createTypeEvaluator( accessMethodName = '__delete__'; } + const subDiag = diag ? new DiagnosticAddendum() : undefined; + const methodTypeResult = getTypeOfBoundMember( errorNode, concreteMemberType, accessMethodName, /* usage */ undefined, - diag?.createAddendum(), + subDiag, MemberAccessFlags.SkipInstanceMembers | MemberAccessFlags.SkipAttributeAccessOverride ); @@ -6246,6 +6248,9 @@ export function createTypeEvaluator( let methodType = methodTypeResult.type; if (methodTypeResult.typeErrors || !methodClassType) { + if (diag && subDiag) { + diag.addAddendum(subDiag); + } return { type: UnknownType.create(), typeErrors: true }; } From 1eb1bc739a113b57be552c79d9ab32a97bafdfa1 Mon Sep 17 00:00:00 2001 From: Eric Traut Date: Mon, 16 Sep 2024 15:28:59 -0700 Subject: [PATCH 19/27] Fixed a bug that results in a false positive type error and confusing error message when assigning to a class variable that uses `Self` in its type definition. This addresses #9011. (#9013) --- .../src/analyzer/typeEvaluator.ts | 37 +++++++++++++------ .../src/tests/samples/classVar5.py | 16 ++++++++ .../src/tests/typeEvaluator7.test.ts | 6 +++ 3 files changed, 48 insertions(+), 11 deletions(-) create mode 100644 packages/pyright-internal/src/tests/samples/classVar5.py diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts index 9d158b0db..b77ec48d5 100644 --- a/packages/pyright-internal/src/analyzer/typeEvaluator.ts +++ b/packages/pyright-internal/src/analyzer/typeEvaluator.ts @@ -2641,6 +2641,7 @@ export function createTypeEvaluator( // Determines whether the specified expression is a symbol with a declared type. function getDeclaredTypeForExpression(expression: ExpressionNode, usage?: EvaluatorUsage): Type | undefined { let symbol: Symbol | undefined; + let selfType: ClassType | TypeVarType | undefined; let classOrObjectBase: ClassType | undefined; let memberAccessClass: Type | undefined; let bindFunction = true; @@ -2683,18 +2684,17 @@ export function createTypeEvaluator( } case ParseNodeType.MemberAccess: { - const baseType = makeTopLevelTypeVarsConcrete( - getTypeOfExpression(expression.d.leftExpr, EvalFlags.MemberAccessBaseDefaults).type - ); + const baseType = getTypeOfExpression(expression.d.leftExpr, EvalFlags.MemberAccessBaseDefaults).type; + const baseTypeConcrete = makeTopLevelTypeVarsConcrete(baseType); let classMemberInfo: ClassMember | undefined; - if (isClassInstance(baseType)) { + if (isClassInstance(baseTypeConcrete)) { classMemberInfo = lookUpObjectMember( - baseType, + baseTypeConcrete, expression.d.member.d.value, MemberAccessFlags.DeclaredTypesOnly ); - classOrObjectBase = baseType; + classOrObjectBase = baseTypeConcrete; memberAccessClass = classMemberInfo?.classType; // If this is an instance member (e.g. a dataclass field), don't @@ -2704,16 +2704,20 @@ export function createTypeEvaluator( } useDescriptorSetterType = true; - } else if (isInstantiableClass(baseType)) { + } else if (isInstantiableClass(baseTypeConcrete)) { classMemberInfo = lookUpClassMember( - baseType, + baseTypeConcrete, expression.d.member.d.value, MemberAccessFlags.SkipInstanceMembers | MemberAccessFlags.DeclaredTypesOnly ); - classOrObjectBase = baseType; + classOrObjectBase = baseTypeConcrete; memberAccessClass = classMemberInfo?.classType; } + if (isTypeVar(baseType)) { + selfType = baseType; + } + if (classMemberInfo) { symbol = classMemberInfo.symbol; } @@ -2765,12 +2769,23 @@ export function createTypeEvaluator( if (classOrObjectBase) { if (memberAccessClass && isInstantiableClass(memberAccessClass)) { - declaredType = partiallySpecializeType(declaredType, memberAccessClass, getTypeClassType()); + declaredType = partiallySpecializeType( + declaredType, + memberAccessClass, + getTypeClassType(), + selfType + ); } if (isFunction(declaredType) || isOverloaded(declaredType)) { if (bindFunction) { - declaredType = bindFunctionToClassOrObject(classOrObjectBase, declaredType); + declaredType = bindFunctionToClassOrObject( + classOrObjectBase, + declaredType, + /* memberClass */ undefined, + /* treatConstructorAsClassMethod */ undefined, + selfType + ); } } } diff --git a/packages/pyright-internal/src/tests/samples/classVar5.py b/packages/pyright-internal/src/tests/samples/classVar5.py new file mode 100644 index 000000000..c255c4d59 --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/classVar5.py @@ -0,0 +1,16 @@ +# This sample tests the access of a ClassVar that uses Self in its +# declaration. + +# It's not clear whether this should be permitted. Arguably, it's not +# type safe, but mypy admits it. This should be clarified in the typing +# spec. + +from typing import ClassVar, Self + + +class Parent: + x: ClassVar[dict[str, Self]] = {} + + @classmethod + def __init_subclass__(cls): + cls.x = {} diff --git a/packages/pyright-internal/src/tests/typeEvaluator7.test.ts b/packages/pyright-internal/src/tests/typeEvaluator7.test.ts index bf4c1109a..0df7164d6 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator7.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator7.test.ts @@ -773,6 +773,12 @@ test('ClassVar4', () => { TestUtils.validateResults(analysisResults, 0); }); +test('ClassVar5', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['classVar5.py']); + + TestUtils.validateResults(analysisResults, 0); +}); + test('TypeVar1', () => { const analysisResults = TestUtils.typeAnalyzeSampleFiles(['typeVar1.py']); From e353c9dec5eb809b31c4dca2ff64b3483cd87119 Mon Sep 17 00:00:00 2001 From: Rich Chiodo Date: Mon, 16 Sep 2024 17:33:02 -0700 Subject: [PATCH 20/27] Put back logic of recreating the background analysis token on every schedule analysis (#9016) * Recreate the cancellation token every time we start analysis like we used to before * Refactor how token is generated to match old way of doing things --- .../pyright-internal/src/analyzer/service.ts | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) diff --git a/packages/pyright-internal/src/analyzer/service.ts b/packages/pyright-internal/src/analyzer/service.ts index cf94c298e..3fda9b80d 100644 --- a/packages/pyright-internal/src/analyzer/service.ts +++ b/packages/pyright-internal/src/analyzer/service.ts @@ -478,16 +478,9 @@ export class AnalyzerService { this._backgroundAnalysisProgram.restart(); } - protected getCancellationToken() { - if (!this._backgroundAnalysisCancellationSource) { - this._backgroundAnalysisCancellationSource = this.cancellationProvider.createCancellationTokenSource(); - } - return this._backgroundAnalysisCancellationSource.token; - } - - protected runAnalysis() { + protected runAnalysis(token: CancellationToken) { // This creates a cancellation source only if it actually gets used. - const moreToAnalyze = this._backgroundAnalysisProgram.startAnalysis(this.getCancellationToken()); + const moreToAnalyze = this._backgroundAnalysisProgram.startAnalysis(token); if (moreToAnalyze) { this._scheduleReanalysis(/* requireTrackedFileUpdate */ false); } @@ -1890,9 +1883,12 @@ export class AnalyzerService { this._updateTrackedFileList(/* markFilesDirtyUnconditionally */ false); } + // Recreate the cancellation token every time we start analysis. + this._backgroundAnalysisCancellationSource = this.cancellationProvider.createCancellationTokenSource(); + // Now that the timer has fired, actually send the message to the BG thread to // start the analysis. - this.runAnalysis(); + this.runAnalysis(this._backgroundAnalysisCancellationSource.token); }, timeUntilNextAnalysisInMs); } From c20e613319ed56a7f349d4d7863d536a24dbd715 Mon Sep 17 00:00:00 2001 From: Eric Traut Date: Tue, 17 Sep 2024 10:01:45 -0700 Subject: [PATCH 21/27] Fixed a bug that results in spurious "variable not allowed in type expression" errors when a type alias is used in a loop in both a type expression and a value expression. This addresses #9017. (#9018) --- .../src/analyzer/codeFlowEngine.ts | 26 +++++++++++++++++-- .../src/tests/samples/loop50.py | 15 +++++++++++ .../src/tests/typeEvaluator3.test.ts | 6 +++++ 3 files changed, 45 insertions(+), 2 deletions(-) create mode 100644 packages/pyright-internal/src/tests/samples/loop50.py diff --git a/packages/pyright-internal/src/analyzer/codeFlowEngine.ts b/packages/pyright-internal/src/analyzer/codeFlowEngine.ts index 454924357..e32942162 100644 --- a/packages/pyright-internal/src/analyzer/codeFlowEngine.ts +++ b/packages/pyright-internal/src/analyzer/codeFlowEngine.ts @@ -401,6 +401,28 @@ export function getCodeFlowEngine( flowNodeTypeCache.cache.delete(flowNode.id); } + // Cleans any "incomplete unknowns" from the specified set of entries + // to compute the final type. + function cleanIncompleteUnknownForCacheEntry(cacheEntry: FlowNodeTypeResult): Type | undefined { + if (!cacheEntry.type) { + return undefined; + } + + if (!cacheEntry.incompleteSubtypes || cacheEntry.incompleteSubtypes.length === 0) { + return cleanIncompleteUnknown(cacheEntry.type); + } + + const typesToCombine: Type[] = []; + + cacheEntry.incompleteSubtypes?.forEach((entry) => { + if (entry.type && !isIncompleteUnknown(entry.type)) { + typesToCombine.push(cleanIncompleteUnknown(entry.type)); + } + }); + + return combineTypes(typesToCombine); + } + function evaluateAssignmentFlowNode(flowNode: FlowAssignment): TypeResult | undefined { // For function and class nodes, the reference node is the name // node, but we need to use the parent node (the FunctionNode or ClassNode) @@ -456,7 +478,7 @@ export function getCodeFlowEngine( // has changed that may cause the previously-reported incomplete type to change. if (cachedEntry.generationCount === flowIncompleteGeneration) { return FlowNodeTypeResult.create( - cachedEntry.type ? cleanIncompleteUnknown(cachedEntry.type) : undefined, + cleanIncompleteUnknownForCacheEntry(cachedEntry), /* isIncomplete */ true ); } @@ -966,7 +988,7 @@ export function getCodeFlowEngine( // that have not been evaluated even once, treat it as incomplete. We clean // any incomplete unknowns from the type here to assist with type convergence. return FlowNodeTypeResult.create( - cacheEntry.type ? cleanIncompleteUnknown(cacheEntry.type) : undefined, + cleanIncompleteUnknownForCacheEntry(cacheEntry), /* isIncomplete */ true ); } diff --git a/packages/pyright-internal/src/tests/samples/loop50.py b/packages/pyright-internal/src/tests/samples/loop50.py new file mode 100644 index 000000000..87b92c36c --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/loop50.py @@ -0,0 +1,15 @@ +# This sample tests the case where a type alias is accessed within +# a loop as both an annotation and a value expression. + +from typing import Literal + + +TA1 = Literal["a", "b"] + + +def func1(values: list): + for value in values: + x: TA1 = value["x"] + + if x not in TA1.__args__: + raise ValueError() diff --git a/packages/pyright-internal/src/tests/typeEvaluator3.test.ts b/packages/pyright-internal/src/tests/typeEvaluator3.test.ts index 3173de03b..c6ae76913 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator3.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator3.test.ts @@ -473,6 +473,12 @@ test('Loop49', () => { TestUtils.validateResults(analysisResults, 0); }); +test('Loop50', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['loop50.py']); + + TestUtils.validateResults(analysisResults, 0); +}); + test('ForLoop1', () => { const analysisResults = TestUtils.typeAnalyzeSampleFiles(['forLoop1.py']); From ea18695c34290d4f257462fc6215b9ed90826352 Mon Sep 17 00:00:00 2001 From: Bill Schnurr Date: Tue, 17 Sep 2024 10:43:59 -0700 Subject: [PATCH 22/27] Add new vscode signing (#8977) (#9019) Add new vscode signing, make sure signature file is different from the source manifest file. When publishing to marketplace reuse artifacts for VSIX, instead of downloading from github Include new manifest and signature files when publishing to marketplace --- build/azuredevops/azure-pipelines-release.yml | 71 ++++++++++++++++--- packages/vscode-pyright/packages.config | 4 ++ packages/vscode-pyright/sign.proj | 53 ++++++++++++++ 3 files changed, 118 insertions(+), 10 deletions(-) create mode 100644 packages/vscode-pyright/packages.config create mode 100644 packages/vscode-pyright/sign.proj diff --git a/build/azuredevops/azure-pipelines-release.yml b/build/azuredevops/azure-pipelines-release.yml index d97865412..14758cf8c 100644 --- a/build/azuredevops/azure-pipelines-release.yml +++ b/build/azuredevops/azure-pipelines-release.yml @@ -23,7 +23,7 @@ extends: codeql: compiled: enabled: false - justificationForDisabling: 'Running a scan on the Pyright-Build' + justificationForDisabling: 'Running a scan on the Pyright-Build azure-pipelines.yml' sourceAnalysisPool: VSEngSS-MicroBuild2022-1ES pool: pool: @@ -82,6 +82,59 @@ extends: SourceFolder: packages/vscode-pyright Contents: '*.vsix' TargetFolder: build_output + + - script: | + npm install -g @vscode/vsce + displayName: 'Install vsce and dependencies' + + - script: npx vsce generate-manifest -i $(VSIX_NAME) -o extension.manifest + displayName: 'Generate extension manifest' + workingDirectory: packages/vscode-pyright + + - task: NuGetToolInstaller@1 + displayName: 'Install NuGet' + + - task: NuGetCommand@2 + inputs: + command: 'restore' + restoreSolution: '$(Build.SourcesDirectory)/packages/vscode-pyright/packages.config' + restoreDirectory: '$(Build.SourcesDirectory)/packages/vscode-pyright/packages' + + - task: MSBuild@1 + displayName: 'Sign binaries' + inputs: + solution: 'packages/vscode-pyright/sign.proj' + msbuildArguments: '/verbosity:diagnostic /p:SignType=real' + + - task: PowerShell@2 + displayName: 'Compare extension.manifest and extension.signature.p7s' + inputs: + targetType: 'inline' + script: | + $manifestPath = "$(Build.SourcesDirectory)\packages\vscode-pyright\extension.manifest" + $signaturePath = "$(Build.SourcesDirectory)\packages\vscode-pyright\extension.signature.p7s" + $compareResult = Compare-Object (Get-Content $manifestPath) (Get-Content $signaturePath) + if ($compareResult -eq $null) { + Write-Error "Files are identical. Failing the build." + exit 1 + } else { + Write-Output "Files are different." + } + + - task: CopyFiles@2 + displayName: 'Copy extension.manifest' + inputs: + SourceFolder: 'packages/vscode-pyright' + Contents: 'extension.manifest' + TargetFolder: build_output + + - task: CopyFiles@2 + displayName: 'Copy extension.signature.p7s' + inputs: + SourceFolder: 'packages/vscode-pyright' + Contents: 'extension.signature.p7s' + TargetFolder: build_output + - stage: CreateRelease dependsOn: - BuildVsix @@ -129,14 +182,12 @@ extends: - task: NodeTool@0 inputs: versionSpec: 18.x - - task: DownloadGitHubRelease@0 - displayName: 'Download VSIX' + - task: DownloadPipelineArtifact@2 + displayName: 'Download Artifacts from Validation Job' inputs: - connection: 'Github-Pylance' - userRepository: 'microsoft/pyright' - defaultVersionType: 'specificTag' - version: $(Build.SourceBranchName) - downloadPath: '$(System.ArtifactsDirectory)' + buildType: 'current' + artifactName: '$(ARTIFACT_NAME_VSIX)' + targetPath: '$(System.ArtifactsDirectory)' # https://code.visualstudio.com/api/working-with-extensions/publishing-extension # Install dependencies and VS Code Extension Manager (vsce >= v2.26.1 needed) - script: | @@ -145,6 +196,7 @@ extends: # https://code.visualstudio.com/api/working-with-extensions/publishing-extension#get-a-personal-access-token # Publish to Marketplace # see. stackoverflow.com/collectives/ci-cd/articles/76873787/publish-azure-devops-extensions-using-azure-workload-identity + # az rest -u https://app.vssps.visualstudio.com/_apis/profile/profiles/me --resource 499b84ac-1321-427f-aa17-267ca6975798 - task: AzureCLI@2 displayName: 'Publishing with Managed Identity' inputs: @@ -152,6 +204,5 @@ extends: scriptType: 'pscore' scriptLocation: 'inlineScript' inlineScript: | - az rest -u https://app.vssps.visualstudio.com/_apis/profile/profiles/me --resource 499b84ac-1321-427f-aa17-267ca6975798 $aadToken = az account get-access-token --query accessToken --resource 499b84ac-1321-427f-aa17-267ca6975798 -o tsv - vsce publish --pat $aadToken --packagePath $(System.ArtifactsDirectory)/$(VSIX_NAME) --noVerify + vsce publish --pat $aadToken --packagePath $(System.ArtifactsDirectory)/$(VSIX_NAME) --noVerify --manifestPath $(System.ArtifactsDirectory)/extension.manifest --signaturePath $(System.ArtifactsDirectory)/extension.signature.p7s diff --git a/packages/vscode-pyright/packages.config b/packages/vscode-pyright/packages.config new file mode 100644 index 000000000..6055d9856 --- /dev/null +++ b/packages/vscode-pyright/packages.config @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/packages/vscode-pyright/sign.proj b/packages/vscode-pyright/sign.proj new file mode 100644 index 000000000..de406b380 --- /dev/null +++ b/packages/vscode-pyright/sign.proj @@ -0,0 +1,53 @@ + + + + + + + + Debug + dist\ + + $(BaseOutputDirectory)/intermediate + $(BaseOutputDirectory) + + + + + + + + + + + + + + + + + + + + + + + VSCodePublisher + + + + + + + + + + + This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}. + + + + + + + From 06ab7a8899bce955735d46d7caef9cc29f954efc Mon Sep 17 00:00:00 2001 From: Erik De Bonte Date: Tue, 17 Sep 2024 12:13:14 -0700 Subject: [PATCH 23/27] Update Unicode range tables to match Unicode 16.0 (#9020) --- build/generateUnicodeTables.py | 19 +-- .../pyright-internal/src/parser/unicode.ts | 144 +++++++++++++++++- 2 files changed, 146 insertions(+), 17 deletions(-) diff --git a/build/generateUnicodeTables.py b/build/generateUnicodeTables.py index 98ae2761e..651b73fc1 100644 --- a/build/generateUnicodeTables.py +++ b/build/generateUnicodeTables.py @@ -115,6 +115,7 @@ def getSurrogateRanges(chars: list[Character]) -> list[CharacterRange]: def writeRangeTable(writer: TextIOWrapper, category: str, chars: list[Character]): chars = [ch for ch in chars if ch.category == category] + writer.write("\n") writer.write(f"export const unicode{category}: UnicodeRangeTable = [\n") consecutiveRangeStartChar: Character | None = None @@ -126,13 +127,13 @@ def writeRangeTable(writer: TextIOWrapper, category: str, chars: list[Character] if i + 1 >= len(chars) or chars[i + 1].code != char.code + 1: if consecutiveRangeStartChar.code == char.code: - writer.write(f" 0x{consecutiveRangeStartChar.code:04X},\n") + writer.write(f" 0x{consecutiveRangeStartChar.code:04x},\n") else: - writer.write(f" [0x{consecutiveRangeStartChar.code:04X}, 0x{char.code:04X}],\n") + writer.write(f" [0x{consecutiveRangeStartChar.code:04x}, 0x{char.code:04x}],\n") consecutiveRangeStartChar = None - writer.write("];\n\n") + writer.write("];\n") # Write out a table of all characters within the specified category using their UTF-16 @@ -146,6 +147,7 @@ def writeSurrogateRangeTable( if len(surrogateRanges) == 0: return + writer.write("\n") writer.write( f"export const unicode{category}Surrogate: UnicodeSurrogateRangeTable = {{\n" ) @@ -160,21 +162,21 @@ def writeSurrogateRangeTable( previousCharRange = None if not previousCharRange: - writer.write(f" 0x{charRange.start.highSurrogate:04X}: [\n") + writer.write(f" 0x{charRange.start.highSurrogate:04x}: [\n") previousCharRange = charRange if charRange.start.lowSurrogate == charRange.end.lowSurrogate: - writer.write(f" 0x{charRange.start.lowSurrogate:04X}, // 0x{charRange.start.code:04X}\n") + writer.write(f" 0x{charRange.start.lowSurrogate:04x}, // 0x{charRange.start.code:04X}\n") else: writer.write( - f" [0x{charRange.start.lowSurrogate:04X}, 0x{charRange.end.lowSurrogate:04X}], // 0x{charRange.start.code:04X}..0x{charRange.end.code:04X}\n" + f" [0x{charRange.start.lowSurrogate:04x}, 0x{charRange.end.lowSurrogate:04x}], // 0x{charRange.start.code:04X}..0x{charRange.end.code:04X}\n" ) writer.write(" ],\n") - writer.write("};\n\n") + writer.write("};\n") -unicodeVersion = "15.1" if len(sys.argv) <= 1 else sys.argv[1] +unicodeVersion = "16.0" if len(sys.argv) <= 1 else sys.argv[1] path = downloadUnicodeData(unicodeVersion) chars = parseFile(path) surrogateRanges = getSurrogateRanges(chars) @@ -196,7 +198,6 @@ def writeSurrogateRangeTable( export type UnicodeRange = [number, number] | number; export type UnicodeRangeTable = UnicodeRange[]; export type UnicodeSurrogateRangeTable = {{ [surrogate: number]: UnicodeRange[] }}; - """ ) diff --git a/packages/pyright-internal/src/parser/unicode.ts b/packages/pyright-internal/src/parser/unicode.ts index 15bbf5222..8a1ac111a 100644 --- a/packages/pyright-internal/src/parser/unicode.ts +++ b/packages/pyright-internal/src/parser/unicode.ts @@ -7,7 +7,7 @@ * defined categories used in the Python spec. * * Generated by build/generateUnicodeTables.py from the UnicodeData.txt - * metadata file for Unicode 15.1. + * metadata file for Unicode 16.0. */ export type UnicodeRange = [number, number] | number; @@ -291,6 +291,7 @@ export const unicodeLu: UnicodeRangeTable = [ 0x10c7, 0x10cd, [0x13a0, 0x13f5], + 0x1c89, [0x1c90, 0x1cba], [0x1cbd, 0x1cbf], 0x1e00, @@ -615,9 +616,12 @@ export const unicodeLu: UnicodeRangeTable = [ 0xa7c2, [0xa7c4, 0xa7c7], 0xa7c9, + [0xa7cb, 0xa7cc], 0xa7d0, 0xa7d6, 0xa7d8, + 0xa7da, + 0xa7dc, 0xa7f5, [0xff21, 0xff3a], [0x10400, 0x10427], @@ -627,6 +631,7 @@ export const unicodeLu: UnicodeRangeTable = [ [0x1058c, 0x10592], [0x10594, 0x10595], [0x10c80, 0x10cb2], + [0x10d50, 0x10d65], [0x118a0, 0x118bf], [0x16e40, 0x16e5f], [0x1d400, 0x1d419], @@ -674,6 +679,7 @@ export const unicodeLuSurrogate: UnicodeSurrogateRangeTable = { ], 0xd803: [ [0xdc80, 0xdcb2], // 0x10C80..0x10CB2 + [0xdd50, 0xdd65], // 0x10D50..0x10D65 ], 0xd806: [ [0xdca0, 0xdcbf], // 0x118A0..0x118BF @@ -994,6 +1000,7 @@ export const unicodeLl: UnicodeRangeTable = [ [0x10fd, 0x10ff], [0x13f8, 0x13fd], [0x1c80, 0x1c88], + 0x1c8a, [0x1d00, 0x1d2b], [0x1d6b, 0x1d77], [0x1d79, 0x1d9a], @@ -1324,11 +1331,13 @@ export const unicodeLl: UnicodeRangeTable = [ 0xa7c3, 0xa7c8, 0xa7ca, + 0xa7cd, 0xa7d1, 0xa7d3, 0xa7d5, 0xa7d7, 0xa7d9, + 0xa7db, 0xa7f6, 0xa7fa, [0xab30, 0xab5a], @@ -1344,6 +1353,7 @@ export const unicodeLl: UnicodeRangeTable = [ [0x105b3, 0x105b9], [0x105bb, 0x105bc], [0x10cc0, 0x10cf2], + [0x10d70, 0x10d85], [0x118c0, 0x118df], [0x16e60, 0x16e7f], [0x1d41a, 0x1d433], @@ -1391,6 +1401,7 @@ export const unicodeLlSurrogate: UnicodeSurrogateRangeTable = { ], 0xd803: [ [0xdcc0, 0xdcf2], // 0x10CC0..0x10CF2 + [0xdd70, 0xdd85], // 0x10D70..0x10D85 ], 0xd806: [ [0xdcc0, 0xdcdf], // 0x118C0..0x118DF @@ -1761,6 +1772,7 @@ export const unicodeLo: UnicodeRangeTable = [ [0x10450, 0x1049d], [0x10500, 0x10527], [0x10530, 0x10563], + [0x105c0, 0x105f3], [0x10600, 0x10736], [0x10740, 0x10755], [0x10760, 0x10767], @@ -1792,8 +1804,11 @@ export const unicodeLo: UnicodeRangeTable = [ [0x10b80, 0x10b91], [0x10c00, 0x10c48], [0x10d00, 0x10d23], + [0x10d4a, 0x10d4d], + 0x10d4f, [0x10e80, 0x10ea9], [0x10eb0, 0x10eb1], + [0x10ec2, 0x10ec4], [0x10f00, 0x10f1c], 0x10f27, [0x10f30, 0x10f45], @@ -1832,6 +1847,13 @@ export const unicodeLo: UnicodeRangeTable = [ 0x1133d, 0x11350, [0x1135d, 0x11361], + [0x11380, 0x11389], + 0x1138b, + 0x1138e, + [0x11390, 0x113b5], + 0x113b7, + 0x113d1, + 0x113d3, [0x11400, 0x11434], [0x11447, 0x1144a], [0x1145f, 0x11461], @@ -1865,6 +1887,7 @@ export const unicodeLo: UnicodeRangeTable = [ [0x11a5c, 0x11a89], 0x11a9d, [0x11ab0, 0x11af8], + [0x11bc0, 0x11be0], [0x11c00, 0x11c08], [0x11c0a, 0x11c2e], 0x11c40, @@ -1887,7 +1910,9 @@ export const unicodeLo: UnicodeRangeTable = [ [0x12f90, 0x12ff0], [0x13000, 0x1342f], [0x13441, 0x13446], + [0x13460, 0x143fa], [0x14400, 0x14646], + [0x16100, 0x1611d], [0x16800, 0x16a38], [0x16a40, 0x16a5e], [0x16a70, 0x16abe], @@ -1895,11 +1920,12 @@ export const unicodeLo: UnicodeRangeTable = [ [0x16b00, 0x16b2f], [0x16b63, 0x16b77], [0x16b7d, 0x16b8f], + [0x16d43, 0x16d6a], [0x16f00, 0x16f4a], 0x16f50, [0x17000, 0x187f7], [0x18800, 0x18cd5], - [0x18d00, 0x18d08], + [0x18cff, 0x18d08], [0x1b000, 0x1b122], 0x1b132, [0x1b150, 0x1b152], @@ -1916,6 +1942,8 @@ export const unicodeLo: UnicodeRangeTable = [ [0x1e290, 0x1e2ad], [0x1e2c0, 0x1e2eb], [0x1e4d0, 0x1e4ea], + [0x1e5d0, 0x1e5ed], + 0x1e5f0, [0x1e7e0, 0x1e7e6], [0x1e7e8, 0x1e7eb], [0x1e7ed, 0x1e7ee], @@ -1988,6 +2016,7 @@ export const unicodeLoSurrogate: UnicodeSurrogateRangeTable = { [0xdc50, 0xdc9d], // 0x10450..0x1049D [0xdd00, 0xdd27], // 0x10500..0x10527 [0xdd30, 0xdd63], // 0x10530..0x10563 + [0xddc0, 0xddf3], // 0x105C0..0x105F3 [0xde00, 0xdf36], // 0x10600..0x10736 [0xdf40, 0xdf55], // 0x10740..0x10755 [0xdf60, 0xdf67], // 0x10760..0x10767 @@ -2023,8 +2052,11 @@ export const unicodeLoSurrogate: UnicodeSurrogateRangeTable = { 0xd803: [ [0xdc00, 0xdc48], // 0x10C00..0x10C48 [0xdd00, 0xdd23], // 0x10D00..0x10D23 + [0xdd4a, 0xdd4d], // 0x10D4A..0x10D4D + 0xdd4f, // 0x10D4F [0xde80, 0xdea9], // 0x10E80..0x10EA9 [0xdeb0, 0xdeb1], // 0x10EB0..0x10EB1 + [0xdec2, 0xdec4], // 0x10EC2..0x10EC4 [0xdf00, 0xdf1c], // 0x10F00..0x10F1C 0xdf27, // 0x10F27 [0xdf30, 0xdf45], // 0x10F30..0x10F45 @@ -2065,6 +2097,13 @@ export const unicodeLoSurrogate: UnicodeSurrogateRangeTable = { 0xdf3d, // 0x1133D 0xdf50, // 0x11350 [0xdf5d, 0xdf61], // 0x1135D..0x11361 + [0xdf80, 0xdf89], // 0x11380..0x11389 + 0xdf8b, // 0x1138B + 0xdf8e, // 0x1138E + [0xdf90, 0xdfb5], // 0x11390..0x113B5 + 0xdfb7, // 0x113B7 + 0xdfd1, // 0x113D1 + 0xdfd3, // 0x113D3 ], 0xd805: [ [0xdc00, 0xdc34], // 0x11400..0x11434 @@ -2102,6 +2141,7 @@ export const unicodeLoSurrogate: UnicodeSurrogateRangeTable = { [0xde5c, 0xde89], // 0x11A5C..0x11A89 0xde9d, // 0x11A9D [0xdeb0, 0xdef8], // 0x11AB0..0x11AF8 + [0xdfc0, 0xdfe0], // 0x11BC0..0x11BE0 ], 0xd807: [ [0xdc00, 0xdc08], // 0x11C00..0x11C08 @@ -2137,10 +2177,23 @@ export const unicodeLoSurrogate: UnicodeSurrogateRangeTable = { 0xd80d: [ [0xdc00, 0xdc2f], // 0x13400..0x1342F [0xdc41, 0xdc46], // 0x13441..0x13446 + [0xdc60, 0xdfff], // 0x13460..0x137FF + ], + 0xd80e: [ + [0xdc00, 0xdfff], // 0x13800..0x13BFF + ], + 0xd80f: [ + [0xdc00, 0xdfff], // 0x13C00..0x13FFF + ], + 0xd810: [ + [0xdc00, 0xdffa], // 0x14000..0x143FA ], 0xd811: [ [0xdc00, 0xde46], // 0x14400..0x14646 ], + 0xd818: [ + [0xdd00, 0xdd1d], // 0x16100..0x1611D + ], 0xd81a: [ [0xdc00, 0xde38], // 0x16800..0x16A38 [0xde40, 0xde5e], // 0x16A40..0x16A5E @@ -2151,6 +2204,7 @@ export const unicodeLoSurrogate: UnicodeSurrogateRangeTable = { [0xdf7d, 0xdf8f], // 0x16B7D..0x16B8F ], 0xd81b: [ + [0xdd43, 0xdd6a], // 0x16D43..0x16D6A [0xdf00, 0xdf4a], // 0x16F00..0x16F4A 0xdf50, // 0x16F50 ], @@ -2177,7 +2231,7 @@ export const unicodeLoSurrogate: UnicodeSurrogateRangeTable = { ], 0xd823: [ [0xdc00, 0xdcd5], // 0x18C00..0x18CD5 - [0xdd00, 0xdd08], // 0x18D00..0x18D08 + [0xdcff, 0xdd08], // 0x18CFF..0x18D08 ], 0xd82c: [ [0xdc00, 0xdd22], // 0x1B000..0x1B122 @@ -2204,6 +2258,8 @@ export const unicodeLoSurrogate: UnicodeSurrogateRangeTable = { ], 0xd839: [ [0xdcd0, 0xdcea], // 0x1E4D0..0x1E4EA + [0xddd0, 0xdded], // 0x1E5D0..0x1E5ED + 0xddf0, // 0x1E5F0 [0xdfe0, 0xdfe6], // 0x1E7E0..0x1E7E6 [0xdfe8, 0xdfeb], // 0x1E7E8..0x1E7EB [0xdfed, 0xdfee], // 0x1E7ED..0x1E7EE @@ -2526,7 +2582,11 @@ export const unicodeLm: UnicodeRangeTable = [ [0x10780, 0x10785], [0x10787, 0x107b0], [0x107b2, 0x107ba], + 0x10d4e, + 0x10d6f, [0x16b40, 0x16b43], + [0x16d40, 0x16d42], + [0x16d6b, 0x16d6c], [0x16f93, 0x16f9f], [0x16fe0, 0x16fe1], 0x16fe3, @@ -2545,10 +2605,16 @@ export const unicodeLmSurrogate: UnicodeSurrogateRangeTable = { [0xdf87, 0xdfb0], // 0x10787..0x107B0 [0xdfb2, 0xdfba], // 0x107B2..0x107BA ], + 0xd803: [ + 0xdd4e, // 0x10D4E + 0xdd6f, // 0x10D6F + ], 0xd81a: [ [0xdf40, 0xdf43], // 0x16B40..0x16B43 ], 0xd81b: [ + [0xdd40, 0xdd42], // 0x16D40..0x16D42 + [0xdd6b, 0xdd6c], // 0x16D6B..0x16D6C [0xdf93, 0xdf9f], // 0x16F93..0x16F9F [0xdfe0, 0xdfe1], // 0x16FE0..0x16FE1 0xdfe3, // 0x16FE3 @@ -2622,7 +2688,7 @@ export const unicodeMn: UnicodeRangeTable = [ [0x0825, 0x0827], [0x0829, 0x082d], [0x0859, 0x085b], - [0x0898, 0x089f], + [0x0897, 0x089f], [0x08ca, 0x08e1], [0x08e3, 0x0902], 0x093a, @@ -2820,8 +2886,9 @@ export const unicodeMn: UnicodeRangeTable = [ 0x10a3f, [0x10ae5, 0x10ae6], [0x10d24, 0x10d27], + [0x10d69, 0x10d6d], [0x10eab, 0x10eac], - [0x10efd, 0x10eff], + [0x10efc, 0x10eff], [0x10f46, 0x10f50], [0x10f82, 0x10f85], 0x11001, @@ -2852,6 +2919,11 @@ export const unicodeMn: UnicodeRangeTable = [ 0x11340, [0x11366, 0x1136c], [0x11370, 0x11374], + [0x113bb, 0x113c0], + 0x113ce, + 0x113d0, + 0x113d2, + [0x113e1, 0x113e2], [0x11438, 0x1143f], [0x11442, 0x11444], 0x11446, @@ -2871,7 +2943,8 @@ export const unicodeMn: UnicodeRangeTable = [ 0x116ad, [0x116b0, 0x116b5], 0x116b7, - [0x1171d, 0x1171f], + 0x1171d, + 0x1171f, [0x11722, 0x11725], [0x11727, 0x1172b], [0x1182f, 0x11837], @@ -2910,8 +2983,11 @@ export const unicodeMn: UnicodeRangeTable = [ [0x11f36, 0x11f3a], 0x11f40, 0x11f42, + 0x11f5a, 0x13440, [0x13447, 0x13455], + [0x1611e, 0x16129], + [0x1612d, 0x1612f], [0x16af0, 0x16af4], [0x16b30, 0x16b36], 0x16f4f, @@ -2941,6 +3017,7 @@ export const unicodeMn: UnicodeRangeTable = [ 0x1e2ae, [0x1e2ec, 0x1e2ef], [0x1e4ec, 0x1e4ef], + [0x1e5ee, 0x1e5ef], [0x1e8d0, 0x1e8d6], [0x1e944, 0x1e94a], [0xe0100, 0xe01ef], @@ -2962,8 +3039,9 @@ export const unicodeMnSurrogate: UnicodeSurrogateRangeTable = { ], 0xd803: [ [0xdd24, 0xdd27], // 0x10D24..0x10D27 + [0xdd69, 0xdd6d], // 0x10D69..0x10D6D [0xdeab, 0xdeac], // 0x10EAB..0x10EAC - [0xdefd, 0xdeff], // 0x10EFD..0x10EFF + [0xdefc, 0xdeff], // 0x10EFC..0x10EFF [0xdf46, 0xdf50], // 0x10F46..0x10F50 [0xdf82, 0xdf85], // 0x10F82..0x10F85 ], @@ -2996,6 +3074,11 @@ export const unicodeMnSurrogate: UnicodeSurrogateRangeTable = { 0xdf40, // 0x11340 [0xdf66, 0xdf6c], // 0x11366..0x1136C [0xdf70, 0xdf74], // 0x11370..0x11374 + [0xdfbb, 0xdfc0], // 0x113BB..0x113C0 + 0xdfce, // 0x113CE + 0xdfd0, // 0x113D0 + 0xdfd2, // 0x113D2 + [0xdfe1, 0xdfe2], // 0x113E1..0x113E2 ], 0xd805: [ [0xdc38, 0xdc3f], // 0x11438..0x1143F @@ -3017,7 +3100,8 @@ export const unicodeMnSurrogate: UnicodeSurrogateRangeTable = { 0xdead, // 0x116AD [0xdeb0, 0xdeb5], // 0x116B0..0x116B5 0xdeb7, // 0x116B7 - [0xdf1d, 0xdf1f], // 0x1171D..0x1171F + 0xdf1d, // 0x1171D + 0xdf1f, // 0x1171F [0xdf22, 0xdf25], // 0x11722..0x11725 [0xdf27, 0xdf2b], // 0x11727..0x1172B ], @@ -3060,11 +3144,16 @@ export const unicodeMnSurrogate: UnicodeSurrogateRangeTable = { [0xdf36, 0xdf3a], // 0x11F36..0x11F3A 0xdf40, // 0x11F40 0xdf42, // 0x11F42 + 0xdf5a, // 0x11F5A ], 0xd80d: [ 0xdc40, // 0x13440 [0xdc47, 0xdc55], // 0x13447..0x13455 ], + 0xd818: [ + [0xdd1e, 0xdd29], // 0x1611E..0x16129 + [0xdd2d, 0xdd2f], // 0x1612D..0x1612F + ], 0xd81a: [ [0xdef0, 0xdef4], // 0x16AF0..0x16AF4 [0xdf30, 0xdf36], // 0x16B30..0x16B36 @@ -3109,6 +3198,7 @@ export const unicodeMnSurrogate: UnicodeSurrogateRangeTable = { ], 0xd839: [ [0xdcec, 0xdcef], // 0x1E4EC..0x1E4EF + [0xddee, 0xddef], // 0x1E5EE..0x1E5EF ], 0xd83a: [ [0xdcd0, 0xdcd6], // 0x1E8D0..0x1E8D6 @@ -3254,6 +3344,12 @@ export const unicodeMc: UnicodeRangeTable = [ [0x1134b, 0x1134d], 0x11357, [0x11362, 0x11363], + [0x113b8, 0x113ba], + 0x113c2, + 0x113c5, + [0x113c7, 0x113ca], + [0x113cc, 0x113cd], + 0x113cf, [0x11435, 0x11437], [0x11440, 0x11441], 0x11445, @@ -3270,6 +3366,7 @@ export const unicodeMc: UnicodeRangeTable = [ 0x116ac, [0x116ae, 0x116af], 0x116b6, + 0x1171e, [0x11720, 0x11721], 0x11726, [0x1182c, 0x1182e], @@ -3298,6 +3395,7 @@ export const unicodeMc: UnicodeRangeTable = [ [0x11f34, 0x11f35], [0x11f3e, 0x11f3f], 0x11f41, + [0x1612a, 0x1612c], [0x16f51, 0x16f87], [0x16ff0, 0x16ff1], [0x1d165, 0x1d166], @@ -3328,6 +3426,12 @@ export const unicodeMcSurrogate: UnicodeSurrogateRangeTable = { [0xdf4b, 0xdf4d], // 0x1134B..0x1134D 0xdf57, // 0x11357 [0xdf62, 0xdf63], // 0x11362..0x11363 + [0xdfb8, 0xdfba], // 0x113B8..0x113BA + 0xdfc2, // 0x113C2 + 0xdfc5, // 0x113C5 + [0xdfc7, 0xdfca], // 0x113C7..0x113CA + [0xdfcc, 0xdfcd], // 0x113CC..0x113CD + 0xdfcf, // 0x113CF ], 0xd805: [ [0xdc35, 0xdc37], // 0x11435..0x11437 @@ -3346,6 +3450,7 @@ export const unicodeMcSurrogate: UnicodeSurrogateRangeTable = { 0xdeac, // 0x116AC [0xdeae, 0xdeaf], // 0x116AE..0x116AF 0xdeb6, // 0x116B6 + 0xdf1e, // 0x1171E [0xdf20, 0xdf21], // 0x11720..0x11721 0xdf26, // 0x11726 ], @@ -3379,6 +3484,9 @@ export const unicodeMcSurrogate: UnicodeSurrogateRangeTable = { [0xdf3e, 0xdf3f], // 0x11F3E..0x11F3F 0xdf41, // 0x11F41 ], + 0xd818: [ + [0xdd2a, 0xdd2c], // 0x1612A..0x1612C + ], 0xd81b: [ [0xdf51, 0xdf87], // 0x16F51..0x16F87 [0xdff0, 0xdff1], // 0x16FF0..0x16FF1 @@ -3429,6 +3537,7 @@ export const unicodeNd: UnicodeRangeTable = [ [0xff10, 0xff19], [0x104a0, 0x104a9], [0x10d30, 0x10d39], + [0x10d40, 0x10d49], [0x11066, 0x1106f], [0x110f0, 0x110f9], [0x11136, 0x1113f], @@ -3438,20 +3547,26 @@ export const unicodeNd: UnicodeRangeTable = [ [0x114d0, 0x114d9], [0x11650, 0x11659], [0x116c0, 0x116c9], + [0x116d0, 0x116e3], [0x11730, 0x11739], [0x118e0, 0x118e9], [0x11950, 0x11959], + [0x11bf0, 0x11bf9], [0x11c50, 0x11c59], [0x11d50, 0x11d59], [0x11da0, 0x11da9], [0x11f50, 0x11f59], + [0x16130, 0x16139], [0x16a60, 0x16a69], [0x16ac0, 0x16ac9], [0x16b50, 0x16b59], + [0x16d70, 0x16d79], + [0x1ccf0, 0x1ccf9], [0x1d7ce, 0x1d7ff], [0x1e140, 0x1e149], [0x1e2f0, 0x1e2f9], [0x1e4f0, 0x1e4f9], + [0x1e5f1, 0x1e5fa], [0x1e950, 0x1e959], [0x1fbf0, 0x1fbf9], ]; @@ -3462,6 +3577,7 @@ export const unicodeNdSurrogate: UnicodeSurrogateRangeTable = { ], 0xd803: [ [0xdd30, 0xdd39], // 0x10D30..0x10D39 + [0xdd40, 0xdd49], // 0x10D40..0x10D49 ], 0xd804: [ [0xdc66, 0xdc6f], // 0x11066..0x1106F @@ -3475,11 +3591,13 @@ export const unicodeNdSurrogate: UnicodeSurrogateRangeTable = { [0xdcd0, 0xdcd9], // 0x114D0..0x114D9 [0xde50, 0xde59], // 0x11650..0x11659 [0xdec0, 0xdec9], // 0x116C0..0x116C9 + [0xded0, 0xdee3], // 0x116D0..0x116E3 [0xdf30, 0xdf39], // 0x11730..0x11739 ], 0xd806: [ [0xdce0, 0xdce9], // 0x118E0..0x118E9 [0xdd50, 0xdd59], // 0x11950..0x11959 + [0xdff0, 0xdff9], // 0x11BF0..0x11BF9 ], 0xd807: [ [0xdc50, 0xdc59], // 0x11C50..0x11C59 @@ -3487,11 +3605,20 @@ export const unicodeNdSurrogate: UnicodeSurrogateRangeTable = { [0xdda0, 0xdda9], // 0x11DA0..0x11DA9 [0xdf50, 0xdf59], // 0x11F50..0x11F59 ], + 0xd818: [ + [0xdd30, 0xdd39], // 0x16130..0x16139 + ], 0xd81a: [ [0xde60, 0xde69], // 0x16A60..0x16A69 [0xdec0, 0xdec9], // 0x16AC0..0x16AC9 [0xdf50, 0xdf59], // 0x16B50..0x16B59 ], + 0xd81b: [ + [0xdd70, 0xdd79], // 0x16D70..0x16D79 + ], + 0xd833: [ + [0xdcf0, 0xdcf9], // 0x1CCF0..0x1CCF9 + ], 0xd835: [ [0xdfce, 0xdfff], // 0x1D7CE..0x1D7FF ], @@ -3501,6 +3628,7 @@ export const unicodeNdSurrogate: UnicodeSurrogateRangeTable = { ], 0xd839: [ [0xdcf0, 0xdcf9], // 0x1E4F0..0x1E4F9 + [0xddf1, 0xddfa], // 0x1E5F1..0x1E5FA ], 0xd83a: [ [0xdd50, 0xdd59], // 0x1E950..0x1E959 From a56a4ecfcd4374f01c34cc681ba9794e6de2ad8c Mon Sep 17 00:00:00 2001 From: Eric Traut Date: Tue, 17 Sep 2024 15:52:44 -0700 Subject: [PATCH 24/27] Published 1.1.381 --- lerna.json | 2 +- packages/pyright-internal/package-lock.json | 4 ++-- packages/pyright-internal/package.json | 2 +- packages/pyright/package-lock.json | 4 ++-- packages/pyright/package.json | 2 +- packages/vscode-pyright/package-lock.json | 4 ++-- packages/vscode-pyright/package.json | 2 +- 7 files changed, 10 insertions(+), 10 deletions(-) diff --git a/lerna.json b/lerna.json index 8b181eda7..96b8f624e 100644 --- a/lerna.json +++ b/lerna.json @@ -2,7 +2,7 @@ "packages": [ "packages/*" ], - "version": "1.1.380", + "version": "1.1.381", "command": { "version": { "push": false, diff --git a/packages/pyright-internal/package-lock.json b/packages/pyright-internal/package-lock.json index 7cc3d33e6..e2c75e64c 100644 --- a/packages/pyright-internal/package-lock.json +++ b/packages/pyright-internal/package-lock.json @@ -1,12 +1,12 @@ { "name": "pyright-internal", - "version": "1.1.380", + "version": "1.1.381", "lockfileVersion": 2, "requires": true, "packages": { "": { "name": "pyright-internal", - "version": "1.1.380", + "version": "1.1.381", "license": "MIT", "dependencies": { "@iarna/toml": "2.2.5", diff --git a/packages/pyright-internal/package.json b/packages/pyright-internal/package.json index 83b475d27..bf6b01508 100644 --- a/packages/pyright-internal/package.json +++ b/packages/pyright-internal/package.json @@ -2,7 +2,7 @@ "name": "pyright-internal", "displayName": "pyright", "description": "Type checker for the Python language", - "version": "1.1.380", + "version": "1.1.381", "license": "MIT", "private": true, "files": [ diff --git a/packages/pyright/package-lock.json b/packages/pyright/package-lock.json index 7d5ee7caf..a4c46cff2 100644 --- a/packages/pyright/package-lock.json +++ b/packages/pyright/package-lock.json @@ -1,12 +1,12 @@ { "name": "pyright", - "version": "1.1.380", + "version": "1.1.381", "lockfileVersion": 2, "requires": true, "packages": { "": { "name": "pyright", - "version": "1.1.380", + "version": "1.1.381", "license": "MIT", "bin": { "pyright": "index.js", diff --git a/packages/pyright/package.json b/packages/pyright/package.json index b223a06a7..32170c32f 100644 --- a/packages/pyright/package.json +++ b/packages/pyright/package.json @@ -2,7 +2,7 @@ "name": "pyright", "displayName": "Pyright", "description": "Type checker for the Python language", - "version": "1.1.380", + "version": "1.1.381", "license": "MIT", "author": { "name": "Microsoft Corporation" diff --git a/packages/vscode-pyright/package-lock.json b/packages/vscode-pyright/package-lock.json index 0a5a60955..729c99646 100644 --- a/packages/vscode-pyright/package-lock.json +++ b/packages/vscode-pyright/package-lock.json @@ -1,12 +1,12 @@ { "name": "vscode-pyright", - "version": "1.1.380", + "version": "1.1.381", "lockfileVersion": 2, "requires": true, "packages": { "": { "name": "vscode-pyright", - "version": "1.1.380", + "version": "1.1.381", "license": "MIT", "dependencies": { "vscode-jsonrpc": "^9.0.0-next.5", diff --git a/packages/vscode-pyright/package.json b/packages/vscode-pyright/package.json index fd4639f58..d03afbdc6 100644 --- a/packages/vscode-pyright/package.json +++ b/packages/vscode-pyright/package.json @@ -2,7 +2,7 @@ "name": "vscode-pyright", "displayName": "Pyright", "description": "VS Code static type checking for Python", - "version": "1.1.380", + "version": "1.1.381", "private": true, "license": "MIT", "author": { From 958af901a7aa39cb9d147d211025e48f66f0df76 Mon Sep 17 00:00:00 2001 From: detachhead Date: Wed, 18 Sep 2024 19:06:12 +1000 Subject: [PATCH 25/27] fix type errors from merge --- packages/browser-pyright/src/browserWorkersHost.ts | 11 ++++++++--- .../pyright-internal/src/backgroundAnalysisBase.ts | 10 +++++----- .../pyright-internal/src/common/nodeWorkersHost.ts | 14 ++++---------- .../pyright-internal/src/common/workersHost.ts | 8 ++++++-- 4 files changed, 23 insertions(+), 20 deletions(-) diff --git a/packages/browser-pyright/src/browserWorkersHost.ts b/packages/browser-pyright/src/browserWorkersHost.ts index 1d9a0d6fa..cbaeffaa4 100644 --- a/packages/browser-pyright/src/browserWorkersHost.ts +++ b/packages/browser-pyright/src/browserWorkersHost.ts @@ -1,7 +1,7 @@ import { Transferable, WorkersHost, - MessageSourceSink, + Worker, MessagePort, MessageChannel, shallowReplace, @@ -22,7 +22,7 @@ export class BrowserWorkersHost implements WorkersHost { return this._parentPort ? new BrowserMessagePort(this._parentPort) : null; } - createWorker(initialData?: any): MessageSourceSink { + createWorker(initialData?: any): Worker { const channel = new globalThis.MessageChannel(); self.postMessage( { @@ -46,7 +46,7 @@ export class BrowserWorkersHost implements WorkersHost { } } -class BrowserMessagePort implements MessagePort { +class BrowserMessagePort implements MessagePort, Worker { constructor(private _delegate: globalThis.MessagePort) {} unwrap() { return this._delegate; @@ -73,6 +73,11 @@ class BrowserMessagePort implements MessagePort { close() { this._delegate.close(); } + terminate = () => { + console.warn('Worker.terminate was called. TODO: figure out what to do'); + this._delegate.close(); // this? + return Promise.resolve(0); + }; } function unwrapForSend(value: any): any { diff --git a/packages/pyright-internal/src/backgroundAnalysisBase.ts b/packages/pyright-internal/src/backgroundAnalysisBase.ts index c325803b2..d8a135702 100644 --- a/packages/pyright-internal/src/backgroundAnalysisBase.ts +++ b/packages/pyright-internal/src/backgroundAnalysisBase.ts @@ -42,13 +42,13 @@ import { Host, HostKind } from './common/host'; import { LogTracker } from './common/logTracker'; import { ServiceProvider } from './common/serviceProvider'; import { Range } from './common/textRange'; -import { createMessageChannel, MessagePort, MessageSourceSink, threadId } from './common/workersHost'; +import { createMessageChannel, MessagePort, threadId, MessageChannel, Worker } from './common/workersHost'; import { Uri } from './common/uri/uri'; import { ProgramView } from './common/extensibility'; import { TestFileSystem } from './tests/harness/vfs/filesystem'; export class BackgroundAnalysisBase { - private _worker: MessageSourceSink | undefined; + private _worker: Worker | undefined; private _onAnalysisCompletion: AnalysisCompleteCallback = nullCallback; private _analysisCancellationToken: CancellationToken | undefined = undefined; private _messageChannel: MessageChannel; @@ -59,7 +59,7 @@ export class BackgroundAnalysisBase { // Create a message channel for handling 'analysis' or 'background' type results. // The other side of this channel will be sent to the BG thread for sending responses. - this._messageChannel = new MessageChannel(); + this._messageChannel = createMessageChannel(); this._messageChannel.port1.on('message', (msg: BackgroundResponse) => this.handleBackgroundResponse(msg)); } @@ -244,7 +244,7 @@ export class BackgroundAnalysisBase { } } - protected setup(worker: MessageSourceSink) { + protected setup(worker: Worker) { this._worker = worker; // global channel to communicate from BG channel to main thread. @@ -808,7 +808,7 @@ function convertDiagnostics(diagnostics: Diagnostic[]) { }); } -export type AnalysisRequestKind = +export type BackgroundRequestKind = // Browser usecase | 'initializeFileSystem' | 'createFile' diff --git a/packages/pyright-internal/src/common/nodeWorkersHost.ts b/packages/pyright-internal/src/common/nodeWorkersHost.ts index 78e27ec04..3501f398a 100644 --- a/packages/pyright-internal/src/common/nodeWorkersHost.ts +++ b/packages/pyright-internal/src/common/nodeWorkersHost.ts @@ -5,14 +5,7 @@ import { MessageChannel as WorkerThreadsMessageChannel, threadId, } from 'worker_threads'; -import { - MessageChannel, - MessagePort, - MessageSourceSink, - shallowReplace, - Transferable, - WorkersHost, -} from './workersHost'; +import { MessageChannel, MessagePort, shallowReplace, Transferable, Worker, WorkersHost } from './workersHost'; export class NodeWorkersHost implements WorkersHost { threadId(): string { @@ -23,7 +16,7 @@ export class NodeWorkersHost implements WorkersHost { return parentPort ? new NodeMessagePort(parentPort) : null; } - createWorker(initialData?: any): MessageSourceSink { + createWorker(initialData?: any): Worker { // this will load this same file in BG thread and start listener const worker = new WorkerThreadsWorker(__filename, { workerData: initialData }); return new NodeWorker(worker); @@ -61,7 +54,7 @@ class NodeMessagePort implements MessagePort { } } -class NodeWorker implements MessageSourceSink { +class NodeWorker implements Worker { constructor(private _delegate: WorkerThreadsWorker) {} postMessage(value: any, transferList?: Transferable[]): void { if (transferList) { @@ -73,6 +66,7 @@ class NodeWorker implements MessageSourceSink { on(type: 'message' | 'error' | 'exit', listener: (data: any) => void): void { this._delegate.on(type, (data) => listener(wrapOnReceive(data))); } + terminate = () => this._delegate.terminate(); } function unwrapForSend(value: any): any { diff --git a/packages/pyright-internal/src/common/workersHost.ts b/packages/pyright-internal/src/common/workersHost.ts index af7666a54..bca9d7b69 100644 --- a/packages/pyright-internal/src/common/workersHost.ts +++ b/packages/pyright-internal/src/common/workersHost.ts @@ -13,6 +13,10 @@ export interface MessageSourceSink { on(type: 'message' | 'error' | 'exit', listener: (data: any) => void): void; } +export interface Worker extends MessageSourceSink { + terminate(): Promise; +} + export interface MessagePort extends MessageSourceSink { start(): void; close(): void; @@ -25,7 +29,7 @@ export interface MessageChannel { export interface WorkersHost { parentPort(): MessagePort | null; - createWorker(initialData?: any): MessageSourceSink; + createWorker(initialData?: any): Worker; createMessageChannel(): MessageChannel; threadId(): string; } @@ -48,7 +52,7 @@ export function createMessageChannel(): MessageChannel { return host().createMessageChannel(); } -export function createWorker(initialData?: any): MessageSourceSink { +export function createWorker(initialData?: any): Worker { return host().createWorker(initialData); } From 03e7502b0f7fbf693d4c341085985d2ce648efab Mon Sep 17 00:00:00 2001 From: detachhead Date: Wed, 18 Sep 2024 21:00:00 +1000 Subject: [PATCH 26/27] fix browser-basedpyright. accidentally dropped this when merging upstream --- packages/pyright-internal/src/backgroundAnalysisBase.ts | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/packages/pyright-internal/src/backgroundAnalysisBase.ts b/packages/pyright-internal/src/backgroundAnalysisBase.ts index d8a135702..39860a2b8 100644 --- a/packages/pyright-internal/src/backgroundAnalysisBase.ts +++ b/packages/pyright-internal/src/backgroundAnalysisBase.ts @@ -61,6 +61,10 @@ export class BackgroundAnalysisBase { // The other side of this channel will be sent to the BG thread for sending responses. this._messageChannel = createMessageChannel(); this._messageChannel.port1.on('message', (msg: BackgroundResponse) => this.handleBackgroundResponse(msg)); + + // required for browser-basedpyright: + this._messageChannel.port1.start(); + this._messageChannel.port2.start(); } dispose() { From d640a5069471624401f188ee4c4202aa40b8d2e7 Mon Sep 17 00:00:00 2001 From: detachhead Date: Wed, 18 Sep 2024 21:00:20 +1000 Subject: [PATCH 27/27] add a dev build script for browser-basedpyright --- packages/browser-pyright/package.json | 1 + packages/browser-pyright/webpack.config.js | 3 +++ 2 files changed, 4 insertions(+) diff --git a/packages/browser-pyright/package.json b/packages/browser-pyright/package.json index 73a851500..71a1abc63 100644 --- a/packages/browser-pyright/package.json +++ b/packages/browser-pyright/package.json @@ -19,6 +19,7 @@ }, "scripts": { "build": "webpack --mode production --progress", + "build:dev": "webpack --mode development --progress", "clean": "shx rm -rf ./dist ./out LICENSE.txt", "prepack": "npm run clean && shx cp ../../LICENSE.txt . && npm run build", "webpack": "webpack --mode development --progress" diff --git a/packages/browser-pyright/webpack.config.js b/packages/browser-pyright/webpack.config.js index b2d00c4e4..055f562e5 100644 --- a/packages/browser-pyright/webpack.config.js +++ b/packages/browser-pyright/webpack.config.js @@ -21,6 +21,9 @@ module.exports = async (_, { mode }) => { entry: { pyright: './src/worker.ts', }, + optimization: { + minimize: mode === 'production', + }, output: { filename: '[name].worker.js', path: outPath,