plover-touch-tablets 0.0.0__tar.gz

plover_touch_tablets-0.0.0/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: plover-touch-tablets
+Version: 0.0.0
+Summary: Touch Tablets Plover Plugin
+Keywords: plover_plugin
+Description-Content-Type: text/markdown
+Requires-Dist: plover>=5.0.0
+Requires-Dist: PySide6
+Requires-Dist: websocket-client
+Requires-Dist: jsonpickle
+Requires-Dist: nacl_middleware
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: dev
+Requires-Dist: plover-touch-tablets[test]; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: bump-my-version; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+
+# Plover Touch Tablets Plugin
+
+This Plover plugin enables seamless integration between Plover and touch-based steno keyboard applications running on tablets. It establishes a secure WebSocket connection, allowing your tablet to function as a steno machine for Plover.
+
+## Compatibility
+
+This plugin is designed to be compatible with the **[Touch Steno Keyboard](https://github.com/CosmicDNA/touch-steno-keyboard)** application and the **[Plover Websocket Relay](https://github.com/CosmicDNA/plover-websocket-relay)**.
+
+## Features
+
+- **Easy Pairing**: Generates a QR code within Plover for quick connection setup.
+- **Secure Connection**: Uses encryption to ensure secure communication between the tablet and Plover.
+- **Bi-directional Communication**: Supports sending steno strokes to Plover and receiving dictionary lookups/translations back on the tablet.
+
+## Installation
+
+1. Open Plover.
+2. Install `plover-touch-tablets` plugin via either plover_console CLI or plugin manager.
+3. Restart Plover.
+
+## Usage
+
+1. Open Plover.
+2. Go to **Tools** > **Tablet QR**.
+3. A window will appear displaying a QR code.
+4. Open the Touch Steno Keyboard application on your tablet.
+5. Use the application to scan the QR code displayed on your computer screen.
+6. Once connected, strokes entered on the tablet will be processed by Plover.
+
+## Powered by
+![Python](https://img.shields.io/badge/Python-repo?logo=python&color=black&style=for-the-badge)
+![Plover](https://img.shields.io/badge/Plover-repo?logo=plover&color=black&style=for-the-badge)

plover_touch_tablets-0.0.0/README.md

@@ -0,0 +1,32 @@
+# Plover Touch Tablets Plugin
+
+This Plover plugin enables seamless integration between Plover and touch-based steno keyboard applications running on tablets. It establishes a secure WebSocket connection, allowing your tablet to function as a steno machine for Plover.
+
+## Compatibility
+
+This plugin is designed to be compatible with the **[Touch Steno Keyboard](https://github.com/CosmicDNA/touch-steno-keyboard)** application and the **[Plover Websocket Relay](https://github.com/CosmicDNA/plover-websocket-relay)**.
+
+## Features
+
+- **Easy Pairing**: Generates a QR code within Plover for quick connection setup.
+- **Secure Connection**: Uses encryption to ensure secure communication between the tablet and Plover.
+- **Bi-directional Communication**: Supports sending steno strokes to Plover and receiving dictionary lookups/translations back on the tablet.
+
+## Installation
+
+1. Open Plover.
+2. Install `plover-touch-tablets` plugin via either plover_console CLI or plugin manager.
+3. Restart Plover.
+
+## Usage
+
+1. Open Plover.
+2. Go to **Tools** > **Tablet QR**.
+3. A window will appear displaying a QR code.
+4. Open the Touch Steno Keyboard application on your tablet.
+5. Use the application to scan the QR code displayed on your computer screen.
+6. Once connected, strokes entered on the tablet will be processed by Plover.
+
+## Powered by
+![Python](https://img.shields.io/badge/Python-repo?logo=python&color=black&style=for-the-badge)
+![Plover](https://img.shields.io/badge/Plover-repo?logo=plover&color=black&style=for-the-badge)

plover_touch_tablets-0.0.0/plover_touch_tablets/client_config.py

@@ -0,0 +1,79 @@
+"""Server configuration."""
+
+from json import dump, load
+from pathlib import Path
+
+from nacl.encoding import HexEncoder
+from nacl.public import PrivateKey
+from nacl_middleware import Nacl
+from plover.oslayer.config import CONFIG_DIR
+
+from plover_touch_tablets.get_logger import get_logger
+
+log = get_logger("ClientConfig")
+
+
+class ClientConfig:
+    """Loads server configuration.
+
+    Attributes:
+        host: The host address for the server to run on.
+        port: The port for the server to run on.
+
+    """
+
+    public_key: str
+    public_key: str
+
+    def __init__(self, client_config_file: str) -> None:
+        """Initialize the server configuration object.
+
+        Args:
+            client_config_file: The file path of the configuration file to load.
+
+        Raises:
+            IOError: Errored when loading the server configuration file.
+
+        """
+        # Try to load from the other plugin's config file first (read-only)
+        other_config_path = Path(CONFIG_DIR) / client_config_file
+        data = {}
+        keys_found = False
+
+        if other_config_path.exists():
+            try:
+                with other_config_path.open(encoding="utf-8") as config_file:
+                    other_data = load(config_file)
+                    if "private_key" in other_data and "public_key" in other_data:
+                        data = other_data
+                        keys_found = True
+                        log.debug(f"Loaded keys from {other_config_path}")
+            except Exception:
+                log.exception(f"Error reading {other_config_path}:")
+
+        # If not found, use our own config file
+        if not keys_found:
+            my_config_path = Path(CONFIG_DIR) / "plover_touch_tablets.json"
+            if my_config_path.exists():
+                try:
+                    with my_config_path.open(encoding="utf-8") as config_file:
+                        data = load(config_file)
+                        if "private_key" in data and "public_key" in data:
+                            keys_found = True
+                            log.debug(f"Loaded keys from {my_config_path}")
+                except Exception:
+                    log.exception(f"Error reading {my_config_path}:")
+
+            if not keys_found:
+                log.info("No existing keys found. Generating new keys...")
+                nacl_helper = Nacl()
+                data["private_key"] = nacl_helper.decoded_private_key()
+                data["public_key"] = nacl_helper.decoded_public_key()
+
+                log.info(f"Saving new keys to {my_config_path}")
+                with my_config_path.open("w", encoding="utf-8") as config_file:
+                    dump(data, config_file, indent=2)
+
+        # Assign values to class attributes
+        self.private_key = PrivateKey(data["private_key"], HexEncoder)
+        self.public_key = data["public_key"]

plover_touch_tablets-0.0.0/plover_touch_tablets/config.py

@@ -0,0 +1,16 @@
+# from plover_touch_tablets.debug import is_debug_mode
+
+# if is_debug_mode():
+#     PROTOCOL = "http:"
+#     BASE_WORKER_URL = "localhost:8787"
+
+WORKER_PROTOCOL = "https:"
+BASE_WORKER_FQDN = "relay.stenography.cosmicdna.co.uk"
+APP_URL = "https://touch.stenography.cosmicdna.co.uk"
+
+SESSION_SLUG = "session"
+INITIATE_SLUG = "initiate"
+CONNECT_SLUG = "connect"
+JOIN_SLUG = "join"
+TOKEN_PARAM = "token"  # nosec B105
+RELAY_PARAM = "relay"

plover_touch_tablets-0.0.0/plover_touch_tablets/debug.py

@@ -0,0 +1,7 @@
+import logging
+
+plover_logger = logging.getLogger("plover")
+
+
+def is_debug_mode():
+    return plover_logger.isEnabledFor(logging.DEBUG)

plover_touch_tablets-0.0.0/plover_touch_tablets/encoding.py

@@ -0,0 +1,5 @@
+import urllib.parse
+
+
+def encode_raw_url(url: str) -> str:
+    return urllib.parse.quote(url, safe="")

plover_touch_tablets-0.0.0/plover_touch_tablets/extended_engine.py

@@ -0,0 +1,29 @@
+from typing import TYPE_CHECKING
+
+from plover.engine import StenoEngine
+
+if TYPE_CHECKING:
+    from plover_touch_tablets.extension import Extension
+
+from plover_touch_tablets.signal import Signal
+
+
+class ExtendedStenoEngine:
+    my_minimal_extension: "Extension"
+    signals: list[Signal]
+    _engine: StenoEngine
+
+    def __init__(self, engine: StenoEngine):
+        self._engine = engine
+
+    def __getattr__(self, name):
+        """Wrapper around StenoEngine."""
+        return getattr(self._engine, name)
+
+    def disconnect_hooks(self, host: object):
+        for signal in self.signals:
+            self._engine.hook_disconnect(signal.hook, getattr(host, signal.callback))
+
+    def connect_hooks(self, host: object):
+        for signal in self.signals:
+            self._engine.hook_connect(signal.hook, getattr(host, signal.callback))

plover_touch_tablets-0.0.0/plover_touch_tablets/extension.py

@@ -0,0 +1,171 @@
+import json
+from collections.abc import Callable
+from importlib.metadata import metadata
+from typing import Any
+
+from jsonpickle import encode
+from nacl_middleware import MailBox
+from plover.engine import StenoEngine
+from plover.gui_qt.paper_tape import TapeModel
+from plover.steno import Stroke
+from websocket import WebSocketApp
+
+from plover_touch_tablets.client_config import ClientConfig
+from plover_touch_tablets.config import BASE_WORKER_FQDN, WORKER_PROTOCOL
+from plover_touch_tablets.extended_engine import ExtendedStenoEngine
+from plover_touch_tablets.get_logger import get_logger
+from plover_touch_tablets.lookup import lookup
+from plover_touch_tablets.signal import Signal
+
+log = get_logger("Extension")
+
+SERVER_CONFIG_FILE = "plover_websocket_server_config.json"
+
+
+class Extension:
+    engine: ExtendedStenoEngine
+    _tape_model: TapeModel
+
+    def __init__(self, engine: StenoEngine):
+        self.engine = ExtendedStenoEngine(engine)
+        engine.my_minimal_extension = self
+
+        self.engine.signals = [Signal("stroked"), Signal("translated")]
+        self._config = ClientConfig(SERVER_CONFIG_FILE)  # reload the configuration when the server is restarted
+        self.mail_boxes: dict[int, MailBox] = {}
+
+        self._tape_model = TapeModel()
+        self._tape_model.reset()
+
+    def on_stroked(self, stroke: Stroke):
+        # Minimal example: just log strokes
+        log.info(f"Stroke: {stroke}")
+
+    def on_translated(self, old, new):
+        if new:
+            log.info(f"Translated: {new}")
+
+    def start(self):
+        log.info("Extension initialised")
+
+        # Example: Connect to stroke signals
+        self.engine.connect_hooks(self)
+
+    def stop(self):
+        self.engine.disconnect_hooks(self)
+
+    def _handle_tablet_connected(
+        self,
+        ws: WebSocketApp,
+        tablet_id: int,
+        public_key: str,
+        on_tablet_connected: Callable[[str], None] | None,
+        new_tablet_token: str | None,
+    ):
+        log.debug(f"Private key: {self._config.private_key} and public key: {public_key}")
+        if public_key:
+            self.mail_boxes[tablet_id] = MailBox(self._config.private_key, public_key)
+        ws.send(
+            json.dumps(
+                {
+                    "to": {"type": "tablet", "id": tablet_id},
+                    "payload": {
+                        "message": "Here is my the public key for you to privately communicate with me...",
+                        "public_key": self._config.public_key,
+                    },
+                }
+            )
+        )
+        if on_tablet_connected and new_tablet_token:
+            on_tablet_connected(new_tablet_token)
+
+    def _handle_stroke(self, ws: WebSocketApp, tablet_id: int, tablet_mail_box: MailBox, steno_keys: list):
+        try:
+            stroke = Stroke(steno_keys)
+            stroke_json = encode(stroke, unpicklable=False)
+            paper = self._tape_model._paper_format(stroke)
+
+            data = {
+                "keys": stroke.steno_keys,
+                "stroked": stroke_json,
+                "rtfcre": stroke.rtfcre,
+                "paper": paper,
+            }
+            message = {"on_stroked": data}
+
+            ws.send(
+                json.dumps(
+                    {
+                        "to": {"type": "tablet", "id": tablet_id},
+                        "payload": tablet_mail_box.box(message),
+                    }
+                )
+            )
+
+            self.engine._engine._machine_stroke_callback(steno_keys)
+        except Exception:
+            log.exception("Failed to process stroke")
+
+    def _handle_lookup(self, ws: WebSocketApp, tablet_id: int, tablet_mail_box: MailBox, text_to_lookup: str):
+        try:
+            steno_options_per_word = lookup(self.engine._engine, text_to_lookup)
+            ws.send(
+                json.dumps(
+                    {
+                        "to": {"type": "tablet", "id": tablet_id},
+                        "payload": tablet_mail_box.box({"lookup": steno_options_per_word}),
+                    }
+                )
+            )
+        except Exception:
+            log.exception("Failed to process lookup request")
+
+    def connect_websocket(self, connection_string: str, on_tablet_connected: Callable[[str], None] | None = None):
+        def on_message(ws: WebSocketApp, message: Any):
+            if isinstance(message, str):
+                message: dict = json.loads(message)
+            log.debug(f"Received: {message}")
+            msg_type = message.get("type")
+            if msg_type == "tablet_connected":
+                tablet_id = message.get("id")
+                public_key = message.get("publicKey")
+                new_tablet_token = message.get("newTabletToken")
+                self._handle_tablet_connected(ws, tablet_id, public_key, on_tablet_connected, new_tablet_token)
+                return
+
+            from_data: dict = message.get("from")
+            if from_data and from_data.get("type") == "tablet":
+                payload = message.get("payload")
+                tablet_id = from_data.get("id")
+                tablet_mail_box = self.mail_boxes.get(tablet_id)
+                decrypted_payload = tablet_mail_box.unbox(payload)
+
+                if "stroke" in decrypted_payload:
+                    steno_keys = decrypted_payload["stroke"]
+                    if isinstance(steno_keys, list):
+                        self._handle_stroke(ws, tablet_id, tablet_mail_box, steno_keys)
+
+                if "lookup" in decrypted_payload:
+                    text_to_lookup = decrypted_payload["lookup"]
+                    log.debug(f"Lookup request for: {text_to_lookup}")
+                    if isinstance(text_to_lookup, str):
+                        self._handle_lookup(ws, tablet_id, tablet_mail_box, text_to_lookup)
+
+        def on_error(ws, error: Exception):
+            log.exception(f"Error: {error}")
+
+        def on_close(ws, close_status_code, close_msg):
+            log.info("Closed")
+
+        def on_open(ws):
+            log.info("Opened")
+
+        meta = metadata("plover-touch-tablets")
+        header = {
+            "User-Agent": f"{meta['Name']}/{meta['Version']}",
+            "Origin": f"{WORKER_PROTOCOL}//{BASE_WORKER_FQDN}",
+            "X-Public-Key": self._config.public_key,
+        }
+        log.info(header)
+        ws = WebSocketApp(connection_string, on_open=on_open, on_message=on_message, on_error=on_error, on_close=on_close, header=header)
+        ws.run_forever(reconnect=5)

plover_touch_tablets-0.0.0/plover_touch_tablets/get_logger.py

@@ -0,0 +1,14 @@
+import logging
+import sys
+
+
+def get_logger(name: str, level=logging.DEBUG):
+    log = logging.getLogger(f"plover.{name.lower()}")
+    if not log.handlers:
+        handler = logging.StreamHandler(sys.stdout)
+        handler.setFormatter(logging.Formatter(f"%(asctime)s [%(threadName)s] %(levelname)s: [{name}] %(filename)s:%(lineno)d %(message)s"))
+        log.addHandler(handler)
+    log.setLevel(level)
+    log.propagate = False
+
+    return log

plover_touch_tablets-0.0.0/plover_touch_tablets/lookup.py

@@ -0,0 +1,147 @@
+# Find the steno strokes for the given text
+import re
+
+from plover import log
+from plover.engine import StenoEngine
+
+
+class PloverLookupError(Exception):
+    def __init__(self, msg, *args):
+        self.msg = msg
+        super().__init__(*args)
+
+
+def lookup(engine: StenoEngine, text_to_lookup: str) -> list:  # noqa: PLR0915
+    """Recursively looks up a phrase by finding the longest possible dictionary match.
+
+    Starts from the beginning of the string and then solving for the remainder.
+
+    A lookup can fail (return an empty list) if any part of the tokenized input
+    string cannot be found in Plover's dictionaries. The lookup is performed
+    recursively, and if any segment of the phrase has no corresponding steno
+    strokes, the entire lookup for that path will fail, and if no alternative
+    paths are found, the overall result will be empty.
+    """
+    memo = {}
+    log.debug(f"Starting lookup for: '{text_to_lookup}'")
+
+    def get_steno_for_phrase(phrase: str) -> list | None:
+        """Finds steno for a phrase.
+
+        Handling capitalization by falling back
+        to lowercase and prepending the capitalization stroke.
+        """
+        # 1. Try the phrase as-is (respecting capitalization)
+        log.debug(f"  - get_steno_for_phrase('{phrase}')")
+
+        steno_capitalized: set = engine.reverse_lookup(phrase)
+
+        # If the phrase is a single non-word character (like '!'),
+        # also try looking it up as a Plover command (e.g., '{!}').
+        if len(phrase) == 1 and not phrase.isalnum():
+            # Handle characters that are special within Plover's command syntax
+            command_phrase = f"{{{phrase}}}"
+            log.debug(f"    - Trying command lookup for '{command_phrase}'")
+            steno_from_command = engine.reverse_lookup(command_phrase)
+            if steno_from_command:
+                steno_capitalized.update(steno_from_command)
+
+        # 2. Try the lowercase version and prepend cap stroke if needed
+        steno_lowercase_modified = set()
+        if phrase.lower() != phrase:
+            steno_lowercase_raw = engine.reverse_lookup(phrase.lower())
+            if steno_lowercase_raw:
+                cap_next_results = ("KPA",)
+                steno_lowercase_modified = {cap_next_results + s_lower for s_lower in steno_lowercase_raw}
+
+        # Prioritize direct capitalized results
+        combined = steno_capitalized.union(steno_lowercase_modified)
+        numeric_phrase = re.sub(r"[$,€£]", "", phrase.replace(",", ""))
+        if numeric_phrase.isdigit():
+            digit_steno_list = []
+            all_digits_found = True
+            for digit in numeric_phrase:
+                digit_steno = engine.reverse_lookup(digit)
+                if not digit_steno:
+                    all_digits_found = False
+                    break
+                digit_steno_list.append(min(digit_steno, key=len))  # Choose shortest steno for the digit
+            if all_digits_found:
+                combined_digit_steno = tuple(s for steno_tuple in digit_steno_list for s in steno_tuple)
+                combined.add(combined_digit_steno)
+
+        # If after all attempts, we have no results, return None.
+        if not combined:
+            # Only issue a warning for single words that are not found, as this is the root cause of failure.
+            is_single_word = " " not in phrase
+            if is_single_word:
+                log.warning(f"Failed to find steno for word: '{phrase}'")
+            else:
+                log.debug(f"    - FAILED to find steno for phrase: '{phrase}'")
+            return None
+
+        # Sort results: 1. Direct cap match, 2. Stroke count, 3. Key count
+        return sorted(combined, key=lambda s: (s not in steno_capitalized, len(s), sum(len(p) for p in s)))
+
+    def solve(words_tuple: tuple) -> list[list[tuple]]:
+        if not words_tuple:
+            return [[]]  # Base case: one valid solution, which is empty.
+        if words_tuple in memo:
+            return memo[words_tuple]
+        log.debug(f"--> solve({words_tuple})")
+
+        def get_steno_options(i):
+            return get_steno_for_phrase(" ".join(words_tuple[:i]))
+
+        max_lookup_length = min(len(words_tuple), engine._dictionaries.longest_key)
+
+        def process_i(i, best_steno_for_prefix):
+            # Recursively find all solutions for the rest of the phrase
+            prefix_phrase = " ".join(words_tuple[:i])
+            suffix_tuple = words_tuple[i:]
+            suffix_solutions = solve(suffix_tuple)
+
+            # Combine the prefix's steno with each suffix solution
+            return [[{"text": prefix_phrase, "steno": best_steno_for_prefix}] + suffix_solution for suffix_solution in suffix_solutions]
+
+        all_solutions = [
+            solution
+            for i in range(max_lookup_length, 0, -1)
+            if (steno_options := get_steno_options(i))
+            for solution in process_i(i, steno_options[0])
+        ]
+
+        if not all_solutions:
+            # This is the point of failure. It means for the current `words_tuple`,
+            # no prefix could be found in the dictionary that also had a valid suffix solution.
+            log.debug(f"  <-- solve({words_tuple}) -> FAILED: No steno found for any prefix.")
+        memo[words_tuple] = all_solutions
+        return all_solutions
+
+    # Tokenize the input string, separating words from punctuation.
+    # This finds sequences of word characters (including those with internal apostrophes)
+    # currency symbols attached to numbers, numbers with commas, or single non-word/non-space characters.
+    token_regex = r"[$€£]?\d+(?:,\d+)*|\w+(?:['’]\w+)*|[^\w\s]"  # nosec B105
+    words = re.findall(token_regex, text_to_lookup)
+
+    all_possible_sequences = solve(tuple(words))
+
+    log.debug(f"All possible sequences: {all_possible_sequences}")
+
+    if not all_possible_sequences:
+        log.debug(f"Lookup failed for '{text_to_lookup}'. No valid steno sequence found.")
+        return []
+
+    # Sort the collected sequences by overall efficiency
+    # 1. Total number of strokes in the sequence
+    # 2. Total number of keys pressed in the sequence
+    sorted_sequences = sorted(
+        all_possible_sequences,
+        key=lambda seq: (
+            sum(len(item["steno"]) for item in seq),
+            sum(sum(len(p) for p in item["steno"]) for item in seq),
+        ),
+    )
+
+    log.debug(f"Lookup finished. Returning {sorted_sequences}")
+    return sorted_sequences

plover_touch_tablets-0.0.0/plover_touch_tablets/signal.py

@@ -0,0 +1,7 @@
+class Signal:
+    hook: str
+    callback: callable
+
+    def __init__(self, name: str) -> None:
+        self.hook = name
+        self.callback = f"on_{name}"

plover_touch_tablets-0.0.0/plover_touch_tablets/tool.py

@@ -0,0 +1,134 @@
+import threading
+from io import BytesIO
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import qrcode
+import requests
+from plover.engine import StenoEngine
+from plover.gui_qt.tool import Tool
+from plover.oslayer.config import ASSETS_DIR
+from PySide6.QtCore import QObject, Qt, Signal
+from PySide6.QtGui import QImage, QPixmap
+from PySide6.QtWidgets import QLabel, QVBoxLayout
+
+from plover_touch_tablets.config import (
+    APP_URL,
+    BASE_WORKER_FQDN,
+    CONNECT_SLUG,
+    INITIATE_SLUG,
+    JOIN_SLUG,
+    RELAY_PARAM,
+    SESSION_SLUG,
+    TOKEN_PARAM,
+    WORKER_PROTOCOL,
+)
+from plover_touch_tablets.encoding import encode_raw_url
+from plover_touch_tablets.extended_engine import ExtendedStenoEngine
+from plover_touch_tablets.get_logger import get_logger
+
+if TYPE_CHECKING:
+    from plover_touch_tablets.extension import Extension
+
+log = get_logger("Tool")
+
+
+class Main(Tool):
+    TITLE = "Tablet QR"
+    ICON = str(Path(ASSETS_DIR) / "plover.png")
+    ROLE = "connection_settings"
+
+    _engine: ExtendedStenoEngine
+    qr: "QRCode"
+    extension: "Extension"
+    tablet_connected = Signal(str)
+    session_id: str
+
+    def __init__(self, engine: StenoEngine):
+        super().__init__(engine)
+        self.tablet_connected.connect(self.on_tablet_connected)
+        self._engine = ExtendedStenoEngine(engine)
+        log.info("Tool initialised")
+
+        self.qr = QRCode(self)
+
+        if not hasattr(engine, "my_minimal_extension"):
+            log.warning("Extension not found. Is the plugin enabled?")
+            return
+
+        self.extension = self._engine.my_minimal_extension
+        log.info("Tool successfully connected to Extension!")
+
+        self.thread_0 = threading.Thread(target=process_data, args=(self,), daemon=True)
+        self.thread_0.start()
+
+    def closeEvent(self, event):  # noqa: N802
+        super().closeEvent(event)
+
+    def on_tablet_connected(self, new_token: str):
+        ws_protocol = WORKER_PROTOCOL.replace("http", "ws")
+        tablet_connection_string = f"{ws_protocol}//{BASE_WORKER_FQDN}/{SESSION_SLUG}/{self.session_id}/{JOIN_SLUG}?{TOKEN_PARAM}={new_token}"
+        log.info(f"Tablet connection string is {tablet_connection_string}")
+        final_qr_url = f"{APP_URL}/?{RELAY_PARAM}={encode_raw_url(tablet_connection_string)}"
+        log.info(final_qr_url)
+        self.qr.qr_ready.emit(final_qr_url)
+
+
+def process_data(main_tool: Main):
+    try:
+        res = requests.post(f"{WORKER_PROTOCOL}//{BASE_WORKER_FQDN}/{SESSION_SLUG}/{INITIATE_SLUG}", timeout=10)
+        response: dict = res.json()
+    except Exception:
+        log.exception("Request failed")
+    else:
+        # protocol = response["protocol"]
+        sessionId = response["sessionId"]
+        pcConnectionToken = response["pcConnectionToken"]
+        tabletConnectionToken = response["tabletConnectionToken"]
+        connection_infos = [
+            (pcConnectionToken, CONNECT_SLUG, WORKER_PROTOCOL, BASE_WORKER_FQDN),
+            (tabletConnectionToken, JOIN_SLUG, WORKER_PROTOCOL, BASE_WORKER_FQDN),
+        ]
+
+        connection_strings = [
+            f"{connection_info[2].replace('http', 'ws')}//{connection_info[3]}/{SESSION_SLUG}/{sessionId}/{connection_info[1]}?{TOKEN_PARAM}={
+                connection_info[0]
+            }"
+            for connection_info in connection_infos
+        ]
+
+        log.info(f"Pc connection string is {connection_strings[0]}")
+
+        tablet_connection_string = connection_strings[1]
+        log.info(f"Tablet connection string is {tablet_connection_string}")
+
+        final_qr_url = f"{APP_URL}/?{RELAY_PARAM}={encode_raw_url(tablet_connection_string)}"
+
+        log.info(final_qr_url)
+
+        if main_tool:
+            main_tool.session_id = sessionId
+            main_tool.qr.qr_ready.emit(final_qr_url)
+            main_tool.extension.connect_websocket(connection_strings[0], on_tablet_connected=main_tool.tablet_connected.emit)
+
+
+class QRCode(QObject):
+    qr_label: QLabel
+    qr_ready = Signal(str)
+
+    def __init__(self, tool: Main) -> None:
+        super().__init__()
+        self.tool = tool
+        self.qr_label = QLabel("Generating QR Code...")
+        self.qr_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        layout = QVBoxLayout()
+        layout.addWidget(self.qr_label)
+        tool.setLayout(layout)
+        self.qr_ready.connect(self.update_qr_code)
+
+    def update_qr_code(self, connection_string):
+        img = qrcode.make(connection_string)
+        buffer = BytesIO()
+        img.save(buffer, format="PNG")
+        qimage = QImage.fromData(buffer.getvalue())
+        self.qr_label.setPixmap(QPixmap.fromImage(qimage))

plover_touch_tablets-0.0.0/plover_touch_tablets.egg-info/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: plover-touch-tablets
+Version: 0.0.0
+Summary: Touch Tablets Plover Plugin
+Keywords: plover_plugin
+Description-Content-Type: text/markdown
+Requires-Dist: plover>=5.0.0
+Requires-Dist: PySide6
+Requires-Dist: websocket-client
+Requires-Dist: jsonpickle
+Requires-Dist: nacl_middleware
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: dev
+Requires-Dist: plover-touch-tablets[test]; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: bump-my-version; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+
+# Plover Touch Tablets Plugin
+
+This Plover plugin enables seamless integration between Plover and touch-based steno keyboard applications running on tablets. It establishes a secure WebSocket connection, allowing your tablet to function as a steno machine for Plover.
+
+## Compatibility
+
+This plugin is designed to be compatible with the **[Touch Steno Keyboard](https://github.com/CosmicDNA/touch-steno-keyboard)** application and the **[Plover Websocket Relay](https://github.com/CosmicDNA/plover-websocket-relay)**.
+
+## Features
+
+- **Easy Pairing**: Generates a QR code within Plover for quick connection setup.
+- **Secure Connection**: Uses encryption to ensure secure communication between the tablet and Plover.
+- **Bi-directional Communication**: Supports sending steno strokes to Plover and receiving dictionary lookups/translations back on the tablet.
+
+## Installation
+
+1. Open Plover.
+2. Install `plover-touch-tablets` plugin via either plover_console CLI or plugin manager.
+3. Restart Plover.
+
+## Usage
+
+1. Open Plover.
+2. Go to **Tools** > **Tablet QR**.
+3. A window will appear displaying a QR code.
+4. Open the Touch Steno Keyboard application on your tablet.
+5. Use the application to scan the QR code displayed on your computer screen.
+6. Once connected, strokes entered on the tablet will be processed by Plover.
+
+## Powered by
+![Python](https://img.shields.io/badge/Python-repo?logo=python&color=black&style=for-the-badge)
+![Plover](https://img.shields.io/badge/Plover-repo?logo=plover&color=black&style=for-the-badge)

plover_touch_tablets-0.0.0/plover_touch_tablets.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+plover_touch_tablets/client_config.py
+plover_touch_tablets/config.py
+plover_touch_tablets/debug.py
+plover_touch_tablets/encoding.py
+plover_touch_tablets/extended_engine.py
+plover_touch_tablets/extension.py
+plover_touch_tablets/get_logger.py
+plover_touch_tablets/lookup.py
+plover_touch_tablets/signal.py
+plover_touch_tablets/tool.py
+plover_touch_tablets.egg-info/PKG-INFO
+plover_touch_tablets.egg-info/SOURCES.txt
+plover_touch_tablets.egg-info/dependency_links.txt
+plover_touch_tablets.egg-info/entry_points.txt
+plover_touch_tablets.egg-info/requires.txt
+plover_touch_tablets.egg-info/top_level.txt
+tests/test_me.py

plover_touch_tablets-0.0.0/plover_touch_tablets.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

plover_touch_tablets-0.0.0/plover_touch_tablets.egg-info/entry_points.txt

@@ -0,0 +1,5 @@
+[plover.extension]
+plover_touch_tablets = plover_touch_tablets.extension:Extension
+
+[plover.gui.qt.tool]
+tablet_qr = plover_touch_tablets.tool:Main

plover_touch_tablets-0.0.0/plover_touch_tablets.egg-info/requires.txt

@@ -0,0 +1,16 @@
+plover>=5.0.0
+PySide6
+websocket-client
+jsonpickle
+nacl_middleware
+
+[dev]
+plover-touch-tablets[test]
+pre-commit
+build
+bump-my-version
+twine
+ruff
+
+[test]
+pytest

plover_touch_tablets-0.0.0/plover_touch_tablets.egg-info/top_level.txt

@@ -0,0 +1 @@
+plover_touch_tablets

plover_touch_tablets-0.0.0/pyproject.toml

@@ -0,0 +1,104 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "plover-touch-tablets"
+version = "0.0.0"
+description = "Touch Tablets Plover Plugin"
+readme = "README.md"
+keywords = ["plover_plugin"]
+dependencies = [
+    "plover>=5.0.0",
+    "PySide6",
+    "websocket-client",
+    "jsonpickle",
+    "nacl_middleware"
+]
+
+[project.optional-dependencies]
+test = ["pytest"]
+
+dev = [
+    "plover-touch-tablets[test]", # Includes all dependencies from the 'test' group,
+    "pre-commit",                   # For managing pre-commit hooks
+    "build",
+    "bump-my-version",
+    "twine",
+    "ruff",
+]
+
+[project.entry-points."plover.gui.qt.tool"]
+tablet_qr = "plover_touch_tablets.tool:Main"
+
+[project.entry-points."plover.extension"]
+plover_touch_tablets = "plover_touch_tablets.extension:Extension"
+
+[tool.bumpversion]
+current_version = "0.0.0"
+parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
+serialize = ["{major}.{minor}.{patch}"]
+search = "{current_version}"
+replace = "{new_version}"
+regex = false
+ignore_missing_version = false
+ignore_missing_files = false
+tag = true
+sign_tags = true
+tag_name = "v{new_version}"
+tag_message = "Bump version: {current_version} → {new_version}"
+allow_dirty = false
+commit = true
+message = "Bump version: {current_version} → {new_version}"
+moveable_tags = []
+commit_args = ""
+setup_hooks = []
+pre_commit_hooks = []
+post_commit_hooks = []
+
+[tool.ruff]
+line-length = 149
+target-version = "py311"
+
+[tool.ruff.lint]
+# Enable Pyflakes (F), pycodestyle (E, W), isort (I)
+# Enable many common Pylint (PL), flake8-bugbear (B), flake8-comprehensions (C4), etc. rules
+select = [
+    "F",
+    "E",
+    "W",
+    "I",
+    "N",
+    "D",   # Core flake8, isort, pep8-naming, pydocstyle
+    "UP",  # pyupgrade
+    "B",   # flake8-bugbear
+    "A",   # flake8-builtins
+    "C4",  # flake8-comprehensions
+    "T20", # flake8-print (T201 for print, T203 for pprint)
+    "SIM", # flake8-simplify
+    "PTH", # flake8-use-pathlib
+    "PL",  # Pylint
+    "TRY", # tryceratops
+]
+ignore = [
+    # Ignore common missing docstring errors for now
+    "D100", # Missing docstring in public module
+    "D101", # Missing docstring in public class
+    "D102", # Missing docstring in public method
+    "D103", # Missing docstring in public function
+    "D104", # Missing docstring in public package
+    "D107", # Missing docstring in `__init__`
+    "D203", # 1 blank line required before class docstring
+    "D213", # Multi-line docstring closing quotes should be on a separate line
+    "D401", # First line of docstring should be in imperative mood
+    "N803", # Function name should be lowercase
+    "N806", # Variable in function should be lowercase
+]
+# mccabe (cyclomatic complexity)
+# mccabe.max-complexity = 10 # Default is 10, adjust as needed
+
+[tool.ruff.format]
+quote-style = "double"            # Black default
+indent-style = "space"
+skip-magic-trailing-comma = false # Black default
+line-ending = "auto"

plover_touch_tablets-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

plover_touch_tablets-0.0.0/tests/test_me.py

@@ -0,0 +1,3 @@
+def test_suite():
+    async def a_simple_test():
+        assert True