errlens-cli 0.1.0__py3-none-any.whl

errlens/conpty_runner.py

@@ -0,0 +1,269 @@
+"""Windows terminal frontend, with a bounded, disposable ConPTY owner.
+
+run_session is the private headless harness used by integration tests. The CLI
+requires real console handles; redirected users keep the default pipe transport.
+"""
+
+from collections.abc import Callable
+import json
+import os
+import queue
+import signal
+import struct
+import subprocess
+import sys
+import threading
+import time
+from typing import BinaryIO
+
+from errlens._conpty_worker import receive, send
+from errlens.capture import TerminalCapture
+from errlens.models import ExecutionContext, ExecutionResult
+from errlens.runner import RunnerError
+
+
+def run_session(context: ExecutionContext, capture: TerminalCapture, stdout: BinaryIO,
+                *, read_input: Callable[[], bytes | None] = lambda: None,
+                get_size: Callable[[], tuple[int, int]] = lambda: (80, 24)) -> ExecutionResult:
+    """Run once; callbacks are nonblocking, sizes are (columns, rows)."""
+    if sys.platform != "win32":
+        raise RunnerError("unsupported", "ConPTY requires Windows")
+    if threading.current_thread() is not threading.main_thread():
+        raise RunnerError("conpty", "ConPTY mode must run on the main thread")
+    process: subprocess.Popen[bytes] | None = None
+    incoming: queue.Queue[tuple[bytes, bytes] | Exception] = queue.Queue(16)
+    outgoing: queue.Queue[tuple[bytes, bytes]] = queue.Queue(16)
+    stop = threading.Event()
+    interrupted = False
+    previous = signal.getsignal(signal.SIGINT)
+    threads: list[threading.Thread] = []
+
+    def on_interrupt(signum: int, frame: object) -> None:
+        nonlocal interrupted
+        interrupted = True
+
+    def publish(item: tuple[bytes, bytes] | Exception) -> None:
+        while not stop.is_set():
+            try:
+                incoming.put(item, timeout=0.05)
+                return
+            except queue.Full:
+                pass
+
+    def reader(stream: BinaryIO) -> None:
+        try:
+            while not stop.is_set():
+                publish(receive(stream))
+        except Exception as exc:
+            publish(exc)
+
+    def writer(stream: BinaryIO) -> None:
+        try:
+            while not stop.is_set():
+                try:
+                    kind, data = outgoing.get(timeout=0.05)
+                except queue.Empty:
+                    continue
+                send(stream, kind, data)
+        except Exception as exc:
+            publish(exc)
+
+    try:
+        size = get_size()
+        configuration = json.dumps({"command": context.command, "cwd": context.cwd,
+                                    "size": size}, ensure_ascii=False).encode("utf-8")
+        if len(configuration) > 65536 or not all(1 <= n <= 32767 for n in size):
+            raise RunnerError("conpty", "ConPTY configuration exceeds transport limits")
+        # An independent hidden console protects the owner from host Ctrl+C
+        # without inheriting CREATE_NEW_PROCESS_GROUP's ignored Ctrl+C flag.
+        # Windows venv python.exe is a redirector which starts another process.
+        # Own the real CPython process so kill()/wait() bound the actual owner.
+        # Reuse the current import path to retain editable/wheel/venv resolution.
+        bootstrap = ("import runpy,sys;sys.path[:]=" + repr(sys.path) +
+                     ";runpy.run_module('errlens._conpty_worker',run_name='__main__')")
+        executable = getattr(sys, "_base_executable", sys.executable)
+        process = subprocess.Popen([executable, "-c", bootstrap],
+                                   stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                                   stderr=subprocess.DEVNULL, bufsize=0, shell=False,
+                                   creationflags=subprocess.CREATE_NO_WINDOW)
+        assert process.stdin is not None and process.stdout is not None
+        threads = [threading.Thread(target=reader, args=(process.stdout,), daemon=True),
+                   threading.Thread(target=writer, args=(process.stdin,), daemon=True)]
+        for thread in threads:
+            thread.start()
+        outgoing.put_nowait((b"C", configuration))
+        signal.signal(signal.SIGINT, on_interrupt)
+        ready = False
+        status: int | None = None
+        deadline: float | None = time.monotonic() + 15  # bounded startup, not execution
+        cancel_at: float | None = None
+        while True:
+            now = time.monotonic()
+            if deadline is not None and now > deadline:
+                raise RunnerError("conpty", "ConPTY startup/cleanup timed out")
+            if interrupted and cancel_at is None:
+                cancel_at = now + 1
+                if ready and status is None:
+                    try:
+                        outgoing.put_nowait((b"I", b"\x03"))
+                    except queue.Full:
+                        pass  # blocked input still has bounded owner/tree termination
+            if cancel_at is not None and now > cancel_at:
+                return ExecutionResult(status, True, not capture.truncated)
+            if ready and status is None and not outgoing.full():
+                new_size = get_size()
+                if new_size != size:
+                    if not all(1 <= n <= 32767 for n in new_size):
+                        raise RunnerError("conpty", "Invalid host terminal size")
+                    outgoing.put_nowait((b"W", struct.pack("!HH", *new_size)))
+                    size = new_size
+                if not outgoing.full():
+                    data = read_input()
+                    if data:
+                        if len(data) > 4096:
+                            raise RunnerError("conpty", "Host input chunk exceeds 4096 bytes")
+                        outgoing.put_nowait((b"I", data))
+            try:
+                item = incoming.get(timeout=0.02)
+            except queue.Empty:
+                if process.poll() is not None and not any(t.is_alive() for t in threads[:1]):
+                    raise RunnerError("conpty", "ConPTY owner exited without a completion record")
+                continue
+            if isinstance(item, Exception):
+                raise RunnerError("conpty", str(item)) from item
+            kind, payload = item
+            if kind == b"O":
+                capture.combined.append(payload)
+                offset = 0
+                while offset < len(payload):
+                    count = stdout.write(payload[offset:])
+                    if count is None or count <= 0:
+                        raise OSError("Output stream made no progress")
+                    offset += count
+                stdout.flush()
+            elif kind == b"R":
+                ready, deadline = True, None
+            elif kind == b"S":
+                status = struct.unpack("!I", payload)[0]
+                deadline = time.monotonic() + 4
+            elif kind == b"E":
+                error = json.loads(payload)
+                raise RunnerError("conpty", error["detail"], error["code"])
+            elif kind == b"D" and status is not None:
+                return ExecutionResult(status, interrupted or status == 0xc000013a, not capture.truncated)
+            else:
+                raise RunnerError("conpty", "Invalid ConPTY owner response")
+    except BrokenPipeError as exc:
+        raise RunnerError("broken_pipe", str(exc), 141) from exc
+    except OSError as exc:
+        raise RunnerError("conpty", str(exc)) from exc
+    finally:
+        stop.set()
+        signal.signal(signal.SIGINT, previous)
+        if process is not None:
+            # Closing the owner's job kills all clients, including descendants.
+            if process.poll() is None:
+                try:
+                    process.wait(timeout=0.2)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+            try:
+                process.wait(timeout=2)
+            except subprocess.TimeoutExpired as exc:
+                raise RunnerError("cleanup", "ConPTY owner did not exit after termination") from exc
+            from errlens._conpty import cancel_thread
+            for thread in threads:
+                if thread.is_alive() and thread.native_id is not None:
+                    cancel_thread(thread.native_id)
+                thread.join(0.5)
+            for stream in (process.stdin, process.stdout):
+                if stream is not None:
+                    stream.close()
+
+
+def run(context: ExecutionContext, capture: TerminalCapture, stdout: BinaryIO,
+        *, input_fd: int = 0) -> ExecutionResult:
+    """Attach only to actual Windows console handles, restoring both modes."""
+    if sys.platform != "win32":
+        raise RunnerError("unsupported", "ConPTY requires Windows")
+    import ctypes as c
+    from ctypes import wintypes as w
+    import msvcrt
+    from errlens._conpty import api, cancel_thread, check, get_mode, screen_info, SCREEN, set_mode
+    try:
+        input_handle = msvcrt.get_osfhandle(input_fd)
+        output_handle = msvcrt.get_osfhandle(stdout.fileno())
+        input_mode, output_mode = w.DWORD(), w.DWORD()
+        if not get_mode(input_handle, c.byref(input_mode)) or not get_mode(output_handle, c.byref(output_mode)):
+            raise RunnerError("conpty", "ConPTY requires console stdin and stdout; use pipe for redirection")
+    except (OSError, ValueError) as exc:
+        raise RunnerError("conpty", str(exc)) from exc
+    if threading.current_thread() is not threading.main_thread():
+        raise RunnerError("conpty", "ConPTY mode must run on the main thread")
+    inputs: queue.Queue[bytes | Exception] = queue.Queue(16)
+    stop = threading.Event()
+    read_console = api("ReadConsoleW", w.BOOL, [w.HANDLE, w.LPVOID, w.DWORD, c.POINTER(w.DWORD), w.LPVOID])
+
+    def read_host() -> None:
+        try:
+            pending = b""
+            while not stop.is_set():
+                buffer, count = c.create_unicode_buffer(512), w.DWORD()
+                check(read_console(input_handle, buffer, 512, c.byref(count), None))
+                # A read can split a UTF-16 surrogate pair.
+                pending += c.string_at(c.addressof(buffer), count.value * 2)
+                if pending and 0xd800 <= int.from_bytes(pending[-2:], "little") <= 0xdbff:
+                    text, pending = pending[:-2], pending[-2:]
+                else:
+                    text, pending = pending, b""
+                data = text.decode("utf-16-le", errors="replace").encode("utf-8")
+                while not stop.is_set():
+                    try:
+                        inputs.put(data, timeout=0.05)
+                        break
+                    except queue.Full:
+                        pass
+        except Exception as exc:
+            if not stop.is_set():
+                try:
+                    inputs.put_nowait(exc)
+                except queue.Full:
+                    pass
+
+    def read_input() -> bytes | None:
+        try:
+            value = inputs.get_nowait()
+        except queue.Empty:
+            return None
+        if isinstance(value, Exception):
+            raise RunnerError("conpty_input", str(value)) from value
+        return value
+
+    def get_size() -> tuple[int, int]:
+        info = SCREEN()
+        check(screen_info(output_handle, c.byref(info)))
+        left, top, right, bottom = info.window
+        return right - left + 1, bottom - top + 1
+
+    thread: threading.Thread | None = None
+    try:
+        check(set_mode(output_handle, output_mode.value | 4))  # VT output
+        check(set_mode(input_handle, (input_mode.value & ~(1 | 2 | 4 | 0x40)) | 0x280))
+        thread = threading.Thread(target=read_host, daemon=True)
+        thread.start()
+        return run_session(context, capture, stdout, read_input=read_input, get_size=get_size)
+    except OSError as exc:
+        raise RunnerError("conpty", str(exc)) from exc
+    finally:
+        stop.set()
+        if thread is not None:
+            if thread.native_id is not None:
+                cancel_thread(thread.native_id)
+            thread.join(0.5)
+        # Restore modes even after a launch, forwarding or cleanup failure.
+        restored_input = set_mode(input_handle, input_mode)
+        restored_output = set_mode(output_handle, output_mode)
+        if not restored_input or not restored_output:
+            raise RunnerError("cleanup", "Could not restore Windows console modes")
+        if thread is not None and thread.is_alive():
+            raise RunnerError("cleanup", "Could not cancel Windows console input")

errlens/i18n.py

@@ -0,0 +1,61 @@
+"""Installed-package JSON catalogs with simple, validated named placeholders."""
+
+import json
+from importlib.resources import files
+from string import Formatter
+
+from errlens.models import Parameter
+
+DEFAULT_LOCALE = "ru"
+SUPPORTED_LOCALES = ("ru", "en")
+
+
+def validate_template(template: str) -> frozenset[str]:
+    """Accept {name} fields and escaped braces, reject expressions/specifiers."""
+    names: set[str] = set()
+    for _, name, specification, conversion in Formatter().parse(template):
+        if name is None:
+            continue
+        if not name.isidentifier() or specification or conversion:
+            raise ValueError(f"Invalid named placeholder in template: {template!r}")
+        names.add(name)
+    return frozenset(names)
+
+
+def load_catalog(locale: str) -> dict[str, str]:
+    """Load and validate one supported catalog, without filesystem cwd lookup."""
+    if locale not in SUPPORTED_LOCALES:
+        raise ValueError(f"Unsupported locale: {locale}")
+    resource = files("errlens").joinpath("locales", f"{locale}.json")
+    data: object = json.loads(resource.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise ValueError("Translation catalog must be an object")
+    catalog: dict[str, str] = {}
+    for key, value in data.items():
+        if not isinstance(key, str) or not key or not isinstance(value, str):
+            raise ValueError("Translation keys must be nonempty strings and values strings")
+        validate_template(value)
+        catalog[key] = value
+    return catalog
+
+
+class Translator:
+    """Fallback: selected locale -> Russian -> literal key.
+
+    Unsupported locales and missing template parameters raise ValueError.
+    A missing key is returned literally, without formatting untrusted key text.
+    """
+
+    def __init__(self, locale: str = DEFAULT_LOCALE) -> None:
+        self.locale = locale
+        self._catalog = load_catalog(locale)
+        self._fallback = load_catalog(DEFAULT_LOCALE)
+
+    def translate(self, key: str, **parameters: Parameter) -> str:
+        template = self._catalog.get(key, self._fallback.get(key))
+        if template is None:
+            return key
+        missing = validate_template(template).difference(parameters)
+        if missing:
+            raise ValueError(f"Missing translation parameters: {', '.join(sorted(missing))}")
+        return template.format_map(parameters)

errlens/locales/en.json

@@ -0,0 +1,96 @@
+{
+  "cli.description": "ErrLens — local Python error explanations after command execution.",
+  "cli.run_help": "Run a program and explain recognized Python errors. Place ErrLens options before COMMAND.",
+  "cli.runner_error": "ErrLens | Execution failure ({kind}): {detail}",
+  "cli.run_pending": "Command execution and error analysis are not implemented yet. They are planned for later stages.",
+  "cli.version": "ErrLens {version}",
+  "cli.postprocess_error": "ErrLens | Could not prepare an explanation ({kind}). Original output was preserved.",
+  "render.header": "ErrLens · Error detected",
+  "render.original": "Python message: {message}",
+  "render.file": "Traceback location: {path}",
+  "render.line": "Line: {line}",
+  "render.incomplete": "Incomplete diagnostic: the exact cause cannot be established.",
+  "render.possible": "Possible causes:",
+  "render.actions": "What you can do:",
+  "render.condition": "Condition:",
+  "render.command": "Command to run manually ({shell}):",
+  "render.related": "Earlier linked exceptions:",
+  "render.chain.context": "The final exception occurred while handling the preceding exception.",
+  "render.chain.cause": "Python explicitly linked the final exception to its predecessor with raise … from ….",
+  "render.other": "Other diagnostics: {count}. They are not identified as causes of this error.",
+  "render.more": "Further linked exceptions: {count}. See the original traceback.",
+  "command.install_condition": "Only if requests is a required third-party dependency and is missing from this interpreter. Installation may not help for a local module or a different environment. ErrLens does not execute this command.",
+  "detail.module_name": "Module reported: {module_name}",
+  "detail.import_name": "Imported name: {import_name}",
+  "detail.name": "Undefined name: {name}",
+  "detail.attribute_name": "Requested attribute: {attribute_name}",
+  "detail.key_repr": "Key reported: {key_repr}",
+  "detail.file_path": "Path reported: {file_path}",
+  "python.module_not_found.title": "Module unavailable",
+  "python.module_not_found.description": "Python could not find the requested module in the current import environment.",
+  "python.module_not_found.cause": "The module may be local, belong to another environment, or be absent from the import search path.",
+  "python.module_not_found.action": "Check the selected Python, active virtual environment, module spelling and local package layout.",
+  "python.module_not_found.condition": "Install only a confirmed third-party dependency; an import name is not always a distribution name.",
+  "python.import_error.title": "Import failed",
+  "python.import_error.description": "Python could not complete an import operation.",
+  "python.import_error.cause": "Circular imports, an incompatible dependency version or an unavailable exported name.",
+  "python.import_error.action": "Compare the imported name with the installed version's API and inspect imports between the modules.",
+  "python.import_error.condition": "The exception alone does not establish that a library is uninstalled.",
+  "python.syntax_error.title": "Invalid syntax",
+  "python.syntax_error.description": "Python could not parse the source code.",
+  "python.syntax_error.cause": "Unclosed brackets or quotes, a missing colon, or syntax from another Python version.",
+  "python.syntax_error.action": "Inspect the pointer and nearby lines: detection can occur after the actual mistake.",
+  "python.syntax_error.condition": "Check the code against the Python version that runs the program.",
+  "python.indentation_error.title": "Invalid indentation",
+  "python.indentation_error.description": "Indentation does not match Python's block structure.",
+  "python.indentation_error.cause": "An unexpected indent, a missing block body or an inconsistent nesting level.",
+  "python.indentation_error.action": "Compare the reported line with adjacent blocks and enable visible whitespace in your editor.",
+  "python.indentation_error.condition": "Adjust indentation to match the intended nesting, not just the pointer position.",
+  "python.tab_error.title": "Inconsistent tabs and spaces",
+  "python.tab_error.description": "Python detected inconsistent use of tabs and spaces in indentation.",
+  "python.tab_error.cause": "Visually similar indentation can represent different nesting levels.",
+  "python.tab_error.action": "Show whitespace characters and make indentation consistent throughout the affected block.",
+  "python.tab_error.condition": "Check the intended nesting before replacing tabs.",
+  "python.name_error.title": "Undefined name",
+  "python.name_error.description": "Python could not find a name in the available scope.",
+  "python.name_error.cause": "A typo, access before a definition, or use outside the defining scope.",
+  "python.name_error.action": "Check the spelling, definition and scope of the variable or function.",
+  "python.name_error.condition": "The definition must run before access along the execution path actually taken.",
+  "python.type_error.title": "Unsupported types or arguments",
+  "python.type_error.description": "Python could not apply an operation or call a function with the supplied values.",
+  "python.type_error.cause": "Incompatible operand types, an incorrect argument count or an unsupported operation.",
+  "python.type_error.action": "Compare the value types and the function signature with the original message.",
+  "python.type_error.condition": "Convert values only when it matches their meaning; there is no universal conversion fix.",
+  "python.attribute_error.title": "Attribute unavailable",
+  "python.attribute_error.description": "The object does not provide the requested attribute or could not return it.",
+  "python.attribute_error.cause": "A typo, an unexpected object type or a version-specific API difference.",
+  "python.attribute_error.action": "Check the actual object type, attribute spelling and API documentation.",
+  "python.attribute_error.condition": "If the value is None, first establish why it was returned; adding a guard may not fix the cause.",
+  "python.key_error.title": "Key unavailable",
+  "python.key_error.description": "A requested key is absent from a dictionary-like structure, or its implementation reported that condition with KeyError.",
+  "python.key_error.cause": "Unexpected input data or a mismatch in the key's value or type.",
+  "python.key_error.action": "Inspect the structure and key membership; consider get() or an explicit membership check.",
+  "python.key_error.condition": "A fallback value is appropriate only when a missing key is allowed by the program's logic.",
+  "python.file_not_found.title": "File or path component not found",
+  "python.file_not_found.description": "The operating system could not find an object required by a file operation.",
+  "python.file_not_found.cause": "An incorrect path, a different working directory or a missing parent directory.",
+  "python.file_not_found.action": "Check the path, current working directory and existence of the required file or directory.",
+  "python.file_not_found.condition": "Create the object only if the program expects it; a traceback source location is not necessarily the missing path.",
+  "python.permission_error.title": "Access denied",
+  "python.permission_error.description": "The operating system refused an operation on a resource.",
+  "python.permission_error.cause": "Access restrictions, a read-only resource or a lock held by another program.",
+  "python.permission_error.action": "Check the path, requested operation and current user's permissions; check whether the resource is in use.",
+  "python.permission_error.condition": "Change access only for the required resource within your authority; administrator privileges are not a universal fix.",
+  "python.unknown.title": "Recognized exception: {error_type}",
+  "python.unknown.description": "No verified explanation is available for this type yet. The original message is reported as a fact.",
+  "python.unknown.action": "Inspect the original message and documentation for the component that raised the exception.",
+  "python.unknown.condition": "The available data does not establish a specific cause or fix.",
+  "python.incomplete.title": "Insufficient diagnostic data",
+  "python.incomplete.description": "An incomplete or damaged Python diagnostic fragment was detected ({error_type}).",
+  "python.incomplete.action": "Obtain the full traceback; for truncated capture, increase the Capture API limit and retry only if rerunning is appropriate.",
+  "python.incomplete.condition": "The incomplete fragment does not establish a cause or a corrective command.",
+  "python.exception_group.title": "Exception group",
+  "python.exception_group.description": "Python reported a group of exceptions. The analyzer retained only the outer level.",
+  "python.exception_group.action": "Inspect the nested exceptions in the original traceback and investigate them individually.",
+  "python.exception_group.condition": "Nested exceptions may have different causes; there is no single fix for the entire group."
+}

errlens/locales/ru.json

@@ -0,0 +1,96 @@
+{
+  "cli.description": "ErrLens — локальные объяснения Python-ошибок после выполнения команды.",
+  "cli.run_help": "Запустить программу и объяснить распознанную Python-ошибку. Опции ErrLens указываются перед COMMAND.",
+  "cli.runner_error": "ErrLens | Ошибка выполнения ({kind}): {detail}",
+  "cli.run_pending": "Запуск команд и анализ ошибок ещё не реализованы. Они появятся на следующих этапах.",
+  "cli.version": "ErrLens {version}",
+  "cli.postprocess_error": "ErrLens | Не удалось подготовить объяснение ({kind}). Исходный вывод сохранён.",
+  "render.header": "ErrLens · Обнаружена ошибка",
+  "render.original": "Сообщение Python: {message}",
+  "render.file": "Расположение в traceback: {path}",
+  "render.line": "Строка: {line}",
+  "render.incomplete": "Диагностика неполная: точную причину установить нельзя.",
+  "render.possible": "Возможные причины:",
+  "render.actions": "Что можно сделать:",
+  "render.condition": "Условие:",
+  "render.command": "Команда для ручного запуска ({shell}):",
+  "render.related": "Предшествующие связанные исключения:",
+  "render.chain.context": "Итоговое исключение возникло при обработке предыдущего.",
+  "render.chain.cause": "Python явно связал итоговое исключение с предыдущим через raise … from ….",
+  "render.other": "Других диагностик: {count}. Они не объявляются причинами этой ошибки.",
+  "render.more": "Ещё связанных исключений: {count}. См. исходный traceback.",
+  "command.install_condition": "Только если requests — нужная сторонняя зависимость проекта и она отсутствует именно у этого интерпретатора. Для локального модуля или другого окружения установка может не помочь. Команда не выполняется ErrLens.",
+  "detail.module_name": "Модуль из сообщения: {module_name}",
+  "detail.import_name": "Импортируемое имя: {import_name}",
+  "detail.name": "Неопределённое имя: {name}",
+  "detail.attribute_name": "Запрошенный атрибут: {attribute_name}",
+  "detail.key_repr": "Ключ из сообщения: {key_repr}",
+  "detail.file_path": "Путь из сообщения: {file_path}",
+  "python.module_not_found.title": "Модуль недоступен",
+  "python.module_not_found.description": "Python не смог найти запрошенный модуль в используемом окружении.",
+  "python.module_not_found.cause": "Модуль может быть локальным, находиться в другом окружении или отсутствовать в пути поиска.",
+  "python.module_not_found.action": "Проверьте выбранный Python, активное виртуальное окружение, имя модуля и структуру локальных пакетов.",
+  "python.module_not_found.condition": "Установка уместна только для подтверждённой сторонней зависимости; имя импорта не всегда равно имени пакета.",
+  "python.import_error.title": "Импорт не выполнен",
+  "python.import_error.description": "Python не смог завершить операцию импорта.",
+  "python.import_error.cause": "Циклический импорт, несовместимая версия зависимости или отсутствие экспортируемого имени.",
+  "python.import_error.action": "Сопоставьте импортируемое имя с API установленной версии и проверьте взаимные импорты модулей.",
+  "python.import_error.condition": "Без дополнительных данных нельзя утверждать, что библиотека не установлена.",
+  "python.syntax_error.title": "Некорректный синтаксис",
+  "python.syntax_error.description": "Python не смог разобрать исходный код.",
+  "python.syntax_error.cause": "Незакрытые скобки или кавычки, пропущенное двоеточие либо синтаксис другой версии Python.",
+  "python.syntax_error.action": "Посмотрите на указатель и соседние строки: место обнаружения может следовать за самой ошибкой.",
+  "python.syntax_error.condition": "Проверяйте код для той версии Python, которой запускается программа.",
+  "python.indentation_error.title": "Нарушены отступы",
+  "python.indentation_error.description": "Отступы не соответствуют структуре блоков Python.",
+  "python.indentation_error.cause": "Лишний отступ, отсутствие тела блока или несовпадение уровня вложенности.",
+  "python.indentation_error.action": "Сравните отступ указанной строки с соседними блоками и включите отображение пробелов в редакторе.",
+  "python.indentation_error.condition": "Меняйте отступы с учётом задуманной вложенности, а не только положения указателя.",
+  "python.tab_error.title": "Неоднозначное смешение табуляции и пробелов",
+  "python.tab_error.description": "Python обнаружил несовместимое использование табуляции и пробелов в отступах.",
+  "python.tab_error.cause": "Визуально похожие отступы могут обозначать разные уровни вложенности.",
+  "python.tab_error.action": "Включите отображение непечатаемых символов и приведите отступы затронутого блока к единому виду.",
+  "python.tab_error.condition": "Перед заменой табуляции проверьте задуманную вложенность блока.",
+  "python.name_error.title": "Имя не определено",
+  "python.name_error.description": "Python не нашёл имя в доступной области видимости.",
+  "python.name_error.cause": "Опечатка, обращение до объявления или использование имени вне его области видимости.",
+  "python.name_error.action": "Проверьте написание имени, место объявления и область видимости переменной или функции.",
+  "python.name_error.condition": "Объявление должно быть выполнено до обращения по той ветке программы, которая действительно запускается.",
+  "python.type_error.title": "Операция получила неподходящий тип или аргументы",
+  "python.type_error.description": "Python не смог применить операцию или вызвать функцию с переданными значениями.",
+  "python.type_error.cause": "Несовместимые типы операндов, неверное число аргументов или неподдерживаемая операция.",
+  "python.type_error.action": "Сверьте типы значений и сигнатуру вызываемой функции с исходным сообщением.",
+  "python.type_error.condition": "Преобразуйте типы только если это соответствует смыслу данных; универсального преобразования нет.",
+  "python.attribute_error.title": "Атрибут недоступен",
+  "python.attribute_error.description": "Объект не предоставляет запрошенный атрибут или не смог вернуть его.",
+  "python.attribute_error.cause": "Опечатка, неожиданный тип объекта или отличия API используемой версии.",
+  "python.attribute_error.action": "Проверьте фактический тип объекта, написание атрибута и документацию его API.",
+  "python.attribute_error.condition": "Если объект оказался None, сначала выясните, почему он получен; добавление проверки не всегда исправляет причину.",
+  "python.key_error.title": "Ключ недоступен",
+  "python.key_error.description": "Запрошенный ключ отсутствует в словаре или аналогичной структуре либо реализация сообщила об этом через KeyError.",
+  "python.key_error.cause": "Неожиданное содержимое данных или несовпадение значения и типа ключа.",
+  "python.key_error.action": "Проверьте содержимое структуры и наличие ключа; рассмотрите get() или явную проверку принадлежности.",
+  "python.key_error.condition": "Безопасный доступ с запасным значением уместен только если отсутствие ключа допустимо по логике программы.",
+  "python.file_not_found.title": "Файл или компонент пути не найден",
+  "python.file_not_found.description": "Операционная система не нашла объект, необходимый для файловой операции.",
+  "python.file_not_found.cause": "Неверный путь, другая рабочая директория или отсутствие одного из родительских каталогов.",
+  "python.file_not_found.action": "Проверьте путь, текущую рабочую директорию и наличие нужного файла или каталога.",
+  "python.file_not_found.condition": "Создавайте объект только если это предусмотрено программой; существующий путь из traceback может указывать на исходный код, а не на отсутствующий файл.",
+  "python.permission_error.title": "Отказано в доступе",
+  "python.permission_error.description": "Операционная система отказала в выполнении операции над ресурсом.",
+  "python.permission_error.cause": "Ограничения доступа, режим только для чтения или блокировка ресурса другой программой.",
+  "python.permission_error.action": "Проверьте путь, требуемую операцию и права текущего пользователя; выясните, не занят ли ресурс.",
+  "python.permission_error.condition": "Меняйте доступ только для нужного ресурса в рамках своих полномочий; запуск с правами администратора не является универсальным решением.",
+  "python.unknown.title": "Распознано исключение: {error_type}",
+  "python.unknown.description": "Для этого типа пока нет проверенного объяснения. Исходное сообщение приведено как факт.",
+  "python.unknown.action": "Изучите исходное сообщение и документацию компонента, который сформировал исключение.",
+  "python.unknown.condition": "Конкретная причина и способ исправления по доступным данным не установлены.",
+  "python.incomplete.title": "Недостаточно диагностических данных",
+  "python.incomplete.description": "Обнаружен неполный или повреждённый фрагмент Python-диагностики ({error_type}).",
+  "python.incomplete.action": "Получите полный traceback; при усечении увеличьте лимит Capture в API и повторите диагностику, если повторный запуск допустим.",
+  "python.incomplete.condition": "Причина и команды исправления по неполному фрагменту не определяются.",
+  "python.exception_group.title": "Группа исключений",
+  "python.exception_group.description": "Python сообщил о группе исключений. Анализатор сохранил только верхний уровень группы.",
+  "python.exception_group.action": "Изучите вложенные исключения в исходном traceback и разберите их по отдельности.",
+  "python.exception_group.condition": "Причины вложенных исключений могут различаться; единого исправления для всей группы нет."
+}