From Kivy to Textual & fix docker builds

client/Pipfile

@@ -6,18 +6,17 @@ name = "pypi"
 [packages]
 websockets = "*"
 mypy = "*"
-coloredlogs = "*"
 pylint = "*"
 result = "*"
 click = "*"
 requests = "*"
 rich = "*"
 pyserial = "*"
-kivy = { version = "*", platform_machine = "!= 'aarch64'" }
 bitstring = "*"
 pyyaml = "*"
 appdirs = "*"
 aiohttp = "*"
+textual = "*"
 
 [dev-packages]
 pyinstaller = "*"

client/README.md

@@ -16,15 +16,15 @@
 - Run `./dist/dip_client --help` to print built client CLI usage definition
 
 ### File tree
-- `dip_client.py` is just an entrypoint for the CLI interface from `cli.py`
-- `cli.py` defines a CLI interface for all possible DIP client commands:
-    - Generic one-off client commands are defined in `backend_util.py`
-    - Microcontroller agent commands are defined in `agent_entrypoints.py`
+- `main.py` is just an entrypoint for the CLI interface from `service/click.py`
+- `service/click.py` and `service/cli.py` define a CLI interface for all possible DIP client commands:
+    - Generic one-off client commands are defined mostly in `service/backend.py`
+    - Persistent event engine agent commands are defined in `agent/*`, `monitor/*`, `engine/*`
 - `agent_entrypoints.py` prepare and run a configured agent `agent.py`
-- `agent.py` runs using an `AgentConfig`, `Engine`, serialization `Encoder`/`Decoder`
-- `agent_util.py` defines a base `AgentConfig`
-- `engine.py` defines a base `Engine`
-- `agent_*.py` define custom `Engine`s and `AgentConfig`s
+- `agent/agent.py` runs using an `AgentConfig` i.e. an `Engine` attached to `SocketInterface` with the help of message `Codec`s
+- `engine/engine.py` defines a base `Engine` which starts, stops, receives messages, processes events, executes side-effects
+- `engine/board/*` define engines to handle hardware board lifecycle - heartbeats, firmware uploads, monitoring
+- `engine/video/*` define video streaming engines using VLC
+- `monitor/*` define serial monitoring interfaces
 - Agents use `ws.py` to exchange WebSocket messages
-- Agents use `s11n_*.py` to serialize messages
-- Agents use `Engine` for stateful actions & resulting messages
+- Agents more specifically SocketInterfaces use `protocol/*` to encode/decode messages

client/build_docker.sh

@@ -11,24 +11,17 @@ cd "${SCRIPT_DIR}"
 rm -rf docker/
 rm -rf dist/
 
-# Build amd64 locally (supposing that we're building on amd64)
-pipenv install && pipenv run ./build.sh &
-LOCAL_INSTALL_PID="$!"
-
 ## Build amd64 & arm64 in docker w/ buildx i.e. moby/buildkit i.e. QEMU
 ## Multi-platform docs: https://github.com/moby/buildkit/blob/master/docs/multi-platform.md
-export TARGET_PLATFORMS=linux/arm64 #,linux/amd64 # Currently Kivy (used in amd64) doesn't comply with docker builds
+export TARGET_PLATFORMS=linux/arm64,linux/amd64
 docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
 docker buildx create --name multiarch --driver docker-container --use || true
 docker buildx build \
   --platform "${TARGET_PLATFORMS}" \
   -o type=local,dest=docker \
   .
 
-# Wait for local stuff to finish
-wait "${LOCAL_INSTALL_PID}"
-
-# Clean up dist
-mv dist/dip_client dist/dip_client_amd64
-#mv docker/linux_arm64/app/dist/dip_client dist/dip_client_arm64
-mv docker/app/dist/dip_client dist/dip_client_arm64
+# Create dist
+mkdir dist
+mv docker/linux_arm64/app/dist/dip_client dist/dip_client_arm64
+mv docker/linux_amd64/app/dist/dip_client dist/dip_client_amd64

client/src/domain/fancy_byte.py

@@ -0,0 +1,36 @@
+import math
+from dataclasses import dataclass
+from typing import Iterable
+from result import Result, Err, Ok
+
+
+@dataclass
+class FancyByte:
+    value: int
+
+    @staticmethod
+    def fromBytes(b: bytes) -> Result['FancyByte', str]:
+        if len(b) > 1:
+            return Err("Only one byte allowed")
+        try:
+            return Ok(FancyByte(int.from_bytes(b, "little")))
+        except Exception as e:
+            return Err(f"Can't build byte: {e}")
+
+    @staticmethod
+    def fromInt(n: int) -> Result['FancyByte', str]:
+        if n < 0:
+            return Err("Byte too small")
+        elif n >= math.pow(2, 8):
+            return Err("Byte too large")
+        return Ok(FancyByte(n))
+
+    def to_binary_bits(self) -> Iterable[bool]:
+        str_bits_8 = bin(self.value)[2:].zfill(8)
+        return list(map(lambda x: x == "1", str_bits_8))
+
+    def to_hex_str(self) -> str:
+        return str(hex(self.value))
+
+    def to_char(self) -> str:
+        return chr(self.value)