pysd10 0.2.0__tar.gz

pysd10-0.2.0/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: pysd10
+Version: 0.2.0
+Summary: Python client for the Epson SD-10 spectrophotometer over Bluetooth LE (spectrum and L*a*b*)
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: bleak>=0.21
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+
+# sd10
+
+Python client for the **Epson SD-10** spectrophotometer over Bluetooth LE: take measurements and get
+the 31-band spectrum (400–700 nm) and CIE L\*a\*b\* exactly as the Epson Spectrometer app computes it.
+
+## Install
+
+```
+pip install -e path\to\sd10_client
+```
+
+Requires Python 3.9+ and [bleak](https://github.com/hbldh/bleak) (installed automatically).
+
+## Quick start (blocking — scripts, Jupyter)
+
+```python
+import sd10
+
+result = sd10.measure_once()            # connect, measure, disconnect
+print(result.lab)                       # Lab(L=..., a=..., b=...)
+
+with sd10.connect_sync() as dev:        # keep the connection open
+    r = dev.measure(illuminant="D65", observer=10, m_factor=0)
+    print(r.lab, r.lch, r.spectrum)
+    print(r.lab_under("A", 2))          # same reading, other illuminant
+
+    for r in dev.button_measurements():  # react to the device's own button
+        print(r.lab)
+```
+
+## Async
+
+```python
+import asyncio, sd10
+
+async def main():
+    async with sd10.connect() as dev:          # strongest SD-10, or connect("40:84:32:52:FD:0F")
+        print(await dev.get_info())
+        r = await dev.measure()
+        print(r.lab)
+        async for r in dev.button_measurements():
+            print(r.lab)
+
+asyncio.run(main())
+```
+
+## API overview
+
+| | |
+|---|---|
+| `scan()` / `scan_sync()` | nearby SD-10s (`address`, `name`, `rssi`) |
+| `connect(address=None)` / `connect_sync(...)` | connect and open a session; on exit the device is handed back to its own UI |
+| `dev.measure(illuminant, observer, m_factor, save)` | one spot measurement → `MeasurementResult` |
+| `dev.button_measurements()` | iterator of results taken with the device button |
+| `dev.get_history(after_id=0, limit=None, progress=None)` | download readings stored on the device (it keeps its last 100), oldest first; pass the last `identifier` you have as `after_id` to fetch only new ones |
+| `dev.history_count(after_id=0)` | how many stored readings are newer than `after_id` |
+| `dev.get_groups()` | colour groups (palettes) stored on the device: 4 slots × up to 80 L\*a\*b\* colours → `[ColorGroup]` |
+| `dev.set_group(ColorGroup(slot, name, colors, illuminant, observer, m_factor, diff_formula, tolerance))` | store/replace a palette in slot 1–4 |
+| `dev.delete_group(slot)` | clear a slot |
+| `dev.calibrate()` | white calibration with the cover **closed** (raises `CoverOpen` otherwise) → `Status` |
+| `dev.scan_row(expected=None, patches=None, tolerance=None, ...)` | scan one row of ≤18 patches by sliding the device; with `expected` + `tolerance` each patch is judged → `RowResult` |
+| `dev.scan_palette_row(slot, row, patches_per_row=10)` | scan one row of a printed chart of a stored palette and compare with it → `RowResult` |
+| `dev.scan_palette(slot, patches_per_row=10)` | whole chart, row by row (async iterator of `RowResult`), then `finish_chart()` |
+| `dev.measure_palette_patch(slot, patch)` | spot-measure one patch against palette colour `patch` → `PatchResult` |
+| `dev.get_info()`, `get_status()`, `get_name()`, `get_serial()`, `get_firmware_version()` | device info |
+| `dev.get_setting(Setting.X)` / `set_setting(...)` | buzzer, panel direction, auto power-off, language |
+| `dev.set_clock()`, `dev.set_name(...)` | |
+| `dev.transact(frame)` | raw command (see `sd10.protocol`) |
+| `MeasurementResult` | `.lab`, `.lch`, `.lab_under(ill, obs)`, `.spectrum`, `.wavelengths`, `.timestamp`, `.to_dict()` |
+| `spectrum_to_lab(spectrum, illuminant, observer)` | offline conversion |
+| `delta_e(ref, sample, "DE2000" / "DE94GA" / "DE94T" / "DE76")`, `delta_e_2000`, `delta_e_94`, `delta_e_76` | colour difference (matches Epson's library) |
+| `median_lab(labs)` | per-component median of several readings (the app's "Median") |
+| `color_scheme(lab, "complementary" / "split_complementary" / "analogous" / "triadic" / "tetradic", illuminant, observer)` | the app's "Color Scheme" |
+| `lab_to_hex(lab, illuminant, observer)`, `lab_to_srgb`, `srgb_to_lab` | sRGB / HEX as the app shows it |
+| `export_aco(path, colors, names)`, `read_aco(path)` | Adobe Color Swatch (.aco) files for Photoshop / Illustrator |
+
+Illuminants: D50, D65, A, F1, F2, F3, F7–F12. Observers: 2, 10.
+
+Errors derive from `sd10.SD10Error` (`DeviceNotFound`, `DeviceRefused`, `SD10Timeout`, `MeasurementFailed`,
+`CoverClosed` — raised instead of measuring when the cover is shut, because the device would just repeat its
+previous reading).
+Enable `logging.getLogger("sd10").setLevel(logging.DEBUG)` to see all traffic.
+
+## Command line
+
+```
+sd10 scan
+sd10 measure --illuminant D65 --observer 10 [--spectrum] [--json]
+sd10 listen          # L*a*b* for every button press
+sd10 history [--after ID] [--last N] [--json | --csv FILE]   # readings stored on the device
+sd10 history --aco FILE                       # stored readings as an Adobe Color Swatch
+sd10 scan-row --patches 6 | --expected row.json [--tolerance 2]
+sd10 chart SLOT [--per-row 10]                # scan a printed chart of a stored palette
+sd10 groups list | delete SLOT | export SLOT FILE(.json|.aco) | import FILE [--slot N]
+sd10 groups from-history SLOT NAME --ids 951,952,953 [--illuminant D65 --tolerance 2]
+sd10 info | calibrate | set-time | set-name NAME | raw ID TYPE [HEX]
+```
+
+(`python -m sd10 ...` works without installing the script; global options such as `-a ADDRESS`
+and `-v` go before the command.)
+
+## Notes
+
+- The SD-10 accepts one host at a time — close the Epson app on your phone first.
+- A random 16-byte host id is kept in `~/.sd10_app_id`, like the app does.
+- L\*a\*b\* reproduces Epson's `librmcc` conversion to ~1e-6 ΔE; bands outside 400–700 nm count as
+  zero, so a perfect white reads L\* ≈ 99.99, same as the app.
+
+## Tests
+
+```
+pip install -e path\to\sd10_client[test]
+pytest path\to\sd10_client\tests
+```

pysd10-0.2.0/README.md

@@ -0,0 +1,114 @@
+# sd10
+
+Python client for the **Epson SD-10** spectrophotometer over Bluetooth LE: take measurements and get
+the 31-band spectrum (400–700 nm) and CIE L\*a\*b\* exactly as the Epson Spectrometer app computes it.
+
+## Install
+
+```
+pip install -e path\to\sd10_client
+```
+
+Requires Python 3.9+ and [bleak](https://github.com/hbldh/bleak) (installed automatically).
+
+## Quick start (blocking — scripts, Jupyter)
+
+```python
+import sd10
+
+result = sd10.measure_once()            # connect, measure, disconnect
+print(result.lab)                       # Lab(L=..., a=..., b=...)
+
+with sd10.connect_sync() as dev:        # keep the connection open
+    r = dev.measure(illuminant="D65", observer=10, m_factor=0)
+    print(r.lab, r.lch, r.spectrum)
+    print(r.lab_under("A", 2))          # same reading, other illuminant
+
+    for r in dev.button_measurements():  # react to the device's own button
+        print(r.lab)
+```
+
+## Async
+
+```python
+import asyncio, sd10
+
+async def main():
+    async with sd10.connect() as dev:          # strongest SD-10, or connect("40:84:32:52:FD:0F")
+        print(await dev.get_info())
+        r = await dev.measure()
+        print(r.lab)
+        async for r in dev.button_measurements():
+            print(r.lab)
+
+asyncio.run(main())
+```
+
+## API overview
+
+| | |
+|---|---|
+| `scan()` / `scan_sync()` | nearby SD-10s (`address`, `name`, `rssi`) |
+| `connect(address=None)` / `connect_sync(...)` | connect and open a session; on exit the device is handed back to its own UI |
+| `dev.measure(illuminant, observer, m_factor, save)` | one spot measurement → `MeasurementResult` |
+| `dev.button_measurements()` | iterator of results taken with the device button |
+| `dev.get_history(after_id=0, limit=None, progress=None)` | download readings stored on the device (it keeps its last 100), oldest first; pass the last `identifier` you have as `after_id` to fetch only new ones |
+| `dev.history_count(after_id=0)` | how many stored readings are newer than `after_id` |
+| `dev.get_groups()` | colour groups (palettes) stored on the device: 4 slots × up to 80 L\*a\*b\* colours → `[ColorGroup]` |
+| `dev.set_group(ColorGroup(slot, name, colors, illuminant, observer, m_factor, diff_formula, tolerance))` | store/replace a palette in slot 1–4 |
+| `dev.delete_group(slot)` | clear a slot |
+| `dev.calibrate()` | white calibration with the cover **closed** (raises `CoverOpen` otherwise) → `Status` |
+| `dev.scan_row(expected=None, patches=None, tolerance=None, ...)` | scan one row of ≤18 patches by sliding the device; with `expected` + `tolerance` each patch is judged → `RowResult` |
+| `dev.scan_palette_row(slot, row, patches_per_row=10)` | scan one row of a printed chart of a stored palette and compare with it → `RowResult` |
+| `dev.scan_palette(slot, patches_per_row=10)` | whole chart, row by row (async iterator of `RowResult`), then `finish_chart()` |
+| `dev.measure_palette_patch(slot, patch)` | spot-measure one patch against palette colour `patch` → `PatchResult` |
+| `dev.get_info()`, `get_status()`, `get_name()`, `get_serial()`, `get_firmware_version()` | device info |
+| `dev.get_setting(Setting.X)` / `set_setting(...)` | buzzer, panel direction, auto power-off, language |
+| `dev.set_clock()`, `dev.set_name(...)` | |
+| `dev.transact(frame)` | raw command (see `sd10.protocol`) |
+| `MeasurementResult` | `.lab`, `.lch`, `.lab_under(ill, obs)`, `.spectrum`, `.wavelengths`, `.timestamp`, `.to_dict()` |
+| `spectrum_to_lab(spectrum, illuminant, observer)` | offline conversion |
+| `delta_e(ref, sample, "DE2000" / "DE94GA" / "DE94T" / "DE76")`, `delta_e_2000`, `delta_e_94`, `delta_e_76` | colour difference (matches Epson's library) |
+| `median_lab(labs)` | per-component median of several readings (the app's "Median") |
+| `color_scheme(lab, "complementary" / "split_complementary" / "analogous" / "triadic" / "tetradic", illuminant, observer)` | the app's "Color Scheme" |
+| `lab_to_hex(lab, illuminant, observer)`, `lab_to_srgb`, `srgb_to_lab` | sRGB / HEX as the app shows it |
+| `export_aco(path, colors, names)`, `read_aco(path)` | Adobe Color Swatch (.aco) files for Photoshop / Illustrator |
+
+Illuminants: D50, D65, A, F1, F2, F3, F7–F12. Observers: 2, 10.
+
+Errors derive from `sd10.SD10Error` (`DeviceNotFound`, `DeviceRefused`, `SD10Timeout`, `MeasurementFailed`,
+`CoverClosed` — raised instead of measuring when the cover is shut, because the device would just repeat its
+previous reading).
+Enable `logging.getLogger("sd10").setLevel(logging.DEBUG)` to see all traffic.
+
+## Command line
+
+```
+sd10 scan
+sd10 measure --illuminant D65 --observer 10 [--spectrum] [--json]
+sd10 listen          # L*a*b* for every button press
+sd10 history [--after ID] [--last N] [--json | --csv FILE]   # readings stored on the device
+sd10 history --aco FILE                       # stored readings as an Adobe Color Swatch
+sd10 scan-row --patches 6 | --expected row.json [--tolerance 2]
+sd10 chart SLOT [--per-row 10]                # scan a printed chart of a stored palette
+sd10 groups list | delete SLOT | export SLOT FILE(.json|.aco) | import FILE [--slot N]
+sd10 groups from-history SLOT NAME --ids 951,952,953 [--illuminant D65 --tolerance 2]
+sd10 info | calibrate | set-time | set-name NAME | raw ID TYPE [HEX]
+```
+
+(`python -m sd10 ...` works without installing the script; global options such as `-a ADDRESS`
+and `-v` go before the command.)
+
+## Notes
+
+- The SD-10 accepts one host at a time — close the Epson app on your phone first.
+- A random 16-byte host id is kept in `~/.sd10_app_id`, like the app does.
+- L\*a\*b\* reproduces Epson's `librmcc` conversion to ~1e-6 ΔE; bands outside 400–700 nm count as
+  zero, so a perfect white reads L\* ≈ 99.99, same as the app.
+
+## Tests
+
+```
+pip install -e path\to\sd10_client[test]
+pytest path\to\sd10_client\tests
+```

pysd10-0.2.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pysd10"
+version = "0.2.0"
+description = "Python client for the Epson SD-10 spectrophotometer over Bluetooth LE (spectrum and L*a*b*)"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = ["bleak>=0.21"]
+
+[project.optional-dependencies]
+test = ["pytest"]
+
+[project.scripts]
+sd10 = "sd10.cli:main"
+
+[tool.setuptools]
+packages = ["sd10"]
+
+[tool.setuptools.package-data]
+sd10 = ["data/*.json", "py.typed"]

pysd10-0.2.0/pysd10.egg-info/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: pysd10
+Version: 0.2.0
+Summary: Python client for the Epson SD-10 spectrophotometer over Bluetooth LE (spectrum and L*a*b*)
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: bleak>=0.21
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+
+# sd10
+
+Python client for the **Epson SD-10** spectrophotometer over Bluetooth LE: take measurements and get
+the 31-band spectrum (400–700 nm) and CIE L\*a\*b\* exactly as the Epson Spectrometer app computes it.
+
+## Install
+
+```
+pip install -e path\to\sd10_client
+```
+
+Requires Python 3.9+ and [bleak](https://github.com/hbldh/bleak) (installed automatically).
+
+## Quick start (blocking — scripts, Jupyter)
+
+```python
+import sd10
+
+result = sd10.measure_once()            # connect, measure, disconnect
+print(result.lab)                       # Lab(L=..., a=..., b=...)
+
+with sd10.connect_sync() as dev:        # keep the connection open
+    r = dev.measure(illuminant="D65", observer=10, m_factor=0)
+    print(r.lab, r.lch, r.spectrum)
+    print(r.lab_under("A", 2))          # same reading, other illuminant
+
+    for r in dev.button_measurements():  # react to the device's own button
+        print(r.lab)
+```
+
+## Async
+
+```python
+import asyncio, sd10
+
+async def main():
+    async with sd10.connect() as dev:          # strongest SD-10, or connect("40:84:32:52:FD:0F")
+        print(await dev.get_info())
+        r = await dev.measure()
+        print(r.lab)
+        async for r in dev.button_measurements():
+            print(r.lab)
+
+asyncio.run(main())
+```
+
+## API overview
+
+| | |
+|---|---|
+| `scan()` / `scan_sync()` | nearby SD-10s (`address`, `name`, `rssi`) |
+| `connect(address=None)` / `connect_sync(...)` | connect and open a session; on exit the device is handed back to its own UI |
+| `dev.measure(illuminant, observer, m_factor, save)` | one spot measurement → `MeasurementResult` |
+| `dev.button_measurements()` | iterator of results taken with the device button |
+| `dev.get_history(after_id=0, limit=None, progress=None)` | download readings stored on the device (it keeps its last 100), oldest first; pass the last `identifier` you have as `after_id` to fetch only new ones |
+| `dev.history_count(after_id=0)` | how many stored readings are newer than `after_id` |
+| `dev.get_groups()` | colour groups (palettes) stored on the device: 4 slots × up to 80 L\*a\*b\* colours → `[ColorGroup]` |
+| `dev.set_group(ColorGroup(slot, name, colors, illuminant, observer, m_factor, diff_formula, tolerance))` | store/replace a palette in slot 1–4 |
+| `dev.delete_group(slot)` | clear a slot |
+| `dev.calibrate()` | white calibration with the cover **closed** (raises `CoverOpen` otherwise) → `Status` |
+| `dev.scan_row(expected=None, patches=None, tolerance=None, ...)` | scan one row of ≤18 patches by sliding the device; with `expected` + `tolerance` each patch is judged → `RowResult` |
+| `dev.scan_palette_row(slot, row, patches_per_row=10)` | scan one row of a printed chart of a stored palette and compare with it → `RowResult` |
+| `dev.scan_palette(slot, patches_per_row=10)` | whole chart, row by row (async iterator of `RowResult`), then `finish_chart()` |
+| `dev.measure_palette_patch(slot, patch)` | spot-measure one patch against palette colour `patch` → `PatchResult` |
+| `dev.get_info()`, `get_status()`, `get_name()`, `get_serial()`, `get_firmware_version()` | device info |
+| `dev.get_setting(Setting.X)` / `set_setting(...)` | buzzer, panel direction, auto power-off, language |
+| `dev.set_clock()`, `dev.set_name(...)` | |
+| `dev.transact(frame)` | raw command (see `sd10.protocol`) |
+| `MeasurementResult` | `.lab`, `.lch`, `.lab_under(ill, obs)`, `.spectrum`, `.wavelengths`, `.timestamp`, `.to_dict()` |
+| `spectrum_to_lab(spectrum, illuminant, observer)` | offline conversion |
+| `delta_e(ref, sample, "DE2000" / "DE94GA" / "DE94T" / "DE76")`, `delta_e_2000`, `delta_e_94`, `delta_e_76` | colour difference (matches Epson's library) |
+| `median_lab(labs)` | per-component median of several readings (the app's "Median") |
+| `color_scheme(lab, "complementary" / "split_complementary" / "analogous" / "triadic" / "tetradic", illuminant, observer)` | the app's "Color Scheme" |
+| `lab_to_hex(lab, illuminant, observer)`, `lab_to_srgb`, `srgb_to_lab` | sRGB / HEX as the app shows it |
+| `export_aco(path, colors, names)`, `read_aco(path)` | Adobe Color Swatch (.aco) files for Photoshop / Illustrator |
+
+Illuminants: D50, D65, A, F1, F2, F3, F7–F12. Observers: 2, 10.
+
+Errors derive from `sd10.SD10Error` (`DeviceNotFound`, `DeviceRefused`, `SD10Timeout`, `MeasurementFailed`,
+`CoverClosed` — raised instead of measuring when the cover is shut, because the device would just repeat its
+previous reading).
+Enable `logging.getLogger("sd10").setLevel(logging.DEBUG)` to see all traffic.
+
+## Command line
+
+```
+sd10 scan
+sd10 measure --illuminant D65 --observer 10 [--spectrum] [--json]
+sd10 listen          # L*a*b* for every button press
+sd10 history [--after ID] [--last N] [--json | --csv FILE]   # readings stored on the device
+sd10 history --aco FILE                       # stored readings as an Adobe Color Swatch
+sd10 scan-row --patches 6 | --expected row.json [--tolerance 2]
+sd10 chart SLOT [--per-row 10]                # scan a printed chart of a stored palette
+sd10 groups list | delete SLOT | export SLOT FILE(.json|.aco) | import FILE [--slot N]
+sd10 groups from-history SLOT NAME --ids 951,952,953 [--illuminant D65 --tolerance 2]
+sd10 info | calibrate | set-time | set-name NAME | raw ID TYPE [HEX]
+```
+
+(`python -m sd10 ...` works without installing the script; global options such as `-a ADDRESS`
+and `-v` go before the command.)
+
+## Notes
+
+- The SD-10 accepts one host at a time — close the Epson app on your phone first.
+- A random 16-byte host id is kept in `~/.sd10_app_id`, like the app does.
+- L\*a\*b\* reproduces Epson's `librmcc` conversion to ~1e-6 ΔE; bands outside 400–700 nm count as
+  zero, so a perfect white reads L\* ≈ 99.99, same as the app.
+
+## Tests
+
+```
+pip install -e path\to\sd10_client[test]
+pytest path\to\sd10_client\tests
+```

pysd10-0.2.0/pysd10.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+pysd10.egg-info/PKG-INFO
+pysd10.egg-info/SOURCES.txt
+pysd10.egg-info/dependency_links.txt
+pysd10.egg-info/entry_points.txt
+pysd10.egg-info/requires.txt
+pysd10.egg-info/top_level.txt
+sd10/__init__.py
+sd10/__main__.py
+sd10/cli.py
+sd10/client.py
+sd10/color.py
+sd10/export.py
+sd10/protocol.py
+sd10/py.typed
+sd10/sync.py
+sd10/data/lab_weights.json
+tests/test_sd10.py

pysd10-0.2.0/pysd10.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pysd10-0.2.0/pysd10.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sd10 = sd10.cli:main

pysd10-0.2.0/pysd10.egg-info/requires.txt

@@ -0,0 +1,4 @@
+bleak>=0.21
+
+[test]
+pytest

pysd10-0.2.0/pysd10.egg-info/top_level.txt

@@ -0,0 +1 @@
+sd10

pysd10-0.2.0/sd10/__init__.py

@@ -0,0 +1,44 @@
+"""Python client for the Epson SD-10 spectrophotometer over Bluetooth LE.
+
+Async::
+
+    import asyncio, sd10
+
+    async def main():
+        async with sd10.connect() as dev:
+            result = await dev.measure(illuminant="D65", observer=10)
+            print(result.lab, result.lch)
+
+    asyncio.run(main())
+
+Blocking::
+
+    import sd10
+    print(sd10.measure_once().lab)
+
+    with sd10.connect_sync() as dev:
+        for result in dev.button_measurements():
+            print(result.lab)
+"""
+from .client import (SD10, CalibrationNeeded, CoverClosed, CoverOpen, DeviceInfo, DeviceNotFound, DeviceRefused,
+                     FoundDevice, MeasurementFailed, PatchResult, RowResult, SD10Error, SD10Timeout, connect,
+                     find_device, load_app_id, scan)
+from .color import (COLOR_SCHEMES, DELTA_E_FORMULAS, ILLUMINANTS, OBSERVERS, WAVELENGTHS, Lab, LCh, color_scheme,
+                    delta_e, delta_e_76, delta_e_94, delta_e_2000, lab_to_hex, lab_to_srgb, median_lab,
+                    spectrum_to_lab, srgb_to_lab)
+from .export import aco_bytes, export_aco, read_aco
+from .protocol import ColorGroup, Event, MeasurementResult, Method, Setting, Status
+from .sync import SyncSD10, connect_sync, measure_once, scan_sync
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "SD10", "connect", "scan", "find_device", "load_app_id", "DeviceInfo", "FoundDevice",
+    "SyncSD10", "connect_sync", "scan_sync", "measure_once",
+    "MeasurementResult", "Status", "Setting", "Event", "Method", "ColorGroup", "PatchResult", "RowResult",
+    "Lab", "LCh", "spectrum_to_lab", "delta_e", "delta_e_76", "delta_e_94", "delta_e_2000", "median_lab",
+    "color_scheme", "lab_to_srgb", "srgb_to_lab", "lab_to_hex", "COLOR_SCHEMES", "DELTA_E_FORMULAS",
+    "ILLUMINANTS", "OBSERVERS", "WAVELENGTHS", "export_aco", "aco_bytes", "read_aco",
+    "SD10Error", "SD10Timeout", "DeviceNotFound", "DeviceRefused", "MeasurementFailed", "CoverClosed",
+    "CalibrationNeeded", "CoverOpen",
+]

pysd10-0.2.0/sd10/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()