Index: python-pyvista/doc/source/conf.py =================================================================== --- python-pyvista.orig/doc/source/conf.py 2026-01-30 19:08:44.499329438 +0100 +++ python-pyvista/doc/source/conf.py 2026-01-30 19:08:44.493480646 +0100 @@ -262,6 +262,7 @@ (r'py:.*', '.*Trimesh'), (r'py:.*', 'networkx.*'), (r'py:.*', 'Rotation'), + (r'py:.*', '.*VtkEvent'), (r'py:.*', 'vtk.*'), (r'py:.*', '_vtk.*'), (r'py:.*', 'VTK'), Index: python-pyvista/pyvista/core/__init__.py =================================================================== --- python-pyvista.orig/pyvista/core/__init__.py 2026-01-30 19:08:44.499329438 +0100 +++ python-pyvista/pyvista/core/__init__.py 2026-01-30 19:08:44.493756707 +0100 @@ -23,6 +23,8 @@ from .errors import PyVistaEfficiencyWarning as PyVistaEfficiencyWarning from .errors import PyVistaFutureWarning as PyVistaFutureWarning from .errors import PyVistaPipelineError as PyVistaPipelineError +from .errors import VTKExecutionError as VTKExecutionError +from .errors import VTKExecutionWarning as VTKExecutionWarning from .errors import VTKVersionError as VTKVersionError from .filters import CompositeFilters as CompositeFilters from .filters import DataObjectFilters as DataObjectFilters Index: python-pyvista/pyvista/core/errors.py =================================================================== --- python-pyvista.orig/pyvista/core/errors.py 2026-01-30 19:08:44.499329438 +0100 +++ python-pyvista/pyvista/core/errors.py 2026-01-30 19:08:44.493909630 +0100 @@ -203,6 +203,26 @@ super().__init__(message) +class VTKExecutionError(RuntimeError): + """Exception when a VTK output message is detected. + + .. versionadded:: 0.47 + + Parameters + ---------- + message : str + Error message. + + """ + + def __init__( + self, + message='VTK output message was detected by PyVista.', + ) -> None: # numpydoc ignore=PR01,RT01 + """Call the base class constructor with the custom message.""" + super().__init__(message) + + class PyVistaDeprecationWarning(Warning): """Non-supressed Deprecation Warning.""" @@ -213,3 +233,11 @@ class PyVistaEfficiencyWarning(Warning): """Efficiency warning.""" + + +class VTKExecutionWarning(RuntimeWarning): + """Warning when a VTK output message is detected. + + .. versionadded:: 0.47 + + """ Index: python-pyvista/pyvista/core/utilities/observers.py =================================================================== --- python-pyvista.orig/pyvista/core/utilities/observers.py 2026-01-30 19:08:44.499329438 +0100 +++ python-pyvista/pyvista/core/utilities/observers.py 2026-01-30 19:09:38.073642926 +0100 @@ -10,13 +10,20 @@ import sys import threading import traceback +from typing import TYPE_CHECKING from typing import NamedTuple import pyvista from pyvista._deprecate_positional_args import _deprecate_positional_args +from pyvista._warn_external import warn_external from pyvista.core import _vtk_core as _vtk +from pyvista.core.errors import VTKExecutionError +from pyvista.core.errors import VTKExecutionWarning from pyvista.core.utilities.misc import _NoNewAttrMixin +if TYPE_CHECKING: + from typing_extensions import Self + def set_error_output_file(filename): """Set a file to write out the VTK errors. @@ -51,46 +58,130 @@ Parameters ---------- raise_errors : bool, default: False - Raise a ``RuntimeError`` when a VTK error is encountered. + Raise a ``pyvista.VTKExecutionError`` (a runtime error) when a VTK error + is observed. + + .. versionchanged:: 0.47 + + A ``pyvista.VTKExecutionError`` is now raised instead of a generic + ``RuntimeError``. send_to_logging : bool, default: True Determine whether VTK errors raised within the context should also be sent to logging. + emit_warnings : bool, default: False + Emit a ``pyvista.VTKExecutionWarning`` (a runtime warning) when a VTK warning + is observed. + + .. versionadded:: 0.47 + Examples -------- - Catch VTK errors using the context manager. + Catch VTK errors using the context manager. This only sends to + logging by default. >>> import pyvista as pv >>> with pv.VtkErrorCatcher() as error_catcher: ... sphere = pv.Sphere() + Raise VTK errors as Python errors and emit VTK warnings as Python warnings. + + >>> with pv.VtkErrorCatcher( + ... raise_errors=True, emit_warnings=True + ... ) as error_catcher: + ... sphere = pv.Sphere() + """ @_deprecate_positional_args - def __init__(self, raise_errors: bool = False, send_to_logging: bool = True) -> None: # noqa: FBT001, FBT002 + def __init__( + self, + raise_errors: bool = False, # noqa: FBT001, FBT002 + send_to_logging: bool = True, # noqa: FBT001, FBT002 + emit_warnings: bool = False, # noqa: FBT001, FBT002 + ) -> None: """Initialize context manager.""" self.raise_errors = raise_errors self.send_to_logging = send_to_logging + self.emit_warnings = emit_warnings - def __enter__(self) -> None: + def __enter__(self: Self) -> Self: """Observe VTK string output window for errors.""" - error_output = _vtk.vtkStringOutputWindow() + self._start_observing() + return self + + def _start_observing(self): + output_window = _vtk.vtkStringOutputWindow() error_win = _vtk.vtkOutputWindow() self._error_output_orig = error_win.GetInstance() - error_win.SetInstance(error_output) - obs = Observer(log=self.send_to_logging, store_history=True) - obs.observe(error_output) - self._observer = obs + error_win.SetInstance(output_window) + + obs = Observer(event_type='ErrorEvent', log=self.send_to_logging, store_history=True) + obs.observe(output_window) + self._error_observer = obs + + obs = Observer(event_type='WarningEvent', log=self.send_to_logging, store_history=True) + obs.observe(output_window) + self._warning_observer = obs def __exit__(self, *args): """Stop observing VTK string output window.""" + self._stop_observing() + self._emit_warnings_and_raise_errors() + + def _stop_observing(self): error_win = _vtk.vtkOutputWindow() error_win.SetInstance(self._error_output_orig) - self.events = self._observer.event_history - if self.raise_errors and self.events: - errors = [RuntimeError(f'{e.kind}: {e.alert}', e.path, e.address) for e in self.events] - raise RuntimeError(errors) + + def _emit_warnings_and_raise_errors(self): + if self.emit_warnings and self.warning_events: + self._emit_warning(self._runtime_warning_message) + if self.raise_errors and self.error_events: + self._raise_error(self._runtime_error_message) + + @property + def events(self) -> list[VtkEvent]: # numpydoc ignore=RT01 + """List of all VTK warning and error events observed. + + .. versionadded:: 0.47 + + """ + return [*self._warning_observer.event_history, *self._error_observer.event_history] + + @property + def error_events(self) -> list[VtkEvent]: # numpydoc ignore=RT01 + """List of VTK error events observed. + + .. versionadded:: 0.47 + + """ + return self._error_observer.event_history + + @property + def warning_events(self) -> list[VtkEvent]: # numpydoc ignore=RT01 + """List of VTK error events observed. + + .. versionadded:: 0.47 + + """ + return self._warning_observer.event_history + + @property + def _runtime_error_message(self) -> str: # numpydoc ignore=RT01 + """List of VTK error events formatted as runtime errors.""" + return '\n'.join([str(e) for e in self.error_events]) + + @property + def _runtime_warning_message(self) -> str: # numpydoc ignore=RT01 + """List of VTK error events formatted as runtime errors.""" + return '\n'.join([str(e) for e in self.warning_events]) + + def _raise_error(self, message: str): + raise VTKExecutionError(message) + + def _emit_warning(self, message: str): + warn_external(message, VTKExecutionWarning) class VtkEvent(NamedTuple): @@ -100,6 +191,16 @@ path: str address: str alert: str + line: str + name: str + + def __str__(self): + if all(self): + return ( + f'{self.kind}: In {self.path}, line {self.line}\n' + f'{self.name} ({self.address}): {self.alert}' + ).strip() + return self.alert class Observer(_NoNewAttrMixin): @@ -113,28 +214,40 @@ store_history: bool = False, # noqa: FBT001, FBT002 ) -> None: """Initialize observer.""" - self.__event_occurred = False - self.__message = None - self.__message_etc = None + self.__event_occurred: bool = False + self.__message: str | None = None + self.__message_etc: str | None = None self.CallDataType = 'string0' - self.__observing = False + self.__observing: bool = False self.event_type = event_type self.__log = log self.store_history = store_history self.event_history: list[VtkEvent] = [] + self._event_history_etc: list[str] = [] @staticmethod - def parse_message(message): # numpydoc ignore=RT01 + def parse_message(message) -> VtkEvent: # numpydoc ignore=RT01 """Parse the given message.""" - # Message format - regex = re.compile(r'([A-Z]+):\sIn\s(.+),\sline\s.+\n\w+\s\((.+)\):\s(.+)') - try: - kind, path, address, alert = regex.findall(message)[0] - except Exception: # noqa: BLE001 - return '', '', '', message - else: - return kind, path, address, alert + regex = re.compile( + r'(?P[a-zA-Z]+):\sIn\s(?P.+?),\sline\s(?P\d+)\r?\n' + r'(?P\w+) \((?P
0x[0-9a-fA-F]+)\):\s(?P.+)', + re.DOTALL, + ) + + match = regex.match(message) + if match: + d = match.groupdict() + kind = d.get('kind', '') + path = d.get('path', '') + line = d.get('line', '') + name = d.get('name', '') + address = d.get('address', '') + alert = d.get('alert', '').strip() + return VtkEvent( + kind=kind, path=path, line=line, name=name, address=address, alert=alert + ) + return VtkEvent(kind='', path='', line='', name='', address='', alert=message.strip()) def log_message(self, kind, alert) -> None: """Parse different event types and passes them to logging.""" @@ -152,12 +265,13 @@ try: self.__event_occurred = True self.__message_etc = message - kind, path, address, alert = self.parse_message(message) - self.__message = alert + event = self.parse_message(message) + self.__message = event.alert if self.store_history: - self.event_history.append(VtkEvent(kind, path, address, alert)) + self.event_history.append(event) + self._event_history_etc.append(message) if self.__log: - self.log_message(kind, alert) + self.log_message(event.kind, event.alert) except Exception: # noqa: BLE001 # pragma: no cover try: if len(message) > 120: Index: python-pyvista/tests/core/test_utilities.py =================================================================== --- python-pyvista.orig/tests/core/test_utilities.py 2026-01-30 19:08:44.499329438 +0100 +++ python-pyvista/tests/core/test_utilities.py 2026-01-30 19:11:55.874758108 +0100 @@ -638,19 +638,27 @@ def test_progress_monitor(): mesh = pv.Sphere() - ugrid = mesh.delaunay_3d(progress_bar=True) - assert isinstance(ugrid, pv.UnstructuredGrid) + ugrid = mesh.warp_by_vector(progress_bar=True) + assert isinstance(ugrid, pv.PolyData) def test_observer(): - msg = 'KIND: In PATH, line 0\nfoo (ADDRESS): ALERT' + msg = 'KIND: In PATH, line 0\nfoo (0x000000): ALERT' obs = Observer() ret = obs.parse_message('foo') assert ret[3] == 'foo' ret = obs.parse_message(msg) - assert ret[3] == 'ALERT' + assert ret[0] == 'KIND' == ret.kind + assert ret[1] == 'PATH' == ret.path + assert ret[2] == '0x000000' == ret.address + assert ret[4] == '0' == ret.line + assert ret[5] == 'foo' == ret.name + assert ret[3] == 'ALERT' == ret.alert + assert str(ret) == msg + for kind in ['WARNING', 'ERROR']: obs.log_message(kind, 'foo') + # Pass positionally as that's what VTK will do obs(None, None, msg) assert obs.has_event_occurred() @@ -664,6 +672,20 @@ obs.observe(alg) +def test_observer_default_event(): + msg = 'This message does not match parsing regex!' + obs = Observer() + ret = obs.parse_message(msg) + assert ret.kind == '' + assert ret.path == '' + assert ret.address == '' + assert ret.line == '' + assert ret.name == '' + assert ret.alert == msg + + assert str(ret) == msg + + @pytest.mark.parametrize('point', [1, object(), None]) def test_valid_vector_raises(point): with pytest.raises(TypeError, match='foo must be a length three iterable of floats.'): @@ -732,19 +754,21 @@ def _generate_vtk_err(): """Simple operation which generates a VTK error.""" - x, y, z = np.meshgrid( - np.arange(-10, 10, 0.5), np.arange(-10, 10, 0.5), np.arange(-10, 10, 0.5) - ) - mesh = pv.StructuredGrid(x, y, z) - x2, y2, z2 = np.meshgrid(np.arange(-1, 1, 0.5), np.arange(-1, 1, 0.5), np.arange(-1, 1, 0.5)) - mesh2 = pv.StructuredGrid(x2, y2, z2) + from vtkmodules.vtkIOLegacy import vtkDataWriter - alg = vtk.vtkStreamTracer() - obs = pv.Observer() - obs.observe(alg) - alg.SetInputDataObject(mesh) - alg.SetSourceData(mesh2) - alg.Update() + # vtkWriter.cxx:55 ERR| vtkDataWriter (0x141efbd10): No input provided! + writer = vtkDataWriter() + writer.Write() + + +def _generate_vtk_warn(): + """Simple operation which generates a VTK warning.""" + from vtkmodules.vtkFiltersCore import vtkMergeFilter + + # vtkMergeFilter.cxx:277 WARN| vtkMergeFilter (0x600003c18000): Nothing to merge! + merge = vtkMergeFilter() + merge.AddInputData(_vtk.vtkPolyData()) + merge.Update() def test_vtk_error_catcher(): @@ -753,7 +777,11 @@ with error_catcher: _generate_vtk_err() _generate_vtk_err() - assert len(error_catcher.events) == 2 + _generate_vtk_warn() + _generate_vtk_warn() + assert len(error_catcher.events) == 4 + assert len(error_catcher.error_events) == 2 + assert len(error_catcher.warning_events) == 2 # raise_errors: False, no error error_catcher = pv.core.utilities.observers.VtkErrorCatcher() @@ -762,13 +790,48 @@ # raise_errors: True error_catcher = pv.core.utilities.observers.VtkErrorCatcher(raise_errors=True) - with pytest.raises(RuntimeError): + error_match = re.compile( + r'ERROR: In vtkWriter\.cxx, line \d+\n' + r'vtkDataWriter \(0x?[0-9a-fA-F]+\): No input provided!\n*' + ) + with pytest.raises(RuntimeError, match=re.compile(error_match)): # noqa: PT012 with error_catcher: _generate_vtk_err() - assert len(error_catcher.events) == 1 + _generate_vtk_warn() + assert len(error_catcher.events) == 2 + assert len(error_catcher.error_events) == 1 + assert len(error_catcher.warning_events) == 1 - # raise_errors: True, no error - error_catcher = pv.core.utilities.observers.VtkErrorCatcher(raise_errors=True) + # Raise two VTK errors as a single RuntimeError + error_catcher = pv.core.utilities.observers.VtkErrorCatcher( + raise_errors=True, emit_warnings=True + ) + error_match2 = re.compile(f'{error_match.pattern}\n{error_match.pattern}') + with pytest.raises(pv.VTKExecutionError, match=error_match2): # noqa: PT012 + with error_catcher: + _generate_vtk_err() + _generate_vtk_err() + + # Warn and raise error. The order emitted by VTK is not guaranteed to be the same + # since warn and err events are logged independently. + # Here we generate VTK err then warn, but expect warning then error + error_catcher = pv.core.utilities.observers.VtkErrorCatcher( + raise_errors=True, emit_warnings=True + ) + warning_match = re.compile( + r'Warning: In vtkMergeFilter\.cxx, line \d+\n' + r'vtkMergeFilter \(0x?[0-9a-fA-F]+\): Nothing to merge!' + ) + with pytest.warns(pv.VTKExecutionWarning, match=warning_match): # noqa: PT031 + with pytest.raises(pv.VTKExecutionError, match=error_match): # noqa: PT012 + with error_catcher: + _generate_vtk_err() + _generate_vtk_warn() + + # Test raise/emit with no errors/warnings generated + error_catcher = pv.core.utilities.observers.VtkErrorCatcher( + raise_errors=True, emit_warnings=True + ) with error_catcher: pass