Report render failures instead of raising out of the operator

A failed write let a RuntimeError escape execute(), so the user got a
Python traceback in the Info editor and no indication of how far the
batch had got. The traceback in the bug report was that: the operator
had nothing to say about which file it could not write.

Record each failure with its filename and reason, print the detail to
the System Console, and summarise at the end. A single unwritable image
no longer throws away a long batch, but if nothing has been written yet
the batch stops there, since that is a setup problem and every remaining
image would fail the same way after burning the render time. Creating
the output folder and each product folder are handled the same way.

Author: Danyals-code

multiview_product_renderer/__init__.py

@@ -1595,10 +1595,29 @@ def _do_clay_render(scene, filepath, clay_color):
         scene.display.shading.show_cavity = saved['show_cavity']
 
 
+class _BatchAborted(Exception):
+    """Stop the batch early without dumping a traceback on the user."""
+
+
 class MV_OT_RenderAll(Operator):
     bl_idname = "mv.render_all"
     bl_label = "Render All"
 
+    def _fail(self, failures, done, path, exc):
+        """Record one failed write, aborting the batch if nothing has landed.
+
+        Collected and reported at the end rather than raised, so a single
+        unwritable file cannot throw away a long batch that is otherwise fine.
+        Before the first success there is nothing to salvage and the cause is
+        almost always the setup, so that case stops immediately instead of
+        failing the same way for every remaining image.
+        """
+        note = f"{os.path.basename(path)}: {exc}"
+        failures.append(note)
+        print(f"[MultiView] FAILED {note}")
+        if not done:
+            raise _BatchAborted from exc
+
     def execute(self, context):
         scene = context.scene
         s = scene.mv_settings
@@ -1615,7 +1634,11 @@ def execute(self, context):
             return {'CANCELLED'}
 
         out_root = bpy.path.abspath(s.render_output_dir)
-        os.makedirs(out_root, exist_ok=True)
+        try:
+            os.makedirs(out_root, exist_ok=True)
+        except OSError as exc:
+            self.report({'ERROR'}, f"Cannot use output folder '{out_root}': {exc}")
+            return {'CANCELLED'}
 
         saved_hide = {}
         for pc in products:
@@ -1630,6 +1653,7 @@ def execute(self, context):
         total_per_pair = (2 if both else 1) * len(cameras)
         total = len(products) * total_per_pair
         done = 0
+        failures = []
 
         try:
             for i, pc in enumerate(products):
@@ -1640,27 +1664,41 @@ def execute(self, context):
 
                 label = product_label(s.start_prefix, s.start_number, i, s.products_per_letter)
                 product_dir = os.path.join(out_root, safe_name(f"{label}_{pc.name}"))
-                os.makedirs(product_dir, exist_ok=True)
+                try:
+                    os.makedirs(product_dir, exist_ok=True)
+                except OSError as exc:
+                    self._fail(failures, done, product_dir, exc)
+                    continue
 
                 for cam in cameras:
                     scene.camera = cam
                     view_name = cam.name.replace("MV_Cam_", "")
                     base = safe_name(f"{label}_{pc.name}_{view_name}")
 
+                    clay = (tuple(s.clay_color),)
                     if mode == 'FULL':
-                        _do_full_render(scene, os.path.join(product_dir, base))
-                        done += 1
+                        attempts = ((_do_full_render, base, ()),)
                     elif mode == 'CLAY':
-                        _do_clay_render(scene, os.path.join(product_dir, base + "_clay"),
-                                        tuple(s.clay_color))
-                        done += 1
+                        attempts = ((_do_clay_render, base + "_clay", clay),)
                     else:
-                        _do_full_render(scene, os.path.join(product_dir, base + "_render"))
+                        attempts = ((_do_full_render, base + "_render", ()),
+                                    (_do_clay_render, base + "_clay", clay))
+
+                    for render, name, extra in attempts:
+                        path = os.path.join(product_dir, name)
+                        try:
+                            render(scene, path, *extra)
+                        except RuntimeError as exc:
+                            # bpy.ops.render.render raises when the image cannot
+                            # be written. Letting that escape put a Python
+                            # traceback in front of the user instead of the name
+                            # of the file that failed.
+                            self._fail(failures, done, path, exc)
+                            continue
                         done += 1
-                        _do_clay_render(scene, os.path.join(product_dir, base + "_clay"),
-                                        tuple(s.clay_color))
-                        done += 1
-                    print(f"[MultiView] {done}/{total}: {scene.render.filepath}")
+                        print(f"[MultiView] {done}/{total}: {scene.render.filepath}")
+        except _BatchAborted:
+            pass
         finally:
             for pc in products:
                 lc = find_layer_coll(context.view_layer.layer_collection, pc.name)
@@ -1669,7 +1707,19 @@ def execute(self, context):
             scene.camera = saved_cam
             scene.render.filepath = saved_path
 
-        self.report({'INFO'}, f"Wrote {done} image(s).")
+        if not failures:
+            self.report({'INFO'}, f"Wrote {done} image(s).")
+            return {'FINISHED'}
+
+        if not done:
+            # Nothing landed at all, so the batch stopped at the first failure
+            # rather than burning render time failing the same way every time.
+            self.report({'ERROR'}, f"Nothing rendered. {failures[0]}")
+            return {'CANCELLED'}
+
+        self.report({'WARNING'},
+                    f"Wrote {done} of {total} image(s). {len(failures)} failed, "
+                    f"first: {failures[0]}. Full list in the System Console.")
         return {'FINISHED'}