relaxed restrictions on nested classifiers

Author: tclose

fileformats/core/mixin.py

@@ -272,7 +272,18 @@ def my_func(file: MyFormatWithClassifiers[Integer]):
     allowed_classifiers : tuple[type,...], optional
         the allowable types (+ subclasses) for the content types. If None all types
         are allowed
-    genericly_classified : bool, optional
+    multiple_classifiers: bool, optional
+        whether multiple classifiers can be provided (true) or just a single classifier (false)
+    allow_optional_classifiers: bool, optional
+        whether Optional classifiers are allowed in the classifier set. Optional classifiers are
+        classifiers that are wrapped in typing.Optional[], indicating that the classifier
+        may or may not be present in the format
+    exclusive_classifiers: tuple[ty.Type[Classifier], ...], optional
+        a set of classifiers that are exclusive, i.e. only one classifier from each
+        by default empty.
+    ordered_classifiers: bool, optional
+        whether the order of the classifiers matters (true) or not (false). If false,
+    genericly_classified: bool, optional
         whether the class can be classified by classifiers in any namespace (true) or just the
         namespace it belongs to (false). If true, then the namespace of the genericly
         classified class is omitted from the "mime-like" string. Note that the
@@ -380,7 +391,9 @@ def __class_getitem__(
                     }
                     for classifier in classifiers_to_check:
                         for exc_classifier in repetitions:
-                            if issubclass(classifier, exc_classifier):
+                            if issubclass(
+                                origin_type(classifier), origin_type(exc_classifier)
+                            ):
                                 repetitions[exc_classifier].append(classifier)
                     repeated = [t for t in repetitions.items() if len(t[1]) > 1]
                     if repeated:
@@ -758,3 +771,11 @@ class WithClassifier(WithClassifiers):
 class WithOrderedClassifiers(WithClassifiers):
 
     ordered_classifiers = True
+
+
+def origin_type(tp: ty.Type) -> ty.Type:
+    """Get the origin type of a possibly generic type"""
+    origin = ty.get_origin(tp)
+    if origin is None:
+        return tp
+    return origin

fileformats/core/tests/test_mime.py

@@ -1,7 +1,11 @@
+import typing as ty
+import pytest
 from fileformats.application import Cdfx___Xml
-from fileformats.core.identification import from_mime
+from fileformats.core import DataType
+from fileformats.core.identification import to_mime, from_mime
 from fileformats.generic import DirectoryOf, FileSet
-from fileformats.testing import Classified, U, V
+from fileformats.application import Zip
+from fileformats.testing import Classified, A, B, U, V, X, MyFormat
 from fileformats.vendor.testing.testing import Psi, VendorClassified, Theta, Zeta
 from fileformats.vendor.openxmlformats_officedocument.application import (
     Wordprocessingml_Document,
@@ -24,59 +28,108 @@ def test_mimelike_roundtrip() -> None:
         assert reloaded is klass
 
 
-def test_vendor_to_mime_roundtrip() -> None:
-    assert Psi.mime_like == "testing/vnd.testing.psi"
-    assert from_mime("testing/vnd.testing.psi") is Psi
+@pytest.mark.parametrize(
+    ["klass", "expected_mime"],
+    [
+        [Psi, "testing/vnd.testing.psi"],
+        [
+            VendorClassified[Zeta, Theta],
+            "testing/[vnd.testing.theta..vnd.testing.zeta]+vnd.testing.vendor-classified",
+        ],
+        [
+            Classified[Zeta, Theta],
+            "testing/[vnd.testing.theta..vnd.testing.zeta]+classified",
+        ],
+        [VendorClassified[U, V], "testing/[u..v]+vnd.testing.vendor-classified"],
+        [Zip[Classified[U]], "testing/u+classified+zip"],
+        [Zip[Classified[U, X]], "testing/[u..v]+classified+zip"],
+        [Classified[U, Zip[MyFormat]], "testing/[u..my-format+zip]+classified"],
+        [Classified[U, MyFormat[A, B]], "testing/[u..[a..b]+my-format]+classified"],
+        [
+            Wordprocessingml_Document,
+            "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        ],
+        [
+            DirectoryOf[Wordprocessingml_Document],
+            "application/vnd.openxmlformats-officedocument.wordprocessingml.document+directory",
+        ],
+        [Cdfx___Xml, "application/vnd.ms-cdfx+xml"],
+        [U | V, "testing/u,testing/v"],
+    ],
+)
+def test_compound_mime_roundtrip(klass: ty.Type[DataType], expected_mime: str) -> None:
+    assert to_mime(klass, official=False) == expected_mime
+    assert from_mime(expected_mime) is klass
+
+
+# def test_vendor_to_mime_roundtrip() -> None:
+#     assert Psi.mime_like == "testing/vnd.testing.psi"
+#     assert from_mime("testing/vnd.testing.psi") is Psi
+
+
+# def test_vendor_to_mime_classified_rountrip() -> None:
+#     assert (
+#         VendorClassified[Zeta, Theta].mime_like
+#         == "testing/[vnd.testing.theta..vnd.testing.zeta]+vnd.testing.vendor-classified"
+#     )
+#     assert (
+#         from_mime(
+#             "testing/[vnd.testing.theta..vnd.testing.zeta]+vnd.testing.vendor-classified"
+#         )
+#         is VendorClassified[Zeta, Theta]
+#     )
+
+
+# def test_vendor_to_mime_parent_classified_rountrip() -> None:
+#     assert (
+#         Classified[Zeta, Theta].mime_like
+#         == "testing/[vnd.testing.theta..vnd.testing.zeta]+classified"
+#     )
+#     assert (
+#         from_mime("testing/[vnd.testing.theta..vnd.testing.zeta]+classified")
+#         is Classified[Zeta, Theta]
+#     )
+
+
+# def test_vendor_to_mime_parent_classifiers_rountrip() -> None:
+#     assert (
+#         VendorClassified[U, V].mime_like
+#         == "testing/[u..v]+vnd.testing.vendor-classified"
+#     )
+#     assert (
+#         from_mime("testing/[u..v]+vnd.testing.vendor-classified")
+#         is VendorClassified[U, V]
+#     )
 
 
-def test_vendor_to_mime_classified_rountrip() -> None:
-    assert (
-        VendorClassified[Zeta, Theta].mime_like
-        == "testing/[vnd.testing.theta..vnd.testing.zeta]+vnd.testing.vendor-classified"
-    )
-    assert (
-        from_mime(
-            "testing/[vnd.testing.theta..vnd.testing.zeta]+vnd.testing.vendor-classified"
-        )
-        is VendorClassified[Zeta, Theta]
-    )
+# def test_double_classified_roundtrip1() -> None:
+#     assert Zip[Classified[U]].mime_like == "testing/u+classified+zip"
+#     assert from_mime("testing/[[u..v]+classified]+zip") is Zip[Classified[U]]
 
 
-def test_vendor_to_mime_parent_classified_rountrip() -> None:
-    assert (
-        Classified[Zeta, Theta].mime_like
-        == "testing/[vnd.testing.theta..vnd.testing.zeta]+classified"
-    )
-    assert (
-        from_mime("testing/[vnd.testing.theta..vnd.testing.zeta]+classified")
-        is Classified[Zeta, Theta]
-    )
+# def test_double_classified_roundtrip2() -> None:
+#     assert Zip[Classified[U, V]].mime_like == "testing/[u..v]+classified+zip"
+#     assert from_mime("testing/[[u..v]+classified]+zip") is Zip[Classified[U, V]]
 
 
-def test_vendor_to_mime_parent_classifiers_rountrip() -> None:
-    assert (
-        VendorClassified[U, V].mime_like
-        == "testing/[u..v]+vnd.testing.vendor-classified"
-    )
-    assert (
-        from_mime("testing/[u..v]+vnd.testing.vendor-classified")
-        is VendorClassified[U, V]
-    )
+# def test_double_classified_roundtrip2() -> None:
+#     assert Zip[Classified[U, V]].mime_like == "testing/[u..v]+classified+zip"
+#     assert from_mime("testing/[[u..v]+classified]+zip") is Zip[Classified[U, V]]
 
 
-def test_vendor_roundtrip() -> None:
+# def test_vendor_roundtrip() -> None:
 
-    mime = Wordprocessingml_Document.mime_like
-    assert Wordprocessingml_Document is from_mime(mime)
+#     mime = Wordprocessingml_Document.mime_like
+#     assert Wordprocessingml_Document is from_mime(mime)
 
 
-def test_vendor_in_container_roundtrip() -> None:
+# def test_vendor_in_container_roundtrip() -> None:
 
-    mime = DirectoryOf[Wordprocessingml_Document].mime_like
-    assert DirectoryOf[Wordprocessingml_Document] is from_mime(mime)
+#     mime = DirectoryOf[Wordprocessingml_Document].mime_like
+#     assert DirectoryOf[Wordprocessingml_Document] is from_mime(mime)
 
 
-def test_native_container_roundtrip() -> None:
+# def test_native_container_roundtrip() -> None:
 
-    mime = Cdfx___Xml.mime_like
-    assert Cdfx___Xml is from_mime(mime)
+#     mime = Cdfx___Xml.mime_like
+#     assert Cdfx___Xml is from_mime(mime)

fileformats/core/utils.py

@@ -3,6 +3,8 @@
 import itertools
 import logging
 import os
+import sys
+import types
 import pkgutil
 import typing as ty
 import urllib.error
@@ -20,6 +22,12 @@
 logger = logging.getLogger("fileformats")
 
 
+if sys.version_info >= (3, 10):
+    UNION_TYPES = (ty.Union, types.UnionType)
+else:
+    UNION_TYPES = (ty.Union,)
+
+
 _excluded_subpackages = set(
     [
         "core",
@@ -256,7 +264,7 @@ def get_optional_type(
     bool
         whether the type is an Optional type or not
     """
-    if ty.get_origin(type_) is None:
+    if not is_union(type_):
         return type_  # type: ignore[return-value]
     if not allowed:
         raise FormatDefinitionError(
@@ -270,3 +278,25 @@ def get_optional_type(
             f"not {type_}"
         )
     return args[0] if args[0] is not None else args[1]  # type: ignore[no-any-return]
+
+
+def is_union(type_: type, args: list[type] = None) -> bool:
+    """Checks whether a type is a Union, in either ty.Union[T, U] or T | U form
+
+    Parameters
+    ----------
+    type_ : type
+        the type to check
+    args : list[type], optional
+        required arguments of the union to check, by default (None) any args will match
+
+    Returns
+    -------
+    is_union : bool
+        whether the type is a Union type
+    """
+    if ty.get_origin(type_) in UNION_TYPES:
+        if args is not None:
+            return ty.get_args(type_) == args
+        return True
+    return False