wirely 0.1.0__py3-none-any.whl

wirely/lib/time.wrl

@@ -0,0 +1,93 @@
+// TODO: Should this only contain real-time-related blocks or also monotonic-time-related blocks?
+
+namespace Time {
+// Block which return false if the current time is before input, true if the current time is at or after input and None if the current time is not comparable to input.
+node type MonotonicTimeReached {
+  implicit input : value MonotonicTime;
+
+  implicit output : value Option[boolean];
+
+  native procedure run depends on implicit input produces implicit output;
+}
+
+// Delay changes until the input has be stable for at least time
+node type DelayChange {
+  parameter Type : ValueType;
+
+  // TODO: Probably should be renamed to Duration
+  parameter Time : Duration;
+
+  implicit input : value Type;
+
+  implicit output : value Type;
+
+  // The value which was last sent as output
+  state CurrentValue : Option[Type] = None;
+  // The value which was the last input
+  state NewValue : Option[Type] = None;
+  // The time when the output will change to NewValue if there are no further changes
+  state UpdateTime : MonotonicTime = MonotonicTime.Invalid;
+
+  node Reached : MonotonicTimeReached;
+  // TODO: Allow this?
+  // connect UpdateTime.old -> Reached;
+  temporary UpdateTimeOld : MonotonicTime;
+  native procedure read_update_time produces UpdateTimeOld;
+  connect UpdateTimeOld -> Reached;
+
+  native procedure run depends on implicit input, Reached produces implicit output, CurrentValue, NewValue, UpdateTime;
+}
+
+// Note: Should not be used directly if possible
+native singleton node type TimeOfDayMinute {
+  implicit output : value TimeOfDay;
+
+  // TODO: Should this be "stage input"? Should this use some global time?
+  native procedure get_value produces implicit output;
+}
+
+// TODO: Implement this in a way which does not cause code to be run every minute
+node type IsBetween {
+  // TODO: capitalization of parameters?
+  parameter start : TimeOfDay;
+  parameter end : TimeOfDay;
+
+  implicit output : value boolean;
+
+  node current_time : TimeOfDayMinute;
+
+  native procedure run depends on current_time produces implicit output;
+}
+
+// Creates an event whenever the current time changes from the range of 8 hours
+// before Time to the range 2 hours after Time, if since the last time it was
+// in the range 2 hours after Time the time was at lease once outside both
+// ranges.
+// 8/2 hours should be long enough to allow triggering even during DST changes
+// and make sure that it is triggered only once a day during DST changes.
+// TODO: Make ranges configurable? (In that case something needs to make sure that the don't overlap, and probably that they don't add up to 24h.)
+node type TriggerAt {
+  parameter Time : TimeOfDay;
+
+  // TODO: Should this be called Type/Value or OutputType/OutputValue?
+  // Defaults to unit
+  parameter Type : ValueType = unit;
+  // Defaults to ()
+  optional parameter Value : Type;
+
+  implicit output : event Type;
+
+  // Keeps track of the last state
+  // TODO: Introduce an enum for this?
+  // 0: Initial state / outside any range
+  // 1: In 'before' range, transition to 'after' range will trigger output
+  // 2: Has already triggered (or at least was in 'after' range), waiting for time outside any range
+  state State : uint8 = 0;
+
+  // Note: This relies on both blocks using the same time source, so that there is no cycle/step at the Time where both or neither are true.
+  node before : IsBetween(start = TimeOfDay_AddWrap(Time, "-08:00"), end = Time);
+  node after : IsBetween(start = Time, end = TimeOfDay_AddWrap(Time, "02:00"));
+
+  native procedure run depends on before, after produces implicit output, State;
+}
+}

wirely/lib/two_n.wrl

@@ -0,0 +1,111 @@
+namespace TwoN {
+native node type Device {
+  parameter Hostname : String;
+  parameter Port : uint16 = 443;
+  parameter TLSA : List[String];
+  parameter UsernamePasswordFile : String;
+
+  implicit output : two_n_device;
+}
+
+// Get an event whenever a key is pressed or released
+native node type KeyEvent {
+  parameter Key : String;
+
+  input Device : two_n_device;
+
+  // True if the key is pressed, false if it released.
+  implicit output : event boolean;
+
+  native procedure get_value stage input produces implicit output;
+}
+
+// Get the current state of a key
+//
+// Might be incorrect after startup if key is already pressed on startup.
+// TODO: When the connection is lost, this also should reset the value to "False"
+node type KeyState {
+  parameter Key : String;
+  // Timeout after which the key will be assumed to be released (because
+  // "2N -> Calling -> Dialing -> Quick dial button functionality test" will
+  // trigger a KeyPressed event but no KeyReleased event).
+  parameter Timeout : Duration = "30s";
+
+  input Device : two_n_device;
+
+  // True if the key is pressed, false otherwise.
+  implicit output : value boolean;
+
+  node key_event : KeyEvent(Key=Key);
+  connect Device -> key_event.Device;
+
+  // The current value which is kept if there is no new event
+  state CurrentValue : boolean = false;
+
+  // The next time at which the the state will be reset to False.
+  // If this time is not comparable to the current time, the the state will be reset to False.
+  state TimeoutTime : MonotonicTime = MonotonicTime.Invalid;
+
+  node TimeoutReached : Time.MonotonicTimeReached;
+  // TODO: Allow this?
+  // connect TimeoutTime.old -> TimeoutReached;
+  temporary TimeoutTimeOld : MonotonicTime;
+  native procedure read_timeout_time produces TimeoutTimeOld;
+  connect TimeoutTimeOld -> TimeoutReached;
+
+  native procedure get_value depends on key_event, TimeoutReached produces implicit output, TimeoutTime, CurrentValue;
+}
+
+// Get the current state of an input or output
+// TODO: Regularly get the current value?
+native node type IOState {
+  parameter Port : String;
+
+  input Device : two_n_device;
+
+  // True if the input/output is on, false otherwise.
+  implicit output : value boolean;
+
+  native procedure get_value stage input produces implicit output;
+}
+
+// Get the current state of a switch
+// TODO: Regularly get the current value?
+native node type SwitchState {
+  parameter SwitchNumber : int32;
+
+  input Device : two_n_device;
+
+  // True if the switch is active, false otherwise.
+  implicit output : value boolean;
+
+  // TODO: Outputs for "locked" and "held"?
+
+  native procedure get_value stage input produces implicit output;
+}
+
+native node type CodeEnteredEvent {
+  parameter Code : String;
+
+  input Device : two_n_device;
+
+  implicit output : event unit;
+
+  native procedure get_value stage input produces implicit output;
+}
+
+native node type OutputControl {
+  parameter Port : String;
+
+  input Device : two_n_device;
+
+  // True to turn the output is on, false to turn it off.
+  implicit input : event boolean;
+
+  native procedure send_value stage output depends on implicit input;
+}
+
+// TODO: Block for setting output from value?
+
+// TODO: Block for setting switch from event? Also allow toggle? Also allow lock/unlock/hold/release?
+}

wirely/misc/service.py

@@ -0,0 +1,48 @@
+import asyncio
+import sys
+import signal
+
+
+# TODO: Should this be in service.util?
+
+# TODO: Shouldn't the handlers be set earlier for most callers?
+# Maybe this should be split into a part which throws when a signal is received and a part which just sleeps until canceled
+async def loop_until_sigint(allow_sigterm=True) -> None:
+    """Loop until Crtl-C was pressed."""
+
+    sigint_received = asyncio.Event()
+
+    def sigint_handler() -> None:
+        """End loop."""
+        sigint_received.set()
+
+    if sys.platform == "win32":
+        print("Windows does not support signals", flush=True)
+    else:
+        loop = asyncio.get_running_loop()
+        loop.add_signal_handler(signal.SIGINT, sigint_handler)
+        if allow_sigterm:
+            loop.add_signal_handler(signal.SIGTERM, sigint_handler)
+    print("Press Ctrl+C to stop", flush=True)
+    await sigint_received.wait()
+    # TODO: Reset handlers?
+
+
+class TerminateProgram(BaseException):
+    pass
+
+
+async def loop_until_sigint_and_throw(allow_sigterm=True):
+    await loop_until_sigint(allow_sigterm=allow_sigterm)
+    # Raising a KeyboardInterrupt (or SystemExit) here causes a
+    # "Task exception was never retrieved" message
+    # See <https://github.com/python/cpython/issues/101515>
+    # Raise a different exception instead
+    # raise KeyboardInterrupt()
+    raise TerminateProgram()
+
+
+async def should_never_return(awaitable):
+    # TODO: Get a stacktrace here and show that if awaitable returns?
+    await awaitable
+    raise Exception('Awaitable which should never return has returned: {}'.format(awaitable))

wirely/native/__init__.py

@@ -0,0 +1,74 @@
+import inspect
+import importlib
+import typing
+
+import wirely as blocks
+from wirely.util import check_parameters
+
+
+@check_parameters
+def native_block_type(namespace_dict, *, has_state: bool, data_type: typing.Optional[type] = None):
+    def native_block_type_impl(cls):
+        cls_name = cls.__name__
+
+        cls.native_block_has_state = has_state
+        cls.native_block_data_type = data_type
+
+        native_procedures = {}
+        for name, value in cls.__dict__.items():
+            if not inspect.isfunction(value):
+                continue
+            if not hasattr(value, 'is_native_procedure') or not value.is_native_procedure:
+                continue
+
+            if not has_state and not isinstance(inspect.getattr_static(cls, name), staticmethod):
+                raise Exception(f'Native procedure name {name!r} in block {cls_name!r} is not static but block type is stateless')
+
+            if name in native_procedures:
+                raise Exception(f'Duplicate native procedure name {name!r} in block {cls_name!r}')
+            native_procedures[name] = value
+        cls.native_procedures = native_procedures
+
+        if cls_name in namespace_dict:
+            raise Exception(f'Duplicate native block name {cls_name!r}')
+        namespace_dict[cls_name] = cls
+
+        return cls
+    return native_block_type_impl
+
+
+def native_procedure(proc):
+    # TODO: Check parameters of procedure?
+    proc.is_native_procedure = True
+    return proc
+
+
+native_block_pkgs = {
+    ('Std',): 'std',
+    ('Time',): 'time',
+    ('KNX',): 'knx',
+    ('ABB', 'JRA'): 'abb_jra',
+    ('MQTT',): 'mqtt',
+    ('CSV',): 'csv',
+    ('TwoN',): 'two_n',
+    ('GPIO',): 'gpio',
+    ('TestLibrary',): 'test_library',
+    ('Memory',): 'memory',
+    ('ExtProg',): 'ext_prog',
+}
+
+
+@check_parameters
+def get_native_block_type(block_type: blocks.BlockType):
+    pkg_name = native_block_pkgs.get(block_type.fullname_tuple[:-1], None)
+    if pkg_name is None:
+        raise Exception(f'Block type {block_type.fullname!r} needs a native class but no native classes found for {block_type.fullname_tuple[:-1]}')
+
+    pkg = importlib.import_module('.' + pkg_name, __name__)
+    native_classes = pkg.native_block_types
+
+    native_class = native_classes.get(block_type.name.id_str, None)
+    if native_class is None:
+        raise Exception(f'Block type {block_type.fullname!r} needs a native class but cannot find one')
+
+    return native_class

wirely/native/abb_jra.py

@@ -0,0 +1,66 @@
+import enum
+
+import wirely as blocks
+from wirely.native import native_block_type, native_procedure
+
+native_block_types = {}
+
+
+class JRAStatus(enum.IntFlag):
+    # See JRAS_xxx1_PH_EN_V1-4_2CDC506051D0204.pdf, page 106
+
+    # Low byte
+    ManualOperation = (1 << 0)
+    BlockActive = (1 << 1)
+    ForcedOperation = (1 << 2)
+    FrostAlarm = (1 << 3)
+    RainAlarm = (1 << 4)
+    WindAlarm = (1 << 5)
+    AutomaticSunProtection = (1 << 6)
+    AutomaticHeatingCooling = (1 << 7)
+
+    # High byte
+    DriveError = (1 << 8)
+    DriveInMotion = (1 << 9)
+    DriveDown = (1 << 10)
+    DriveUp = (1 << 11)
+    SendReceiveDelayActive = (1 << 12)
+    # Unassigned13 = (1 << 13)
+    # Unassigned14 = (1 << 14)
+    # Unassigned15 = (1 << 15)
+
+@native_block_type(native_block_types, has_state=False)
+class InterpretStatusInformation:
+    @native_procedure
+    @staticmethod
+    def run(*, context):
+        input_var = context.static.sources['implicit input']
+
+        val = context.dep_values[input_var]
+        val = JRAStatus(val)
+
+        for flag in JRAStatus:
+            name = flag.name
+            output_var = context.static.targets[name]
+            res = bool(val & flag)
+            context.results[output_var] = res
+
+@native_block_type(native_block_types, has_state=False)
+class InterpretStatusInformationOption:
+    @native_procedure
+    @staticmethod
+    def run(*, context):
+        input_var = context.static.sources['implicit input']
+
+        val = context.dep_values[input_var]
+        if val is not None:
+            val = JRAStatus(val[0])
+
+        for flag in JRAStatus:
+            name = flag.name
+            output_var = context.static.targets[name]
+            if val is None:
+                res = None
+            else:
+                res = (bool(val & flag),)
+            context.results[output_var] = res

wirely/native/csv.py

@@ -0,0 +1,194 @@
+import asyncio
+import contextlib
+import dataclasses
+import os
+import sys
+
+import wirely as blocks
+from wirely.native import native_block_type, native_procedure
+
+native_block_types = {}
+
+
+class CsvValue:
+    def __init__(self, value, do_quote):
+        self.value = value
+        self.do_quote = do_quote
+
+        if not do_quote:
+            if '\r' in value or '\n' in value or ',' in value or '"' in value:
+                raise Exception(f'Attempting to create CsvValue for string {value!r} without quoting')
+
+
+class MyCsvWriter:
+    def __init__(self, stream):
+        self.stream = stream
+
+    # https://www.rfc-editor.org/rfc/rfc4180
+    def write_row(self, row):
+        csv_string = ''
+        for i, value in enumerate(row):
+            if not isinstance(value, CsvValue):
+                raise Exception(f'Expected a CsvValue, got a {type(value)}')
+
+            if i > 0:
+                csv_string += ','
+
+            if value.do_quote:
+                csv_string += '"' + value.value.replace('"', '""')
+            else:
+                csv_string += value.value
+        csv_string += '\r\n'
+
+        encoded = csv_string.encode('utf-8')
+        # print(encoded)
+        # TODO: Use os.write or stream.write? Is stream.write atomic?
+        self.stream.write(encoded)
+
+
+@dataclasses.dataclass(frozen=True)
+class CsvWriterParameters:
+    type: blocks.Type
+    filename: str
+
+    @staticmethod
+    def create(*, parameter_values):
+        ty = parameter_values['Type']
+        if not ty.has_to_csv_value:
+            # TODO: Error message position?
+            raise Exception(f'Type {ty} does not support converting to CSV')
+
+        filename = parameter_values['Filename'].value
+
+        return CsvWriterParameters(type=ty, filename=filename)
+
+
+@native_block_type(native_block_types, has_state=True, data_type=CsvWriterParameters)
+class ValueWriter(blocks.NativeState):
+    # TODO: Should writing to the file be done on a background thread?
+
+    def __init__(self, path, engine, static_block_context):
+        super().__init__(path, engine, static_block_context)
+
+        self.file = None
+
+        self.data = static_block_context.parsed_native_instance
+
+        self.last_value_csv = ('', False)
+
+        # TODO: Clean this up
+        proc = None
+        for p in self.block_or_singleton.block_procedures:
+            if p.name == 'run':
+                proc = p
+        if proc is None:
+            raise Exception('proc is None')
+        self.proc = proc
+
+    def start_tasks(self, task_group, async_exit_stack: contextlib.AsyncExitStack):
+        super().start_tasks(task_group, async_exit_stack)
+
+        async_exit_stack.enter_context(self.open_file())
+
+    @contextlib.contextmanager
+    def open_file(self):
+        if self.file is not None:
+            raise Exception('File already open')
+
+        print(f'Opening CSV file {self.data.filename!r}', flush=True)
+        with open(self.data.filename, 'a+b', buffering=0) as file:
+            size = file.seek(0, 2)
+            if size != 0:
+                last_byte = os.pread(file.fileno(), 1, size - 1)
+                print(f'  got byte at end: {last_byte!r}', flush=True)
+                if last_byte == b'':
+                    raise Exception('Failed to read last byte')
+                elif last_byte != b'\n':
+                    print(f'  Incomplete line at end, writing newline', flush=True)
+                    # Note: Write only \n instead of \r\n, so a reader can see that this was an incomplete line
+                    # TODO: Use os.write instead?
+                    file.write(b'\n')
+
+            try:
+                self.file = file
+                self.writer = MyCsvWriter(file)
+
+                try:
+                    yield
+                finally:
+                    time = self.engine.shutdown_time
+                    if time is None:
+                        if self.last_value_csv != ('', False):
+                            print(f'CSV.ValueWriter: Warning: engine.shutdown_time is None during shutdown but a value has been written', flush=True, file=sys.stderr)
+                    else:
+                        self.write_value(('', False), time)
+                        # Make sure that if after the shutdown another step is run run() will be called again
+                        self.engine.trigger(self.block_path, self.proc)
+            finally:
+                self.writer = None
+                self.file = None
+
+    # TODO: Periodically re-write the current value
+
+    def write_value(self, new_value_csv, time, *, force=False):
+        if self.last_value_csv == new_value_csv and not force:
+            return False
+
+        row = [
+            CsvValue(time.isoformat(), False),
+            CsvValue(*self.last_value_csv),
+            CsvValue(*new_value_csv),
+        ]
+        # print(f'CSV: Got value {new_value} {time.isoformat()}')
+        if self.writer is None:
+            # TODO: What should be done here? Seems to happen during shutdown (called from run())
+            print(f'CSV.ValueWriter: Warning: self.writer is None in write_value()', flush=True, file=sys.stderr)
+            # TODO: What should be returned here?
+            return True
+        self.writer.write_row(row)
+        self.last_value_csv = new_value_csv
+        return True
+
+    @native_procedure
+    def read_update_time(self, *, context):
+        var_output = context.static.targets['RepeatTimeOld']
+        var_state = context.static.state['RepeatTime']
+
+        value = context.state_old[var_state]
+        context.results[var_output] = value
+
+    @native_procedure
+    def run(self, *, context):
+        data = context.static.block.parsed_native_instance
+
+        var_input = context.static.sources['implicit input']
+        var_repeat_time_reached = context.static.sources['RepeatTimeReached']
+        var_repeat_time = context.static.state['RepeatTime']
+
+        new_value = context.dep_values[var_input]
+        reached = context.dep_values[var_repeat_time_reached]
+        repeat_time = context.state_old[var_repeat_time]
+
+        new_value_csv = self.data.type.to_csv_value(new_value)
+
+        # If reached is None or (True,), the value has to be repeated
+        # Note: The empty value is not repeated
+        force = reached != (False,) and new_value_csv != ('', False)
+        # print(f'NewValue={new_value} Reached={reached} force={force}')
+
+        # Note: This uses RunStage.Default to be as consistent as possible with the time seen by procedures in the default stage
+        time = context.step_info.stage_start_time[blocks.RunStage.Default]
+
+        if force:
+            # Make sure that if in the next cycle/step the timeout is reached again, the procedure will be called again.
+            # TODO: Should this simply be done whenever write_value() is called?
+            self.engine.trigger(self.block_path, self.proc)
+
+        written = self.write_value(new_value_csv, time, force=force)
+        if written:
+            # TODO: Think what happens if new_value_csv is ('', False)
+            now = context.step_info.stage_start_time_monotonic[blocks.RunStage.Default]
+            # Write value once an hour
+            repeat_time = now + blocks.Duration.parse('PT1H')
+
+        context.state_new[var_repeat_time] = repeat_time

wirely/native/ext_prog.py

@@ -0,0 +1,77 @@
+import dataclasses
+import contextlib
+import asyncio
+
+import wirely as blocks
+from wirely.native import native_block_type, native_procedure
+
+native_block_types = {}
+
+
+@dataclasses.dataclass(frozen=True)
+class LaunchOnEventData:
+    shell_command: str
+
+    @staticmethod
+    def create(*, parameter_values):
+        par_shell_command = parameter_values['ShellCommand'].value
+
+        return LaunchOnEventData(shell_command=par_shell_command)
+
+
+@native_block_type(native_block_types, has_state=True, data_type=LaunchOnEventData)
+class LaunchOnEvent(blocks.NativeState):
+    def __init__(self, path, engine, static_block_context):
+        super().__init__(path, engine, static_block_context)
+
+        self.data = static_block_context.parsed_native_instance
+
+        self.task = None
+        self.pending = False
+        self.event = asyncio.Event()
+
+        # TODO: Clean this up
+        proc = None
+        for p in self.block_or_singleton.block_procedures:
+            if p.name == 'run':
+                proc = p
+        if proc is None:
+            raise Exception('proc is None')
+        self.proc = proc
+
+    def start_tasks(self, task_group, async_exit_stack: contextlib.AsyncExitStack):
+        super().start_tasks(task_group, async_exit_stack)
+
+        if self.task is not None:
+            raise Exception('self.task is not None')
+
+        self.task = self.start_task(task_group, async_exit_stack, self.run_task())
+
+    @native_procedure
+    def run(self, *, context):
+        var_input = context.static.sources['implicit input']
+        inp = context.dep_values[var_input]
+
+        if inp is None:
+            return
+
+        if self.pending:
+            print('Warning: ExtProg.LaunchOnEvent: Got new trigger while launch is already pending', flush=True)
+        self.pending = True
+        self.event.set()
+
+        # This makes sure that the value is sent again if the input does not change
+        self.engine.trigger(self.block_path, self.proc)
+
+    async def run_task(self):
+        while True:
+            while not self.pending:
+                # Note: This relies on the fact that everything is running on one thread and therefore everything without await is atomic with regard to other tasks
+                self.event.clear()
+                await self.event.wait()
+            self.pending = False
+
+            print(f'Launching command {self.data.shell_command!r}', flush=True)
+            proc = await asyncio.create_subprocess_exec('/bin/sh', '-c', self.data.shell_command)
+            code = await proc.wait()
+            print(f'Command {self.data.shell_command!r} finished with exit code {code}', flush=True)