controlpi_plugins.util

  1"""Provide utility plugins for all kinds of systems.
  2
  3- Log logs messages on stdout.
  4- Init sends list of messages on startup and on demand.
  5- Execute sends configurable list of messages on demand.
  6- Alias translates messages to an alias.
  7
  8>>> import controlpi
  9>>> asyncio.run(controlpi.test(
 10...     {"Test Log": {"plugin": "Log",
 11...                   "filter": [{"sender": {"const": "Test Alias"}}]},
 12...      "Test Init": {"plugin": "Init",
 13...                    "messages": [{"id": 42, "content": "Test Message"}]},
 14...      "Test Alias": {"plugin": "Alias",
 15...                     "from": {"sender": {"const": "Test Init"},
 16...                              "id": {"const": 42}},
 17...                     "to": {"id": "translated"}}}, []))
 18... # doctest: +NORMALIZE_WHITESPACE
 19test(): {'sender': '', 'event': 'registered',
 20         'client': 'Test Log', 'plugin': 'Log',
 21         'sends': [], 'receives': [{'sender': {'const': 'Test Alias'}}]}
 22test(): {'sender': '', 'event': 'registered',
 23         'client': 'Test Init', 'plugin': 'Init',
 24         'sends': [{'id': {'const': 42},
 25                    'content': {'const': 'Test Message'}}],
 26         'receives': [{'target': {'const': 'Test Init'},
 27                       'command': {'const': 'execute'}}]}
 28test(): {'sender': '', 'event': 'registered',
 29         'client': 'Test Alias', 'plugin': 'Alias',
 30         'sends': [{'id': {'const': 'translated'}}],
 31         'receives': [{'sender': {'const': 'Test Init'},
 32                       'id': {'const': 42}}]}
 33test(): {'sender': 'Test Init', 'id': 42,
 34         'content': 'Test Message'}
 35test(): {'sender': 'Test Alias', 'id': 'translated',
 36         'content': 'Test Message'}
 37Test Log: {'sender': 'Test Alias', 'id': 'translated',
 38           'content': 'Test Message'}
 39"""
 40
 41import asyncio
 42from datetime import datetime
 43
 44from controlpi import BasePlugin, Message, MessageTemplate
 45
 46from typing import List
 47
 48
 49class Log(BasePlugin):
 50    """Log messages on stdout.
 51
 52    The "filter" configuration key gets a list of message templates defining
 53    the messages that should be logged by the plugin instance.
 54
 55    In the following example the first and third message match the given
 56    template and are logged by the instance "Test Log", while the second
 57    message does not match and is only logged by the test, but not by the
 58    Log instance:
 59    >>> import controlpi
 60    >>> asyncio.run(controlpi.test(
 61    ...     {"Test Log": {"plugin": "Log",
 62    ...                   "filter": [{"id": {"const": 42}}]}},
 63    ...     [{"id": 42, "message": "Test Message"},
 64    ...      {"id": 42.42, "message": "Second Message"},
 65    ...      {"id": 42, "message": "Third Message"}]))
 66    ... # doctest: +NORMALIZE_WHITESPACE
 67    test(): {'sender': '', 'event': 'registered',
 68             'client': 'Test Log', 'plugin': 'Log',
 69             'sends': [], 'receives': [{'id': {'const': 42}}]}
 70    test(): {'sender': 'test()', 'id': 42, 'message': 'Test Message'}
 71    Test Log: {'sender': 'test()', 'id': 42, 'message': 'Test Message'}
 72    test(): {'sender': 'test()', 'id': 42.42, 'message': 'Second Message'}
 73    test(): {'sender': 'test()', 'id': 42, 'message': 'Third Message'}
 74    Test Log: {'sender': 'test()', 'id': 42, 'message': 'Third Message'}
 75
 76    The "filter" key is required:
 77    >>> asyncio.run(controlpi.test(
 78    ...     {"Test Log": {"plugin": "Log"}}, []))
 79    data must contain ['filter'] properties
 80    Configuration for 'Test Log' is not valid.
 81
 82    The "filter" key has to contain a list of message templates, i.e.,
 83    JSON objects:
 84    >>> asyncio.run(controlpi.test(
 85    ...     {"Test Log": {"plugin": "Log",
 86    ...                   "filter": [42]}}, []))
 87    data.filter[0] must be object
 88    Configuration for 'Test Log' is not valid.
 89    """
 90
 91    CONF_SCHEMA = {
 92        "properties": {"filter": {"type": "array", "items": {"type": "object"}}},
 93        "required": ["filter"],
 94    }
 95    """Schema for Log plugin configuration.
 96
 97    Required configuration key:
 98
 99    - 'filter': list of message templates to be logged.
100    """
101
102    def process_conf(self) -> None:
103        """Register plugin as bus client."""
104        self.bus.register(self.name, "Log", [], [(self.conf["filter"], self._log)])
105
106    async def _log(self, message: Message) -> None:
107        print(f"{self.name}: {message}")
108
109    async def run(self) -> None:
110        """Run no code proactively."""
111        pass
112
113
114class Init(BasePlugin):
115    """Send list of messages on startup and on demand.
116
117    The "messages" configuration key gets a list of messages to be sent on
118    startup. The same list is sent in reaction to a message with
119    "target": NAME and "command": "execute".
120
121    In the example, the two configured messages are sent twice, once at
122    startup and a second time in reaction to the "execute" command sent by
123    the test:
124    >>> import controlpi
125    >>> asyncio.run(controlpi.test(
126    ...     {"Test Init": {"plugin": "Init",
127    ...                    "messages": [{"id": 42,
128    ...                                  "content": "Test Message"},
129    ...                                 {"id": 42.42,
130    ...                                  "content": "Second Message"}]}},
131    ...     [{"target": "Test Init", "command": "execute"}]))
132    ... # doctest: +NORMALIZE_WHITESPACE
133    test(): {'sender': '', 'event': 'registered',
134             'client': 'Test Init', 'plugin': 'Init',
135             'sends': [{'id': {'const': 42},
136                        'content': {'const': 'Test Message'}},
137                       {'id': {'const': 42.42},
138                        'content': {'const': 'Second Message'}}],
139             'receives': [{'target': {'const': 'Test Init'},
140                           'command': {'const': 'execute'}}]}
141    test(): {'sender': 'Test Init', 'id': 42, 'content': 'Test Message'}
142    test(): {'sender': 'Test Init', 'id': 42.42, 'content': 'Second Message'}
143    test(): {'sender': 'test()', 'target': 'Test Init', 'command': 'execute'}
144    test(): {'sender': 'Test Init', 'id': 42, 'content': 'Test Message'}
145    test(): {'sender': 'Test Init', 'id': 42.42, 'content': 'Second Message'}
146
147    The "messages" key is required:
148    >>> asyncio.run(controlpi.test(
149    ...     {"Test Init": {"plugin": "Init"}}, []))
150    data must contain ['messages'] properties
151    Configuration for 'Test Init' is not valid.
152
153    The "messages" key has to contain a list of (partial) messages, i.e.,
154    JSON objects:
155    >>> asyncio.run(controlpi.test(
156    ...     {"Test Init": {"plugin": "Init",
157    ...                    "messages": [42]}}, []))
158    data.messages[0] must be object
159    Configuration for 'Test Init' is not valid.
160    """
161
162    CONF_SCHEMA = {
163        "properties": {"messages": {"type": "array", "items": {"type": "object"}}},
164        "required": ["messages"],
165    }
166    """Schema for Init plugin configuration.
167
168    Required configuration key:
169
170    - 'messages': list of messages to be sent.
171    """
172
173    def process_conf(self) -> None:
174        """Register plugin as bus client."""
175        self.bus.register(
176            self.name,
177            "Init",
178            [
179                MessageTemplate.from_message(message)
180                for message in self.conf["messages"]
181            ],
182            [
183                (
184                    [
185                        MessageTemplate(
186                            {
187                                "target": {"const": self.name},
188                                "command": {"const": "execute"},
189                            }
190                        )
191                    ],
192                    self._execute,
193                )
194            ],
195        )
196
197    async def _execute(self, message: Message) -> None:
198        for message in self.conf["messages"]:
199            await self.bus.send(Message(self.name, message))
200            # Give immediate reactions to messages opportunity to happen:
201            await asyncio.sleep(0)
202
203    async def run(self) -> None:
204        """Send configured messages on startup."""
205        for message in self.conf["messages"]:
206            await self.bus.send(Message(self.name, message))
207
208
209class Execute(BasePlugin):
210    """Send configurable list of messages on demand.
211
212    An Execute plugin instance receives two kinds of commands.
213    The "set messages" command has a "messages" key with a list of (partial)
214    messages, which are sent by the Execute instance in reaction to an
215    "execute" command.
216
217    In the example, the first command sent by the test sets two messages,
218    which are then sent in reaction to the second command sent by the test:
219    >>> import controlpi
220    >>> asyncio.run(controlpi.test(
221    ...     {"Test Execute": {"plugin": "Execute"}},
222    ...     [{"target": "Test Execute", "command": "set messages",
223    ...       "messages": [{"id": 42, "content": "Test Message"},
224    ...                    {"id": 42.42, "content": "Second Message"}]},
225    ...      {"target": "Test Execute", "command": "execute"}]))
226    ... # doctest: +NORMALIZE_WHITESPACE
227    test(): {'sender': '', 'event': 'registered',
228             'client': 'Test Execute', 'plugin': 'Execute',
229             'sends': [{}],
230             'receives': [{'target': {'const': 'Test Execute'},
231                           'command': {'const': 'set messages'},
232                           'messages': {'type': 'array',
233                                        'items': {'type': 'object'}}},
234                          {'target': {'const': 'Test Execute'},
235                           'command': {'const': 'execute'}}]}
236    test(): {'sender': 'test()', 'target': 'Test Execute',
237             'command': 'set messages',
238             'messages': [{'id': 42, 'content': 'Test Message'},
239                          {'id': 42.42, 'content': 'Second Message'}]}
240    test(): {'sender': 'test()', 'target': 'Test Execute',
241             'command': 'execute'}
242    test(): {'sender': 'Test Execute', 'id': 42,
243             'content': 'Test Message'}
244    test(): {'sender': 'Test Execute', 'id': 42.42,
245             'content': 'Second Message'}
246    """
247
248    CONF_SCHEMA = True
249    """Schema for Execute plugin configuration.
250
251    There are no required or optional configuration keys.
252    """
253
254    def process_conf(self) -> None:
255        """Register plugin as bus client."""
256        self.messages: List[Message] = []
257        self.bus.register(
258            self.name,
259            "Execute",
260            [MessageTemplate()],
261            [
262                (
263                    [
264                        MessageTemplate(
265                            {
266                                "target": {"const": self.name},
267                                "command": {"const": "set messages"},
268                                "messages": {
269                                    "type": "array",
270                                    "items": {"type": "object"},
271                                },
272                            }
273                        )
274                    ],
275                    self._set_messages,
276                ),
277                (
278                    [
279                        MessageTemplate(
280                            {
281                                "target": {"const": self.name},
282                                "command": {"const": "execute"},
283                            }
284                        )
285                    ],
286                    self._execute,
287                ),
288            ],
289        )
290
291    async def _set_messages(self, message: Message) -> None:
292        assert isinstance(message["messages"], list)
293        self.messages = list(message["messages"])
294
295    async def _execute(self, message: Message) -> None:
296        for message in self.messages:
297            await self.bus.send(Message(self.name, message))
298            # Give immediate reactions to messages opportunity to happen:
299            await asyncio.sleep(0)
300
301    async def run(self) -> None:
302        """Run no code proactively."""
303        pass
304
305
306class Alias(BasePlugin):
307    """Translate messages to an alias.
308
309    The "from" configuration key gets a message template and the
310    configuration key "to" a (partial) message. The "translate"
311    configuration key contains pairs of message keys, where the "from"
312    message key is translated to the "to" message key if present in the
313    message.
314
315    All messages matching the "from" template are received by the Alias
316    instance and a message translated by adding the keys and values of the
317    "to" message and the translated key-value pairs according to
318    "translate" is sent. Keys that are not "sender" and not modified by
319    "to" or "translate" are retained.
320
321    In the example, the two messages sent by the test are translated by the
322    Alias instance and the translated messages are sent by it preserving
323    the "content" keys:
324    >>> import controlpi
325    >>> asyncio.run(controlpi.test(
326    ...     {"Test Alias": {"plugin": "Alias",
327    ...                     "from": {"id": {"const": 42}},
328    ...                     "to": {"id": "translated"},
329    ...                     "translate": [{'from': "old", "to": "new"}]}},
330    ...     [{"id": 42, "content": "Test Message", "old": "content"},
331    ...      {"id": 42, "content": "Second Message", "old": "content"}]))
332    ... # doctest: +NORMALIZE_WHITESPACE
333    test(): {'sender': '', 'event': 'registered',
334             'client': 'Test Alias', 'plugin': 'Alias',
335             'sends': [{'id': {'const': 'translated'}}],
336             'receives': [{'id': {'const': 42}}]}
337    test(): {'sender': 'test()', 'id': 42,
338             'content': 'Test Message', 'old': 'content'}
339    test(): {'sender': 'test()', 'id': 42,
340             'content': 'Second Message', 'old': 'content'}
341    test(): {'sender': 'Test Alias', 'id': 'translated',
342             'content': 'Test Message', 'old': 'content', 'new': 'content'}
343    test(): {'sender': 'Test Alias', 'id': 'translated',
344             'content': 'Second Message', 'old': 'content', 'new': 'content'}
345
346    An Alias instance can also translate to a list of messages instead of
347    a single message:
348    >>> asyncio.run(controlpi.test(
349    ...     {"Test Alias": {"plugin": "Alias",
350    ...                     "from": {"id": {"const": 42}},
351    ...                     "to": [{"id": "first"}, {"id": "second"}],
352    ...                     "translate": [{'from': "old", "to": "new"}]}},
353    ...     [{"id": 42, "content": "Test Message", "old": "content"}]))
354    ... # doctest: +NORMALIZE_WHITESPACE
355    test(): {'sender': '', 'event': 'registered',
356             'client': 'Test Alias', 'plugin': 'Alias',
357             'sends': [{'id': {'const': 'first'}},
358                       {'id': {'const': 'second'}}],
359             'receives': [{'id': {'const': 42}}]}
360    test(): {'sender': 'test()', 'id': 42,
361             'content': 'Test Message', 'old': 'content'}
362    test(): {'sender': 'Test Alias', 'id': 'first',
363             'content': 'Test Message', 'old': 'content', 'new': 'content'}
364    test(): {'sender': 'Test Alias', 'id': 'second',
365             'content': 'Test Message', 'old': 'content', 'new': 'content'}
366
367    The "from" key is required:
368    >>> asyncio.run(controlpi.test(
369    ...     {"Test Alias": {"plugin": "Alias"}}, []))
370    data must contain ['from'] properties
371    Configuration for 'Test Alias' is not valid.
372
373    The "from" key has to contain a message template and the "to" key a
374    (partial) message, i.e., both have to be JSON objects:
375    >>> asyncio.run(controlpi.test(
376    ...     {"Test Alias": {"plugin": "Alias",
377    ...                     "from": 42,
378    ...                     "to": 42}}, []))
379    data.from must be object
380    Configuration for 'Test Alias' is not valid.
381    >>> asyncio.run(controlpi.test(
382    ...     {"Test Alias": {"plugin": "Alias",
383    ...                     "from": {"id": {"const": 42}},
384    ...                     "to": 42}}, []))
385    data.to cannot be validated by any definition
386    Configuration for 'Test Alias' is not valid.
387    """
388
389    CONF_SCHEMA = {
390        "properties": {
391            "from": {"type": "object"},
392            "to": {
393                "anyOf": [
394                    {"type": "object"},
395                    {"type": "array", "items": {"type": "object"}},
396                ]
397            },
398            "translate": {
399                "type": "array",
400                "items": {
401                    "type": "object",
402                    "properties": {
403                        "from": {"type": "string"},
404                        "to": {"type": "string"},
405                    },
406                },
407            },
408        },
409        "required": ["from"],
410    }
411    """Schema for Alias plugin configuration.
412
413    Required configuration keys:
414
415    - 'from': template of messages to be translated.
416
417    Optional configuration keys:
418
419    - 'to': translated message(s) to be sent.
420    - 'translate': array of pairs of keys to be translated.
421    """
422
423    def process_conf(self) -> None:
424        """Register plugin as bus client."""
425        sends = []
426        self._to = []
427        if "to" in self.conf:
428            if isinstance(self.conf["to"], list):
429                self._to = self.conf["to"]
430                for to in self.conf["to"]:
431                    sends.append(MessageTemplate.from_message(to))
432            else:
433                self._to = [self.conf["to"]]
434                sends.append(MessageTemplate.from_message(self.conf["to"]))
435        self._translate = {}
436        if "translate" in self.conf:
437            for pair in self.conf["translate"]:
438                self._translate[pair["from"]] = pair["to"]
439        self.bus.register(
440            self.name, "Alias", sends, [([self.conf["from"]], self._alias)]
441        )
442
443    async def _alias(self, message: Message) -> None:
444        # Prevent endless loop:
445        if message["sender"] != self.name:
446            for to in self._to:
447                alias_message = Message(self.name, message)
448                alias_message.update(to)
449                for key in self._translate:
450                    if key in message:
451                        alias_message[self._translate[key]] = message[key]
452                await self.bus.send(alias_message)
453
454    async def run(self) -> None:
455        """Run no code proactively."""
456        pass
457
458
459class Counter(BasePlugin):
460    """Count messages confirming to a given template.
461
462    The plugin counts messages confirming to the given template. The
463    counter can be queried and reset by commands. The 'reset' command also
464    queries the last count before the reset:
465    >>> import controlpi
466    >>> asyncio.run(controlpi.test(
467    ...     {"Test Counter": {"plugin": "Counter",
468    ...                       "count": {"id": {"const": 42}}}},
469    ...     [{"target": "Test Counter", "command": "get count"},
470    ...      {"id": 42}, {"id": 42}, {"id": 49},
471    ...      {"target": "Test Counter", "command": "get count"},
472    ...      {"id": 42}, {"id": 42}, {"id": 42},
473    ...      {"target": "Test Counter", "command": "reset"},
474    ...      {"target": "Test Counter", "command": "get count"},
475    ...      {"id": 42}, {"id": 42}, {"id": 42},
476    ...      {"target": "Test Counter", "command": "get count"}]))
477    ... # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
478    test(): {'sender': '', 'event': 'registered',
479             'client': 'Test Counter', 'plugin': 'Counter',
480             'sends': [{'count': {'type': 'integer'}}],
481             'receives': [{'id': {'const': 42}},
482                          {'target': {'const': 'Test Counter'},
483                           'command': {'const': 'get count'}},
484                          {'target': {'const': 'Test Counter'},
485                           'command': {'const': 'reset'}}]}
486    test(): {'sender': 'test()', 'target': 'Test Counter',
487             'command': 'get count'}
488    test(): {'sender': 'test()', 'id': 42}
489    test(): {'sender': 'Test Counter', 'count': 0,
490             'since': ..., 'until': ...}
491    test(): {'sender': 'test()', 'id': 42}
492    test(): {'sender': 'test()', 'id': 49}
493    test(): {'sender': 'test()', 'target': 'Test Counter',
494             'command': 'get count'}
495    test(): {'sender': 'test()', 'id': 42}
496    test(): {'sender': 'Test Counter', 'count': 2,
497             'since': ..., 'until': ...}
498    test(): {'sender': 'test()', 'id': 42}
499    test(): {'sender': 'test()', 'id': 42}
500    test(): {'sender': 'test()', 'target': 'Test Counter',
501             'command': 'reset'}
502    test(): {'sender': 'test()', 'target': 'Test Counter',
503             'command': 'get count'}
504    test(): {'sender': 'Test Counter', 'count': 5,
505             'since': ..., 'until': ...}
506    test(): {'sender': 'test()', 'id': 42}
507    test(): {'sender': 'Test Counter', 'count': 0,
508             'since': ..., 'until': ...}
509    test(): {'sender': 'test()', 'id': 42}
510    test(): {'sender': 'test()', 'id': 42}
511    test(): {'sender': 'test()', 'target': 'Test Counter',
512             'command': 'get count'}
513    test(): {'sender': 'Test Counter', 'count': 3,
514             'since': ..., 'until': ...}
515    """
516
517    CONF_SCHEMA = {
518        "properties": {
519            "count": {"type": "object"},
520            "date format": {"type": "string", "default": "%Y-%m-%d %H:%M:%S"},
521        },
522        "required": ["count"],
523    }
524    """Schema for Counter plugin configuration.
525
526    Required configuration key:
527
528    - 'count': template of messages to be counted.
529    """
530
531    def process_conf(self) -> None:
532        """Register plugin as bus client."""
533        self._since = datetime.now().strftime(self.conf["date format"])
534        self._counter = 0
535        self.bus.register(
536            self.name,
537            "Counter",
538            [MessageTemplate({"count": {"type": "integer"}})],
539            [
540                ([MessageTemplate(self.conf["count"])], self._count),
541                (
542                    [
543                        MessageTemplate(
544                            {
545                                "target": {"const": self.name},
546                                "command": {"const": "get count"},
547                            }
548                        )
549                    ],
550                    self._get_count,
551                ),
552                (
553                    [
554                        MessageTemplate(
555                            {
556                                "target": {"const": self.name},
557                                "command": {"const": "reset"},
558                            }
559                        )
560                    ],
561                    self._reset,
562                ),
563            ],
564        )
565
566    async def _count(self, message: Message) -> None:
567        self._counter += 1
568
569    async def _get_count(self, message: Message) -> None:
570        now = datetime.now().strftime(self.conf["date format"])
571        await self.bus.send(
572            Message(
573                self.name, {"count": self._counter, "since": self._since, "until": now}
574            )
575        )
576
577    async def _reset(self, message: Message) -> None:
578        now = datetime.now().strftime(self.conf["date format"])
579        counter = self._counter
580        self._counter = 0
581        await self.bus.send(
582            Message(self.name, {"count": counter, "since": self._since, "until": now})
583        )
584        self._since = now
585
586    async def run(self) -> None:
587        """Run no code proactively."""
588        pass
589
590
591class Date(BasePlugin):
592    """Send message with current date.
593
594    The plugin reacts to 'get date' commands by sending messages with
595    a 'date' key:
596    >>> import controlpi
597    >>> asyncio.run(controlpi.test(
598    ...     {"Test Date": {"plugin": "Date"}},
599    ...     [{"target": "Test Date", "command": "get date"}]))
600    ... # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
601    test(): {'sender': '', 'event': 'registered',
602             'client': 'Test Date', 'plugin': 'Date',
603             'sends': [{'date': {'type': 'string'}}],
604             'receives': [{'target': {'const': 'Test Date'},
605                           'command': {'const': 'get date'}}]}
606    test(): {'sender': 'test()', 'target': 'Test Date',
607             'command': 'get date'}
608    test(): {'sender': 'Test Date', 'date': ...}
609
610    The format of the date can be configured with the 'format'
611    configuration key:
612    >>> asyncio.run(controlpi.test(
613    ...     {"Test Date": {"plugin": "Date",
614    ...                    "format": "%Y%m%d%H%M%S%f"}},
615    ...     [{"target": "Test Date", "command": "get date"}]))
616    ... # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
617    test(): {'sender': '', 'event': 'registered',
618             'client': 'Test Date', 'plugin': 'Date',
619             'sends': [{'date': {'type': 'string'}}],
620             'receives': [{'target': {'const': 'Test Date'},
621                           'command': {'const': 'get date'}}]}
622    test(): {'sender': 'test()', 'target': 'Test Date',
623             'command': 'get date'}
624    test(): {'sender': 'Test Date', 'date': ...}
625    """
626
627    CONF_SCHEMA = {
628        "properties": {"format": {"type": "string", "default": "%Y-%m-%d %H:%M:%S"}}
629    }
630    """Schema for Date plugin configuration.
631
632    Optional configuration key:
633
634    - 'format': format for the sent datetime string.
635                Default: '%Y-%m-%d %H:%M:%S'
636    """
637
638    def process_conf(self) -> None:
639        """Register plugin as bus client."""
640        self.bus.register(
641            self.name,
642            "Date",
643            [MessageTemplate({"date": {"type": "string"}})],
644            [
645                (
646                    [
647                        MessageTemplate(
648                            {
649                                "target": {"const": self.name},
650                                "command": {"const": "get date"},
651                            }
652                        )
653                    ],
654                    self._date,
655                )
656            ],
657        )
658
659    async def _date(self, message: Message) -> None:
660        date = datetime.now().strftime(self.conf["format"])
661        await self.bus.send(Message(self.name, {"date": date}))
662
663    async def run(self) -> None:
664        """Run no code proactively."""
665        pass