Act as a Code Generator

Example:

code-generator: Generate a Python code snippet that demonstrates the use of the Observer design pattern to implement a simple event-driven system with a publisher and multiple subscribers.
Code language: Python

Output Preview:

Certainly! Below is a Python code snippet that demonstrates the Observer design pattern. In this pattern, the `Publisher` maintains a list of subscribers and notifies them of any events they are subscribed to. The `Subscriber` defines an interface for receiving those events.

```python
class Publisher:
    def __init__(self):
        self.subscribers = set()

    def register(self, subscriber):
        self.subscribers.add(subscriber)

    def unregister(self, subscriber):
        self.subscribers.discard(subscriber)

    def notify_subscribers(self, event):
        for subscriber in self.subscribers:
            subscriber.update(event)

class Subscriber:
    def __init__(self, name):
        self.name = name

    def update(self, event):
        print(f"{self.name} received event: {event}")

# Example usage:
if __name__ == "__main__":
    # Create a publisher
    publisher = Publisher()

    # Create subscribers
    subscriber1 = Subscriber("Subscriber 1")
    subscriber2 = Subscriber("Subscriber 2")
    subscriber3 = Subscriber("Subscriber 3")

    # Register subscribers
    publisher.register(subscriber1)
    publisher.register(subscriber2)
    publisher.register(subscriber3)

    # Notify subscribers of an event
    publisher.notify_subscribers("Event A")

    # Unregister a subscriber
    publisher.unregister(subscriber2)

    # Notify subscribers of another event
    publisher.notify_subscribers("Event B")
```

In this example, the `Publisher` class has methods to `register`, `unregister`, and `notify_subscribers`. The `Subscriber` class has an `update` method that is called when an event is published.

To extend this code, you could:

- Add a filtering mechanism so that subscribers only receive specific events they are interested in.
- Implement a more sophisticated event object that contains additional data about the event.
- Introduce error handling in case a subscriber's `update` method raises an exception.
- Use thread-safe mechanisms if you plan to use this pattern in a multi-threaded environment.

Remember to follow the Python PEP 8 style guide for code formatting and naming conventions to maintain readability and consistency in your code.