wirely 0.1.0__py3-none-any.whl

wirely/engine.py

@@ -0,0 +1,418 @@
+import asyncio
+import contextlib
+import datetime
+
+import wirely as blocks
+from wirely.util import check_parameters
+
+class Engine:
+    def __init__(self, program):
+        if not isinstance(program, blocks.Program):
+            raise Exception('program parameter is not a Program')
+
+        self.program = program
+
+        self.cache = None
+
+        self.debug = False
+
+        # Is a datetime during async task shutdown unless the shutdown was triggered before all async tasks were started
+        self.shutdown_time = None
+
+        # The time of the last complete async task shutdown. Should be used only for debugging / tests.
+        self.last_shutdown_time = None
+
+        self.triggered_procs = set()
+        self.triggered_procs_event = asyncio.Event()
+
+        self.wakeups = {}
+        self.next_wakeup = None
+
+        self.state = blocks.VariableBlockInstance(self.program.state_variables)
+        self.native_states = {}
+
+        self.fake_monotonic_time_offset = None
+
+        # TODO: Clean up iterating over all blocks paths
+        done_block_path = set()
+        for block_name in self.program.graph.blocks:
+            for block_path in self.program.graph.blocks[block_name].get_all_block_paths(()):
+                if block_path in done_block_path:
+                    if len(block_path) != 1 or not isinstance(block_path[-1], blocks.BlockType):
+                        raise Exception('Got duplicate non-singleton block')
+                    continue
+                done_block_path.add(block_path)
+
+                block = block_path[-1]
+                instance = self.program.instances[block_path]
+                # TODO: Clean up
+                if instance.is_singleton:
+                    if block != instance.block_type:
+                        raise Exception('block != instance.block_type')
+                else:
+                    if block != instance.block:
+                        raise Exception('block != instance.block')
+
+                # TODO: Pass full context to native state constructor?
+                self.native_states[block_path] = block.create_native_state(block_path, self, static_block_context=instance.static_context)
+                # TODO: Remove hack
+                if not isinstance(block, blocks.Block):
+                    block = block.singleton_instance
+                for var in block.block_statevars:
+                    self.state.add(self.program.state_map[block_path, var], var.initial_value)
+
+    async def start_tasks_async(self, task_group, async_exit_stack: contextlib.AsyncExitStack):
+        def start_task_cleanup():
+            now_monotonic = blocks.MonotonicTime.current_time()
+            if self.fake_monotonic_time_offset is not None:
+                now_monotonic += self.fake_monotonic_time_offset
+
+            now_utc = datetime.datetime.now(datetime.timezone.utc)
+            now = now_utc.astimezone()
+
+            print(f'Task cleanup starting at {now}')
+
+            # TODO: Set monotonic_shutdown_time?
+            self.shutdown_time = now
+
+        def finish_task_cleanup():
+            print('Task cleanup done')
+
+            self.last_shutdown_time = self.shutdown_time
+            self.shutdown_time = None
+
+        async_exit_stack.callback(finish_task_cleanup)
+
+        # TODO: Currently this (e.g. connecting to knxd) is blocking and done sequentially. Should ths be non-blocking instead? (I.e. should the connection be created on the background task and should start_tasks_async() be removed?)
+        for state in self.native_states.values():
+            if state is not None:
+                state.start_tasks(task_group, async_exit_stack)
+                await state.start_tasks_async(task_group, async_exit_stack)
+
+        async_exit_stack.callback(start_task_cleanup)
+
+    # TODO: Threading?
+    def trigger(self, path, proc):
+        # TODO: More checks with path
+        if not isinstance(proc, blocks.Block.Procedure):
+            raise Exception('proc parameter is not a Block.Procedure')
+
+        if (path, proc) not in self.program.all_procs_set:
+            # print(self.program.all_procs_set)
+            raise Exception(f'Got procedure {path} {proc} which is not in {self.program.graph}')
+
+        self.triggered_procs.add((path, proc))
+        self.triggered_procs_event.set()
+
+    # Update self.next_wakeup to include wakeup_time
+    def update_next_wakeup(self, now, wakeup_time):
+        if wakeup_time is not None and not wakeup_time.is_invalid and not blocks.MonotonicTime.is_comparable(now, wakeup_time):
+            print('Warning: Got non-current wakeup time {wakeup_time}', flush=True)
+            wakeup_time = blocks.MonotonicTime.create_invalid()
+        if wakeup_time is None:
+            return
+
+        if self.next_wakeup is None or wakeup_time.is_invalid or blocks.MonotonicTime.compare(self.next_wakeup, wakeup_time) > 0:
+            self.next_wakeup = wakeup_time
+
+    def step(self):
+        if self.debug:
+            print(f'Starting step of {self.program.graph}')
+            # print(f'Wakeups: {self.wakeups}')
+
+        self.next_wakeup = None
+
+        cache = self.cache
+        state_old = self.state
+        state_new = blocks.VariableBlockInstance(self.program.state_variables)
+        vars = blocks.VariableBlockInstance(self.program.temporaries)
+        run_count = 0
+        change_count = 0
+        state_change_count = 0
+        step_info = blocks.StepContext()
+        for stage, stage_procs in self.program.procs.items():
+            # print(f'Stage {stage}', flush=True)
+            step_info.start_stage(self, stage)
+
+            now = step_info.stage_start_time_monotonic[stage]
+
+            for path, proc in stage_procs:
+                if path[-1] != proc.block:
+                    if isinstance(path[-1], blocks.Block):  # TODO: Handle singletons here?
+                        raise Exception('path[-1] != proc.block')
+                native_state = self.native_states[path]
+
+                # print(proc)
+                deps = {}
+                skip_step = cache is not None and (path, proc) not in self.triggered_procs
+                for dep in proc.dependencies:
+                    if isinstance(dep, blocks.Block.StateVariable):
+                        # TODO
+                        raise Exception('isinstance(dep, blocks.Block.StateVariable)')
+                        if skip_step and not dep.impl_var_type.equals(state_old[self.program.state_map[path, dep]], cache[dep]):
+                            skip_step = False
+                    elif isinstance(dep, blocks.Block.Input) and dep.is_list:
+                        for child in dep.members:
+                            # TODO: Move this code somewhere else? / Use already resolved type?
+                            var_type = child.impl_var_type
+                            for block in reversed(path):
+                                var_type = var_type.resolve_self(block.par_values)
+
+                            deps[child] = vars[self.program.variable_map[path, child.var_identifier]]
+                            if skip_step and not var_type.equals(vars[self.program.variable_map[path, child.var_identifier]], cache[self.program.variable_map[path, child.var_identifier]]):
+                                skip_step = False
+                    else:
+                        # TODO: Move this code somewhere else? / Use already resolved type?
+                        var_type = dep.impl_var_type
+                        for block in reversed(path):
+                            var_type = var_type.resolve_self(block.par_values)
+
+                        # TODO: Program should contain some mapping from a procedures dependencies to variables, this should not be done here
+                        # print(path, dep, dep.var_identifier)
+                        if isinstance(path[-1], blocks.Block) and path[-1] != dep.block:
+                            if dep.block.block_type.is_singleton:
+                                variable = self.program.variable_map[(dep.block.block_type,), dep.var_identifier]
+                            else:
+                                # TODO: This assumes that dep.block is a direct child of the current block, this will not work otherwise
+                                variable = self.program.variable_map[path + (dep.block,), dep.var_identifier]
+                        else:
+                            variable = self.program.variable_map[path, dep.var_identifier]
+
+                        deps[dep] = vars[variable]
+                        if skip_step and not var_type.equals(vars[variable], cache[variable]):
+                            skip_step = False
+                # TODO: Avoid depending on the value of all state variables?
+                for dep in proc.block.block_statevars:
+                    if skip_step and cache[self.program.state_map_changed[path, dep]]:
+                        skip_step = False
+                res = {}
+
+                if (path, proc) in self.wakeups:
+                    if not blocks.MonotonicTime.is_comparable(now, self.wakeups[(path, proc)]) or blocks.MonotonicTime.compare(now, self.wakeups[(path, proc)]) >= 0:
+                        # Timeout, run step
+                        skip_step = False
+
+                if skip_step:
+                    for res_var in proc.results:
+                        if isinstance(res_var, blocks.Block.StateVariable):
+                            old_value = state_old[self.program.state_map[path, res_var]]
+                            state_new.add(self.program.state_map[path, res_var], old_value)
+                            vars.add(self.program.state_map_new[path, res_var], old_value)
+                            vars.add(self.program.state_map_changed[path, res_var], False)
+                        else:
+                            # TODO: Clean up temporary / output stuff
+                            vars.add(self.program.variable_map[path, res_var.var_identifier], cache[self.program.variable_map[path, res_var.var_identifier]])
+
+                    if (path, proc) in self.wakeups:
+                        self.update_next_wakeup(now, self.wakeups[(path, proc)])
+                    continue
+
+                if self.debug:
+                    print(f'Running procedure {path} {proc}')
+
+                run_count += 1
+
+                if (path, proc) in self.triggered_procs:
+                    self.triggered_procs.remove((path, proc))
+
+                state_old_block = {}
+                # TODO: Remove state_new_block, use res instead?
+                state_new_block = {}
+                for var in proc.block.block_statevars:
+                    state_old_block[var] = state_old[self.program.state_map[path, var]]
+                    # TODO: Should this be initialized here?
+                    # state_new_block[var] = state_old[var]
+
+                variables = None # TODO
+                instance = self.program.instances[path]
+                pcontext = blocks.ProcedureContext(dep_values=deps, results=res, state_old=state_old_block, state_new=state_new_block, static=self.program.proc_static_contexts[(instance, proc)], step_info=step_info)
+                proc.impl(context=pcontext, native_state=native_state)
+
+                if pcontext.wakeup_time is None:
+                    if (path, proc) in self.wakeups:
+                        del self.wakeups[(path, proc)]
+                else:
+                    self.wakeups[(path, proc)] = pcontext.wakeup_time
+                self.update_next_wakeup(now=now, wakeup_time=pcontext.wakeup_time)
+
+                unknown = set(res)
+                unknown_newstate = set(state_new_block)
+                # TODO: Clean up, more checking for state variables
+                for res_var in proc.results:
+                    if isinstance(res_var, blocks.Block.StateVariable):
+                        if res_var not in unknown_newstate:
+                            raise Exception(f'State output {res_var.name} of native procedure {proc} is missing')
+                        unknown_newstate.remove(res_var)
+                        val = state_new_block[res_var]
+                        state_new.add(self.program.state_map[path, res_var], val)
+
+                        new_value = res_var.impl_var_type.verify_value(val)
+                        vars.add(self.program.state_map_new[path, res_var], state_old_block[res_var])
+                        if not res_var.impl_var_type.equals(state_old_block[res_var], new_value):
+                            state_change_count += 1
+                            vars.add(self.program.state_map_changed[path, res_var], True)
+                        else:
+                            vars.add(self.program.state_map_changed[path, res_var], False)
+
+                        continue
+
+                    if res_var not in unknown:
+                        raise Exception(f'Output {res_var.name_desc} of native procedure {proc} is missing')
+                    unknown.remove(res_var)
+                    val = res[res_var]
+                    # print(f'Writing {res_var}')
+                    # TODO: Clean up temporary / output stuff
+
+                    # TODO: Move this code somewhere else? / Use already resolved type?
+                    var_type = res_var.impl_var_type
+                    for block in reversed(path):
+                        if isinstance(block, blocks.Block):  # TODO: Handle singletons here?
+                            var_type = var_type.resolve_self(block.par_values)
+
+                    # print('RESULT', proc.block.block_type, proc, res_var)
+                    new_value = var_type.verify_value(val)
+                    if cache is None or not var_type.equals(new_value, cache[self.program.variable_map[path, res_var.var_identifier]]):
+                        change_count += 1
+                    # print(self.program.variable_map, [path, res_var.var_identifier])
+                    vars.add(self.program.variable_map[path, res_var.var_identifier], new_value)
+                if len(unknown):
+                    raise Exception(f'{proc} returned unknown values: {sorted(unknown)}')
+                if len(unknown_newstate):
+                    raise Exception(f'{proc} returned unknown state values: {sorted(unknown_newstate)}')
+
+        self.cache = vars
+        self.state = state_new
+
+        if self.debug:
+            print(f'Finished step of {self.program.graph}')
+
+        # print(state_old, state_new)
+        # print(run_count, change_count, state_change_count)
+        # return run_count
+        # return change_count
+        # TODO: Clean up return values
+        return run_count, state_change_count, step_info
+
+    async def run(self):
+        while True:
+            await asyncio.sleep(0)
+            run_count, state_change_count, step_info = self.step()
+            if state_change_count == 0:
+                now = blocks.MonotonicTime.current_time()
+                # TODO: This probably is not really used or tested currently
+                if self.fake_monotonic_time_offset is not None:
+                    now_monotonic += self.fake_monotonic_time_offset
+
+                # TODO: If there is a "while True" here, the code will crash (instead of looping) because of EAGAIN when writing to the terminal, seems like NONBLOCK is set
+                # while True:
+                # import os; import fcntl; fcntl.fcntl(1, fcntl.F_GETFL)
+                # print(f'Waiting, wakeup is {self.next_wakeup}', flush=True)
+                # import os; print(os.
+                if self.next_wakeup is None:
+                    # Sleep without timeout
+                    await self.triggered_procs_event.wait()
+                elif self.next_wakeup.is_invalid or not blocks.MonotonicTime.is_comparable(now, self.next_wakeup):
+                    # Don't sleep
+                    pass
+                else:
+                    diff = self.next_wakeup - now
+                    # Sleep until timeout
+                    try:
+                        async with asyncio.timeout(diff.total_seconds):
+                            await self.triggered_procs_event.wait()
+                    except TimeoutError:
+                        pass
+                self.triggered_procs_event.clear()
+
+    def get_block_path_list(self, name_parts):
+        path = []
+        graph = self.program.graph
+        for part in name_parts:
+            # print('XXX', graph, part, list(graph.blocks))
+            if part not in graph.blocks:
+                # TODO: Clean up
+                # raise Exception('Cannot find block ' + '.'.join([block.name for block in path] + [part]))
+                raise Exception('Cannot find block ' + '.'.join([(block.name if isinstance(block, blocks.Block) else block.name.id_str) for block in path] + [part]))
+            block = graph.blocks[part]
+            path.append(block)
+            graph = block.block_type
+
+        # For singletons, return the block type
+        if path[-1].block_type.is_singleton:
+            return (path[-1].block_type,)
+
+        return tuple(path)
+
+    def get_block_path(self, name):
+        return self.get_block_path_list(name.split('.'))
+
+    def get_block_path_singleton(self, name):
+        scope = self.program.graph
+        parts = name.split('.')
+        for part in parts[:-1]:
+            scope = scope.libraries[part]
+        ty = scope.block_type_implementations[parts[-1]]
+        return (ty,)
+
+    # TODO: Name? get_native_state? get_native_block? get_block_instance?
+    def get_native_state(self, name):
+        path = self.get_block_path(name)
+        return self.native_states[path]
+
+    def get_native_state_singleton(self, name):
+        path = self.get_block_path_singleton(name)
+        return self.native_states[path]
+
+    def get_variable(self, name):
+        name_parts = name.split('.')
+
+        # TODO: Avoid special case
+        if len(name_parts) == 1:
+            path = self.get_block_path_list(name_parts)
+            block = path[-1]
+            # return blocks.resolve_variable(path, block.block_outputs_byname[''])
+            path, var = blocks.resolve_variable(path, block.block_outputs_byname[''])
+            return path, var.var_identifier
+
+        path = self.get_block_path_list(name_parts[:-1])
+        block = path[-1]
+        lname = name_parts[-1]
+
+        # TODO: Clean this up
+        # TODO: How to handle input/output clashes?
+        for value in block.block_inputs:
+            if value.name == lname:
+                return path, value.var_identifier
+        for value in block.block_outputs:
+            if value.name == lname:
+                return path, value.var_identifier
+        for value in block.block_statevars:
+            if value.name == lname:
+                return path, value.var_identifier
+        for value in block.block_temporaries:
+            if value.name == lname:
+                return path, value.var_identifier
+
+        # print(block.block_inputs, block.block_temporaries, block.block_statevars)
+        raise Exception(f'Could not find {name}')
+
+
+    def get_value(self, name):
+        var = self.program.variable_map[self.get_variable(name)]
+        return self.cache[var]
+
+    def assert_value_is(self, name, expected_value):
+        actual_value = self.get_value(name)
+        if actual_value != expected_value:
+            raise Exception(f'Got unexpected value for {name}: Expected {expected_value}, got {actual_value}')
+
+    def assert_is_idle(self):
+        run_count, state_change_count, step_info = self.step()
+        if run_count != 0:
+            raise Exception(f'Is not idle, executed {run_count} procs')
+
+    def advance_fake_monotonic_time(self, offset):
+        if self.fake_monotonic_time_offset is None:
+            print('Warning: Setting fake monotonic time offset', flush=True)
+            self.fake_monotonic_time_offset = blocks.Duration(duration_ns=0)
+        self.fake_monotonic_time_offset += offset

wirely/enum.py

@@ -0,0 +1,15 @@
+import enum
+
+
+# TODO: Move enums somewhere else?
+# See Matter Application Cluster Specification
+class ThermostatSystemMode(enum.Enum):
+    Off = 0
+    Auto = 1
+    Cool = 3
+    Heat = 4
+    EmergencyHeat = 5
+    Precooling = 6
+    FanOnly = 7
+    Dry = 8
+    Sleep = 9

wirely/example.py

@@ -0,0 +1,36 @@
+import asyncio
+import sys
+import os
+
+import wirely as blocks
+from wirely.util import check_parameters
+
+# TODO: Where should these imports be done?
+import wirely.compiler
+import wirely.run
+
+fn = os.path.dirname(__file__) + '/../examples/test.wrl'
+global_block_type = blocks.compiler.compile_files([fn])
+if global_block_type is None:
+    sys.exit(1)
+
+prog = blocks.Program.compile(global_block_type)
+if prog is None:
+    sys.exit(1)
+
+eng = blocks.Engine(prog)
+
+# eng.debug = True
+
+inp1_inst = eng.native_states[(global_block_type.blocks['inp1'],)]
+inp2_inst = eng.native_states[(global_block_type.blocks['inp2'],)]
+
+if True:
+    inp1_inst.set_value(True)
+    inp2_inst.set_value(True)
+    eng.step()
+    eng.step()
+
+    inp2_inst.set_value(False)
+
+asyncio.run(blocks.run.run(eng))

wirely/graphviz.py

@@ -0,0 +1,107 @@
+import graphviz
+
+def htmlescape(s):
+    return s.replace('&', '&amp;').replace('"', '&quot;').replace('<', '&lt;').replace('>', '&gt;')
+
+def get_graph(graph, engine=None):
+    digraph = graphviz.Digraph()
+
+    for block_name in graph.blocks:
+        block = graph.blocks[block_name]
+
+        # label = f'{block.name}\n{block.block_type.name}'
+
+        inputs = ''
+        for input in block.all_block_inputs:
+            label = input.name
+            if label == '':
+                label = '()'
+            if engine is not None and engine.cache is not None:
+                # TODO: Clean up .temporary
+                key = (input.temporary.block), input.temporary
+                if key in engine.program.variable_map:
+                    label += f' = {engine.cache[engine.program.variable_map[key]]}'
+                else:
+                    # TODO: Handle this
+                    label += f' = MISSING'
+            inputs += f'<TD PORT="{htmlescape(input.name)}">{htmlescape(label)}</TD>'
+        if inputs != '':
+            inputs = f'''
+            <TR><TD>
+            <TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0">
+              <TR>{inputs}</TR>
+            </TABLE>
+            </TD></TR>
+            '''
+
+        outputs = ''
+        for output in block.block_outputs:
+            label = output.name
+            if label == '':
+                label = '()'
+            if engine is not None and engine.cache is not None:
+                # TODO: Clean up .temporary
+                key = (output.temporary.block,), output.temporary
+                if key in engine.program.variable_map:
+                    label += f' = {engine.cache[engine.program.variable_map[key]]}'
+                else:
+                    # TODO: Handle this
+                    label += f' = MISSING'
+            outputs += f'<TD PORT="{htmlescape(output.name)}">{htmlescape(label)}</TD>'
+        if outputs != '':
+            outputs = f'''
+            <TR><TD>
+            <TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0">
+              <TR>{outputs}</TR>
+            </TABLE>
+            </TD></TR>
+            '''
+
+        s = f'''<
+        <TABLE BORDER="1" CELLBORDER="0" CELLSPACING="0">
+        {inputs}
+        <TR><TD>
+        <TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0">
+          <TR>
+            <TD>{htmlescape(block.name)}</TD>
+          </TR>
+          <TR>
+            <TD>{htmlescape(block.block_type.name.id_str)}</TD>
+          </TR>
+        </TABLE>
+        </TD></TR>
+        {outputs}
+        </TABLE>
+        >'''
+        # digraph.node(block.name, label, shape='box')
+        digraph.node(block.name, s, shape='plaintext')
+
+    for block_name in graph.blocks:
+        block = graph.blocks[block_name]
+        for input in block.all_block_inputs:
+            if input.connected_source is not None:
+                source = input.connected_source
+                source_block = source.block
+
+                # label = f'{source.name} -> {input.name}'
+                # digraph.edge(source_block.name, block.name, label=label)
+
+                # edge_name = block.name + '/' + input.name
+                # digraph.node(edge_name, '', shape='point')
+                # digraph.edge(source_block.name, edge_name, label=source.name)
+                # digraph.edge(edge_name, block.name, label=input.name)
+
+                digraph.edge(source_block.name + ':' + source.name, block.name + ':' + input.name)
+        digraph.node(block_name)
+
+    return digraph
+
+
+def run(args):
+    import wirely.compiler
+
+    graph = wirely.compiler.compile_files([args.input_filename])
+    if graph is None:
+        return 1
+
+    get_graph(graph).view()

wirely/knx/connection_adapter.py

@@ -0,0 +1,90 @@
+"""Connect xknx TCP tunnels through Wirely-provided stream connections."""
+
+import asyncio
+
+import xknx
+from xknx.io import ConnectionConfig, ConnectionType, KNXIPInterface, TCPTunnel
+from xknx.io.transport import TCPTransport
+
+
+class StreamConnectionConfig(ConnectionConfig):
+    """TCP tunnel configuration with a callback for opening its stream."""
+
+    def __init__(self, connect_cb, individual_address=None):
+        super().__init__(
+            connection_type=ConnectionType.TUNNELING_TCP,
+            individual_address=individual_address,
+        )
+        self.connect_cb = connect_cb
+
+
+class StreamTCPTransport(TCPTransport):
+    """Use xknx's TCP framing over a caller-provided stream."""
+
+    __slots__ = ("_stream_connect_cb",)
+
+    def __init__(self, connect_cb, connection_lost_cb):
+        super().__init__(
+            remote_addr=("0.0.0.0", 0),
+            connection_lost_cb=connection_lost_cb,
+        )
+        self._stream_connect_cb = connect_cb
+
+    async def connect(self):
+        protocol = self.TCPTransportFactory(
+            data_received_callback=self.data_received_callback,
+            connection_lost_callback=self._connection_lost,
+        )
+        self.transport, _ = await self._stream_connect_cb(
+            asyncio.get_running_loop(), lambda: protocol
+        )
+
+
+class StreamTCPTunnel(TCPTunnel):
+    """Create the stream transport while retaining xknx's tunnel logic."""
+
+    __slots__ = ("_stream_connect_cb",)
+
+    def __init__(self, xknx_instance, connect_cb, individual_address,
+                 cemi_received_callback, auto_reconnect, auto_reconnect_wait):
+        self._stream_connect_cb = connect_cb
+        super().__init__(
+            xknx_instance,
+            cemi_received_callback=cemi_received_callback,
+            gateway_ip="0.0.0.0",
+            gateway_port=0,
+            individual_address=individual_address,
+            auto_reconnect=auto_reconnect,
+            auto_reconnect_wait=auto_reconnect_wait,
+        )
+
+    def _init_transport(self):
+        self.transport = StreamTCPTransport(
+            connect_cb=self._stream_connect_cb,
+            connection_lost_cb=self._tunnel_lost,
+        )
+
+
+class StreamKNXIPInterface(KNXIPInterface):
+    """Start a TCP tunnel using a StreamConnectionConfig."""
+
+    async def start(self):
+        config = self.connection_config
+        self.xknx.cemi_handler.data_secure_init(keyring=None)
+        self._interface = StreamTCPTunnel(
+            self.xknx,
+            connect_cb=config.connect_cb,
+            individual_address=config.individual_address,
+            cemi_received_callback=self.cemi_received,
+            auto_reconnect=config.auto_reconnect,
+            auto_reconnect_wait=config.auto_reconnect_wait,
+        )
+        await self._interface.connect()
+
+
+def create_xknx(connection_config):
+    """Create xknx with the stream interface when the configuration needs one."""
+    knx = xknx.XKNX(connection_config=connection_config)
+    if isinstance(connection_config, StreamConnectionConfig):
+        knx.knxip_interface = StreamKNXIPInterface(knx, connection_config)
+    return knx