scrylab 0.1.0__tar.gz

scrylab-0.1.0/.gitignore

@@ -0,0 +1,3 @@
+__pycache__/
+.pytest_cache/
+dist/

scrylab-0.1.0/LICENSE

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

scrylab-0.1.0/PKG-INFO

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: scrylab
+Version: 0.1.0
+Summary: Python client for the ScryLab GUI – send signals into a live ScryLab session from scripts, notebooks or simulation pipelines
+Project-URL: Repository, https://github.com/scrylab/scrylab-python
+Project-URL: Issues, https://github.com/scrylab/scrylab-python/issues
+Author-email: ScryLab <support@scrylab.de>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: measurement,plot,scrylab,signal,time-series,visualization
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24
+Requires-Dist: requests>=2.28
+Provides-Extra: dev
+Requires-Dist: pandas>=1.5; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Provides-Extra: pandas
+Requires-Dist: pandas>=1.5; extra == 'pandas'
+Description-Content-Type: text/markdown
+
+# scrylab-python
+
+Python wrapper for the [ScryLab](https://scrylab.de) REST API. Lets you send signals directly into a running ScryLab GUI from any Python environment – scripts, Jupyter notebooks or simulation pipelines – as a faster, more interactive alternative to matplotlib or plotly for exploratory signal analysis.
+
+## What you can do
+
+- Send 1D signals (time series, measurement channels, …) into ScryLab's data browser
+- Send ~~colored lines (signal + scalar color axis)~~ (coming soon) or spectrograms (2D matrix)
+- Convenience function: open signals directly in a plot from code
+
+## Installation
+
+1. Prerequisite: the ScryLab GUI (desktop app) needs to be running on the same machine. [Installation Guide](https://docs.scrylab.de/docs/getting-started/installation/) 
+2. Install the wrapper: `pip install scrylab`
+
+## Quick start
+
+```python
+import scrylab as scry
+import numpy as np
+
+t = np.linspace(0, 10, 1_000)
+y = np.sin(2 * np.pi * 5 * t)
+
+scry.plot(y, name="Example Signal", x=t, y_unit="V", x_unit="s") # Convenience function: send + plot in one step
+
+# Or send without plotting – then you can drag the signal into plots manually from the data browser
+scry.send(y, name="Example Signal via send", x=t, y_unit="V", x_unit="s")
+
+# Update the "Example Signal"
+y2 = np.sin(2 * np.pi * 10 * t)
+scry.send(y2, name="Example Signal", x=t, y_unit="V", x_unit="s", overwrite=True) # overwrite=True replaces the existing signal with the same name
+```
+
+## Usage
+
+### `scry.send(y, …)`
+
+Sends a signal into a data source without automatic plotting.
+
+```python
+scry.send(y, name="Speed", source="Testrun 01", x=t, y_unit="km/h", x_unit="s")
+```
+
+| Parameter | Description |
+|-----------|-------------|
+| `y` | numpy array, list, or `pandas.Series`; for a Series, `name` and `x` default to the series' name and index |
+| `name` | signal name (auto-generated if omitted) |
+| `source` | [data source](https://docs.scrylab.de/docs/concepts/data-sources/) to send into, default `"Sent from API"`; created automatically if it doesn't exist yet |
+| `x` | numpy array, list, or `pandas.Series`/`Index`; auto-generated if omitted |
+| `z` | optional color axis – 1D array/list/`pandas.Series` (one value per sample, colors the trace) or 2D array/`pandas.DataFrame` (matrix → spectrogram; columns map to x-axis, index to y-axis) |
+| `y_unit`, `x_unit`, `z_unit` | axis units, e.g. `"V"`, `"s"`, `"Hz"` |
+| `overwrite` | replace an existing signal with the same name; raises `ScryLabError` if `False` (default) and a signal with that name already exists |
+
+### `scry.send_many(y, …)`
+
+Sends multiple signals at once. `y` can be a list of arrays or a `pandas.DataFrame` (each column becomes a signal).
+
+```python
+scry.send_many(
+    y=[channel_1, channel_2, channel_3],
+    names=["Speed", "RPM", "Torque"],
+    y_unit=["km/h", "1/min", "Nm"],
+    source="Testrun 02",
+)
+```
+
+| Parameter | Description |
+|-----------|-------------|
+| `y` | list of numpy arrays/lists/`pandas.Series`, or `pandas.DataFrame` (each column becomes one signal); Series names and indices are used automatically |
+| `names` | list of signal names; auto-generated if omitted |
+| `source` | [data source](https://docs.scrylab.de/docs/concepts/data-sources/) to send into, default `"Sent from API"`; created automatically if it doesn't exist yet |
+| `x` | a single numpy array/list broadcast to all signals, or a list of numpy arrays/lists (one per signal) |
+| `z` | ~~1D array (colored trace)~~ (coming soon) or 2D array/`pandas.DataFrame` (spectrogram) – broadcast a single value to all signals, or pass a list (one per signal) |
+| `y_unit`, `x_unit`, `z_unit` | a single string applied to all signals, or a list of strings (one per signal) |
+| `overwrite` | replace existing signals with the same name; raises `ScryLabError` if `False` (default) and a signal with that name already exists |
+
+### `scry.plot(y, …)`
+
+Same as `send()` but also opens the signal in a plot. Always uses `"Sent from API"` as the data source – use `send()` if you need a specific source. A new plot is created if none exists yet.
+
+```python
+scry.plot(y, name="Accelerometer", y_unit="m/s²", x_unit="s")
+```
+
+## pandas integration
+
+Pass a `pandas.Series` as `y` and `name` and `x` are derived automatically from the series:
+
+```python
+import pandas as pd
+import scrylab as scry
+
+voltage = pd.Series(
+    data=[0.1, 0.4, 0.9, 0.7],
+    index=[0.0, 0.1, 0.2, 0.3],
+    name="Voltage",
+)
+
+scry.send(voltage, y_unit="V", x_unit="s")
+# equivalent to: scry.send(voltage.to_numpy(), name="Voltage", x=voltage.index, y_unit="V", x_unit="s")
+```
+
+You can still override `name` or `x` explicitly – they take precedence over the series metadata.
+
+`send_many()` works the same way for a list of Series. Pass a `pandas.DataFrame` and every column becomes a signal, with the index shared as x-axis:
+
+```python
+df = pd.DataFrame({"Speed": [...], "RPM": [...]}, index=t)
+scry.send_many(df, source="Testrun 03", y_unit=["km/h", "1/min"], x_unit="s")
+```
+
+## Spectrograms
+
+Pass a `pandas.DataFrame` as `z` to send a spectrogram – columns map to the x-axis (e.g. time), the index to the y-axis (e.g. frequency):
+
+```python
+import numpy as np
+import pandas as pd
+from scipy.signal import spectrogram
+
+fs = 1000  # Hz
+t = np.linspace(0, 4, fs * 4, endpoint=False)
+
+# 20 Hz for the first 2 s, then 80 Hz
+y = np.where(t < 2, np.sin(2 * np.pi * 20 * t), np.sin(2 * np.pi * 80 * t))
+
+f, t_bins, Sxx = spectrogram(y, fs=fs, nperseg=256)
+Sxx_db = 10 * np.log10(Sxx + 1e-12)
+
+spec = pd.DataFrame(Sxx_db, index=f, columns=t_bins)
+scry.send(y=f, z=spec, name="Spectrogram", y_unit="Hz", x_unit="s", z_unit="dB")
+```

scrylab-0.1.0/README.md

@@ -0,0 +1,133 @@
+# scrylab-python
+
+Python wrapper for the [ScryLab](https://scrylab.de) REST API. Lets you send signals directly into a running ScryLab GUI from any Python environment – scripts, Jupyter notebooks or simulation pipelines – as a faster, more interactive alternative to matplotlib or plotly for exploratory signal analysis.
+
+## What you can do
+
+- Send 1D signals (time series, measurement channels, …) into ScryLab's data browser
+- Send ~~colored lines (signal + scalar color axis)~~ (coming soon) or spectrograms (2D matrix)
+- Convenience function: open signals directly in a plot from code
+
+## Installation
+
+1. Prerequisite: the ScryLab GUI (desktop app) needs to be running on the same machine. [Installation Guide](https://docs.scrylab.de/docs/getting-started/installation/) 
+2. Install the wrapper: `pip install scrylab`
+
+## Quick start
+
+```python
+import scrylab as scry
+import numpy as np
+
+t = np.linspace(0, 10, 1_000)
+y = np.sin(2 * np.pi * 5 * t)
+
+scry.plot(y, name="Example Signal", x=t, y_unit="V", x_unit="s") # Convenience function: send + plot in one step
+
+# Or send without plotting – then you can drag the signal into plots manually from the data browser
+scry.send(y, name="Example Signal via send", x=t, y_unit="V", x_unit="s")
+
+# Update the "Example Signal"
+y2 = np.sin(2 * np.pi * 10 * t)
+scry.send(y2, name="Example Signal", x=t, y_unit="V", x_unit="s", overwrite=True) # overwrite=True replaces the existing signal with the same name
+```
+
+## Usage
+
+### `scry.send(y, …)`
+
+Sends a signal into a data source without automatic plotting.
+
+```python
+scry.send(y, name="Speed", source="Testrun 01", x=t, y_unit="km/h", x_unit="s")
+```
+
+| Parameter | Description |
+|-----------|-------------|
+| `y` | numpy array, list, or `pandas.Series`; for a Series, `name` and `x` default to the series' name and index |
+| `name` | signal name (auto-generated if omitted) |
+| `source` | [data source](https://docs.scrylab.de/docs/concepts/data-sources/) to send into, default `"Sent from API"`; created automatically if it doesn't exist yet |
+| `x` | numpy array, list, or `pandas.Series`/`Index`; auto-generated if omitted |
+| `z` | optional color axis – 1D array/list/`pandas.Series` (one value per sample, colors the trace) or 2D array/`pandas.DataFrame` (matrix → spectrogram; columns map to x-axis, index to y-axis) |
+| `y_unit`, `x_unit`, `z_unit` | axis units, e.g. `"V"`, `"s"`, `"Hz"` |
+| `overwrite` | replace an existing signal with the same name; raises `ScryLabError` if `False` (default) and a signal with that name already exists |
+
+### `scry.send_many(y, …)`
+
+Sends multiple signals at once. `y` can be a list of arrays or a `pandas.DataFrame` (each column becomes a signal).
+
+```python
+scry.send_many(
+    y=[channel_1, channel_2, channel_3],
+    names=["Speed", "RPM", "Torque"],
+    y_unit=["km/h", "1/min", "Nm"],
+    source="Testrun 02",
+)
+```
+
+| Parameter | Description |
+|-----------|-------------|
+| `y` | list of numpy arrays/lists/`pandas.Series`, or `pandas.DataFrame` (each column becomes one signal); Series names and indices are used automatically |
+| `names` | list of signal names; auto-generated if omitted |
+| `source` | [data source](https://docs.scrylab.de/docs/concepts/data-sources/) to send into, default `"Sent from API"`; created automatically if it doesn't exist yet |
+| `x` | a single numpy array/list broadcast to all signals, or a list of numpy arrays/lists (one per signal) |
+| `z` | ~~1D array (colored trace)~~ (coming soon) or 2D array/`pandas.DataFrame` (spectrogram) – broadcast a single value to all signals, or pass a list (one per signal) |
+| `y_unit`, `x_unit`, `z_unit` | a single string applied to all signals, or a list of strings (one per signal) |
+| `overwrite` | replace existing signals with the same name; raises `ScryLabError` if `False` (default) and a signal with that name already exists |
+
+### `scry.plot(y, …)`
+
+Same as `send()` but also opens the signal in a plot. Always uses `"Sent from API"` as the data source – use `send()` if you need a specific source. A new plot is created if none exists yet.
+
+```python
+scry.plot(y, name="Accelerometer", y_unit="m/s²", x_unit="s")
+```
+
+## pandas integration
+
+Pass a `pandas.Series` as `y` and `name` and `x` are derived automatically from the series:
+
+```python
+import pandas as pd
+import scrylab as scry
+
+voltage = pd.Series(
+    data=[0.1, 0.4, 0.9, 0.7],
+    index=[0.0, 0.1, 0.2, 0.3],
+    name="Voltage",
+)
+
+scry.send(voltage, y_unit="V", x_unit="s")
+# equivalent to: scry.send(voltage.to_numpy(), name="Voltage", x=voltage.index, y_unit="V", x_unit="s")
+```
+
+You can still override `name` or `x` explicitly – they take precedence over the series metadata.
+
+`send_many()` works the same way for a list of Series. Pass a `pandas.DataFrame` and every column becomes a signal, with the index shared as x-axis:
+
+```python
+df = pd.DataFrame({"Speed": [...], "RPM": [...]}, index=t)
+scry.send_many(df, source="Testrun 03", y_unit=["km/h", "1/min"], x_unit="s")
+```
+
+## Spectrograms
+
+Pass a `pandas.DataFrame` as `z` to send a spectrogram – columns map to the x-axis (e.g. time), the index to the y-axis (e.g. frequency):
+
+```python
+import numpy as np
+import pandas as pd
+from scipy.signal import spectrogram
+
+fs = 1000  # Hz
+t = np.linspace(0, 4, fs * 4, endpoint=False)
+
+# 20 Hz for the first 2 s, then 80 Hz
+y = np.where(t < 2, np.sin(2 * np.pi * 20 * t), np.sin(2 * np.pi * 80 * t))
+
+f, t_bins, Sxx = spectrogram(y, fs=fs, nperseg=256)
+Sxx_db = 10 * np.log10(Sxx + 1e-12)
+
+spec = pd.DataFrame(Sxx_db, index=f, columns=t_bins)
+scry.send(y=f, z=spec, name="Spectrogram", y_unit="Hz", x_unit="s", z_unit="dB")
+```

scrylab-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["hatchling>=1.26"]
+build-backend = "hatchling.build"
+
+[project]
+name = "scrylab"
+version = "0.1.0"
+description = "Python client for the ScryLab GUI – send signals into a live ScryLab session from scripts, notebooks or simulation pipelines"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+authors = [
+    { name = "ScryLab", email = "support@scrylab.de" },
+]
+keywords = ["scrylab", "signal", "measurement", "visualization", "time-series", "plot"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering",
+]
+dependencies = [
+    "requests>=2.28",
+    "numpy>=1.24",
+]
+
+[project.urls]
+Repository = "https://github.com/scrylab/scrylab-python"
+Issues = "https://github.com/scrylab/scrylab-python/issues"
+
+[project.optional-dependencies]
+pandas = ["pandas>=1.5"]
+dev = ["pytest>=7", "pandas>=1.5"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/scrylab"]

scrylab-0.1.0/src/scrylab/__init__.py

@@ -0,0 +1,105 @@
+"""
+scrylab – Python client for ScryLab.
+"""
+
+from ._client import ScryLabError, _default_client
+from ._utils import normalize_one, normalize_many
+from typing import Optional, Union
+
+ScryLabError.__module__ = "scrylab"
+
+__all__ = ["send", "send_many", "plot", "ScryLabError"]
+__version__ = "0.1.0"
+
+
+def send(
+    y,
+    name: Optional[str] = None,
+    source: str = "Sent from API",
+    x=None,
+    z=None,
+    y_unit: Optional[str] = None,
+    x_unit: Optional[str] = None,
+    z_unit: Optional[str] = None,
+    overwrite: bool = False,
+) -> None:
+    """Send a single signal to ScryLab without plotting.
+
+    y accepts a numpy array, a plain list, or a pandas Series.
+    For a Series, x defaults to the index and name to the series name.
+    x accepts a numpy array, list, or pandas Series/Index.
+    z is optional – pass a 1D array/list/Series for a color axis or a 2D array/DataFrame for a spectrogram.
+    source is created automatically if it doesn't exist yet.
+    Raises ScryLabError on failure or if the name already exists (overwrite=False).
+    """
+    try:
+        yi, ni, xi, zi = normalize_one(y, name, x, z)
+        client    = _default_client
+        source_id = client._resolve_source(source)
+        client.send_one(yi, ni, source_id, xi, zi, y_unit, x_unit, z_unit, overwrite=overwrite)
+    except ScryLabError as e:
+        raise ScryLabError(str(e)) from None
+    except Exception as e:
+        raise ScryLabError(str(e)) from None
+
+
+def send_many(
+    y,
+    names=None,
+    source: str = "Sent from API",
+    x=None,
+    z=None,
+    y_unit: Union[str, list, None] = None,
+    x_unit: Union[str, list, None] = None,
+    z_unit: Union[str, list, None] = None,
+    overwrite: bool = False,
+) -> None:
+    """Send multiple signals to ScryLab without plotting.
+
+    y accepts:
+      - a list of arrays, lists, or pandas Series: each element is one signal
+      - a pandas DataFrame: each column is one signal, index as x
+
+    x and z can each be a list (one entry per signal) or a single value broadcast to all.
+    z accepts a 1D array (color axis) or 2D matrix (spectrogram) per signal.
+    y_unit, x_unit, z_unit each accept a single string (applied to all signals) or a list
+    (one unit per signal).
+    Raises ScryLabError on failure.
+    """
+    try:
+        ys, ns, xs, zs = normalize_many(y, names, x, z)
+        client    = _default_client
+        source_id = client._resolve_source(source)
+        client.send(ys, ns, source_id, xs, zs, y_unit, x_unit, z_unit, overwrite=overwrite)
+    except ScryLabError as e:
+        raise ScryLabError(str(e)) from None
+    except Exception as e:
+        raise ScryLabError(str(e)) from None
+
+
+def plot(
+    y,
+    name: Optional[str] = None,
+    x=None,
+    z=None,
+    y_unit: Optional[str] = None,
+    x_unit: Optional[str] = None,
+    z_unit: Optional[str] = None,
+    overwrite: bool = False,
+) -> None:
+    """Send a single signal to ScryLab and plot a signal-instance.
+
+    Accepts the same y, x, z types as send(). Always lands in data source "Sent from API".
+    A new plot is created if none exists.
+    """
+    try:
+        yi, ni, xi, zi = normalize_one(y, name, x, z)
+        client    = _default_client
+        source_id = client._resolve_source("Sent from API")
+        results   = client.send_one(yi, ni, source_id, xi, zi, y_unit, x_unit, z_unit, overwrite=overwrite)
+        for r in results:
+            client.plot(r["signal_id"])
+    except ScryLabError as e:
+        raise ScryLabError(str(e)) from None
+    except Exception as e:
+        raise ScryLabError(str(e)) from None

scrylab-0.1.0/src/scrylab/_client.py

@@ -0,0 +1,127 @@
+import io
+import json
+from typing import Optional
+
+import requests
+
+
+_MIN_APP_VERSION = "0.1.10"
+
+
+def _parse_version(v: str) -> tuple:
+    try:
+        return tuple(int(x) for x in v.split("."))
+    except (ValueError, AttributeError):
+        return (0,)
+
+
+class ScryLabError(Exception):
+    pass
+
+
+class _Client:
+    def __init__(self, host: str = "127.0.0.1", port: int = 5678, timeout: float = 30):
+        self._base = f"http://{host}:{port}"
+        self._timeout = timeout
+        self._session = requests.Session()
+        self._version_checked = False
+
+    def _url(self, path):
+        return f"{self._base}{path}"
+
+    def _request(self, method, path, **kwargs):
+        try:
+            return self._check(self._session.request(method, self._url(path), timeout=self._timeout, **kwargs))
+        except ScryLabError:
+            raise
+        except Exception:
+            raise ScryLabError("ScryLab desktop app is not running or unreachable – download it at https://scrylab.de/download.") from None
+
+    def _get(self, path):
+        return self._request("GET", path)
+
+    def _post(self, path, body=None, *, files=None, data=None):
+        return self._request("POST", path, json=body, files=files, data=data)
+
+    @staticmethod
+    def _check(resp):
+        try:
+            data = resp.json()
+        except ValueError:
+            resp.raise_for_status()
+            return {}
+        if resp.status_code == 404:
+            raise ScryLabError(f"Feature not available – please update ScryLab to v{_MIN_APP_VERSION} or later")
+        if resp.status_code >= 400:
+            raise ScryLabError(f"ScryLab error ({resp.status_code}): {data.get('error', resp.text)}")
+        if data.get("status") == "error":
+            raise ScryLabError(data.get("error", "Unknown error"))
+        return data
+
+    def _ensure_version(self):
+        if self._version_checked:
+            return
+        data = self._get("/api/status")
+        app_ver = data.get("version", "")
+        if _parse_version(app_ver) < _parse_version(_MIN_APP_VERSION):
+            raise ScryLabError(
+                f"ScryLab v{app_ver} is too old – please update to v{_MIN_APP_VERSION} or later"
+            )
+        self._version_checked = True
+
+    def _resolve_source(self, name: str) -> str:
+        self._ensure_version()
+        data = self._get("/api/sources")
+        for s in (data.get("result") or []):
+            if s.get("name") == name:
+                return s["source_id"]
+        created = self._post("/api/sources", {"name": name})
+        return (created.get("result") or {})["source_id"]
+
+    def send(self, ys: list, names: list, source_id: str, xs: list, zs: list,
+             y_units, x_units, z_units,
+             overwrite: bool = False) -> list[dict]:
+        import numpy as np
+
+        n = len(ys)
+        def _norm(u):
+            if u is None or isinstance(u, str):
+                return [u] * n
+            lst = list(u)
+            return lst * n if len(lst) == 1 else lst
+
+        y_units, x_units, z_units = _norm(y_units), _norm(x_units), _norm(z_units)
+        files, metas = [], []
+        for yi, ni, xi, zi, yu, xu, zu in zip(ys, names, xs, zs, y_units, x_units, z_units):
+            buf = io.BytesIO()
+            arrays = {"y": np.asarray(yi)}
+            if xi is not None: arrays["x"] = np.asarray(xi)
+            if zi is not None: arrays["z"] = np.asarray(zi)
+            np.savez(buf, **arrays)
+            buf.seek(0)
+            files.append(("file", (f"{ni}.npz", buf.read(), "application/octet-stream")))
+            m = {"name": ni, "target_source_id": source_id}
+            if yu is not None: m["y_unit"] = yu
+            if xu is not None: m["x_unit"] = xu
+            if zu is not None: m["z_unit"] = zu
+            if overwrite: m["overwrite"] = True
+            metas.append(m)
+
+        data   = self._post("/api/signals/upload_batch", files=files, data={"meta": json.dumps(metas)})
+        result = data.get("result") or {}
+        errors = result.get("errors", [])
+        if errors:
+            details = "; ".join(f"#{e['index']}: {e['error']}" for e in errors)
+            raise ScryLabError(f"{len(errors)} signal(s) failed: {details}")
+        return result.get("signals", [])
+
+    def send_one(self, y, name: str, source_id: str, x, z,
+                 y_unit, x_unit, z_unit, overwrite: bool = False) -> list[dict]:
+        return self.send([y], [name], source_id, [x], [z],
+                         y_unit, x_unit, z_unit, overwrite=overwrite)
+
+    def plot(self, signal_id: str):
+        self._post("/api/plot", {"signal_id": signal_id})
+
+
+_default_client = _Client()

scrylab-0.1.0/src/scrylab/_utils.py

@@ -0,0 +1,62 @@
+from typing import Optional
+import numpy as np
+
+
+def _broadcast(val, n):
+    return list(val) if isinstance(val, (list, tuple)) else [val] * n
+
+
+def normalize_one(y, name: Optional[str], x, z):
+    try:
+        import pandas as pd
+        if isinstance(y, pd.Series):
+            name = name or y.name
+            x    = x if x is not None else y.index.to_numpy()
+            y    = y.to_numpy()
+        if isinstance(z, pd.DataFrame):
+            x = x if x is not None else z.columns.to_numpy()
+            z = z.to_numpy()
+        elif isinstance(z, pd.Series):
+            z = z.to_numpy()
+    except ImportError:
+        pass
+    if x is not None:
+        x = np.asarray(x)
+    if z is not None:
+        z = np.asarray(z)
+    return np.asarray(y), name or "Unnamed Signal 1", x, z
+
+
+def normalize_many(y, names, x, z):
+    try:
+        import pandas as pd
+    except ImportError:
+        pd = None
+
+    if pd is not None and isinstance(y, pd.DataFrame):
+        cols  = list(y.columns)
+        ys    = [y[col].to_numpy() for col in cols]
+        names = names if names is not None else cols
+        x_eff = y.index.to_numpy() if x is None else x
+        xs    = [np.asarray(xi) if xi is not None else None for xi in _broadcast(x_eff, len(ys))]
+        zs    = [np.asarray(zi) if zi is not None else None for zi in _broadcast(z, len(ys))]
+        return ys, names, xs, zs
+
+    y_items = list(y)
+    n       = len(y_items)
+    ys, auto_names, xs, zs = [], [], [], []
+    for yi, xi, zi in zip(y_items, _broadcast(x, n), _broadcast(z, n)):
+        if pd is not None and isinstance(yi, pd.Series):
+            auto_names.append(yi.name)
+            xs.append(np.asarray(xi) if xi is not None else yi.index.to_numpy())
+            ys.append(yi.to_numpy())
+        else:
+            auto_names.append(None)
+            xs.append(np.asarray(xi) if xi is not None else None)
+            ys.append(np.asarray(yi))
+        zs.append(np.asarray(zi) if zi is not None else None)
+    if names is None:
+        names = [an or f"Unnamed Signal {i + 1}" for i, an in enumerate(auto_names)]
+    else:
+        names = list(names)
+    return ys, names, xs, zs

scrylab-0.1.0/tests/test_utils.py

@@ -0,0 +1,71 @@
+import numpy as np
+import pandas as pd
+
+from scrylab._utils import normalize_one, normalize_many
+
+# --- normalize_one ---
+
+def test_normalize_one_numpy_array():
+    y = np.array([1.0, 2.0, 3.0])
+    yi, name, xi, zi = normalize_one(y, None, None, None)
+    assert isinstance(yi, np.ndarray)
+    np.testing.assert_array_equal(yi, y)
+    assert name == "Unnamed Signal 1"
+    assert xi is None
+    assert zi is None
+
+
+def test_normalize_one_series_name_and_index():
+    s = pd.Series([10.0, 20.0], index=[0.0, 0.5], name="Speed")
+    yi, name, xi, zi = normalize_one(s, None, None, None)
+    assert name == "Speed"
+    np.testing.assert_array_equal(xi, [0.0, 0.5])
+    np.testing.assert_array_equal(yi, [10.0, 20.0])
+
+
+def test_normalize_one_series_x_override():
+    s = pd.Series([10.0, 20.0], index=[0.0, 0.5], name="Speed")
+    x = np.array([1.0, 2.0])
+    _, _, xi, _ = normalize_one(s, None, x, None)
+    np.testing.assert_array_equal(xi, x)
+
+
+def test_normalize_one_z_dataframe():
+    z_df = pd.DataFrame([[1, 2], [3, 4]], index=[10.0, 20.0], columns=[0.0, 1.0])
+    _, _, xi, zi = normalize_one(np.array([10.0, 20.0]), None, None, z_df)
+    np.testing.assert_array_equal(zi, z_df.to_numpy())
+    np.testing.assert_array_equal(xi, z_df.columns.to_numpy())
+
+
+def test_normalize_one_custom_name_overrides_series():
+    s = pd.Series([1.0, 2.0], name="Original")
+    _, name, _, _ = normalize_one(s, "Custom", None, None)
+    assert name == "Custom"
+
+
+# --- normalize_many ---
+
+def test_normalize_many_list_of_arrays():
+    a = np.array([1.0, 2.0])
+    b = np.array([3.0, 4.0])
+    ys, names, xs, zs = normalize_many([a, b], None, None, None)
+    assert names == ["Unnamed Signal 1", "Unnamed Signal 2"]
+    assert all(xi is None for xi in xs)
+    assert all(zi is None for zi in zs)
+
+
+def test_normalize_many_dataframe_input():
+    df = pd.DataFrame({"Alpha": [1.0, 2.0], "Beta": [3.0, 4.0]}, index=[0.0, 1.0])
+    _, names, xs, _ = normalize_many(df, None, None, None)
+    assert names == ["Alpha", "Beta"]
+    np.testing.assert_array_equal(xs[0], df.index.to_numpy())
+    np.testing.assert_array_equal(xs[1], df.index.to_numpy())
+
+
+def test_normalize_many_list_of_series():
+    s1 = pd.Series([1.0, 2.0], index=[0.0, 0.5], name="Temp")
+    s2 = pd.Series([3.0, 4.0], index=[0.0, 0.5], name="Pressure")
+    _, names, xs, _ = normalize_many([s1, s2], None, None, None)
+    assert names == ["Temp", "Pressure"]
+    np.testing.assert_array_equal(xs[0], s1.index.to_numpy())
+    np.testing.assert_array_equal(xs[1], s2.index.to_numpy())