Add MathML pydantic objects.

Generalize tree generation code from HTML for reuse in MathML.

Author: rtibbles

contentcuration/contentcuration/tests/utils/qti/test_mathml.py

@@ -0,0 +1,6 @@
+from .base import ElementTreeBase
+
+
+__all__ = [
+    "ElementTreeBase",
+]

contentcuration/contentcuration/utils/assessment/qti/__init__.py

@@ -7,6 +7,7 @@
 from typing import List
 from typing import Optional
 from typing import Set
+from typing import Type
 from typing import Union
 
 from pydantic import BaseModel
@@ -174,3 +175,108 @@ class BaseSequence(XMLElement):
     label: Optional[str] = None
     # We explicitly do not set the base value.
     dir_: Optional[Dir] = None
+
+
+# Pydantic's BaseModel Metaclass is only importable from an internal module,
+# so we inspect the BaseSequence class to get its metaclass.
+BaseSequenceMetaclass = type(BaseSequence)
+
+
+class RegistryMeta(BaseSequenceMetaclass):
+    """Generic metaclass that creates separate registries for each subclass"""
+
+    def __new__(mcs, name, bases, attrs):
+        cls = super().__new__(mcs, name, bases, attrs)
+
+        # Each metaclass gets its own registry
+        if not hasattr(mcs, "_registry"):
+            mcs._registry = {}
+
+        element_name = cls.element_name()
+        if element_name in mcs._registry and mcs._registry[element_name] is not cls:
+            raise ValueError(
+                f"Element name '{element_name}' already registered in {mcs.__name__}"
+            )
+        mcs._registry[element_name] = cls
+
+        return cls
+
+    @classmethod
+    def _ensure_registry_complete(cls):
+        """Ensure all HTML and MathML classes are registered"""
+        if not hasattr(cls, "_registry_initialized"):
+            # Import modules to trigger registration
+            from contentcuration.utils.assessment.qti import html, mathml  # noqa: F401
+
+            cls._registry_initialized = True
+
+    @classmethod
+    def get_class_for_tag(cls, tag_name: str) -> Optional[Type]:
+        """Get the registered class for a given tag name"""
+        cls._ensure_registry_complete()
+        return getattr(cls, "_registry", {}).get(tag_name)
+
+
+class ElementTreeBase(BaseSequence, metaclass=RegistryMeta):
+    @classmethod
+    def from_element(cls, element: ET.Element) -> "ElementTreeBase":
+        # Get the appropriate class for this tag
+        target_class = type(cls).get_class_for_tag(element.tag)
+        if target_class is None:
+            raise ValueError(f"No registered class found for tag: {element.tag}")
+
+        # Convert attributes to field data - Pydantic will handle type coercion
+        field_data = {}
+        for attr_name, attr_value in element.attrib.items():
+            field_name = cls._attr_name_to_field_name(attr_name)
+            field_data[field_name] = attr_value
+
+        # Convert children and text
+        children = cls._extract_children(element)
+        if children:
+            field_data["children"] = children
+
+        return target_class(**field_data)
+
+    @classmethod
+    def _attr_name_to_field_name(cls, attr_name: str) -> str:
+        """Convert attribute name to Python field name"""
+        # kebab-case -> snake_case, : -> __
+        field_name = attr_name.replace(":", "__").replace("-", "_")
+
+        # Add trailing underscore for Python keywords
+        if field_name in {"class", "for", "type", "id", "dir"}:
+            field_name += "_"
+
+        return field_name
+
+    @classmethod
+    def _extract_children(
+        cls, element: ET.Element
+    ) -> List[Union["ElementTreeBase", TextNode]]:
+        """Extract child elements and text nodes from XML element"""
+        children = []
+
+        # Add initial text if present
+        if element.text and element.text.strip():
+            children.append(TextNode(text=element.text))
+
+        # Process child elements
+        for child_elem in element:
+            children.append(cls.from_element(child_elem))
+            # Add tail text after child element
+            if child_elem.tail and child_elem.tail.strip():
+                children.append(TextNode(text=child_elem.tail))
+
+        return children
+
+    @classmethod
+    def from_string(cls, string: str) -> List["ElementTreeBase"]:
+        """Parse markup string and return list of ElementTreeBase instances"""
+        try:
+            # Wrap in a root element to handle multiple top-level elements
+            wrapped_markup = f"<root>{string}</root>"
+            root = ET.fromstring(wrapped_markup)
+            return [cls.from_element(child) for child in root]
+        except ET.ParseError as e:
+            raise ValueError(f"Invalid Markup: {e}") from e

contentcuration/contentcuration/utils/assessment/qti/base.py

@@ -1,118 +1,22 @@
-import xml.etree.ElementTree as ET
-from typing import Dict
 from typing import List
 from typing import Optional
-from typing import Type
-from typing import Union
 
 from pydantic import model_validator
 
-from contentcuration.utils.assessment.qti.base import BaseSequence
-from contentcuration.utils.assessment.qti.base import TextNode
+from contentcuration.utils.assessment.qti.base import ElementTreeBase
 from contentcuration.utils.assessment.qti.fields import LocalSrcPath
 from contentcuration.utils.assessment.qti.fields import LocalSrcSet
 
 
-# Pydantic's BaseModel Metaclass is only importable from an internal module,
-# so we inspect the BaseSequence class to get its metaclass.
-BaseSequenceMetaclass = type(BaseSequence)
-
-
-class HTMLElementMeta(BaseSequenceMetaclass):
-    """Metaclass that auto-registers HTML element classes by their tag name"""
-
-    # Class registry mapping tag names to classes
-    _registry: Dict[str, Type["HTMLElement"]] = {}
-
-    def __new__(mcs, name, bases, attrs):
-        cls = super().__new__(mcs, name, bases, attrs)
-        element_name = cls.element_name()
-        mcs._registry[element_name] = cls
-        return cls
-
-    @classmethod
-    def get_class_for_tag(mcs, tag_name: str) -> Optional[Type["HTMLElement"]]:
-        """Get the registered class for a given tag name"""
-        return mcs._registry.get(tag_name)
-
-    @classmethod
-    def register_class(mcs, tag_name: str, cls: Type["HTMLElement"]):
-        """Manually register a class for a tag name"""
-        mcs._registry[tag_name] = cls
-
-
-class HTMLElement(BaseSequence, metaclass=HTMLElementMeta):
+class HTMLElement(ElementTreeBase):
     """
     Represents an HTML element within QTI.
     """
 
-    @classmethod
-    def element_name(cls):
-        return cls.__name__.lower()
-
-    @classmethod
-    def from_element(cls, element: ET.Element) -> "HTMLElement":
-        """Create HTMLElement instance from ET.Element"""
-        # Get the appropriate class for this tag
-        target_class = HTMLElementMeta.get_class_for_tag(element.tag)
-        if target_class is None:
-            raise ValueError(f"No registered class found for tag: {element.tag}")
-
-        # Convert attributes to field data - Pydantic will handle type coercion
-        field_data = {}
-        for attr_name, attr_value in element.attrib.items():
-            field_name = cls._attr_name_to_field_name(attr_name)
-            field_data[field_name] = attr_value
-
-        # Convert children and text
-        children = cls._extract_children(element)
-        if children:
-            field_data["children"] = children
-
-        return target_class(**field_data)
-
-    @classmethod
-    def _attr_name_to_field_name(cls, attr_name: str) -> str:
-        """Convert HTML attribute name to Python field name"""
-        # kebab-case -> snake_case, : -> __
-        field_name = attr_name.replace(":", "__").replace("-", "_")
-
-        # Add trailing underscore for Python keywords
-        if field_name in {"class", "for", "type", "id", "dir"}:
-            field_name += "_"
-
-        return field_name
-
-    @classmethod
-    def _extract_children(
-        cls, element: ET.Element
-    ) -> List[Union["HTMLElement", TextNode]]:
-        """Extract child elements and text nodes from XML element"""
-        children = []
-
-        # Add initial text if present
-        if element.text and element.text.strip():
-            children.append(TextNode(text=element.text))
-
-        # Process child elements
-        for child_elem in element:
-            children.append(cls.from_element(child_elem))
-            # Add tail text after child element
-            if child_elem.tail and child_elem.tail.strip():
-                children.append(TextNode(text=child_elem.tail))
-
-        return children
-
     @classmethod
     def from_html_string(cls, html_string: str) -> List["HTMLElement"]:
         """Parse HTML string and return list of HTMLElement instances"""
-        try:
-            # Wrap in a root element to handle multiple top-level elements
-            wrapped_html = f"<root>{html_string}</root>"
-            root = ET.fromstring(wrapped_html)
-            return [cls.from_element(child) for child in root]
-        except ET.ParseError as e:
-            raise ValueError(f"Invalid HTML: {e}") from e
+        return cls.from_string(html_string)
 
 
 class FlowContentElement(HTMLElement):

contentcuration/contentcuration/utils/assessment/qti/html/base.py

@@ -4,9 +4,11 @@
 from contentcuration.utils.assessment.qti.base import TextType
 from contentcuration.utils.assessment.qti.html.base import FlowContentElement
 from contentcuration.utils.assessment.qti.html.base import InlineContentElement
+from contentcuration.utils.assessment.qti.interaction_types.base import BlockInteraction
 from contentcuration.utils.assessment.qti.interaction_types.base import (
     InlineInteraction,
 )
+from contentcuration.utils.assessment.qti.mathml import Math
 
 
 FlowContent = Union[FlowContentElement, TextType]
@@ -26,8 +28,17 @@
     # InlineChoiceInteraction,
     # EndAttemptInteraction,
     # CustomInteraction,
-    # Math,
+    Math,
     # Include,
 ]
 
 InlineGroupList = List[Union[InlineGroup, TextType]]
+
+FlowGroup = Union[
+    FlowContentElement,
+    BlockInteraction,
+    InlineInteraction,
+    Math,
+]
+
+FlowGroupList = List[Union[FlowGroup, TextType]]

contentcuration/contentcuration/utils/assessment/qti/html/content_types.py

@@ -4,7 +4,7 @@
 from pydantic import HttpUrl
 
 from contentcuration.utils.assessment.qti.html.base import BlockContentElement
-from contentcuration.utils.assessment.qti.html.content_types import FlowContentList
+from contentcuration.utils.assessment.qti.html.content_types import FlowGroupList
 
 
 class HTMLFlowContainer(BlockContentElement):
@@ -14,7 +14,7 @@ class HTMLFlowContainer(BlockContentElement):
     Corresponds to HTML "Flow Content" category.
     """
 
-    children: FlowContentList = Field(default_factory=list)
+    children: FlowGroupList = Field(default_factory=list)
 
 
 class Blockquote(HTMLFlowContainer):

contentcuration/contentcuration/utils/assessment/qti/html/flow.py

@@ -0,0 +1,77 @@
+from .base import MathMLElement
+from .core import Annotation
+from .core import AnnotationXml
+from .core import Maction
+from .core import Math
+from .core import Merror
+from .core import Mfrac
+from .core import Mi
+from .core import Mmultiscripts
+from .core import Mn
+from .core import Mo
+from .core import Mover
+from .core import Mpadded
+from .core import Mphantom
+from .core import Mprescripts
+from .core import Mroot
+from .core import Mrow
+from .core import Ms
+from .core import Mspace
+from .core import Msqrt
+from .core import Mstyle
+from .core import Msub
+from .core import Msubsup
+from .core import Msup
+from .core import Mtable
+from .core import Mtd
+from .core import Mtext
+from .core import Mtr
+from .core import Munder
+from .core import Munderover
+from .core import Semantics
+from .fields import MathMLDisplay
+from .fields import MathMLForm
+
+__all__ = [
+    "MathMLElement",
+    # Root element
+    "Math",
+    # Token elements
+    "Mi",
+    "Mn",
+    "Mo",
+    "Mtext",
+    "Ms",
+    "Mspace",
+    # Layout elements
+    "Mrow",
+    "Mfrac",
+    "Msqrt",
+    "Mroot",
+    "Mpadded",
+    # Script elements
+    "Msub",
+    "Msup",
+    "Msubsup",
+    "Munder",
+    "Mover",
+    "Munderover",
+    "Mmultiscripts",
+    "Mprescripts",
+    # Table elements
+    "Mtd",
+    "Mtr",
+    "Mtable",
+    # Grouping elements
+    "Mstyle",
+    "Merror",
+    "Mphantom",
+    "Maction",
+    # Semantic elements
+    "Annotation",
+    "AnnotationXml",
+    "Semantics",
+    # enums
+    "MathMLForm",
+    "MathMLDisplay",
+]