devstream/shadow.py at main · diegofps/devstream · GitHub

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
128
129
130
131
132
133
134
135
from devstreamlog import DevStreamLogger


class Shadow:

    def __init__(self, name=None):
        self.name = type(self).__name__ if name is None else name
        self.state_name = f"{self.name}>STATE"
        self.required_devices = set()
        self.reflex_kwargs = {}
        self.active = False
        self.reflexes = {}
        self.mind = None

        self.log = DevStreamLogger(filename=f"{self.name}.log")
        self.log.info(f"Creating shadow {self.name}")

    def add_reflex(self, ReflexType, **kwargs):
        self.log.debug(f"Adding reflex: ReflexType.name=\"{ReflexType.__name__}\", kwargs=\"{kwargs}\"")
        reflex = ReflexType(**{**self.reflex_kwargs, **kwargs})
        assert not reflex.name in self.reflexes, f"Shadow {self.name} already contains a reflex with the name {reflex.name}"
        self.reflexes[reflex.name] = reflex
        reflex.attach(self)
        return reflex

    def remove_reflex(self, reflex_name):
        if reflex_name in self.reflexes:
            reflex = self.reflexes[reflex_name]
            del self.reflexes[reflex_name]
            reflex.dettach()

    def require_device(self, device_name):
        self.log.debug(f"Requiring device_name=\"{device_name}\"")
        self.required_devices.update(device_name)

    def attach(self, mind):
        assert not self.is_attached(), "This shadow is already attached to a mind"
        assert not self.is_activated(), "This shadow is already activated"

        self.log.info(f"Attaching shadow {self.name} to mind")
        self.mind = mind

        self.on_configure()

    def dettach(self):
        assert self.is_attached(), "This shadow is not attached to a mind"

        self.log.info(f"Dettaching shadow {self.name}")

        if self.is_activated():
            self.deactivate()

        self.mind = None

    def activate(self):
        self.log.debug(f"Inside activate for shadow {self.name}")

        assert self.is_attached(), "This shadow is not attached"
        assert not self.is_activated(), "This shadow is already activated"

        self.active = True
        self.mind.add_listener(self.state_name, self.on_state_changed)
        self.mind.require_device(self.required_devices)

        for reflex in self.reflexes.values():
            if reflex.autostart or reflex.keepalive:
                self.log.debug(f"Shadow {self.name} is activating reflex {reflex.name}")
                reflex.activate()

        self.on_activate()

    def shift_reflex(self, reflex_name, *args, **kwargs):
        self.log.debug(f"Shifting to reflex {reflex_name}, args={args}m kwargs={kwargs} within shadow {self.name}")
        assert self.is_attached(), "Needs to be attached to use activate_reflex"
        self.mind.emit(self.state_name, (reflex_name, args, kwargs), 50)

    def deactivate(self):
        self.log.info(f"Deactivating shadow {self.name}")

        assert self.is_attached(), "This shadow is not attached"
        assert self.is_activated(), "This shadow is not activated"

        self.mind.remove_listener(self.state_name, self.on_state_changed)

        for reflex in self.reflexes.values():
            if reflex.is_activated():
                reflex.deactivate()

        self.active = False
        self.on_deactivate()

    def is_attached(self):
        return self.mind is not None

    def is_activated(self):
        return self.active

    def on_configure(self, **reflex_kwargs):
        if not 'log_prefix' in reflex_kwargs:
            reflex_kwargs['log_prefix'] = self.name
        self.log.info(f"Configuring Shadow name=\"{self.name}\", reflex_kwargs=\"{reflex_kwargs}\"")
        self.reflex_kwargs = reflex_kwargs
        self.require_device(reflex_kwargs.get('required_devices', []))

    def on_activate(self):
        pass

    def on_deactivate(self):
        pass

    def on_state_changed(self, topic_name, event):
        self.log.info(f"Received an state changed event at shadow {self.name}: topic={topic_name}, event={event}")

        reflex_name, args, kwargs = event
        target_reflex = None

        for reflex in self.reflexes.values():
            if reflex.name == reflex_name:
                target_reflex = reflex
                break

        if target_reflex is None:
            self.log.warn(f"Shadow {self.name} if trying to shift reflexes but couldn't find the target reflex {reflex_name}, args={args}, kwargs={kwargs}")

        elif target_reflex.is_activated():
            self.log.warn(f"Shadow {self.name} if trying to shift reflexes but the target reflex {reflex_name} is already activated, args={args}, kwargs={kwargs}")

        else:
            for reflex in self.reflexes.values():
                if reflex != target_reflex and not reflex.keepalive:
                    if reflex.is_activated():
                        reflex.deactivate()

            target_reflex.activate(*args, **kwargs)