sbts-py 1.0.0__tar.gz

sbts_py-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 123VincentB
+
+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.

sbts_py-1.0.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: sbts-py
+Version: 1.0.0
+Summary: Parser for Gigahertz-Optik S-BTS2048 and S-BTS256 spectral data files
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: xlrd>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file

sbts_py-1.0.0/README.md

@@ -0,0 +1,62 @@
+# sbts-py
+
+[![PyPI version](https://img.shields.io/pypi/v/sbts-py)](https://pypi.org/project/sbts-py/)
+[![License](https://img.shields.io/pypi/l/sbts-py)](LICENSE)
+[![Python](https://img.shields.io/pypi/pyversions/sbts-py)](https://pypi.org/project/sbts-py/)
+
+Parser for spectral data files exported by **Gigahertz-Optik S-BTS2048** and **S-BTS256** spectroradiometers (`.xls` BIFF8 format).
+
+## Installation
+
+```bash
+pip install sbts-py
+```
+
+## Usage
+
+```python
+from sbts import read
+
+# Single measurement
+measurements = read('measurement.xls')
+s = measurements[0]
+
+print(s.instrument)               # 'S-BTS2048' or 'S-BTS256'
+print(s.wavelengths[0])           # 350.0  (nm)
+print(len(s.spd))                 # 701 (S-BTS2048) or 371 (S-BTS256)
+
+print(s.data.get('CCT'))          # 4043.16
+print(s.data.get('CRI: Ra'))      # 82.45
+print(s.data.get('date'))         # '23.06.2025'
+
+# Multi-measurement file
+measurements = read('multi.xls')
+for m in measurements:
+    print(m.data.get('CCT'), m.data.get('samplenumber'))
+
+# S-BTS256 — diode progression
+s = read('S-BTS256.xls')[0]
+print(s.diode_time_ms)            # [0.0, 0.02, ...] or None
+print(s.data.get('Pst'))          # flicker Pst
+```
+
+## Returned object
+
+`read()` always returns `list[Sbts]` — a list of one element for a single-measurement file, N elements for a multi-measurement file.
+
+```python
+@dataclass
+class Sbts:
+    wavelengths: list[float]        # wavelengths in nm
+    spd: list[float]                # spectral irradiance (W/m²)/nm
+    data: dict[str, Any]            # all scalar key/value pairs from the file
+    diode_time_ms: list[float] | None
+    diode_values: list[float] | None
+    instrument: str | None          # 'S-BTS2048' | 'S-BTS256' | None
+```
+
+All missing or unavailable values (`-9999.0` convention) are normalized to `None`.
+
+## License
+
+MIT

sbts_py-1.0.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sbts-py"
+version = "1.0.0"
+description = "Parser for Gigahertz-Optik S-BTS2048 and S-BTS256 spectral data files"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = ["xlrd>=2.0"]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

sbts_py-1.0.0/setup.cfg

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

sbts_py-1.0.0/src/sbts/__init__.py

@@ -0,0 +1,4 @@
+from .sbts import Sbts, read
+
+__version__ = "1.0.0"
+__all__ = ["Sbts", "read"]

sbts_py-1.0.0/src/sbts/sbts.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import xlrd
+from xlrd import XL_CELL_EMPTY, XL_CELL_NUMBER, XL_CELL_TEXT
+
+_NULL_NUMERIC = {-9999.0}
+_SVM_NULL = {-1.0}
+
+
+@dataclass
+class Sbts:
+    wavelengths: list[float]
+    spd: list[float]
+    data: dict[str, Any]
+    diode_time_ms: list[float] | None = None
+    diode_values: list[float] | None = None
+    instrument: str | None = None
+
+
+def _is_separator_row(ws, row_idx: int) -> bool:
+    if all(t == XL_CELL_EMPTY for t in ws.row_types(row_idx)):
+        return True
+    return ws.cell_type(row_idx, 0) == XL_CELL_TEXT and ws.cell_value(row_idx, 0).strip() == ''
+
+
+def _normalize_value(key: str, v: Any) -> Any:
+    if isinstance(v, str) and v.strip() == '':
+        return None
+    if isinstance(v, float):
+        if v in _NULL_NUMERIC:
+            return None
+        if key == 'SVM' and v in _SVM_NULL:
+            return None
+    return v
+
+
+def _detect_instrument(data: dict, n_spd_points: int) -> str | None:
+    if 'device type' in data:
+        return 'S-BTS2048'
+    if n_spd_points == 701:
+        return 'S-BTS2048'
+    if n_spd_points == 371:
+        return 'S-BTS256'
+    return None
+
+
+def _parse_sheet(ws, col_idx: int) -> Sbts:
+    data: dict[str, Any] = {}
+    wavelengths: list[float] = []
+    spd: list[float] = []
+    diode_time_ms_list: list[float] = []
+    diode_values_list: list[float] = []
+
+    mode: str | None = None  # None | 'spd' | 'diode'
+
+    for row_idx in range(ws.nrows):
+        if _is_separator_row(ws, row_idx):
+            mode = None
+            continue
+
+        cell_type_0 = ws.cell_type(row_idx, 0)
+        col0_val = ws.cell_value(row_idx, 0)
+
+        if cell_type_0 == XL_CELL_NUMBER:
+            if mode == 'spd':
+                wavelengths.append(float(col0_val))
+                spd.append(float(ws.cell_value(row_idx, col_idx)))
+            elif mode == 'diode':
+                diode_time_ms_list.append(float(col0_val))
+                diode_values_list.append(float(ws.cell_value(row_idx, col_idx)))
+            continue
+
+        if cell_type_0 != XL_CELL_TEXT:
+            continue
+
+        key = col0_val.strip()
+        if not key:
+            mode = None
+            continue
+
+        if key == 'wavelength /nm':
+            mode = 'spd'
+            continue
+
+        if key == 'time / ms':
+            mode = 'diode'
+            continue
+
+        val = ws.cell_value(row_idx, col_idx)
+        data[key] = _normalize_value(key, val)
+
+    instrument = _detect_instrument(data, len(wavelengths))
+
+    return Sbts(
+        wavelengths=wavelengths,
+        spd=spd,
+        data=data,
+        diode_time_ms=diode_time_ms_list or None,
+        diode_values=diode_values_list or None,
+        instrument=instrument,
+    )
+
+
+def read(path: str | Path) -> list[Sbts]:
+    """
+    Parse un fichier .xls Gigahertz-Optik S-BTS2048 ou S-BTS256.
+
+    Retourne toujours une list[Sbts] :
+    - liste de 1 élément pour un fichier single-mesure
+    - liste de N éléments pour un fichier multi-mesures (N colonnes de valeurs)
+
+    Raises:
+        FileNotFoundError: fichier introuvable
+        ValueError: feuille 'Sheet3' absente ou fichier non parseable
+    """
+    wb = xlrd.open_workbook(str(path))
+
+    if 'Sheet3' not in wb.sheet_names():
+        raise ValueError(f"Feuille 'Sheet3' absente dans {path}")
+
+    ws = wb.sheet_by_name('Sheet3')
+    n_measures = ws.ncols - 1
+
+    return [_parse_sheet(ws, col_idx) for col_idx in range(1, n_measures + 1)]

sbts_py-1.0.0/src/sbts_py.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: sbts-py
+Version: 1.0.0
+Summary: Parser for Gigahertz-Optik S-BTS2048 and S-BTS256 spectral data files
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: xlrd>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file

sbts_py-1.0.0/src/sbts_py.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/sbts/__init__.py
+src/sbts/sbts.py
+src/sbts_py.egg-info/PKG-INFO
+src/sbts_py.egg-info/SOURCES.txt
+src/sbts_py.egg-info/dependency_links.txt
+src/sbts_py.egg-info/requires.txt
+src/sbts_py.egg-info/top_level.txt
+tests/test_sbts.py

sbts_py-1.0.0/src/sbts_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sbts_py-1.0.0/src/sbts_py.egg-info/requires.txt

@@ -0,0 +1,4 @@
+xlrd>=2.0
+
+[dev]
+pytest>=7.0

sbts_py-1.0.0/src/sbts_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+sbts

sbts_py-1.0.0/tests/test_sbts.py

@@ -0,0 +1,95 @@
+import pytest
+from sbts import read
+
+FIXTURE_2048 = 'tests/fixtures/S_BTS2048_single.xls'
+FIXTURE_2048_MULTI = 'tests/fixtures/S_BTS2048_multi.xls'
+FIXTURE_256 = 'tests/fixtures/S_BTS256_single.xls'
+
+
+def test_read_returns_list():
+    result = read(FIXTURE_2048)
+    assert isinstance(result, list)
+    assert len(result) == 1
+
+
+def test_multi_returns_multiple():
+    result = read(FIXTURE_2048_MULTI)
+    assert isinstance(result, list)
+    assert len(result) == 3
+
+
+def test_instrument_detection_2048():
+    s = read(FIXTURE_2048)[0]
+    assert s.instrument == 'S-BTS2048'
+
+
+def test_instrument_detection_256():
+    s = read(FIXTURE_256)[0]
+    assert s.instrument == 'S-BTS256'
+
+
+def test_spd_2048():
+    s = read(FIXTURE_2048)[0]
+    assert len(s.wavelengths) == 701
+    assert len(s.spd) == len(s.wavelengths)
+    assert s.wavelengths[0] == 350.0
+    assert s.wavelengths[-1] == 1050.0
+
+
+def test_spd_256():
+    s = read(FIXTURE_256)[0]
+    assert len(s.wavelengths) == 371
+    assert len(s.spd) == len(s.wavelengths)
+    assert s.wavelengths[0] == 380.0
+    assert s.wavelengths[-1] == 750.0
+
+
+def test_data_contains_scalar_keys():
+    s = read(FIXTURE_2048)[0]
+    assert 'CCT' in s.data
+    assert 'CRI: Ra' in s.data
+    assert 'date' in s.data
+    assert 'serial number' in s.data
+
+
+def test_minus9999_becomes_none():
+    s = read(FIXTURE_256)[0]
+    assert s.data.get('saturation') is None
+    assert s.data.get('temperature') is None
+
+
+def test_svm_minus1_becomes_none():
+    s = read(FIXTURE_256)[0]
+    assert s.data.get('SVM') is None
+
+
+def test_photometric_values_present():
+    s = read(FIXTURE_2048)[0]
+    assert s.data.get('photopic') is not None
+    assert s.data.get('photometric unit') == 'lx'
+
+
+def test_diode_progression_256():
+    s = read(FIXTURE_256)[0]
+    assert s.diode_time_ms is not None
+    assert s.diode_values is not None
+    assert len(s.diode_time_ms) == len(s.diode_values)
+    assert s.diode_time_ms[0] == 0.0
+
+
+def test_diode_progression_2048_absent():
+    s = read(FIXTURE_2048)[0]
+    assert s.diode_time_ms is None
+    assert s.diode_values is None
+
+
+def test_key_stripping():
+    s = read(FIXTURE_2048)[0]
+    assert 'Blue Light Hazard [350 nm - 700 nm]' in s.data
+    assert 'ACGIH(skin & eye) [350 nm - 400 nm]' in s.data
+
+
+def test_multi_independent_measurements():
+    measurements = read(FIXTURE_2048_MULTI)
+    ccts = [m.data.get('CCT') for m in measurements]
+    assert len(set(ccts)) > 1