feat: Allow falling back to internal rendering on any cache error

Previously, passing `fallback_render_aird` would only cause a fallback
to the internal rendering engine on cache misses. With this commit,
diagrams are also rendered internally for any other cache error, for
example if a remote cache server is unreachable or the cached artifacts
have expired.

Author: Wuestengecko

src/capellambse/model/_model.py

@@ -254,10 +254,14 @@ def __init__(
 
             *This argument is **not** passed to the file handler.*
         fallback_render_aird: bool
-            If set to True, enable the internal engine to render
-            diagrams that were not found in the pre-rendered cache.
-            Defaults to False, which means an exception is raised
-            instead. Ignored if no ``diagram_cache`` was specified.
+            If set to True, always fall back to rendering diagrams
+            internally if the configured ``diagram_cache`` is not
+            available.
+
+            By default, the internal renderer is entirely disabled for
+            AIRD diagrams, and only used during cache misses
+            (``FileNotFoundError`` from the underlying file handler) for
+            all other types of diagrams.
         **kwargs
             Additional arguments are passed on to the underlying
             :class:`~capellambse.loader.core.MelodyLoader`, which in

src/capellambse/model/diagram.py

@@ -223,12 +223,14 @@ def _allow_render(self) -> bool: ...
 
     else:
         _allow_render: bool = True
-        """Allow this diagram to be rendered by the internal rendering engine.
+        """Always allow rendering this diagram with the internal engine.
 
         If this property is set to False, and a diagram cache was
         specified for the model, this diagram can only be loaded from
-        the cache, and will never be rendered. Has no effect if there
-        was no diagram cache specified.
+        the cache, and will never be rendered. If set to True, a cache
+        miss will instead cause the diagram to be rendered internally.
+
+        Has no effect if there was no diagram cache specified.
 
         :meta public:
         """
@@ -400,10 +402,25 @@ def render(
                 try:
                     return self.__load_cache(chain)
                 except KeyError:
-                    pass
-
-                if not self._allow_render:
-                    raise RuntimeError(f"Diagram not in cache: {self.name}")
+                    if not (
+                        self._model._fallback_render_aird or self._allow_render
+                    ):
+                        raise RuntimeError(
+                            f"Diagram not in cache: {self.name}"
+                        ) from None
+                except Exception:
+                    if not self._model._fallback_render_aird:
+                        raise
+                    LOGGER.warning(
+                        (
+                            "Diagram cache lookup failed,"
+                            " falling back to internal renderer"
+                            " for diagram %r (%s)"
+                        ),
+                        self.name,
+                        self.uuid,
+                        exc_info=True,
+                    )
 
         render = self.__render_fresh(params)
         return _run_converter_chain(chain, render, pretty_print=pretty_print)
@@ -634,9 +651,10 @@ class DRepresentationDescriptor(AbstractDiagram):
     description = _pods.HTMLStringPOD("documentation")
 
     _element: aird.DRepresentationDescriptor
-
     _node_cache: list[etree._Element]
 
+    _allow_render = False
+
     @classmethod
     def from_model(
         cls,
@@ -700,10 +718,6 @@ def semantic_nodes(self) -> _obj.ElementList:
                 elems.append(obj._element)
         return _obj.ElementList(self._model, elems, legacy_by_type=True)
 
-    @property
-    def _allow_render(self) -> bool:
-        return self._model._fallback_render_aird
-
     @property
     def viewpoint(self) -> str:
         return aird.viewpoint_of(self._element)