fix(core): ignore registered subclasses of the canonical model class

- controllers and result wrappers inherit the category IRI they extend
- oold's registry keeps whichever of them was defined last
- UploadFileResult thus replaced WikiFile and broke file up/download
- prefer osw.model.entity's class when the registered one specializes it

Author: LukasGold

src/osw/core.py

@@ -1276,6 +1276,27 @@ def load_entity(
                             # oold type registry entry for this category and hide
                             # the packaged class' typed fields/helpers.
                             registered_cls = oold_type_registry.get(category)
+                            # Controllers and result wrappers (e.g.
+                            #  WikiFileController, UploadFileResult) inherit
+                            #  their category IRI from the model class they
+                            #  extend, and the registry keeps whichever class
+                            #  was defined last. Such a specialization asks for
+                            #  fields a plain page's jsondata does not carry, so
+                            #  prefer the canonical class from osw.model.entity
+                            #  over a subclass of it.
+                            canonical_cls = getattr(model, cls_name, None)
+                            if (
+                                registered_cls is not None
+                                and canonical_cls is not None
+                                and registered_cls is not canonical_cls
+                                and issubclass(registered_cls, canonical_cls)
+                            ):
+                                _logger.debug(
+                                    f"Ignoring '{registered_cls}' registered for "
+                                    f"category '{category}': it specializes "
+                                    f"'{canonical_cls}', which is used instead."
+                                )
+                                registered_cls = None
                             if registered_cls is not None:
                                 category_to_cls[category] = registered_cls
                             else:

tests/test_load_entity_registered_class.py

@@ -171,6 +171,59 @@ def test_load_entity_falls_back_to_generated_class_when_nothing_registered():
         delattr(model, cls_name)
 
 
+def test_load_entity_ignores_a_registered_subclass_of_the_model_class():
+    """osw's own controllers and result wrappers (WikiFileController,
+    UploadFileResult, ...) inherit the category IRI of the model class they
+    extend, and oold's registry keeps whichever class was defined last. Such a
+    specialization needs fields a plain page does not carry, so load_entity()
+    must fall back to the canonical class in osw.model.entity.
+    """
+    category = "Category:OSWSubclassTest000000000000000000000000"
+    cls_name = "SubclassTestBase"
+
+    base_cls = make_isolated_cls(cls_name)
+    # a controller-like specialization that additionally requires a field the
+    # page's jsondata does not provide, mirroring UploadFileResult.source
+    specialized_cls = type(base_cls)(
+        "SubclassTestController",
+        (base_cls,),
+        {"__annotations__": {"source": str}, "__qualname__": "SubclassTestController"},
+    )
+    setattr(model, cls_name, base_cls)
+    oold_type_registry[category] = specialized_cls
+    try:
+        entity_page = OfflineWtPage(
+            title="Item:OSWSubclassEntity0000000000000000000000000"
+        )
+        jsondata = {
+            "type": [category],
+            "uuid": "22222222-2222-2222-2222-222222222222",
+            "name": "x",
+            "label": [{"text": "x"}],
+        }
+        remove_empty(jsondata)
+        entity_page.set_slot_content("jsondata", jsondata)
+        schema_page = make_schema_page(category, cls_name)
+
+        osw_obj = OSW(site=make_offline_wtsite())
+
+        result = osw_obj.load_entity(
+            OSW.LoadEntityParam(
+                titles=[entity_page.title],
+                autofetch_schema=True,
+                offline_pages={
+                    entity_page.title: entity_page,
+                    category: schema_page,
+                },
+            )
+        )
+
+        assert type(result.entities[0]) is base_cls
+    finally:
+        delattr(model, cls_name)
+        oold_type_registry.pop(category, None)
+
+
 def test_load_entity_warns_on_registry_conflict(monkeypatch, caplog):
     """If the class about to be used for a category differs from whatever is
     now registered for that IRI, load_entity() logs a warning instead of