You are given an existing ABC-based interface and two classes that currently inherit from it. Your task is to create an equivalent Protocol, verify that both classes satisfy it without inheritance, and compare `isinstance()` behavior between the two approaches.

You are given the following existing code:

```python
from abc import ABC, abstractmethod

class Transformer(ABC):
    @abstractmethod
    def transform(self, data):
        pass

    @abstractmethod
    def get_name(self):
        pass

class UpperCaseTransformer(Transformer):
    def transform(self, data):
        return [item.upper() for item in data]

    def get_name(self):
        return "UpperCase"

class TrimTransformer(Transformer):
    def transform(self, data):
        return [item.strip() for item in data]

    def get_name(self):
        return "Trim"
```

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_transformer_protocol_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "TransformerProtocol"),
            "The `TransformerProtocol` class is declared.",
            "Expected `TransformerProtocol` to be declared."
        )

    def test_reverse_transformer_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "ReverseTransformer"),
            "The `ReverseTransformer` class is declared.",
            "Expected `ReverseTransformer` to be declared."
        )

    def test_reverse_transformer_no_abc_inheritance(self):
        import user_code
        _dynamic_test(
            self,
            not issubclass(user_code.ReverseTransformer, user_code.Transformer),
            "`ReverseTransformer` does not inherit from `Transformer`.",
            "Expected `ReverseTransformer` to not inherit from `Transformer`."
        )

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

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

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

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

    def test_reverse_transform_correct(self):
        import user_code
        reverser = user_code.ReverseTransformer()
        result = reverser.transform(["hello", "world"])
        _dynamic_test(
            self,
            result == ["olleh", "dlrow"],
            "`ReverseTransformer.transform()` returns correctly reversed strings.",
            f"Expected `['olleh', 'dlrow']`, but got `{result}`."
        )


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: Refactoring an ABC to a Protocol

Løsning