pyflashgui 0.2.0__tar.gz → 0.2.1__tar.gz

{pyflashgui-0.2.0/pyflashgui.egg-info → pyflashgui-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyflashgui
-Version: 0.2.0
+Version: 0.2.1
 Summary: Graphical flash programming tool: Arm Cortex-M with any probe pyOCD supports, and more through J-Link Commander
 Author: davhodg
 License-Expression: Apache-2.0
@@ -29,7 +29,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE
 Requires-Dist: PySide6-Essentials>=6.8
-Requires-Dist: pyocd>=0.45
+Requires-Dist: pyocd>=0.46
 Requires-Dist: bincopy>=20.0
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
@@ -97,6 +97,7 @@ A probe is usable without root on Linux once a udev rule allows it; pyOCD publis
 - **Workspaces**: one for each board or project, holding its probe, target, files and layout.
 - **A Python console** with the probe and the target as `flash`: read, write RAM, erase, program, verify and reset from a prompt or a script, each call waiting for its answer. *File > Run script...* runs one, and keeps the last five a click away.
 - **A simulated probe and target**, to try all of it with no hardware.
+- **Help > Diagnostics**: how the connection was made, the last operations in order and what pyOCD reported, ready to paste into a bug report.
 
 The [manual](https://github.com/davhodg/pyflashgui/blob/master/pyflashgui/help/manual.md) covers each of these, and is also under **Help > Documentation** in the application.
 

{pyflashgui-0.2.0 → pyflashgui-0.2.1}/PYPI.md

@@ -57,6 +57,7 @@ A probe is usable without root on Linux once a udev rule allows it; pyOCD publis
 - **Workspaces**: one for each board or project, holding its probe, target, files and layout.
 - **A Python console** with the probe and the target as `flash`: read, write RAM, erase, program, verify and reset from a prompt or a script, each call waiting for its answer. *File > Run script...* runs one, and keeps the last five a click away.
 - **A simulated probe and target**, to try all of it with no hardware.
+- **Help > Diagnostics**: how the connection was made, the last operations in order and what pyOCD reported, ready to paste into a bug report.
 
 The [manual](https://github.com/davhodg/pyflashgui/blob/master/pyflashgui/help/manual.md) covers each of these, and is also under **Help > Documentation** in the application.
 

{pyflashgui-0.2.0 → pyflashgui-0.2.1}/pyflashgui/__init__.py

@@ -2,5 +2,5 @@
 # SPDX-FileCopyrightText: 2026 davhodg
 """pyflashgui — a graphical flash programming tool."""
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"
 APP_NAME = "pyflashgui"  # single place to change the display name

{pyflashgui-0.2.0 → pyflashgui-0.2.1}/pyflashgui/__main__.py

@@ -89,7 +89,7 @@ def selftest() -> int:
 
     # libusb is a native library carried inside a Python package, which is
     # the kind of file a build leaves behind. Without it pyOCD lists no
-    # CMSIS-DAP v2 probe and no ST-Link, and says nothing about why.
+    # CMSIS-DAP v2 probe and no ST-Link, so the self-test checks for it.
     try:
         import libusb_package
 
@@ -160,7 +160,8 @@ def set_icon(app) -> None:
 
 #: The libraries Qt's X11 plugin needs that Debian, Ubuntu and Linux Mint can
 #: leave out, each with the package it comes in. Without one, Qt stops with
-#: "could not load the Qt platform plugin xcb" and does not say which.
+#: "could not load the Qt platform plugin xcb", so they are looked for first
+#: and the package to install is named.
 XCB_LIBRARIES = (
     ("libxcb-cursor.so.0", "libxcb-cursor0"),
     ("libxcb-icccm.so.4", "libxcb-icccm4"),

{pyflashgui-0.2.0 → pyflashgui-0.2.1}/pyflashgui/backends/base.py

@@ -197,6 +197,16 @@ class Connection(ABC):
     def close(self) -> None:
         """Let go of the probe. Safe to call twice."""
 
+    def details(self) -> list[str]:
+        """What Help > Diagnostics says of this connection, a line each.
+
+        How the backend was asked to connect and what it found there, beyond
+        the probe and the target the window already knows. Read on the
+        window's thread while the worker may be using the connection, so
+        only what is already known is said: nothing here asks the probe.
+        """
+        return []
+
     def read_range(
         self,
         address: int,

{pyflashgui-0.2.0 → pyflashgui-0.2.1}/pyflashgui/backends/jlink_backend.py

@@ -72,13 +72,14 @@ NOT_FOUND = (
 )
 
 #: Said by Commander when the probe is there and the device does not answer.
-#: Looked for as well as its exit code, which has been seen to be 0 with it.
+#: Looked for as well as its exit code, which can be 0 with it.
 NO_TARGET = "Cannot connect to target"
 
-#: A J-Link script that does nothing where SEGGER's software would set the
+#: A J-Link script that does nothing where J-Link's software would set the
 #: device up after connecting to it. On some parts that set-up writes to
 #: the device -- an S32K3's RAM is filled, for its error correction -- and
-#: a read made to see what a running program left there finds it gone.
+#: a read made to see what a running program left there finds the set-up's
+#: bytes instead.
 NO_SETUP_SCRIPT = "int SetupTarget(void) {\n  return 0;\n}\n"
 
 #: Where Commander is, when it has been said. None to go and look.
@@ -146,6 +147,20 @@ def find_commander() -> list[str] | None:
     return None
 
 
+def report() -> list[str]:
+    """For Help > Diagnostics: the Commander used, how it was found, and every
+    J-Link software folder there is, newest first."""
+    found = find_commander()
+    if found is None:
+        lines = ["not found"]
+    else:
+        how = "chosen in Tools > Settings" if _chosen is not None else "found"
+        lines = [f"{' '.join(found)} ({how})"]
+    folders = _installed()
+    lines += [f"installed: {folder}" for folder in folders] or ["no J-Link software folder found"]
+    return lines
+
+
 def _is_seggers(program: Path) -> bool:
     """Whether a program of Commander's name is Commander, and not Java's jlink.
 
@@ -407,6 +422,11 @@ class JLinkConnection(Connection):
     def regions(self) -> list[Region]:
         return list(self._regions)
 
+    def details(self) -> list[str]:
+        if self._arguments is None:
+            return ["closed"]
+        return [f"device: {self._device}", f"Commander run with: {' '.join(self._arguments)}"]
+
     def erase_chip(self) -> None:
         self._run(["H", "Erase"], WORK_S, f"Erasing {self._device}")
 
@@ -535,7 +555,10 @@ class JLinkConnection(Connection):
 
     def reset(self, halt: bool = False, kind: str = RESET_DEFAULT) -> None:
         if kind != RESET_DEFAULT:
-            raise BackendError("J-Link Commander resets each device its own way, and no other.")
+            raise BackendError(
+                "Through J-Link Commander, a device is reset the usual way only. The other "
+                "ways are offered through pyOCD."
+            )
         # R restarts the device and leaves it stopped; G sets it going.
         self._run(["R"] if halt else ["R", "G"], QUICK_S, f"Resetting {self._device}")
 
@@ -581,8 +604,8 @@ class JLinkBackend(Backend):
                 # it that is not, and latin-1 reads any byte there is.
                 text = path.read_text(encoding="latin-1")
             except (BackendError, OSError):
-                # A Commander that will not write the list still programs a
-                # device whose name is typed in.
+                # Without the list, a device whose name is typed in is still
+                # programmed.
                 text = ""
         self._devices = {device.name.upper(): device for device in parse_devices(text)}
         return self._devices

{pyflashgui-0.2.0 → pyflashgui-0.2.1}/pyflashgui/backends/pyocd_backend.py

@@ -7,7 +7,7 @@ exception said again in pyflashgui's words. Anything worth testing without a
 probe plugged in is in ``core`` or in the base class, and what is left here
 can only be tried on hardware.
 
-pyOCD is imported inside the methods that use it. It is the slowest thing
+pyOCD is imported inside the methods that use it. It is the largest thing
 pyflashgui loads, and a window should not wait for it to say which probes
 are plugged in before it can be drawn.
 """
@@ -17,6 +17,7 @@ from __future__ import annotations
 import contextlib
 import time
 from collections.abc import Sequence
+from pathlib import Path
 
 from pyflashgui.backends import pyocd_packs
 from pyflashgui.backends.base import (
@@ -90,9 +91,8 @@ def regions_of(memory_map, generic: bool = False) -> list[Region]:
 def needs_one_packet_at_a_time(*names: str | None) -> bool:
     """Whether a probe called this must be sent one command and then waited for.
 
-    pyOCD's own advice for the TI XDS110, whose firmware loses track when
-    several commands are outstanding. Set for every one of them, since it
-    is not known which versions are free of it, and the cost is only speed.
+    pyOCD's own advice for the TI XDS110: one command at a time. Set for
+    every one of them, as pyOCD advises, and the cost is only speed.
     """
     return any("xds110" in (name or "").lower() for name in names)
 
@@ -144,11 +144,11 @@ def _stages(progress: Progress) -> Progress:
 def _let_go(session) -> Exception | None:
     """Close a pyOCD session, and its probe even where closing the session fails.
 
-    pyOCD's close lets go of the target before the probe, and when the
-    first fails -- the board's power was turned off -- never closes the
-    probe. A J-Link left open that way stays open: Find probes lists it, and
-    every connect says "No emulator with serial number".
-    Returns what went wrong, if anything did.
+    Closing a session lets go of the target, then of the probe. With the
+    board's power turned off, letting go of the target raises, and the probe
+    is still open: a J-Link still open is listed by Find probes, and every
+    connect says "No emulator with serial number". So the probe is closed
+    here as well. Returns what went wrong, if anything did.
     """
     try:
         session.close()
@@ -202,6 +202,44 @@ class PyocdConnection(Connection):
         #: Makes a new session on the same probe and target, attaching to it
         #: as it is, for when a reset has taken the old one with it.
         self._reopen = reopen
+        #: The options pyOCD was given, for Help > Diagnostics.
+        self.options: dict = {}
+        #: How many times a reset took the connection with it and it was made again.
+        self.reattached = 0
+
+    def details(self) -> list[str]:
+        packs = self.options.get("pack") or []
+        given = ", ".join(f"{k}={v}" for k, v in sorted(self.options.items()) if k != "pack")
+        lines = [f"pyOCD options: {given or 'none'}"]
+        if packs:
+            lines.append(f"packs handed to pyOCD: {', '.join(Path(p).name for p in packs)}")
+        if self.reattached:
+            lines.append(f"connected again after a reset: {self.reattached} time(s)")
+        session = self._session
+        if session is None:
+            return [*lines, "session: closed"]
+        target, probe = getattr(session, "target", None), getattr(session, "probe", None)
+        if target is not None:
+            if is_generic(target):
+                where = "no device in particular: the generic Cortex-M"
+            elif "_pack_device" in vars(type(target)):
+                where = "from a pack"
+            else:
+                where = "built in"
+            lines.append(f"target class: {type(target).__name__}, {where}")
+            for core in getattr(target, "cores", {}).values():
+                architecture = getattr(getattr(core, "architecture", None), "name", "")
+                lines.append(
+                    f"core {getattr(core, 'core_number', '?')}: {getattr(core, 'name', '?')}"
+                    + (f" ({architecture})" if architecture else "")
+                )
+        if probe is not None:
+            wire = getattr(getattr(probe, "wire_protocol", None), "name", "") or "not known"
+            lines.append(
+                f"probe: {probe.description}; {type(probe).__name__}; "
+                f"{probe.vendor_name or '?'} {probe.product_name or '?'}; wire protocol {wire}"
+            )
+        return lines
 
     def _target(self):
         if self._session is None:
@@ -277,13 +315,12 @@ class PyocdConnection(Connection):
         """Reset the target and stop it at its first instruction, before a flash
         routine is run on it.
 
-        pyOCD stops the processor wherever it happens to be and runs its
-        routine there. Reported on an XMC4500 attached to its firmware as it
-        ran: stopped amid the firmware, with its interrupts and the rest of
-        what it had set up still on, the erase routine ended in a HardFault
-        (IPSR=3). Reset first, the routine runs on a device as it starts,
-        which is what flash routines are written for, and what SEGGER's own
-        download does.
+        A flash routine runs on the processor as it is when stopped.
+        Reported on an XMC4500 attached to its firmware as it ran: stopped
+        amid the firmware, with its interrupts and the rest of what it had set
+        up still on, the erase routine ended in a HardFault (IPSR=3). Reset
+        first, the routine runs on a device as it starts, which is what flash
+        routines are written for.
         """
         try:
             self._target().reset_and_halt()
@@ -328,9 +365,8 @@ class PyocdConnection(Connection):
                     progress((before + fraction * size) / total)
 
                 # keep_unwritten: the rest of a page written to is read and
-                # written back as it is. Filled instead with what pyOCD takes
-                # erased flash to read as, it would be written to: pyOCD
-                # says FF for an XMC4500, whose erased flash reads 00.
+                # written back as it is, so it holds what it held, whatever
+                # erased flash reads as on this device.
                 builder.program(progress_cb=report, smart_flash=False, keep_unwritten=True)
                 written += size
         except BackendError:
@@ -416,6 +452,7 @@ class PyocdConnection(Connection):
             time.sleep(wait)
             try:
                 self._session = self._reopen()
+                self.reattached += 1
                 break
             except BackendError as exc:
                 failed = exc
@@ -444,7 +481,7 @@ class PyocdConnection(Connection):
 
 class PyocdBackend(Backend):
     # pyOCD's own, whatever the probe could do: 1 MHz, chosen to work with
-    # a long or untidy cable, and slow for anything else.
+    # a long or untidy cable. A faster one can be chosen in the bar.
     default_speed = "Default (1 MHz)"
     can_skip_erase = True
     can_attach = True
@@ -587,6 +624,7 @@ class PyocdBackend(Backend):
         connection = PyocdConnection(session, lambda: self._open(chosen, again, target))
         connection.speed = speed_text(session.options.get("frequency"))
         connection.notes = tuple(notes)
+        connection.options = dict(options)
         return connection
 
     @staticmethod

{pyflashgui-0.2.0 → pyflashgui-0.2.1}/pyflashgui/backends/pyocd_packs.py

@@ -248,9 +248,8 @@ def read_pack(path: Path) -> tuple[Pack, tuple[tuple[str, str], ...]]:
     from xml.etree import ElementTree
 
     # By the way in pyOCD's own modules take, before the part of it wanted
-    # here. Started part way in, pyOCD can import itself in a circle, which
-    # it does not survive; and the backend may be importing it on another
-    # thread at the same moment.
+    # here: its modules are written to be imported from the top, and the
+    # backend may be importing it on another thread at the same moment.
     import pyocd.target  # noqa: F401
     from pyocd.target.pack.cmsis_pack import CmsisPack
 
@@ -263,8 +262,8 @@ def read_pack(path: Path) -> tuple[Pack, tuple[tuple[str, str], ...]]:
                     f"{path.name} is not a CMSIS-Pack: there is no description (.pdsc) in it."
                 )
             root = ElementTree.fromstring(archive.read(min(described, key=lambda n: n.count("/"))))
-            # Read through this archive, which is closed after: one pyOCD opened
-            # itself would stay open, and Windows will not delete an open file.
+            # Read through this archive, which is closed after, so the file can
+            # be removed again: Windows will not delete an open file.
             found = {
                 (d.part_number, (d.vendor or "").split(":")[0]) for d in CmsisPack(archive).devices
             }
@@ -314,6 +313,22 @@ def file_devices() -> list[Device]:
     return out
 
 
+def report() -> list[str]:
+    """For Help > Diagnostics: where the packs are, which there are, and how
+    old the list of devices is. Found from the files, without reading the
+    list itself, which is twenty megabytes."""
+    where = folder()
+    fetched = list_fetched()
+    lines = [
+        f"folder: {where}",
+        f"list of devices fetched {fetched:%Y-%m-%d %H:%M}" if fetched else "list never fetched",
+    ]
+    downloaded = sorted(p.relative_to(where).as_posix() for p in where.rglob("*.pack"))
+    lines += [f"installed: {name}" for name in downloaded] or ["none installed"]
+    lines += [f"added from a file: {p.name}" for p in sorted(files_folder().glob("*.pack"))]
+    return lines
+
+
 def same_name(part: str) -> str:
     """A device's name as pyOCD files it, whichever way it is spelt.
 

{pyflashgui-0.2.0 → pyflashgui-0.2.1}/pyflashgui/core/excepthook.py

@@ -3,9 +3,9 @@
 """Put unhandled exceptions in the Event Log instead of nowhere.
 
 pyflashgui is started with ``pythonw.exe``, which has no console. An exception
-raised inside a Qt slot does not propagate anywhere useful: PySide prints the
-traceback to a standard error stream that does not exist, the slot simply
-does not finish, and the window carries on looking perfectly healthy.
+raised inside a Qt slot is printed by PySide to standard error, which pythonw
+does not have: the slot does not finish, and the window carries on looking
+perfectly healthy.
 
 A stale call to a widget method -- ``.text()`` on what had become a combo box
 -- is enough: nothing is logged, no dialog appears, and whatever the slot was
@@ -27,10 +27,9 @@ from PySide6.QtCore import QObject, Qt, QtMsgType, Signal, Slot, qInstallMessage
 
 from pyflashgui.core.events import ERROR, INFORMATION
 
-#: Said of a Python traceback and of nothing else. Qt complains through the
-#: same handler about things that are often not pyflashgui's doing at all -- a
-#: platform plugin, a window manager -- and telling somebody those are bugs in
-#: this application is both wrong and unhelpful.
+#: Said of a Python traceback and of nothing else. Qt reports through the
+#: same handler what other parts of the system say -- a platform plugin, a
+#: window manager -- and those are not faults in this application.
 BUG = "Unhandled error (this is a bug in pyflashgui; the action it interrupted did not finish):"
 
 

{pyflashgui-0.2.0 → pyflashgui-0.2.1}/pyflashgui/core/flasher.py

@@ -16,7 +16,10 @@ from __future__ import annotations
 
 import threading
 import time
+from collections import deque
 from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from datetime import datetime
 from typing import Any
 
 from PySide6.QtCore import QObject, Signal
@@ -47,7 +50,7 @@ RESET_SAID = {
     RESET_CORE: "by restarting its processor only",
 }
 #: How long letting go of the probe is waited for when the window closes, in
-#: seconds: a library that never comes back must not keep the window frozen.
+#: seconds: a probe that does not answer must not keep the window waiting.
 CLOSE_S = 5.0
 
 
@@ -59,6 +62,30 @@ def _close_quietly(connection) -> None:
         pass
 
 
+#: How many operations are remembered for Help > Diagnostics.
+REMEMBERED = 20
+
+
+@dataclass(frozen=True)
+class Operation:
+    """One thing done, or asked for, for Help > Diagnostics to list in order."""
+
+    #: When it was asked for, as a time of day.
+    when: str
+    name: str
+    #: done, failed, cancelled, or not done as asked -- a verify that found
+    #: differences, which is not a failure of the probe.
+    outcome: str
+    #: How long it took, in seconds.
+    took: float
+    #: What it failed with, where it did, as the Event Log said it.
+    said: str = ""
+
+    def line(self) -> str:
+        why = f": {self.said.splitlines()[0]}" if self.said else ""
+        return f"{self.when} {self.name}: {self.outcome}{why}, {self.took:.1f} s"
+
+
 #: Progress is passed on when it has moved this far, and not otherwise: a
 #: library reporting every page would otherwise queue a thousand signals to
 #: move a bar a thousand times by less than a pixel.
@@ -128,6 +155,13 @@ class Flasher(QObject):
         self.regions: list[Region] = []
         self._regions_for = ""
         self.busy = False
+        #: What is being done while busy: "Programming". Empty otherwise.
+        self.doing = ""
+        #: The last few operations, oldest first, for Help > Diagnostics: the
+        #: order things happened in is most of what a fault report needs.
+        self.history: deque[Operation] = deque(maxlen=REMEMBERED)
+        #: The probes found when they were last looked for.
+        self.probes_found: list = []
         self._cancel = threading.Event()
         self._worker = Worker(self)
         self._last_progress = -1.0
@@ -156,14 +190,19 @@ class Flasher(QObject):
             if self.busy:
                 self.events.warning(f"{name} was not started: something else is still running.")
                 return False
+            self.doing = name
             self._set_busy(True)
             self._cancel.clear()
             self._last_progress = -1.0
+        asked, started = f"{datetime.now():%H:%M:%S}", time.monotonic()
+
+        def remember(outcome: str, said: str = "") -> None:
+            took = time.monotonic() - started
+            self.history.append(Operation(asked, name, outcome, took, said))
 
         def job() -> tuple[Any, str | None, bool]:
             # A backend's own error is a sentence already and is passed on as
-            # one. Anything else is a fault in pyflashgui or in a library,
-            # and says what kind it was.
+            # one. Anything else was not expected, and says what kind it was.
             try:
                 return work(), None, False
             except CancelledError as exc:
@@ -176,13 +215,16 @@ class Flasher(QObject):
             if error is None:
                 result, error, cancelled = result
             if not quiet:
+                self.doing = ""
                 self._set_busy(False)
             if error is not None:
+                remember("cancelled" if cancelled else "failed", error)
                 (self.events.warning if cancelled else self.events.error)(error)
                 if not quiet:
                     self.finished.emit(name, False)
                 return
             ok = done(result)
+            remember("done" if ok is not False else "not done as asked")
             if not quiet:
                 self.finished.emit(name, ok is not False)
 
@@ -243,6 +285,7 @@ class Flasher(QObject):
 
         def done(result: tuple[list, str]) -> None:
             probes, error = result
+            self.probes_found = list(probes)
             if error:
                 self.events.warning(error)
             self.probes_changed.emit(probes)

pyflashgui-0.2.1/pyflashgui/core/library_log.py

@@ -0,0 +1,96 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2026 davhodg
+"""What pyOCD and pylink say for themselves, kept for Help > Diagnostics.
+
+Both write to Python's logging rather than raising everything they have to
+say: a probe that did not answer on disconnecting, a flash routine that
+reported a fault, the parts of the debug port found on connecting. With no
+handler of their own those lines went to a console pyflashgui started with
+pythonw does not have, and were lost.
+
+So the last of them are kept, from information up, for the diagnostics
+report -- which is where the question "what did pyOCD make of this target?"
+is answered -- and errors are passed to the Event Log as they happen.
+Warnings are only kept: pyOCD gives several on an ordinary connection to
+some targets, and an Event Log that opens itself for those would soon be
+closed and not opened again.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections import deque
+from datetime import datetime
+
+from pyflashgui.core.events import EventLog
+
+#: The loggers listened to, and what each library is called when it is named.
+LIBRARIES = {"pyocd": "pyOCD", "pylink": "pylink"}
+#: How many lines are kept for the report.
+KEPT = 100
+
+
+def library_of(logger_name: str) -> str:
+    """The library a logger belongs to, as it is written: pyocd.coresight.ap is pyOCD."""
+    return LIBRARIES.get(logger_name.split(".")[0], logger_name)
+
+
+def text_of(record: logging.LogRecord) -> str:
+    """The line a record says, with the exception it carries where it adds anything."""
+    try:
+        text = record.getMessage()
+    except Exception:  # a library's own mistake in its format string
+        text = str(record.msg)
+    if record.exc_info and (exc := record.exc_info[1]) is not None:
+        said = str(exc).strip() or type(exc).__name__
+        if said not in text:
+            text = f"{text.rstrip(':')}: {said}" if text else said
+    return text.strip()
+
+
+class LibraryLog(logging.Handler):
+    """Keeps what the libraries said, and passes their errors to the Event Log.
+
+    Called on whichever thread the library was on -- usually the worker
+    talking to the probe -- which is safe for both: a deque appends from any
+    thread, and the Event Log crosses to the window's thread itself.
+    """
+
+    def __init__(self, events: EventLog, kept: int = KEPT) -> None:
+        super().__init__(logging.INFO)
+        self.events = events
+        #: (time, level, library, text), oldest first.
+        self.recent: deque[tuple[str, str, str, str]] = deque(maxlen=kept)
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            library, text = library_of(record.name), text_of(record)
+            self.recent.append(
+                (f"{datetime.now():%H:%M:%S}", record.levelname.lower(), library, text)
+            )
+            if record.levelno >= logging.ERROR:
+                self.events.error(f"{library}: {text}")
+        except Exception:
+            # Nothing a library says may stop it doing what it was doing, and
+            # a handler that fails would be reported through logging again.
+            pass
+
+    def lines(self) -> list[str]:
+        return [f"{when} {library} {level}: {text}" for when, level, library, text in self.recent]
+
+    def install(self) -> None:
+        """Listen to the libraries, from information up.
+
+        Their loggers are left at information once set there: one handler
+        removed and another added, as when a workspace is opened in a new
+        window, must not leave the next listening to less.
+        """
+        for name in LIBRARIES:
+            logger = logging.getLogger(name)
+            if logger.getEffectiveLevel() > logging.INFO:
+                logger.setLevel(logging.INFO)
+            logger.addHandler(self)
+
+    def remove(self) -> None:
+        for name in LIBRARIES:
+            logging.getLogger(name).removeHandler(self)

{pyflashgui-0.2.0 → pyflashgui-0.2.1}/pyflashgui/core/memory_map.py

@@ -46,8 +46,8 @@ class Region:
     #: show the same flash at several addresses and take writes at only one.
     alias_of: str = ""
     #: What a byte of this flash reads as once erased, as far as the backend
-    #: knows: FF for most devices, 00 for some. Not to be relied on -- pyOCD
-    #: says FF for an XMC4500, whose erased flash reads 00.
+    #: knows: FF for most devices, 00 for some, an XMC4500 among them. FF
+    #: where nothing says, so a Memory pane lets it be chosen as well.
     erased: int = 0xFF
 
     @property

{pyflashgui-0.2.0 → pyflashgui-0.2.1}/pyflashgui/core/worker.py

@@ -56,8 +56,7 @@ class Worker(QThread):
 
         The ``done`` connection is dropped first: a queued result arriving
         after the owner has been torn down would be delivered to a dead
-        object, which Qt punishes with an access violation rather than an
-        exception.
+        object, which ends in an access violation rather than an exception.
         """
         if self._delivering:
             self._delivering = False

{pyflashgui-0.2.0 → pyflashgui-0.2.1}/pyflashgui/help/about.md

@@ -4,7 +4,31 @@
 
 **Help > Documentation** opens this manual. It ships inside pyflashgui; *Back* and *Contents* get you around it.
 
-**Help > Diagnostics...** writes a report of the versions of pyflashgui, Python and every package it runs on, and any panes out on their own, to the Event Log and copies it to the clipboard -- ready to paste into a bug report.
+**Help > Diagnostics...** opens a report in a window of its own, and copies it to the
+clipboard as it opens -- ready to paste into a bug report. **Refresh** makes it again,
+**Copy** copies it again and **Save...** writes it to a file. It gives:
+
+- the versions of pyflashgui, Python and every package it runs on;
+- **the connection**: what is chosen under Using, Probe, Target and Speed, what is
+  connected, and whether anything is being done; through pyOCD, the options pyOCD was
+  given, whether the target is built in, from a pack or the generic Cortex-M, its cores and
+  the probe's wire protocol; through J-Link Commander, how Commander is run;
+- the probes found when they were last looked for;
+- the target's memory as pyflashgui has it, and what the memory map says of the files
+  ticked;
+- each entry in the Files pane, and the Memory panes open;
+- **the last twenty operations**, in order -- connecting, erasing, programming, reading,
+  resetting -- each with how it ended and how long it took;
+- **what pyOCD and pylink said for themselves**: their last hundred lines, from information
+  up. Their errors are also put in the Event Log as they happen;
+- the last twenty warnings and errors from the Event Log;
+- J-Link Commander's location and every J-Link software folder found, and pyOCD's packs;
+- the workspace, any confirmation not being asked, and the threads running;
+- the panes out on their own, and how long starting took.
+
+A part of it that cannot be read says so and the rest is still given. It names the probes'
+serial numbers, the workspace folder and the files in the Files pane: remove any of that
+from a bug report if you would rather.
 
 The report names the version, and -- when pyflashgui is being run from a source checkout rather than an installed build -- the branch or tag and the commit it is on, read from `.git` without running git. Between two releases every build calls itself the same version, so that line is what tells one pull from another. It does not say whether any file has been edited since: that needs git itself, and the launcher runs without a console for it to use.
 
@@ -16,6 +40,6 @@ The report names the version, and -- when pyflashgui is being run from a source
 
 ## If pyflashgui will not start
 
-Started from the source folder, `pyflashgui.cmd` and `pyflashgui.sh` install anything missing before they start pyflashgui, and a library that is still missing is reported in a window rather than as nothing happening. The entry made by *Tools > Settings > Add shortcut to Start menu* (*Add shortcut to applications menu* on Linux), or by *Add shortcut to desktop* on Windows, starts the launcher too, so starting from it after a pull does the same. Installed with pip, the same two make a shortcut that starts pyflashgui with the Python it is installed in. The first start says where they are in the Event Log; the launchers ask nothing. On Linux, a library Qt needs to draw the window is named, with the package it comes in, before Qt is started: Qt itself says only that it could not load the "xcb" plugin. `python -m pyflashgui --selftest` imports everything a build is most likely to be missing, checks that pyOCD can find its probe drivers and targets, and exits with 0 if it is all there, which is how the build checks itself.
+Started from the source folder, `pyflashgui.cmd` and `pyflashgui.sh` install anything missing before they start pyflashgui, and a library that is still missing is reported in a window rather than as nothing happening. The entry made by *Tools > Settings > Add shortcut to Start menu* (*Add shortcut to applications menu* on Linux), or by *Add shortcut to desktop* on Windows, starts the launcher too, so starting from it after a pull does the same. Installed with pip, the same two make a shortcut that starts pyflashgui with the Python it is installed in. The first start says where they are in the Event Log; the launchers ask nothing. On Linux, a library Qt needs to draw the window is looked for before Qt is started, and one that is missing is named with the package it comes in. `python -m pyflashgui --selftest` imports everything a build is most likely to be missing, checks that pyOCD can find its probe drivers and targets, and exits with 0 if it is all there, which is how the build checks itself.
 
 **If pyflashgui is slow to start**, the diagnostics report says where the seconds went: starting is measured on every run, step by step and package by package, so the breakdown is already there when somebody thinks to ask. A start that takes longer than usual says so in the Event Log and points to *Help > Diagnostics*. The first start after an update is the usual one: Python compiles every changed file again, and that start says how many it compiled. To have the whole report in the Event Log after every start, and in `startup-timing.txt` in pyflashgui's own folder, start pyflashgui with `--timing` -- `pyflashgui.cmd --timing`, or `pyflashgui.sh --timing` -- or set `PYFLASHGUI_TIMING=1`.