wirely 0.1.0__tar.gz

wirely-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Steffen Kieß
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

wirely-0.1.0/MANIFEST.in

@@ -0,0 +1,11 @@
+recursive-include doc *.md
+recursive-include examples *.wrl
+recursive-include test *.py *.wrl
+include test/username_password.txt
+include tools/build-pex
+include tools/git_write_wd_tree.py
+include tools/run-tests
+include tools/setup-venv
+include tools/test-gitlab-ci
+include tools/wirely
+global-exclude *~ *.py[cod]

wirely-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: wirely
+Version: 0.1.0
+Summary: Node-based language and runtime for low-level home automation
+Author: Steffen Kieß
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lark
+Requires-Dist: sdnotify
+Provides-Extra: knx
+Requires-Dist: xknx<4,>=3.0; extra == "knx"
+Provides-Extra: mqtt
+Requires-Dist: aiomqtt<3,>=2.3; extra == "mqtt"
+Provides-Extra: two-n
+Requires-Dist: aiohttp<4,>=3.12; extra == "two-n"
+Requires-Dist: cryptography; extra == "two-n"
+Provides-Extra: graphviz
+Requires-Dist: graphviz; extra == "graphviz"
+Provides-Extra: gpio
+Requires-Dist: gpiod<3,>=2.1; extra == "gpio"
+Provides-Extra: all
+Requires-Dist: wirely[gpio,graphviz,knx,mqtt,two-n]; extra == "all"
+Provides-Extra: test
+Requires-Dist: pyOpenSSL; extra == "test"
+Provides-Extra: pex
+Requires-Dist: pex; extra == "pex"
+Provides-Extra: dev
+Requires-Dist: wirely[pex,test]; extra == "dev"
+Dynamic: license-file
+
+Wirely
+======
+
+Wirely is a node-based language and runtime for low-level home automation.
+It connects signals from KNX group addresses, MQTT topics, and other device
+interfaces through nodes that process values and apply logic. For example,
+it can listen for boolean values on two KNX group addresses and publish
+`first_value AND NOT second_value` to a third. Wirely works directly with
+these signals; it does not model higher-level concepts such as rooms,
+as Home Assistant does.
+
+See the [language documentation](doc/language.md) for how to write Wirely
+programs.
+
+Installation
+------------
+
+Wirely requires Python 3.11 or newer. Install the core package with:
+
+```
+python3 -m pip install wirely
+```
+
+The core install includes the compiler and command-line interface. The
+installed `wirely` command and `python3 -m wirely` provide the same
+subcommands. For example:
+
+```
+wirely compile program.wrl
+python3 -m wirely compile program.wrl
+```
+
+Install optional integrations as needed:
+
+```
+python3 -m pip install 'wirely[knx]'           # KNX
+python3 -m pip install 'wirely[mqtt]'          # MQTT
+python3 -m pip install 'wirely[two-n]'         # 2N devices
+python3 -m pip install 'wirely[graphviz]'      # show-graph
+python3 -m pip install 'wirely[gpio]'          # GPIO
+python3 -m pip install 'wirely[all]'           # all optional integrations
+```
+
+The `test` extra adds dependencies used only by the test suite. Install
+`wirely[all,test]` to include both integrations and test dependencies.
+
+Development checkout
+--------------------
+
+Create a virtual environment with all dependencies, then use the
+checkout launchers:
+
+```
+tools/setup-venv
+tools/wirely compile test/simple.wrl
+tools/run-tests
+```
+
+The launchers use `venv/bin/python` when available. Otherwise, they warn and
+use the current Python interpreter. `tools/wirely` accepts the same arguments
+as `wirely` and runs the source in this checkout from any working directory.
+The test suite also requires `knxd` and `mosquitto`.

wirely-0.1.0/README.md

@@ -0,0 +1,62 @@
+Wirely
+======
+
+Wirely is a node-based language and runtime for low-level home automation.
+It connects signals from KNX group addresses, MQTT topics, and other device
+interfaces through nodes that process values and apply logic. For example,
+it can listen for boolean values on two KNX group addresses and publish
+`first_value AND NOT second_value` to a third. Wirely works directly with
+these signals; it does not model higher-level concepts such as rooms,
+as Home Assistant does.
+
+See the [language documentation](doc/language.md) for how to write Wirely
+programs.
+
+Installation
+------------
+
+Wirely requires Python 3.11 or newer. Install the core package with:
+
+```
+python3 -m pip install wirely
+```
+
+The core install includes the compiler and command-line interface. The
+installed `wirely` command and `python3 -m wirely` provide the same
+subcommands. For example:
+
+```
+wirely compile program.wrl
+python3 -m wirely compile program.wrl
+```
+
+Install optional integrations as needed:
+
+```
+python3 -m pip install 'wirely[knx]'           # KNX
+python3 -m pip install 'wirely[mqtt]'          # MQTT
+python3 -m pip install 'wirely[two-n]'         # 2N devices
+python3 -m pip install 'wirely[graphviz]'      # show-graph
+python3 -m pip install 'wirely[gpio]'          # GPIO
+python3 -m pip install 'wirely[all]'           # all optional integrations
+```
+
+The `test` extra adds dependencies used only by the test suite. Install
+`wirely[all,test]` to include both integrations and test dependencies.
+
+Development checkout
+--------------------
+
+Create a virtual environment with all dependencies, then use the
+checkout launchers:
+
+```
+tools/setup-venv
+tools/wirely compile test/simple.wrl
+tools/run-tests
+```
+
+The launchers use `venv/bin/python` when available. Otherwise, they warn and
+use the current Python interpreter. `tools/wirely` accepts the same arguments
+as `wirely` and runs the source in this checkout from any working directory.
+The test suite also requires `knxd` and `mosquitto`.

wirely-0.1.0/doc/README.md

@@ -0,0 +1,8 @@
+# Wirely documentation
+
+Wirely programs are graphs of typed nodes written in `.wrl` files. Start with
+the [language guide](language.md) to learn how to declare nodes and connect
+them. Then use the [library reference](libraries.md) to find the nodes supplied
+with Wirely.
+
+For Python contributions, follow the [Python style guide](python-style.md).

wirely-0.1.0/doc/language.md

@@ -0,0 +1,166 @@
+# The Wirely language
+
+Wirely is a declarative language for connecting typed nodes. A `.wrl` file
+instantiates node types and connects their outputs to inputs. A node can
+compute a value, emit an event, keep state, or interact with an external
+service. Several `.wrl` files passed to the compiler form one program.
+
+## A first program
+
+```wrl
+node source : Std.Constant(Type = boolean, Value = true);
+node printer : Std.DebugPrinter(type = boolean);
+connect source -> printer;
+```
+
+`source` has an implicit `value boolean` output, and `printer` has an implicit
+`value boolean` input. The connection feeds the output to the input. Save this
+as `hello.wrl` and check it from the repository root with:
+
+```sh
+python3 -m wirely compile hello.wrl
+```
+
+`compile` builds the graph and checks its connections. To start the service,
+use `python3 -m wirely run-service hello.wrl`. Runtime service dependencies
+are described in [the library reference](libraries.md).
+
+## Declarations and names
+
+Declarations may appear at the top level or inside a node type. Node
+instantiation uses `node name : Type;` or named parameters in parentheses:
+
+```wrl
+node source : Std.Constant(Type = boolean, Value = true);
+node sink : Std.DebugPrinter(type = boolean);
+connect source -> sink;
+```
+
+The type name may be a local name or a namespace-qualified name such as
+`Std.Constant`. A program may also declare its own types:
+
+```wrl
+node type Forward {
+  implicit input : value boolean;
+  implicit output : value boolean;
+  native procedure run depends on implicit input produces implicit output;
+}
+```
+
+This illustrates a type declaration, but its `native procedure` needs a
+matching Python implementation before the type can be instantiated. To make
+a composite type entirely in `.wrl`, connect its external input to child
+nodes:
+
+```wrl
+node type PrintBoolean {
+  implicit input : value boolean;
+  node printer : Std.DebugPrinter(type = boolean);
+  connect implicit input -> printer;
+}
+
+node source : Std.Constant(Type = boolean, Value = true);
+node sink : PrintBoolean;
+connect source -> sink;
+```
+
+A `namespace Name { ... }` groups node types under `Name.Type`. Namespaces can
+contain other namespaces, and a dotted declaration names the same path:
+
+```wrl
+namespace ABB.JRA { node type Status { } }
+// Equivalent to: namespace ABB { namespace JRA { node type Status { } } }
+```
+
+Both forms define `ABB.JRA.Status`. Repeated declarations of the same namespace
+path add their contents to one namespace; node type names within it must remain
+unique. Namespaces contain node types or other namespaces, not instances.
+A `singleton node type` shares one instance across its uses and cannot declare
+parameters. `native node type` indicates that the implementation also owns
+Python state or resources. Both forms require native support when instantiated.
+
+Identifiers are case-sensitive. A keyword can be used as an identifier with
+the `r#` prefix, for example `node r#node : Std.And;`. Declarations end with
+`;`, except type and namespace bodies, which use braces. `//` starts a line
+comment, and `/* ... */` block comments may be nested.
+
+## Parameters, types, and literals
+
+A node type declares parameters with `parameter Name : Type;`. A parameter
+may have a default (`= value`) or be marked `optional`. Instantiation passes
+named arguments, for example `Time.TriggerAt(Time = "08:00")`. Type parameters
+use `ValueType`; a later parameter or connector can refer to one:
+
+```wrl
+node type Example {
+  parameter Type : ValueType;
+  parameter Initial : Type;
+  implicit output : value Type;
+  node constant : Std.Constant(Type = Type, Value = Initial);
+  connect constant -> implicit output;
+}
+```
+
+Built-in types are `unit`, `boolean`, signed `int8`/`int16`/`int32`/`int64`,
+unsigned `uint8`/`uint16`/`uint32`/`uint64`, `String`, `Duration`,
+`TimeOfDay`, `MonotonicTime`, and `ThermostatSystemMode`. `ValueType` is used
+for type parameters. `Option[T]` and `List[T]` construct types from `T`.
+
+Use `true` and `false` for booleans, non-negative decimal or `0x`/`0o`
+integers for integer parameters, quoted strings for `String`, and `[a, b]`
+for list values. Raw strings (`r"..."` and `r#"..."#`) are also accepted.
+Durations and times of day are passed as strings, for example `"PT1S"` and
+`"08:00"`. `None` is the available `Option[T]` literal; use library nodes
+such as `Std.OptionSome` to create an optional value at runtime.
+`MonotonicTime.Invalid` is the available monotonic-time constant. The
+compile-time function `TimeOfDay_AddWrap(time, offset)` adds an `"HH:MM"`
+offset and wraps at midnight.
+
+Expressions have limited support: literals, parameter references, lists,
+generic types, and the named time function above. In particular, unary
+minus and general arithmetic expressions are not currently implemented.
+
+## Connectors and connections
+
+An `input` or `output` declares a named connector. `implicit input` and
+`implicit output` declare the connectors used when a connection names just
+the node. For example:
+
+```wrl
+node bus : KNX.Connection(UnixPath = "/run/knxnet");
+node receiver : KNX.ValueReceiver(Type = boolean,
+                                  GroupAddress = "0/4/5");
+connect bus -> receiver.Bus;
+```
+
+The first connection uses `bus`'s implicit output and the named `Bus` input.
+For a named output, write `node_name.OutputName`. Inside a type body,
+`implicit input` and `implicit output` may also be connection endpoints.
+
+Data connectors have a kind and a type: `value boolean` carries the current
+value, while `event boolean` carries an occurrence with a boolean payload.
+An event may be absent in a step. Source and target must have the same kind
+and type; Wirely does not automatically convert them. Ordinary inputs accept
+one source. A `list value T` or `list event T` input accepts several sources;
+`connect a, b -> target;` connects both. `Std.And` is an example of a list
+input. Libraries also define resource connectors `knx_bus`, `mqtt_server`,
+and `two_n_device`, which connect a service node to its clients.
+
+## State and execution
+
+Inside a node type, `state name : Type = value;` declares a persistent value
+with an initial value. `temporary name : Type;` holds a value calculated
+within a step. Native procedures declare which inputs or temporaries they
+`depend on` and which connectors or variables they `produce`. The engine
+orders procedures from these dependencies and rejects dependency cycles.
+
+Procedures run in three stages: `stage input` reads external sources, the
+default stage calculates values and updates state, and `stage output` sends
+results to external systems. State updates become visible on the next step.
+`Std.Delay` demonstrates this: it outputs the previous value and stores the
+current input for the following step.
+
+The `.wrl` declaration specifies a native procedure's interface; its code
+lives in Python under `wirely/native/`. Node types can combine child nodes
+and connections in `.wrl`, as `KNX.ValueProvider` does. See the
+[library reference](libraries.md) for available nodes and their connectors.

wirely-0.1.0/doc/libraries.md

@@ -0,0 +1,177 @@
+# Library reference
+
+The compiler loads all ten libraries below by default. Instantiate a node
+as `node name : Library.Type(Parameter = value);`. Names and parameter
+capitalization matter. In the signatures below, `in` and `out` mean implicit
+connectors; named connectors are written explicitly. `value T` carries a
+current value, and `event T` carries an occurrence with a payload. A dash
+means no connector of that kind.
+
+See the [language guide](language.md) for syntax and connection rules. The
+declarations in [`wirely/lib/`](../wirely/lib/) are the source for exact
+signatures; behavior comes from [`wirely/native/`](../wirely/native/).
+
+## Std
+
+General data flow, optional values, edge detection, and debug nodes.
+
+| Node type | Parameters | Connectors and behavior |
+| --- | --- | --- |
+| `Constant` | `Type: ValueType`, `Value: Type` | Out: `value Type`. Produces the supplied value. |
+| `And` | None | In: `list value boolean`; out: `value boolean`. True when every connected input is true, including an empty list. |
+| `Delay` | `type: ValueType`, `initialValue: type` | In/out: `value type`. Outputs the previous step's input, initially `initialValue`. |
+| `TwoStageValueForward` | `type: ValueType` | In/out: `value type`. Forwards through two native procedures. |
+| `DebugPrinter` | `type: ValueType` | In: `value type`. Prints changes in the output stage. |
+| `DebugEventPrinter` | `type: ValueType` | In: `event type`. Prints events in the output stage. |
+| `DebugInput` | `type: ValueType` | Out: `value type`. Debug-controlled value source. |
+| `DebugEventSource` | `type: ValueType` | Out: `event type`. Debug-controlled event source. |
+| `OptionNone` | `InnerType: ValueType` | Out: `value Option[InnerType]`. Produces `None`. |
+| `OptionSome` | `InnerType: ValueType` | In: `value InnerType`; out: `value Option[InnerType]`. Wraps the input. |
+| `OptionUnwrapOrDefault` | `InnerType: ValueType`, `Default: InnerType` | In: `value Option[InnerType]`; out: `value InnerType`. Uses `Default` for `None`. |
+| `OptionIsSome` | `InnerType: ValueType` | In: `value Option[InnerType]`; out: `value boolean`. True when a value is present. |
+| `OptionCreate` | `InnerType: ValueType` | Named in: `HasValue: value boolean`, `Value: value InnerType`; out: `value Option[InnerType]`. Wraps `Value` when `HasValue` is true; otherwise produces `None`. |
+| `DetectEdge` | `EdgeType: String` | In: `value boolean`; out: `event boolean`. Only `"Falling"` works; `"Rising"` and `"Both"` raise an error when run. |
+
+The debug sources are intended for testing and interactive control. Their
+input is supplied through the engine's debug interface, not a `.wrl`
+connection. `TwoStageValueForward` is primarily a demonstration of procedure
+dependencies.
+
+## Time
+
+Time-based values and triggers. `TimeOfDay` parameters use strings such as
+`"08:00"`; `Duration` parameters use strings such as `"PT1S"`.
+
+| Node type | Parameters | Connectors and behavior |
+| --- | --- | --- |
+| `MonotonicTimeReached` | None | In: `value MonotonicTime`; out: `value Option[boolean]`. True once the time is reached, false before it, or `None` if the times cannot be compared. |
+| `DelayChange` | `Type: ValueType`, `Time: Duration` | In/out: `value Type`. Changes the output only after the input has remained stable for `Time`. |
+| `TimeOfDayMinute` | None | Out: `value TimeOfDay`. Shared singleton that updates at minute boundaries; normally used through other Time nodes. |
+| `IsBetween` | `start: TimeOfDay`, `end: TimeOfDay` | Out: `value boolean`. Tests the interval from `start` (inclusive) to `end` (exclusive), including intervals that cross midnight. |
+| `TriggerAt` | `Time: TimeOfDay`, `Type: ValueType = unit`, optional `Value: Type` | Out: `event Type`. Emits around the requested time, with logic to avoid duplicate daily events during clock changes. Supply `Value` when `Type` is not `unit`. |
+
+## KNX
+
+KNX nodes use a `KNX.Connection` node and a named `Bus: knx_bus` input.
+`GroupAddress` is a KNX group address string such as `"0/4/5"`.
+
+| Node type | Parameters | Connectors and behavior |
+| --- | --- | --- |
+| `Connection` | Optional `Host: String`, `Protocol: String`, `Port: uint16`, `UnixPath: String`, `SSHTarget: String`, `IndividualAddress: String` | Out: `knx_bus`. Opens a KNX connection. |
+| `ValueReceiver` | `Type: ValueType`, `GroupAddress: String` | Named in: `Bus`; out: `value Option[Type]`. Reads the latest value, with `None` before one is available. |
+| `ValueOptionProvider` | `Type: ValueType`, `GroupAddress: String` | Named in: `Bus`; in: `value Option[Type]`. Exposes an optional value on the bus. |
+| `ValueProvider` | `Type: ValueType`, `GroupAddress: String` | Named in: `Bus`; in: `value Type`. Wraps the value with `Std.OptionSome` and uses `ValueOptionProvider`. |
+| `EventReceiver` | `Type: ValueType`, `GroupAddress: String` | Named in: `Bus`; out: `event Type`. Emits received KNX events. |
+| `EventEmitter` | `Type: ValueType`, `GroupAddress: String` | Named in: `Bus`; in: `event Type`. Sends KNX events. |
+
+The current native value receiver and provider support `boolean` and
+`uint16`. Other declared `Type` values may fail when those nodes are
+instantiated. Event support depends on the KNX value type handled by the
+native implementation. KNX use requires the `xknx` package and a reachable
+KNX service.
+
+Choose one connection mode:
+
+- `Host` with `Protocol = "TCP"` or `"UDP"` opens a direct tunnel. `Port`
+  defaults to `3671`.
+- `Protocol = "Unix"` opens a local Unix socket. `UnixPath` defaults to
+  `/run/knxnet`; supplying `UnixPath` implies `Protocol = "Unix"`.
+- `SSHTarget` opens a Unix socket on a remote host over SSH. It requires
+  `Protocol = "Unix"` unless `UnixPath` is also supplied.
+- `Protocol = "Auto"` uses automatic discovery.
+
+`IndividualAddress` is supported for TCP and Unix socket connections. An
+empty connection, an SSH target without a protocol or Unix path, and
+parameters from conflicting modes are errors. For example,
+`KNX.Connection(UnixPath = "/run/knxnet")` uses a local socket.
+
+## ABB.JRA
+
+These nodes decode a 16-bit ABB JRA status word into named boolean outputs.
+`InterpretStatusInformation` takes `value uint16` and produces `value
+boolean` outputs. `InterpretStatusInformationOption` takes `value
+Option[uint16]` and produces `value Option[boolean]` outputs; a missing input
+remains missing in every output. Neither node has parameters.
+
+Both expose the same named outputs: `ManualOperation`, `BlockActive`,
+`ForcedOperation`, `FrostAlarm`, `RainAlarm`, `WindAlarm`,
+`AutomaticSunProtection`, `AutomaticHeatingCooling`, `DriveError`,
+`DriveInMotion`, `DriveDown`, `DriveUp`, and `SendReceiveDelayActive`.
+
+## MQTT
+
+MQTT nodes use a `MQTT.Server` and a named `Server: mqtt_server` input.
+`Topic` is a topic string. `Format` and `Template`, where offered, are
+optional strings used by the native JSON encoder. A template embeds the
+encoded value at one `%s` placeholder; `%%` represents a literal percent
+sign. The `URI` accepts `mqtt://host`, `mqtts://host`, or `mqtt+unix:///path`.
+
+| Node type | Parameters | Connectors and behavior |
+| --- | --- | --- |
+| `Server` | `URI: String` | Out: `mqtt_server`. Connects to a broker. |
+| `ValueOptionProvider` | `Type: ValueType`, `Topic: String`, optional `Format: String`, `Template: String` | Named in: `Server`; in: `value Option[Type]`. Publishes JSON; `None` publishes an empty payload. |
+| `ValueProvider` | Same as `ValueOptionProvider` | Named in: `Server`; in: `value Type`. Wraps the value and uses `ValueOptionProvider`. |
+| `EventEmitter` | `Type: ValueType`, `Topic: String`, optional `Format: String`, `Template: String` | Named in: `Server`; in: `event Type`. Publishes each event as JSON. |
+| `EventReceiver` | `Type: ValueType`, `Topic: String`, optional `Format: String` | Named in: `Server`; out: `event Type`. Emits decoded messages received on the topic. |
+
+Only types supported by the native JSON encoder/decoder can be used. MQTT
+requires the `aiomqtt` package and a reachable broker.
+
+## CSV
+
+`CSV.ValueWriter` takes `Type: ValueType` and `Filename: String`. It appends
+rows from an implicit `value Type` input, recording the timestamp, old value,
+and new value. An empty field marks an unavailable value at startup or
+shutdown. It writes on changes and repeats a current value hourly. `Type`
+must support CSV conversion, such as `boolean`, an integer type, or an
+`Option` of one. The file is opened for append when the service starts.
+
+## TwoN
+
+TwoN nodes communicate with a 2N device. Create `TwoN.Device`, then connect
+its implicit `two_n_device` output to each client's named `Device` input.
+
+| Node type | Parameters | Connectors and behavior |
+| --- | --- | --- |
+| `Device` | `Hostname: String`, `Port: uint16 = 443`, `TLSA: List[String]`, `UsernamePasswordFile: String` | Out: `two_n_device`. Connects to the device. The credential file contains a username and password on separate lines; a relative path is resolved beside the `.wrl` file. |
+| `KeyEvent` | `Key: String` | Named in: `Device`; out: `event boolean`. True on press, false on release. |
+| `KeyState` | `Key: String`, `Timeout: Duration = "30s"` | Named in: `Device`; out: `value boolean`. Tracks a key, assuming release after the timeout. Startup state can be wrong if the key was already pressed. |
+| `IOState` | `Port: String` | Named in: `Device`; out: `value boolean`. Tracks an input or output port. |
+| `SwitchState` | `SwitchNumber: int32` | Named in: `Device`; out: `value boolean`. Tracks whether a switch is active. |
+| `CodeEnteredEvent` | `Code: String` | Named in: `Device`; out: `event unit`. Emits when the specified code is entered. |
+| `OutputControl` | `Port: String` | Named in: `Device`; in: `event boolean`. Sets an output on or off. |
+
+`TLSA` provides certificate association records. TwoN use needs the bundled
+TwoN dependencies, device credentials, and network access to the device.
+
+## GPIO
+
+`GPIO.Output` sets a GPIO line from an implicit `value boolean` input.
+Parameters are `ChipDeviceFile: String`, `Name: String`,
+`ActiveState: String = "High"`, `Drive: String = "PushPull"`, and
+`Bias: String = "AsIs"`. `ActiveState` accepts `"High"` or `"Low"`;
+`Drive` accepts `"PushPull"`, `"OpenDrain"`, or `"OpenSource"`; and
+`Bias` accepts `"PullDown"`, `"PullUp"`, `"Disable"`, or `"AsIs"`.
+GPIO use requires the `gpio` extra (or the official `gpiod` 2.x Python
+bindings) and access to the chip device.
+
+## Memory
+
+`Memory.ToggleFlipFlopTrigger` can switch an external impulse relay
+(latching relay) on or off. Each pulse toggles the relay, so the node compares
+the requested state with feedback and emits a pulse only when the state needs
+to change. It takes an implicit `event boolean` command input (`true` for on,
+`false` for off) and a named `Feedback: value Option[boolean]` input. Its
+implicit `event OutputType` output provides the trigger pulse. If feedback is
+`None`, commands are ignored. Its parameters are `OutputType: ValueType = unit`,
+optional `OutputValue: OutputType`, and `MinimumDelay: Duration = "PT1S"`.
+Set `OutputValue` when `OutputType` is not `unit`. The minimum delay limits
+successive output events.
+
+## ExtProg
+
+`ExtProg.LaunchOnEvent` launches a shell command when an input event arrives.
+Events received while a launch is pending may be combined into one launch.
+It takes `ShellCommand: String` and `Type: ValueType = unit`, with an implicit
+`event Type` input. The event payload is ignored. The command is passed to
+`sh -c` in the output stage and runs with the service process's permissions.

wirely-0.1.0/doc/python-style.md

@@ -0,0 +1,12 @@
+# Python style guide
+
+## Text format
+
+- Save Python files as UTF-8 with LF line endings and a final newline.
+- Use spaces, not tabs. Indent code with four spaces per level.
+
+## Code style
+
+- Generally, follow PEP 8.
+- Longer lines are acceptable when they improve readability.
+- Use `snake_case` for functions and variables and `PascalCase` for classes.

wirely-0.1.0/examples/delay.wrl

@@ -0,0 +1,7 @@
+node in : Std.DebugInput(type = boolean);
+
+node delay : Time.DelayChange(Type = boolean, Time = "PT1S");
+connect in -> delay;
+
+node prnt : Std.DebugPrinter(type = boolean);
+connect delay -> prnt;

wirely-0.1.0/examples/flipflop.wrl

@@ -0,0 +1,10 @@
+node in : Std.DebugEventSource(type = boolean);
+
+node fb : Std.DebugInput(type = Option[boolean]);
+
+node trigger : Memory.ToggleFlipFlopTrigger(OutputType = boolean, OutputValue = true, MinimumDelay = "PT1S");
+connect in -> trigger;
+connect fb -> trigger.Feedback;
+
+node prnt : Std.DebugEventPrinter(type = boolean);
+connect trigger -> prnt;

wirely-0.1.0/examples/gpio.wrl

@@ -0,0 +1,4 @@
+node in : Std.DebugInput(type = boolean);
+
+node gpio : GPIO.Output(ChipDeviceFile = "/dev/gpiochip0", Name = "GPIO5", ActiveState = "Low", Bias = "PullUp");
+connect in -> gpio;

wirely-0.1.0/examples/knx.wrl

@@ -0,0 +1,23 @@
+// Meeting-room lighting example: turn the lights on only when the room is
+// occupied and lighting is enabled.
+node Bus : KNX.Connection(UnixPath = "/run/knxnet");
+
+node Occupancy : KNX.ValueReceiver(GroupAddress = "0/0/1", Type = boolean);
+connect Bus -> Occupancy.Bus;
+
+node LightingEnabled : KNX.ValueReceiver(GroupAddress = "0/0/2", Type = boolean);
+connect Bus -> LightingEnabled.Bus;
+
+// Keep the lights off until both input values have been received.
+node OccupiedValue : Std.OptionUnwrapOrDefault(InnerType = boolean, Default = false);
+connect Occupancy -> OccupiedValue;
+
+node EnabledValue : Std.OptionUnwrapOrDefault(InnerType = boolean, Default = false);
+connect LightingEnabled -> EnabledValue;
+
+node LightsOn : Std.And;
+connect OccupiedValue, EnabledValue -> LightsOn;
+
+node Lights : KNX.ValueProvider(GroupAddress = "0/0/3", Type = boolean);
+connect Bus -> Lights.Bus;
+connect LightsOn -> Lights;