handle mixed cases where classified formats are split across parent/child packages

Author: tclose

fileformats/core/classifier.py

@@ -1,4 +1,5 @@
 from .utils import classproperty
+from .exceptions import FileFormatsError
 
 
 class Classifier:
@@ -9,3 +10,15 @@ class Classifier:
     def type_name(cls):
         """Name of type to be used in __repr__. Defined here so it can be overridden"""
         return cls.__name__
+
+    @classproperty
+    def namespace(cls):
+        """The "namespace" the format belongs to under the "fileformats" umbrella
+        namespace"""
+        module_parts = cls.__module__.split(".")
+        if module_parts[0] != "fileformats":
+            raise FileFormatsError(
+                f"Cannot create reversible MIME type for {cls} as it is not in the "
+                "fileformats namespace"
+            )
+        return module_parts[1].replace("_", "-")

fileformats/core/datatype.py

@@ -5,14 +5,14 @@
 import itertools
 from .converter import SubtypeVar
 from .exceptions import (
-    FileFormatsError,
     FormatMismatchError,
     FormatConversionError,
     FormatRecognitionError,
 )
 from .utils import (
     classproperty,
     subpackages,
+    add_exc_note,
     to_mime_format_name,
     from_mime_format_name,
     IANA_MIME_TYPE_REGISTRIES,
@@ -51,18 +51,6 @@ def matches(cls, values) -> bool:
         else:
             return True
 
-    @classproperty
-    def namespace(cls):
-        """The "namespace" the format belongs to under the "fileformats" umbrella
-        namespace"""
-        module_parts = cls.__module__.split(".")
-        if module_parts[0] != "fileformats":
-            raise FileFormatsError(
-                f"Cannot create reversible MIME type for {cls} as it is not in the "
-                "fileformats namespace"
-            )
-        return module_parts[1].replace("_", "-")
-
     @classproperty
     def all_types(self):
         return itertools.chain(FileSet.all_formats, Field.all_fields)
@@ -195,34 +183,52 @@ def from_mime(cls, mime_string):
                 klass = getattr(module, class_name)
             except AttributeError:
                 if "+" in format_name:
-                    qualifier_names, classified_name = format_name.split("+")
-                    try:
-                        classifiers = [
-                            getattr(module, from_mime_format_name(q))
-                            for q in qualifier_names.split(".")
-                        ]
-                    except AttributeError:
-                        raise FormatRecognitionError(
-                            f"Could not load classifiers [{qualifier_names}] from "
-                            f"fileformats.{namespace}, corresponding to MIME, "
-                            f"or MIME-like, type {mime_string}"
-                        ) from None
-                    try:
-                        classified = getattr(
-                            module, from_mime_format_name(classified_name)
+                    if "_" in namespace:
+                        parent_namespace = namespace.split("_")[0]
+                        parent_module = importlib.import_module(
+                            "fileformats." + parent_namespace
                         )
-                    except AttributeError:
+                    else:
+                        parent_namespace = parent_module = None
+
+                    def get_format(mime_name):
+                        name = from_mime_format_name(mime_name)
+                        try:
+                            return getattr(module, name)
+                        except AttributeError:
+                            if parent_module:
+                                try:
+                                    return getattr(parent_module, name)
+                                except AttributeError:
+                                    pass
+                                err_msg_part = f" or fileformats.{parent_namespace}"
+                            else:
+                                err_msg_part = ""
+                            raise FormatRecognitionError(
+                                f"Could not load format class {name} (from "
+                                f"'{mime_name}') fileformats.{namespace}"
+                                f"{err_msg_part} corresponding "
+                                f"to MIME, or MIME-like, type {mime_string}"
+                            ) from None
+
+                    classifiers_str, classified_name = format_name.split("+")
+                    classifiers = [get_format(c) for c in classifiers_str.split(".")]
+                    try:
+                        classified = get_format(classified_name)
+                    except FormatRecognitionError as e:
                         try:
                             classified = cls.generically_classifies_by_name[
                                 classified_name
                             ]
                         except KeyError:
-                            raise FormatRecognitionError(
-                                f"Could not load classified class '{classified_name}' from "
-                                f"fileformats.{namespace} or list of generic types "
-                                f"({list(cls.generically_classifies_by_name)}), "
-                                f"corresponding to MIME, or MIME-like, type {mime_string}"
-                            ) from None
+                            add_exc_note(
+                                e,
+                                (
+                                    "neither list of generic types "
+                                    f"({list(cls.generically_classifies_by_name)})"
+                                ),
+                            )
+                            raise e
                     klass = classified[classifiers]
                 else:
                     raise FormatRecognitionError(

fileformats/core/mixin.py

@@ -627,11 +627,18 @@ def namespace(cls):  # pylint: disable=no-self-argument
             if len(namespaces) == 1:
                 return next(iter(namespaces))
             else:
+                # Handle subpackage namespaces and parent, e.g. medimage & medimage-fsl
+                namespaces = sorted(namespaces)
+                if (
+                    len(namespaces) == 2
+                    and namespaces[1].split("-")[0] == namespaces[0]
+                ):
+                    return namespaces[1]
                 msg = (
                     "Cannot create reversible MIME type for because did not find a "
                     f"common namespace between all classifiers {list(cls.classifiers)}"
                 )
-                if cls.generically_classifies:
+                if not cls.generically_classifies:
                     msg += (
                         f" and (non genericly classified) base class {cls.unclassified}"
                     )

fileformats/core/tests/test_mime.py

@@ -1,9 +1,10 @@
 from fileformats.generic import FileSet
 from fileformats.core.utils import from_mime
+from fileformats.testing import Classified, U, V
+from fileformats.testing_subpackage import Psi, SubpackageClassified, Zeta, Theta
 
 
 def test_mime_roundtrip():
-
     for klass in FileSet.all_formats:
         mimetype = klass.mime_type
         assert isinstance(mimetype, str)
@@ -12,9 +13,44 @@ def test_mime_roundtrip():
 
 
 def test_mimelike_roundtrip():
-
     for klass in FileSet.all_formats:
         mimetype = klass.mime_like
         assert isinstance(mimetype, str)
         reloaded = from_mime(mimetype)
         assert reloaded is klass
+
+
+def test_subpackage_to_mime_roundtrip():
+    assert Psi.mime_like == "testing-subpackage/psi"
+    assert from_mime("testing-subpackage/psi") is Psi
+
+
+def test_subpackage_to_mime_classified_rountrip():
+    assert (
+        SubpackageClassified[Zeta, Theta].mime_like
+        == "testing-subpackage/theta.zeta+subpackage-classified"
+    )
+    assert (
+        from_mime("testing-subpackage/theta.zeta+subpackage-classified")
+        is SubpackageClassified[Zeta, Theta]
+    )
+
+
+def test_subpackage_to_mime_parent_classified_rountrip():
+    assert (
+        Classified[Zeta, Theta].mime_like == "testing-subpackage/theta.zeta+classified"
+    )
+    assert (
+        from_mime("testing-subpackage/theta.zeta+classified") is Classified[Zeta, Theta]
+    )
+
+
+def test_subpackage_to_mime_parent_classifiers_rountrip():
+    assert (
+        SubpackageClassified[U, V].mime_like
+        == "testing-subpackage/u.v+subpackage-classified"
+    )
+    assert (
+        from_mime("testing-subpackage/u.v+subpackage-classified")
+        is SubpackageClassified[U, V]
+    )

fileformats/testing_subpackage/__init__.py

@@ -0,0 +1,22 @@
+from fileformats.core import Classifier, DataType
+from fileformats.core.mixin import WithClassifiers
+
+
+class SubpackageClassified(WithClassifiers, DataType):
+    classifiers_attr_name = "classifiers"
+    classifiers = ()
+    multiple_classifiers = True
+    allowed_classifiers = (Classifier,)
+    generically_classifies = False
+
+
+class Psi(DataType):
+    pass
+
+
+class Zeta(Classifier):
+    pass
+
+
+class Theta(Classifier):
+    pass