You are building a plugin system for a data export tool. Plugins are registered with a central registry and must conform to a standard interface. Your task is to implement the ABC, two concrete plugins, and a virtual subclass registration.

You are given the following third-party class that you cannot modify:

```python
class LegacyXmlExporter:
    def export(self, data):
        items = "".join(f"<item>{row}</item>" for row in data)
        return f"<root>{items}</root>"

    def get_format(self):
        return "XML"
```



import unittest
from abc import ABC

# Helper function to dynamically generate test names and assertions
def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)


class TestUserCode(unittest.TestCase):

    def test_exporter_plugin_is_abc(self):
        import user_code
        _dynamic_test(
            self,
            issubclass(user_code.ExporterPlugin, ABC),
            "`ExporterPlugin` is a subclass of `ABC`.",
            "Expected `ExporterPlugin` to inherit from `ABC`."
        )

    def test_exporter_plugin_abstract_methods(self):
        import user_code
        expected = {"export", "get_format"}
        actual = user_code.ExporterPlugin.__abstractmethods__
        _dynamic_test(
            self,
            actual == expected,
            f"`ExporterPlugin.__abstractmethods__` contains `{expected}`.",
            f"Expected `__abstractmethods__` to be `{expected}`, but got `{actual}`."
        )

    def test_markdown_exporter_is_concrete(self):
        import user_code
        _dynamic_test(
            self,
            len(user_code.MarkdownExporter.__abstractmethods__) == 0,
            "`MarkdownExporter` has no remaining abstract methods.",
            "Expected `MarkdownExporter` to implement all abstract methods."
        )

    def test_markdown_export_output(self):
        import user_code
        exporter = user_code.MarkdownExporter()
        result = exporter.export(["item_one", "item_two"])
        _dynamic_test(
            self,
            "- item_one" in result and "- item_two" in result,
            "`MarkdownExporter.export()` returns a markdown list with both items.",
            f"Expected result to contain `- item_one` and `- item_two`, but got `{result!r}`."
        )

    def test_md_is_plugin(self):
        import user_code
        condition = False
        failure_message = "The `md_is_plugin` variable is not declared."
        try:
            condition = user_code.md_is_plugin is True
            failure_message = f"Expected `md_is_plugin` to be `True`, but got `{user_code.md_is_plugin}`."
        except AttributeError:
            pass
        _dynamic_test(
            self,
            condition,
            "The `md_is_plugin` is `True`.",
            failure_message
        )

    def test_xml_is_plugin(self):
        import user_code
        condition = False
        failure_message = "The `xml_is_plugin` variable is not declared."
        try:
            condition = user_code.xml_is_plugin is True
            failure_message = f"Expected `xml_is_plugin` to be `True`, but got `{user_code.xml_is_plugin}`."
        except AttributeError:
            pass
        _dynamic_test(
            self,
            condition,
            "The `xml_is_plugin` is `True`.",
            failure_message
        )

    def test_subclasshook_defined(self):
        import user_code
        _dynamic_test(
            self,
            "__subclasshook__" in user_code.ExporterPlugin.__dict__,
            "`ExporterPlugin` defines `__subclasshook__`.",
            "Expected `ExporterPlugin` to define `__subclasshook__`."
        )

    def test_legacy_registered(self):
        import user_code
        _dynamic_test(
            self,
            issubclass(user_code.LegacyXmlExporter, user_code.ExporterPlugin),
            "`LegacyXmlExporter` is recognized as a subclass of `ExporterPlugin`.",
            "Expected `LegacyXmlExporter` to be registered or recognized as a subclass of `ExporterPlugin`."
        )


if __name__ == "__main__":
    unittest.main()

test_main.py

Explore the power and flexibility of Python's Abstract Base Classes (ABCs). Learn how to design robust APIs, enforce contracts, and distinguish between ABCs and protocols for advanced object-oriented programming.

Discover why Abstract Base Classes matter, how to define them, and the rules for enforcing abstract methods in Python.

Delve into advanced features of ABCs, including abstract properties, virtual subclassing, and custom membership logic.

Compare typing.Protocol with ABCs, explore runtime checkable protocols, and learn when to use each approach.

Challenge: Building a Plugin Interface

Solution