Skip to content

Subject

Subject

Create subjects for components to communicate on.

A subject is an entity that maintains a state and notifies its observers when the state changes. Observers can be any object that implements the Observer interface.

Key Features:

  • State Management: Subjects maintain their own state and provide access to it through the state property.
  • Observer Management: Subjects manage a list of attached observers and notify them when the state changes.
  • Loose Coupling: Subjects are not directly dependent on the implementation of their observers, promoting flexibility and maintainability.

Usage:

  1. Create a subject instance.
  2. Attach observers to the subject using the attach method.
  3. Modify the subject's state using the state property.
  4. The subject will automatically notify all attached observers when the state changes.

Example:

class ConcreteSubject(Subject):
    def __init__(self, initial_state):
        super().__init__()
        self._state = initial_state

    def do_something(self):
        # Modify the subject's state
        self.state = {"key": "value"}

# Create a subject and an observer
subject = ConcreteSubject({"initial": "value"})
observer = Observer()

# Attach the observer to the subject
subject.attach(observer)

# Modify the subject's state
subject.do_something()

Additional Notes:

  • The state property can be any type of data, depending on the subject's implementation.
  • Observers can choose to ignore notifications if they are not interested in the updated state.
  • The subject can manage multiple observers and notify them individually or in groups.
Source code in zenaura/client/observer/subject.py 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
class Subject:
    """
    Create subjects for components to communicate on.

    A subject is an entity that maintains a state and notifies its observers when the state changes.
    Observers can be any object that implements the `Observer` interface.

    **Key Features:**

    - **State Management:** Subjects maintain their own state and provide access to it through the `state` property.
    - **Observer Management:** Subjects manage a list of attached observers and notify them when the state changes.
    - **Loose Coupling:** Subjects are not directly dependent on the implementation of their observers, 
      promoting flexibility and maintainability.

    **Usage:**

    1. Create a subject instance.
    2. Attach observers to the subject using the `attach` method.
    3. Modify the subject's state using the `state` property.
    4. The subject will automatically notify all attached observers when the state changes.

    **Example:**

    ```python
    class ConcreteSubject(Subject):
        def __init__(self, initial_state):
            super().__init__()
            self._state = initial_state

        def do_something(self):
            # Modify the subject's state
            self.state = {"key": "value"}

    # Create a subject and an observer
    subject = ConcreteSubject({"initial": "value"})
    observer = Observer()

    # Attach the observer to the subject
    subject.attach(observer)

    # Modify the subject's state
    subject.do_something()
    ```

    **Additional Notes:**

    - The `state` property can be any type of data, depending on the subject's implementation.
    - Observers can choose to ignore notifications if they are not interested in the updated state.
    - The subject can manage multiple observers and notify them individually or in groups.
    """

    def __init__(self):
        """
        Initialize a new Subject.

        Parameters:
        None

        Returns:
        None
        """
        self._observers = set()
        self._state = {}

    def attach(self, observer):
        """
        Attach an observer to the subject.

        Parameters:
        observer (Observer): The observer to attach.

        Returns:
        None
        """
        self._observers.add(observer)

    def detach(self, observer):
        """
        Detach an observer from the subject.

        Parameters:
        observer (Observer): The observer to detach.

        Returns:
        None
        """
        self._observers.discard(observer)

    def notify(self):
        """
        Notify all attached observers.

        Parameters:
        None

        Returns:
        None
        """
        for observer in self._observers:
            observer.update(self._state)

    @property
    def state(self):
        """
        Get the state of the subject.

        Parameters:
        None

        Returns:
        dict: The state of the subject.
        """
        return self._state

    @state.setter
    def state(self, new_value):
        """
        Set the state of the subject and notify observers.

        Parameters:
        new_value (dict): The new state of the subject.

        Returns:
        None
        """
        self._state = new_value
        self.notify()

state property writable

Get the state of the subject.

Parameters: None

Returns: dict: The state of the subject.

__init__()

Initialize a new Subject.

Parameters: None

Returns: None

Source code in zenaura/client/observer/subject.py 
52
53
54
55
56
57
58
59
60
61
62
63
def __init__(self):
    """
    Initialize a new Subject.

    Parameters:
    None

    Returns:
    None
    """
    self._observers = set()
    self._state = {}

attach(observer)

Attach an observer to the subject.

Parameters: observer (Observer): The observer to attach.

Returns: None

Source code in zenaura/client/observer/subject.py 
65
66
67
68
69
70
71
72
73
74
75
def attach(self, observer):
    """
    Attach an observer to the subject.

    Parameters:
    observer (Observer): The observer to attach.

    Returns:
    None
    """
    self._observers.add(observer)

detach(observer)

Detach an observer from the subject.

Parameters: observer (Observer): The observer to detach.

Returns: None

Source code in zenaura/client/observer/subject.py 
77
78
79
80
81
82
83
84
85
86
87
def detach(self, observer):
    """
    Detach an observer from the subject.

    Parameters:
    observer (Observer): The observer to detach.

    Returns:
    None
    """
    self._observers.discard(observer)

notify()

Notify all attached observers.

Parameters: None

Returns: None

Source code in zenaura/client/observer/subject.py 
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
def notify(self):
    """
    Notify all attached observers.

    Parameters:
    None

    Returns:
    None
    """
    for observer in self._observers:
        observer.update(self._state)