uwscli 0.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- uwscli/__init__.py +11 -0
- uwscli/cli.py +416 -0
- uwscli/lcd.py +594 -0
- uwscli/logging_utils.py +34 -0
- uwscli/structs.py +108 -0
- uwscli/system_usb.py +160 -0
- uwscli/usbutil.py +207 -0
- uwscli/wireless.py +362 -0
- uwscli-0.1.0.dist-info/METADATA +169 -0
- uwscli-0.1.0.dist-info/RECORD +14 -0
- uwscli-0.1.0.dist-info/WHEEL +5 -0
- uwscli-0.1.0.dist-info/entry_points.txt +2 -0
- uwscli-0.1.0.dist-info/licenses/LICENSE +21 -0
- uwscli-0.1.0.dist-info/top_level.txt +1 -0
uwscli/__init__.py
ADDED
uwscli/cli.py
ADDED
|
@@ -0,0 +1,416 @@
|
|
|
1
|
+
"""Command line interface for the UWS toolkit."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
import argparse
|
|
6
|
+
import json
|
|
7
|
+
import time
|
|
8
|
+
from importlib import metadata
|
|
9
|
+
from pathlib import Path
|
|
10
|
+
from typing import Iterable, List
|
|
11
|
+
|
|
12
|
+
from . import lcd, wireless
|
|
13
|
+
from .logging_utils import configure_logging
|
|
14
|
+
from .structs import LCDControlSetting, ScreenRotation, clamp_pwm_values
|
|
15
|
+
|
|
16
|
+
|
|
17
|
+
def _resolve_version() -> str:
|
|
18
|
+
try:
|
|
19
|
+
return metadata.version("uwscli")
|
|
20
|
+
except metadata.PackageNotFoundError:
|
|
21
|
+
from . import __version__
|
|
22
|
+
|
|
23
|
+
return getattr(__version__, "__version__", __version__ if isinstance(__version__, str) else "0.0.0")
|
|
24
|
+
|
|
25
|
+
|
|
26
|
+
def build_parser() -> argparse.ArgumentParser:
|
|
27
|
+
parser = argparse.ArgumentParser(
|
|
28
|
+
prog="uws",
|
|
29
|
+
description="UWS CLI for Uni fan wireless controllers",
|
|
30
|
+
)
|
|
31
|
+
parser.add_argument(
|
|
32
|
+
"--version",
|
|
33
|
+
action="version",
|
|
34
|
+
version=f"%(prog)s {_resolve_version()}",
|
|
35
|
+
)
|
|
36
|
+
parser.add_argument(
|
|
37
|
+
"-v",
|
|
38
|
+
"--verbose",
|
|
39
|
+
action="count",
|
|
40
|
+
default=0,
|
|
41
|
+
help="Increase log verbosity (-v for INFO, -vv for DEBUG)",
|
|
42
|
+
)
|
|
43
|
+
parser.add_argument(
|
|
44
|
+
"--output",
|
|
45
|
+
choices=["text", "json"],
|
|
46
|
+
default="text",
|
|
47
|
+
help="Output format for supported commands (default: text)",
|
|
48
|
+
)
|
|
49
|
+
subparsers = parser.add_subparsers(dest="namespace")
|
|
50
|
+
|
|
51
|
+
# LCD namespace
|
|
52
|
+
lcd_parser = subparsers.add_parser("lcd", help="Interact with UNI FAN TL LCD panels")
|
|
53
|
+
lcd_sub = lcd_parser.add_subparsers(dest="command", required=True)
|
|
54
|
+
|
|
55
|
+
lcd_sub.add_parser("list", help="List attached LCD devices")
|
|
56
|
+
|
|
57
|
+
info_parser = lcd_sub.add_parser("info", help="Display firmware and handshake info")
|
|
58
|
+
info_parser.add_argument("--serial", required=False, help="USB serial number of the LCD device")
|
|
59
|
+
|
|
60
|
+
send_jpg_parser = lcd_sub.add_parser("send-jpg", help="Send a JPEG frame to the LCD")
|
|
61
|
+
send_jpg_parser.add_argument("--file", required=True, type=Path, help="JPEG file path")
|
|
62
|
+
send_jpg_parser.add_argument("--serial", required=False, help="USB serial number of the LCD device")
|
|
63
|
+
|
|
64
|
+
keep_alive_parser = lcd_sub.add_parser("keep-alive", help="Send periodic keep-alive handshakes")
|
|
65
|
+
keep_alive_parser.add_argument("--serial", required=False, help="USB serial number of the LCD device")
|
|
66
|
+
keep_alive_parser.add_argument(
|
|
67
|
+
"--interval",
|
|
68
|
+
type=float,
|
|
69
|
+
default=5.0,
|
|
70
|
+
help="Seconds between keep-alive messages (default: 5)",
|
|
71
|
+
)
|
|
72
|
+
|
|
73
|
+
control_parser = lcd_sub.add_parser("control", help="Send an LCD control setting")
|
|
74
|
+
control_parser.add_argument("--serial", required=False, help="USB serial number of the LCD device")
|
|
75
|
+
control_parser.add_argument("--mode", default="show_jpg", help="Control mode (e.g. show_jpg, show_app_sync, lcd_test)")
|
|
76
|
+
control_parser.add_argument("--jpg-index", type=int, default=0, help="JPG index for show_jpg mode")
|
|
77
|
+
control_parser.add_argument("--brightness", type=int, default=50, help="LCD brightness 0-100")
|
|
78
|
+
control_parser.add_argument("--fps", type=int, default=30, help="Video FPS")
|
|
79
|
+
control_parser.add_argument("--rotation", type=int, default=0, choices=[0, 90, 180, 270], help="Screen rotation in degrees")
|
|
80
|
+
control_parser.add_argument("--test-color", default="0,0,0", help="RGB triple for LCD test mode (comma separated)")
|
|
81
|
+
control_parser.add_argument("--enable-test", action="store_true", help="Enable test color overlay")
|
|
82
|
+
|
|
83
|
+
# Fan namespace (wireless TL hubs)
|
|
84
|
+
fan_parser = subparsers.add_parser("fan", help="Interact with UNI FAN TL fans")
|
|
85
|
+
fan_sub = fan_parser.add_subparsers(dest="command", required=True)
|
|
86
|
+
|
|
87
|
+
fan_sub.add_parser("list", help="List wireless hubs discovered via RF dongle")
|
|
88
|
+
|
|
89
|
+
set_fan_parser = fan_sub.add_parser("set-fan", help="Send PWM to a wireless hub")
|
|
90
|
+
set_fan_parser.add_argument("--mac", required=True, help="MAC address of the wireless hub (aa:bb:cc:dd:ee:ff)")
|
|
91
|
+
set_fan_parser.add_argument("--pwm", type=int, help="Single PWM value (0-255) applied to all ports")
|
|
92
|
+
set_fan_parser.add_argument(
|
|
93
|
+
"--pwm-list",
|
|
94
|
+
help="Comma separated list of up to four PWM values",
|
|
95
|
+
)
|
|
96
|
+
set_fan_parser.add_argument(
|
|
97
|
+
"--sequence-index",
|
|
98
|
+
type=int,
|
|
99
|
+
default=1,
|
|
100
|
+
help="Sequence index used by the RF command (default: 1)",
|
|
101
|
+
)
|
|
102
|
+
|
|
103
|
+
bind_parser = fan_sub.add_parser("bind", help="Bind an unlinked wireless hub to the current master")
|
|
104
|
+
bind_parser.add_argument("--mac", required=True, help="MAC address of the wireless hub to bind")
|
|
105
|
+
bind_parser.add_argument(
|
|
106
|
+
"--master-mac",
|
|
107
|
+
help="Master MAC to bind against (defaults to first bound device)",
|
|
108
|
+
)
|
|
109
|
+
bind_parser.add_argument(
|
|
110
|
+
"--rx-type",
|
|
111
|
+
type=int,
|
|
112
|
+
help="Optional RX type (1-15). Auto-selects when omitted.",
|
|
113
|
+
)
|
|
114
|
+
|
|
115
|
+
unbind_parser = fan_sub.add_parser("unbind", help="Unbind a wireless hub from the current master")
|
|
116
|
+
unbind_parser.add_argument("--mac", required=True, help="MAC address of the wireless hub to unbind")
|
|
117
|
+
|
|
118
|
+
sync_parser = fan_sub.add_parser("pwm-sync", help="Toggle motherboard PWM sync mode")
|
|
119
|
+
sync_target = sync_parser.add_mutually_exclusive_group(required=True)
|
|
120
|
+
sync_target.add_argument("--mac", help="MAC address of the wireless hub to update")
|
|
121
|
+
sync_target.add_argument("--all", action="store_true", help="Apply to all bound wireless hubs")
|
|
122
|
+
sync_state = sync_parser.add_mutually_exclusive_group(required=True)
|
|
123
|
+
sync_state.add_argument("--enable", action="store_true", help="Enable motherboard PWM sync")
|
|
124
|
+
sync_state.add_argument("--disable", action="store_true", help="Disable motherboard PWM sync and use fallback PWM")
|
|
125
|
+
sync_parser.add_argument(
|
|
126
|
+
"--fallback-pwm",
|
|
127
|
+
type=int,
|
|
128
|
+
default=100,
|
|
129
|
+
help="PWM value to use when disabling sync (default: 100)",
|
|
130
|
+
)
|
|
131
|
+
sync_parser.add_argument(
|
|
132
|
+
"--watch",
|
|
133
|
+
action="store_true",
|
|
134
|
+
help="Keep polling hubs (requires running until interrupted)",
|
|
135
|
+
)
|
|
136
|
+
|
|
137
|
+
return parser
|
|
138
|
+
|
|
139
|
+
|
|
140
|
+
def _resolve_lcd_serial(cli_serial: str | None) -> str:
|
|
141
|
+
if cli_serial:
|
|
142
|
+
return _normalize_serial(cli_serial)
|
|
143
|
+
devices = [dev for dev in lcd.enumerate_devices() if dev.serial_number]
|
|
144
|
+
if not devices:
|
|
145
|
+
raise SystemExit("No LCD devices detected")
|
|
146
|
+
if len(devices) > 1:
|
|
147
|
+
choices = "\n".join(
|
|
148
|
+
f" {dev.serial_number} ({dev.product or 'unknown'} @ {dev.path})"
|
|
149
|
+
for dev in devices
|
|
150
|
+
)
|
|
151
|
+
raise SystemExit(
|
|
152
|
+
"Multiple LCD devices detected; please provide --serial from one of:\n" + choices,
|
|
153
|
+
)
|
|
154
|
+
return _normalize_serial(devices[0].serial_number) # type: ignore[arg-type]
|
|
155
|
+
|
|
156
|
+
|
|
157
|
+
def _normalize_serial(value: str) -> str:
|
|
158
|
+
normalized = value.strip()
|
|
159
|
+
if not normalized:
|
|
160
|
+
raise SystemExit("Serial value cannot be empty")
|
|
161
|
+
if normalized.startswith("serial:"):
|
|
162
|
+
normalized = normalized.split(":", 1)[1].strip()
|
|
163
|
+
if not normalized:
|
|
164
|
+
raise SystemExit("Serial value cannot be empty")
|
|
165
|
+
return normalized
|
|
166
|
+
|
|
167
|
+
|
|
168
|
+
def _load_file_bytes(path: Path) -> bytes:
|
|
169
|
+
if not path.exists():
|
|
170
|
+
raise SystemExit(f"File not found: {path}")
|
|
171
|
+
data = path.read_bytes()
|
|
172
|
+
if not data:
|
|
173
|
+
raise SystemExit("File is empty")
|
|
174
|
+
return data
|
|
175
|
+
|
|
176
|
+
|
|
177
|
+
def _parse_test_color(value: str) -> tuple[int, int, int]:
|
|
178
|
+
try:
|
|
179
|
+
parts = [int(part.strip()) for part in value.split(",")]
|
|
180
|
+
except ValueError as exc:
|
|
181
|
+
raise SystemExit("--test-color must be three integers separated by commas") from exc
|
|
182
|
+
if len(parts) != 3:
|
|
183
|
+
raise SystemExit("--test-color must contain exactly three comma separated integers")
|
|
184
|
+
for part in parts:
|
|
185
|
+
if not 0 <= part <= 255:
|
|
186
|
+
raise SystemExit("--test-color values must be between 0 and 255")
|
|
187
|
+
return tuple(parts) # type: ignore[return-value]
|
|
188
|
+
|
|
189
|
+
|
|
190
|
+
def _ensure_pwm_values(args) -> List[int]:
|
|
191
|
+
if args.pwm_list:
|
|
192
|
+
try:
|
|
193
|
+
values = [int(part.strip()) for part in args.pwm_list.split(",") if part.strip()]
|
|
194
|
+
except ValueError as exc:
|
|
195
|
+
raise SystemExit("--pwm-list must contain integers") from exc
|
|
196
|
+
if not values:
|
|
197
|
+
raise SystemExit("--pwm-list cannot be empty")
|
|
198
|
+
return list(clamp_pwm_values(values))
|
|
199
|
+
if args.pwm is None:
|
|
200
|
+
raise SystemExit("Either --pwm or --pwm-list must be provided")
|
|
201
|
+
return [args.pwm] * 4
|
|
202
|
+
|
|
203
|
+
|
|
204
|
+
def handle_lcd(args: argparse.Namespace) -> None:
|
|
205
|
+
if args.command == "list":
|
|
206
|
+
devices = lcd.enumerate_devices()
|
|
207
|
+
if not devices:
|
|
208
|
+
_emit_output(args, {"devices": []}, text="No LCD devices detected")
|
|
209
|
+
return
|
|
210
|
+
device_payloads = []
|
|
211
|
+
for dev in devices:
|
|
212
|
+
info = dev.__dict__.copy()
|
|
213
|
+
if dev.serial_number:
|
|
214
|
+
info.setdefault("serial", dev.serial_number)
|
|
215
|
+
device_payloads.append(info)
|
|
216
|
+
payload = {"devices": device_payloads}
|
|
217
|
+
text = "\n".join(json.dumps(info, ensure_ascii=False) for info in device_payloads)
|
|
218
|
+
_emit_output(args, payload, text=text)
|
|
219
|
+
return
|
|
220
|
+
|
|
221
|
+
serial = _resolve_lcd_serial(getattr(args, "serial", None))
|
|
222
|
+
try:
|
|
223
|
+
with lcd.TLLCDDevice(serial) as device:
|
|
224
|
+
if args.command == "info":
|
|
225
|
+
info = {
|
|
226
|
+
"handshake": device.handshake(),
|
|
227
|
+
"firmware": device.firmware_version(),
|
|
228
|
+
}
|
|
229
|
+
_emit_output(args, info, text=json.dumps(info, indent=2))
|
|
230
|
+
elif args.command == "send-jpg":
|
|
231
|
+
payload = _load_file_bytes(args.file)
|
|
232
|
+
device.send_jpg(payload)
|
|
233
|
+
_emit_output(args, {"bytes_sent": len(payload)}, text=f"Sent {len(payload)} bytes to LCD")
|
|
234
|
+
elif args.command == "control":
|
|
235
|
+
setting = LCDControlSetting(
|
|
236
|
+
mode=lcd.mode_from_arg(args.mode),
|
|
237
|
+
jpg_index=args.jpg_index,
|
|
238
|
+
brightness=args.brightness,
|
|
239
|
+
video_fps=args.fps,
|
|
240
|
+
rotation=ScreenRotation.from_degrees(args.rotation),
|
|
241
|
+
enable_test=args.enable_test,
|
|
242
|
+
test_color=_parse_test_color(args.test_color),
|
|
243
|
+
)
|
|
244
|
+
device.control(setting)
|
|
245
|
+
_emit_output(args, {"status": "control_sent"}, text="LCD control command sent")
|
|
246
|
+
elif args.command == "keep-alive":
|
|
247
|
+
interval = max(args.interval, 0.5)
|
|
248
|
+
print(f"Keeping LCD {serial} awake every {interval:.1f}s. Press Ctrl+C to stop.")
|
|
249
|
+
# Perform an initial handshake to confirm connectivity.
|
|
250
|
+
device.handshake()
|
|
251
|
+
try:
|
|
252
|
+
while True:
|
|
253
|
+
time.sleep(interval)
|
|
254
|
+
device.handshake()
|
|
255
|
+
except KeyboardInterrupt:
|
|
256
|
+
print("Keep-alive stopped.")
|
|
257
|
+
else:
|
|
258
|
+
raise SystemExit("Unknown lcd command")
|
|
259
|
+
except lcd.LCDDeviceError as exc:
|
|
260
|
+
raise SystemExit(str(exc))
|
|
261
|
+
|
|
262
|
+
|
|
263
|
+
def handle_fan(args: argparse.Namespace) -> None:
|
|
264
|
+
if args.command == "list":
|
|
265
|
+
try:
|
|
266
|
+
with wireless.WirelessTransceiver() as tx:
|
|
267
|
+
snapshot = tx.list_devices()
|
|
268
|
+
if not snapshot.devices:
|
|
269
|
+
_emit_output(args, {"devices": []}, text="No wireless devices detected")
|
|
270
|
+
return
|
|
271
|
+
devices = [
|
|
272
|
+
{
|
|
273
|
+
"mac": dev.mac,
|
|
274
|
+
"master_mac": dev.master_mac,
|
|
275
|
+
"channel": dev.channel,
|
|
276
|
+
"rx_type": dev.rx_type,
|
|
277
|
+
"device_type": dev.device_type,
|
|
278
|
+
"fan_count": dev.fan_count,
|
|
279
|
+
"fan_pwm": list(dev.pwm_values),
|
|
280
|
+
"fan_rpm": list(dev.fan_rpm),
|
|
281
|
+
"bound": dev.is_bound,
|
|
282
|
+
}
|
|
283
|
+
for dev in snapshot.devices
|
|
284
|
+
]
|
|
285
|
+
_emit_output(
|
|
286
|
+
args,
|
|
287
|
+
{"devices": devices},
|
|
288
|
+
text="\n".join(json.dumps(dev) for dev in devices),
|
|
289
|
+
)
|
|
290
|
+
return
|
|
291
|
+
except wireless.WirelessError as exc:
|
|
292
|
+
raise SystemExit(str(exc))
|
|
293
|
+
|
|
294
|
+
if args.command == "set-fan":
|
|
295
|
+
pwm_values = _ensure_pwm_values(args)
|
|
296
|
+
try:
|
|
297
|
+
with wireless.WirelessTransceiver() as tx:
|
|
298
|
+
tx.set_pwm(args.mac, pwm_values, sequence_index=args.sequence_index)
|
|
299
|
+
payload = {
|
|
300
|
+
"mac": args.mac,
|
|
301
|
+
"pwm": list(pwm_values),
|
|
302
|
+
"sequence_index": args.sequence_index,
|
|
303
|
+
}
|
|
304
|
+
_emit_output(args, payload, text=f"Applied PWM {pwm_values} to {args.mac}")
|
|
305
|
+
return
|
|
306
|
+
except wireless.WirelessError as exc:
|
|
307
|
+
raise SystemExit(str(exc))
|
|
308
|
+
|
|
309
|
+
if args.command == "bind":
|
|
310
|
+
try:
|
|
311
|
+
with wireless.WirelessTransceiver() as tx:
|
|
312
|
+
updated = tx.bind_device(args.mac, master_mac=args.master_mac, rx_type=args.rx_type)
|
|
313
|
+
if updated and updated.is_bound:
|
|
314
|
+
data = {
|
|
315
|
+
"mac": updated.mac,
|
|
316
|
+
"master_mac": updated.master_mac,
|
|
317
|
+
"channel": updated.channel,
|
|
318
|
+
"rx_type": updated.rx_type,
|
|
319
|
+
"fan_count": updated.fan_count,
|
|
320
|
+
}
|
|
321
|
+
_emit_output(args, data, text=json.dumps(data))
|
|
322
|
+
else:
|
|
323
|
+
_emit_output(
|
|
324
|
+
args,
|
|
325
|
+
{"mac": args.mac, "status": "bind_sent"},
|
|
326
|
+
text="Bind command sent; re-run `uws fan list` to confirm status",
|
|
327
|
+
)
|
|
328
|
+
return
|
|
329
|
+
except wireless.WirelessError as exc:
|
|
330
|
+
raise SystemExit(str(exc))
|
|
331
|
+
|
|
332
|
+
if args.command == "unbind":
|
|
333
|
+
try:
|
|
334
|
+
with wireless.WirelessTransceiver() as tx:
|
|
335
|
+
updated = tx.unbind_device(args.mac)
|
|
336
|
+
if updated and not updated.is_bound:
|
|
337
|
+
data = {
|
|
338
|
+
"mac": updated.mac,
|
|
339
|
+
"master_mac": updated.master_mac,
|
|
340
|
+
"channel": updated.channel,
|
|
341
|
+
"rx_type": updated.rx_type,
|
|
342
|
+
"bound": updated.is_bound,
|
|
343
|
+
}
|
|
344
|
+
_emit_output(args, data, text=json.dumps(data))
|
|
345
|
+
else:
|
|
346
|
+
_emit_output(
|
|
347
|
+
args,
|
|
348
|
+
{"mac": args.mac, "status": "unbind_sent"},
|
|
349
|
+
text="Unbind command sent; re-run `uws fan list` to confirm status",
|
|
350
|
+
)
|
|
351
|
+
return
|
|
352
|
+
except wireless.WirelessError as exc:
|
|
353
|
+
raise SystemExit(str(exc))
|
|
354
|
+
|
|
355
|
+
if args.command == "pwm-sync":
|
|
356
|
+
targets: list[str]
|
|
357
|
+
if args.mac:
|
|
358
|
+
targets = [args.mac]
|
|
359
|
+
else:
|
|
360
|
+
with wireless.WirelessTransceiver() as tx:
|
|
361
|
+
snapshot = tx.list_devices()
|
|
362
|
+
targets = [dev.mac for dev in snapshot.devices if dev.is_bound]
|
|
363
|
+
if not targets:
|
|
364
|
+
raise SystemExit("No bound wireless devices found")
|
|
365
|
+
try:
|
|
366
|
+
if args.watch:
|
|
367
|
+
wireless.run_pwm_sync_loop(
|
|
368
|
+
targets,
|
|
369
|
+
enable=args.enable,
|
|
370
|
+
fallback_pwm=args.fallback_pwm,
|
|
371
|
+
)
|
|
372
|
+
return
|
|
373
|
+
with wireless.WirelessTransceiver() as tx:
|
|
374
|
+
for mac in targets:
|
|
375
|
+
if args.enable:
|
|
376
|
+
tx.set_pwm_sync(mac, enable=True)
|
|
377
|
+
else:
|
|
378
|
+
tx.set_pwm_sync(mac, enable=False, fallback_pwm=args.fallback_pwm)
|
|
379
|
+
result = {
|
|
380
|
+
"targets": targets,
|
|
381
|
+
"mode": "enable" if args.enable else "disable",
|
|
382
|
+
"fallback_pwm": args.fallback_pwm,
|
|
383
|
+
}
|
|
384
|
+
_emit_output(args, result, text=json.dumps(result))
|
|
385
|
+
return
|
|
386
|
+
except wireless.WirelessError as exc:
|
|
387
|
+
raise SystemExit(str(exc))
|
|
388
|
+
|
|
389
|
+
raise SystemExit("Unknown fan command")
|
|
390
|
+
|
|
391
|
+
|
|
392
|
+
def main(argv: Iterable[str] | None = None) -> None:
|
|
393
|
+
parser = build_parser()
|
|
394
|
+
args = parser.parse_args(list(argv) if argv is not None else None)
|
|
395
|
+
configure_logging(args.verbose)
|
|
396
|
+
if not args.namespace:
|
|
397
|
+
parser.print_help()
|
|
398
|
+
return
|
|
399
|
+
if args.namespace == "lcd":
|
|
400
|
+
handle_lcd(args)
|
|
401
|
+
elif args.namespace == "fan":
|
|
402
|
+
handle_fan(args)
|
|
403
|
+
else:
|
|
404
|
+
raise SystemExit("Unknown namespace")
|
|
405
|
+
|
|
406
|
+
|
|
407
|
+
if __name__ == "__main__":
|
|
408
|
+
main()
|
|
409
|
+
|
|
410
|
+
|
|
411
|
+
def _emit_output(args: argparse.Namespace, payload, *, text: str) -> None:
|
|
412
|
+
"""Emit payload according to the caller's preferred output format."""
|
|
413
|
+
if args.output == "json":
|
|
414
|
+
print(json.dumps(payload, ensure_ascii=False))
|
|
415
|
+
else:
|
|
416
|
+
print(text)
|