Bump mypy from 1.14.1 to 1.15.0

cwltool/command_line_tool.py

@@ -1342,7 +1342,7 @@
                                 ]
                             )
                         except OSError as e:
-                            _logger.warning(str(e))
+                            _logger.warning(str(e), exc_info=builder.debug)
                         except Exception:
                             _logger.error("Unexpected error from fs_access", exc_info=True)
                             raise

cwltool/cuda.py

@@ -2,6 +2,7 @@
 
 import subprocess  # nosec
 import xml.dom.minidom  # nosec
+from typing import Union
 
 from .loghandler import _logger
 from .utils import CWLObjectType
@@ -10,9 +11,9 @@
 def cuda_version_and_device_count() -> tuple[str, int]:
     """Determine the CUDA version and number of attached CUDA GPUs."""
     try:
-        out = subprocess.check_output(["nvidia-smi", "-q", "-x"])  # nosec
+        out: Union[str, bytes] = subprocess.check_output(["nvidia-smi", "-q", "-x"])  # nosec
     except Exception as e:
-        _logger.warning("Error checking CUDA version with nvidia-smi: %s", e)
+        _logger.warning("Error checking CUDA version with nvidia-smi: %s", e, exc_info=e)
         return ("", 0)
     dm = xml.dom.minidom.parseString(out)  # nosec
 
@@ -62,5 +63,5 @@
             return 0
         return requestCount
     except Exception as e:
-        _logger.warning("Error checking CUDA requirements: %s", e)
+        _logger.warning("Error checking CUDA requirements: %s", e, exc_info=e)
         return 0

cwltool/cwlprov/provenance_profile.py

@@ -546,7 +546,7 @@
             # FIXME: list value does not support adding "@id"
             return coll
         except TypeError:
-            _logger.warning("Unrecognized type %s of %r", type(value), value)
+            _logger.warning("Unrecognized type %s of %r", type(value), value, exc_info=True)
             # Let's just fall back to Python repr()
             entity = self.document.entity(uuid.uuid4().urn, {PROV_LABEL: repr(value)})
             self.research_object.add_uri(entity.identifier.uri)

cwltool/cwlviewer.py

@@ -1,18 +1,28 @@
 """Visualize a CWL workflow."""
 
 from collections.abc import Iterator
-from pathlib import Path
+from importlib.resources import files
 from typing import cast
 from urllib.parse import urlparse
 
 import pydot
 import rdflib
 
-_queries_dir = (Path(__file__).parent / "rdfqueries").resolve()
-_get_inner_edges_query_path = _queries_dir / "get_inner_edges.sparql"
-_get_input_edges_query_path = _queries_dir / "get_input_edges.sparql"
-_get_output_edges_query_path = _queries_dir / "get_output_edges.sparql"
-_get_root_query_path = _queries_dir / "get_root.sparql"
+
+def _get_inner_edges_query() -> str:
+    return files("cwltool").joinpath("rdfqueries/get_inner_edges.sparql").read_text()
+
+
+def _get_input_edges_query() -> str:
+    return files("cwltool").joinpath("rdfqueries/get_input_edges.sparql").read_text()
+
+
+def _get_output_edges_query() -> str:
+    return files("cwltool").joinpath("rdfqueries/get_output_edges.sparql").read_text()
+
+
+def _get_root_query() -> str:
+    return files("cwltool").joinpath("rdfqueries/get_root.sparql").read_text()
 
 
 class CWLViewer:
@@ -33,8 +43,7 @@ def _load_cwl_graph(self, rdf_description: str) -> rdflib.graph.Graph:
         return rdf_graph
 
     def _set_inner_edges(self) -> None:
-        with open(_get_inner_edges_query_path) as f:
-            get_inner_edges_query = f.read()
+        get_inner_edges_query = _get_inner_edges_query()
         inner_edges = cast(
             Iterator[rdflib.query.ResultRow],
             self._rdf_graph.query(
@@ -96,8 +105,7 @@ def _set_inner_edges(self) -> None:
             )
 
     def _set_input_edges(self) -> None:
-        with open(_get_input_edges_query_path) as f:
-            get_input_edges_query = f.read()
+        get_input_edges_query = _get_input_edges_query()
         inputs_subgraph = pydot.Subgraph(graph_name="cluster_inputs")
         self._dot_graph.add_subgraph(inputs_subgraph)
         inputs_subgraph.set("rank", "same")
@@ -124,8 +132,7 @@ def _set_input_edges(self) -> None:
             self._dot_graph.add_edge(pydot.Edge(str(input_row["input"]), str(input_row["step"])))
 
     def _set_output_edges(self) -> None:
-        with open(_get_output_edges_query_path) as f:
-            get_output_edges = f.read()
+        get_output_edges = _get_output_edges_query()
         outputs_graph = pydot.Subgraph(graph_name="cluster_outputs")
         self._dot_graph.add_subgraph(outputs_graph)
         outputs_graph.set("rank", "same")
@@ -152,8 +159,7 @@ def _set_output_edges(self) -> None:
             self._dot_graph.add_edge(pydot.Edge(output_edge_row["step"], output_edge_row["output"]))
 
     def _get_root_graph_uri(self) -> rdflib.term.Identifier:
-        with open(_get_root_query_path) as f:
-            get_root_query = f.read()
+        get_root_query = _get_root_query()
         root = cast(
             list[rdflib.query.ResultRow],
             list(

cwltool/executors.py

@@ -326,7 +326,10 @@
             self.exceptions.append(err)
         except Exception as err:  # pylint: disable=broad-except
             _logger.exception(f"Got workflow error: {err}")
-            self.exceptions.append(WorkflowException(str(err)))
+            wf_exc = WorkflowException(str(err))
+            wf_exc.__cause__ = err
+            wf_exc.__suppress_context__ = True
+            self.exceptions.append(wf_exc)
         finally:
             if runtime_context.workflow_eval_lock:
                 with runtime_context.workflow_eval_lock:

cwltool/job.py

@@ -376,17 +376,30 @@
         except OSError as e:
             if e.errno == 2:
                 if runtime:
-                    _logger.error("'%s' not found: %s", runtime[0], str(e))
+                    _logger.error(
+                        "'%s' not found: %s", runtime[0], str(e), exc_info=runtimeContext.debug
+                    )
                 else:
-                    _logger.error("'%s' not found: %s", self.command_line[0], str(e))
+                    _logger.error(
+                        "'%s' not found: %s",
+                        self.command_line[0],
+                        str(e),
+                        exc_info=runtimeContext.debug,
+                    )
             else:
-                _logger.exception("Exception while running job")
+                _logger.exception(
+                    "Exception while running job: %s", str(e), exc_info=runtimeContext.debug
+                )
             processStatus = "permanentFail"
         except WorkflowException as err:
-            _logger.error("[job %s] Job error:\n%s", self.name, str(err))
+            _logger.error(
+                "[job %s] Job error:\n%s", self.name, str(err), exc_info=runtimeContext.debug
+            )
             processStatus = "permanentFail"
-        except Exception:
-            _logger.exception("Exception while running job")
+        except Exception as err:
+            _logger.exception(
+                "Exception while running job: %s.", str(err), exc_info=runtimeContext.debug
+            )
             processStatus = "permanentFail"
         if (
             runtimeContext.research_obj is not None
@@ -795,7 +808,7 @@
                     )
             except Exception as err:
                 container = "Singularity" if runtimeContext.singularity else "Docker"
-                _logger.debug("%s error", container, exc_info=True)
+                _logger.debug("%s error", container, exc_info=runtimeContext.debug)
                 if docker_is_req:
                     raise UnsupportedRequirement(
                         f"{container} is required to run this tool: {str(err)}"

cwltool/main.py

@@ -1289,7 +1289,7 @@
                 if isinstance(err.code, int):
                     return err.code
                 else:
-                    _logger.debug("Non-integer SystemExit: %s", err.code)
+                    _logger.debug("Non-integer SystemExit: %s", err.code, exc_info=args.debug)
                     return 1
 
             del args.workflow

cwltool/procgenerator.py

@@ -57,7 +57,7 @@
         except WorkflowException:
             raise
         except Exception as exc:
-            _logger.exception("Unexpected exception")
+            _logger.exception("Unexpected exception", exc_info=runtimeContext.debug)
             raise WorkflowException(str(exc)) from exc
 
 
@@ -80,7 +80,7 @@
                 self.embedded_tool = load_tool(toolpath_object["run"], loadingContext)
         except ValidationException as vexc:
             if loadingContext.debug:
-                _logger.exception("Validation exception")
+                _logger.exception("Validation exception", exc_info=loadingContext.debug)
             raise WorkflowException(
                 "Tool definition %s failed validation:\n%s"
                 % (toolpath_object["run"], indent(str(vexc)))
@@ -108,7 +108,7 @@
             )
         except ValidationException as vexc:
             if runtimeContext.debug:
-                _logger.exception("Validation exception")
+                _logger.exception("Validation exception", exc_info=runtimeContext.debug)
             raise WorkflowException(
                 "Tool definition %s failed validation:\n%s"
                 % (jobout["runProcess"], indent(str(vexc)))

cwltool/resolver.py

@@ -15,8 +15,8 @@
 
     try:
         pathobj = Path(pathpart).resolve()
-    except OSError:
-        _logger.debug("local resolver could not resolve %s", uri)
+    except OSError as exc:
+        _logger.debug("local resolver could not resolve %s due to %s", uri, str(exc))
         return None
 
     if pathobj.is_file():

cwltool/singularity_utils.py

@@ -2,7 +2,7 @@
 
 import os
 import os.path
-from subprocess import DEVNULL, PIPE, Popen, TimeoutExpired  # nosec
+import subprocess  # nosec
 from typing import Optional
 
 _USERNS: Optional[bool] = None
@@ -14,17 +14,17 @@
     if _USERNS is None:
         try:
             hello_image = os.path.join(os.path.dirname(__file__), "hello.simg")
-            result = Popen(  # nosec
+            result = subprocess.run(  # nosec
                 ["singularity", "exec", "--userns", hello_image, "true"],
-                stderr=PIPE,
-                stdout=DEVNULL,
-                universal_newlines=True,
-            ).communicate(timeout=60)[1]
+                capture_output=True,
+                timeout=60,
+                text=True,
+            ).stderr
             _USERNS = (
                 "No valid /bin/sh" in result
                 or "/bin/sh doesn't exist in container" in result
                 or "executable file not found in" in result
             )
-        except TimeoutExpired:
+        except subprocess.TimeoutExpired:
             _USERNS = False
     return _USERNS

cwltool/workflow.py

@@ -442,7 +442,9 @@ def job(
                 runtimeContext,
             )
         except WorkflowException:
-            _logger.error("Exception on step '%s'", runtimeContext.name)
+            _logger.error(
+                "Exception on step '%s'", runtimeContext.name, exc_info=runtimeContext.debug
+            )
             raise
         except Exception as exc:
             _logger.exception("Unexpected exception")

cwltool/workflow_job.py

@@ -406,7 +406,7 @@ def object_from_state(
                                 ("merge_nested" if len(connections) > 1 else None),
                             ),
                         ),
-                        valueFrom=cast(str, inp.get("valueFrom")),
+                        valueFrom=cast(Optional[str], inp.get("valueFrom")),
                     ):
                         raise WorkflowException(
                             "Type mismatch between source '%s' (%s) and "

mypy-requirements.txt

@@ -1,4 +1,4 @@
-mypy==1.14.1  # also update pyproject.toml
+mypy==1.15.0  # also update pyproject.toml
 ruamel.yaml>=0.16.0,<0.19
 cwl-utils>=0.32
 cwltest

pyproject.toml

@@ -2,7 +2,7 @@
 requires = [
     "setuptools>=45",
     "setuptools_scm[toml]>=8.0.4,<9",
-    "mypy==1.14.1",  # also update mypy-requirements.txt
+    "mypy==1.15.0",  # also update mypy-requirements.txt
     "types-requests",
     "types-psutil",
     "importlib_resources>=1.4;python_version<'3.9'",