ewokstxs 1.0.0__tar.gz

ewokstxs-1.0.0/LICENSE.md

@@ -0,0 +1,20 @@
+# MIT License
+
+**Copyright (c) 2023 European Synchrotron Radiation Facility**
+
+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.

ewokstxs-1.0.0/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: ewokstxs
+Version: 1.0.0
+Summary: Data processing workflows for ID09
+Author-email: ESRF <dau-pydev@esrf.fr>
+License-Expression: MIT
+Project-URL: Homepage, https://gitlab.esrf.fr/workflow/ewoksapps/ewokstxs/
+Project-URL: Documentation, https://ewokstxs.readthedocs.io/
+Project-URL: Repository, https://gitlab.esrf.fr/workflow/ewoksapps/ewokstxs/
+Project-URL: Issues, https://gitlab.esrf.fr/workflow/ewoksapps/ewokstxs/issues
+Project-URL: Changelog, https://gitlab.esrf.fr/workflow/ewoksapps/ewokstxs/-/blob/main/CHANGELOG.md
+Keywords: ewoks
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: blissdata>=2.3.0
+Requires-Dist: ewoks
+Requires-Dist: ewokscore
+Requires-Dist: ewoksdata[online]
+Requires-Dist: ewoksutils
+Requires-Dist: pytxs
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: pyqt5; extra == "test"
+Provides-Extra: dev
+Requires-Dist: ewokstxs[test]; extra == "dev"
+Requires-Dist: bandit; extra == "dev"
+Requires-Dist: black>=26; extra == "dev"
+Requires-Dist: flake8>=4; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Provides-Extra: doc
+Requires-Dist: ewokstxs[test]; extra == "doc"
+Requires-Dist: sphinx>=4.5; extra == "doc"
+Requires-Dist: pydata_sphinx_theme; extra == "doc"
+Requires-Dist: ewokssphinx; extra == "doc"
+Requires-Dist: sphinx-copybutton; extra == "doc"
+Dynamic: license-file
+
+# ewokstxs
+
+Ewoks tasks for the [txs package](https://gitlab.esrf.fr/levantin/txs).
+
+## Resources
+
+- [Package on pypi.org](https://pypi.org/project/ewokstxs/)
+- [Documentation](https://ewokstxs.readthedocs.io/)
+- [Contributing](CONTRIBUTING.md)
+- [Changelog](CHANGELOG.md)
+

ewokstxs-1.0.0/README.md

@@ -0,0 +1,11 @@
+# ewokstxs
+
+Ewoks tasks for the [txs package](https://gitlab.esrf.fr/levantin/txs).
+
+## Resources
+
+- [Package on pypi.org](https://pypi.org/project/ewokstxs/)
+- [Documentation](https://ewokstxs.readthedocs.io/)
+- [Contributing](CONTRIBUTING.md)
+- [Changelog](CHANGELOG.md)
+

ewokstxs-1.0.0/pyproject.toml

@@ -0,0 +1,78 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ewokstxs"
+version = "1.0.0"
+keywords = ['ewoks']
+authors = [{name = "ESRF", email = "dau-pydev@esrf.fr"}]
+description = "Data processing workflows for ID09"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE.md"]
+classifiers = [
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+]
+requires-python = ">=3.10"
+dependencies = [
+    "blissdata >= 2.3.0",
+    "ewoks",
+    "ewokscore",
+    "ewoksdata[online]",
+    "ewoksutils",
+    "pytxs",
+]
+
+[project.urls]
+Homepage = "https://gitlab.esrf.fr/workflow/ewoksapps/ewokstxs/"
+Documentation = "https://ewokstxs.readthedocs.io/"
+Repository = "https://gitlab.esrf.fr/workflow/ewoksapps/ewokstxs/"
+Issues = "https://gitlab.esrf.fr/workflow/ewoksapps/ewokstxs/issues"
+Changelog = "https://gitlab.esrf.fr/workflow/ewoksapps/ewokstxs/-/blob/main/CHANGELOG.md"
+
+[project.optional-dependencies]
+test = [
+    "pytest >=7",
+    "pyqt5",
+]
+dev = [
+    "ewokstxs[test]",
+    "bandit",
+    "black >=26",
+    "flake8 >=4",
+    "isort",
+    "mypy",
+]
+doc = [
+    "ewokstxs[test]",
+    "sphinx >=4.5",
+    "pydata_sphinx_theme",
+    "ewokssphinx",
+    "sphinx-copybutton",
+]
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[project.entry-points."ewoks.tasks.class"]
+"ewokstxs.tasks.*" = "ewokstxs"
+
+[tool.bandit.assert_used]
+skips = ["*/test_*.py"]
+
+[tool.coverage.run]
+omit = ['*/tests/*']
+
+[tool.isort]
+profile = "black"
+
+[tool.mypy]
+python_version = "3.10"
+files = "src"
+ignore_missing_imports = true
+explicit_package_bases = true

ewokstxs-1.0.0/setup.cfg

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

ewokstxs-1.0.0/src/ewokstxs/__main__.py

@@ -0,0 +1,109 @@
+import argparse
+import logging
+from pprint import pprint
+
+from ewoks import execute_graph
+from ewoksutils.task_utils import task_inputs
+
+
+def main():
+    """Run TxsTask with the provided arguments"""
+    parser = argparse.ArgumentParser(
+        description="Run TxsTask with the given arguments",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument(
+        "filename",
+        type=str,
+        help="Path of the HDF5 file where the scan is saved",
+    )
+    parser.add_argument(
+        "scan",
+        type=int,
+        help="Scan number",
+    )
+    parser.add_argument(
+        "output_filename",
+        type=str,
+        help="Path of the HDF5 file where to save the integrated results",
+    )
+    parser.add_argument(
+        "-e",
+        "--energy",
+        required=True,
+        type=float,
+        help="X-ray photon energy (eV)",
+    )
+    parser.add_argument(
+        "-d",
+        "--distance",
+        required=True,
+        type=float,
+        help="Sample-to-detector distance (m)",
+    )
+
+    # optional
+
+    parser.add_argument(
+        "-c",
+        "--center",
+        nargs=2,
+        type=float,
+        default=(960.0, 960.0),
+        help="Coordinates of the image center (hor, ver) (pixel)",
+    )
+    parser.add_argument(
+        "--detector",
+        type=str,
+        default="rayonix",
+        help="Detector name",
+    )
+    parser.add_argument(
+        "-b",
+        "--binning",
+        nargs=2,
+        type=int,
+        default=(2, 2),
+        help="Detector binning (hor, ver)",
+    )
+    parser.add_argument(
+        "-p",
+        "--pixel",
+        nargs=2,
+        type=float,
+        default=None,
+        help="Pixel size (hor, ver) (m)",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="count",
+        default=0,
+        help="Increase verbosity level (-v: INFO, -vv:DEBUG)",
+    )
+
+    inputs = {k: v for k, v in vars(parser.parse_args()).items() if k != "verbose"}
+    inputs["scan_key"] = None
+
+    print("Inputs:")
+    pprint(inputs)
+    result = execute_graph(
+        {
+            "graph": {"id": "txs"},
+            "nodes": [
+                {
+                    "id": "txs_task",
+                    "task_type": "class",
+                    "task_identifier": "ewokstxs.tasks.txs.TxsTask",
+                },
+            ],
+        },
+        inputs=task_inputs(id="txs_task", inputs=inputs),
+    )
+    print("Result:")
+    pprint(result)
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.WARNING)
+    main()

ewokstxs-1.0.0/src/ewokstxs/tasks/txs.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+import os.path
+from collections.abc import Generator
+from typing import Any
+
+import numpy as np
+import txs
+from ewokscore import Task
+from pyFAI.containers import Integrate1dResult
+from silx.io.url import DataUrl
+
+from .utils import TxsResultsWriter, detector_frames
+
+
+def txs_integration_results(
+    scan_key: str | None,
+    filename: str | None,
+    scan_number: int,
+    energy: float,
+    distance: float,
+    center: tuple[float, float],
+    detector: str,
+    binning: int | tuple[int, int] | None,
+    pixel: float | tuple[float, float] | None = None,
+    integrate1d_options: dict[str, Any] | None = None,
+) -> Generator[tuple[float, Integrate1dResult]]:
+    """Generator of txs's azimuthal integration results
+
+    At least one of scan_key and filename must not be None or an empty string
+
+    :param scan_key: blissdata scan unique identifier
+    :param filename: Path of the HDF5 file where the scan is saved
+    :param scan_number: Scan number
+    :param energy: X-ray photon energy (eV)
+    :param distance: Sample-to-detector distance (m)
+    :param center: Coordinates of the image center (hor, ver) (pixel)
+    :param detector: Detector name
+    :param binning: Detector binning (hor, ver). Giving one value will set both hor and ver.
+    :param pixel: Pixel size (hor, ver) (m)
+    :param integrate1d_options: Extra arguments to pass to integrate1d
+    """
+    if not scan_key and not filename:
+        raise ValueError(
+            "Both scan_key and filename are None or an empty string. At least one must be defined"
+        )
+
+    if pixel:
+        ai = txs.get_ai(energy, distance, center, binning=binning, pixel=pixel)
+    else:
+        ai = txs.get_ai(energy, distance, center, binning=binning, detector=detector)
+
+    if integrate1d_options is None:
+        integrate1d_options = {}
+    for timestamp, image in detector_frames(scan_key, filename, scan_number, detector):
+        yield timestamp, txs.azav.integrate1d(image, ai, **integrate1d_options)
+
+
+class TxsTask(  # type: ignore[call-arg]
+    Task,
+    input_names=[
+        "scan_key",
+        "filename",
+        "scan",
+        "energy",
+        "distance",
+        "center",
+        "detector",
+        "binning",
+        "output_filename",
+    ],
+    optional_input_names=["pixel", "integrate1d_options"],
+    output_names=["nxdata_url"],
+):
+    """txs integration task which saves the results to a HDF5 file"""
+
+    def run(self):
+        scan_group_name = f"/{self.inputs.scan}.1"
+
+        with TxsResultsWriter(
+            scan_nxentry_url=DataUrl(
+                file_path=os.path.abspath(self.inputs.filename),
+                data_path=scan_group_name,
+            ),
+            results_nxentry_url=DataUrl(
+                file_path=os.path.abspath(self.inputs.output_filename),
+                data_path=scan_group_name,
+            ),
+        ) as writer:
+            for timestamp, result in txs_integration_results(
+                self.inputs.scan_key,
+                self.inputs.filename,
+                self.inputs.scan,
+                self.inputs.energy,
+                self.inputs.distance,
+                self.inputs.center,
+                self.inputs.detector,
+                self.inputs.binning,
+                self.get_input_value("pixel", None),
+                self.get_input_value("integrate1d_options", None),
+            ):
+                writer.add_result(result, timestamp)
+
+        nxdata_url = writer.nxdata_url
+        self.outputs.nxdata_url = nxdata_url.path() if nxdata_url else None
+
+
+class TxsTaskWithoutSaving(  # type: ignore[call-arg]
+    Task,
+    input_names=[
+        "scan_key",
+        "filename",
+        "scan",
+        "energy",
+        "distance",
+        "center",
+        "detector",
+        "binning",
+    ],
+    optional_input_names=["pixel", "integrate1d_options"],
+    output_names=[
+        "radial",
+        "radial_units",
+        "intensity",
+        "intensity_error",
+    ],
+):
+    """txs integration task which returns the results"""
+
+    def run(self):
+        results = []
+        for _, result in txs_integration_results(
+            self.inputs.scan_key,
+            self.inputs.filename,
+            self.inputs.scan,
+            self.inputs.energy,
+            self.inputs.distance,
+            self.inputs.center,
+            self.inputs.detector,
+            self.inputs.binning,
+            self.get_input_value("pixel", None),
+            self.get_input_value("integrate1d_options", None),
+        ):
+            results.append(result)
+
+        if not results:
+            raise RuntimeError("No data was processed")
+
+        self.outputs.radial = results[0].radial
+        self.outputs.radial_units = results[0].unit.name
+        self.outputs.intensity = np.array([res.intensity for res in results])
+        self.outputs.intensity_error = np.array([res.sigma for res in results])

ewokstxs-1.0.0/src/ewokstxs/tasks/utils.py

@@ -0,0 +1,282 @@
+from __future__ import annotations
+
+import logging
+import os.path
+from collections.abc import Generator
+
+import h5py
+import numpy as np
+import txs
+from blissdata.beacon.data import BeaconData
+from blissdata.exceptions import ScanNotFoundError, ScanValidationError
+from blissdata.redis_engine.store import DataStore
+from ewoksdata.data import nexus
+from ewoksdata.data.bliss import iter_bliss_scan_data, iter_bliss_scan_data_from_memory
+from pyFAI.containers import Integrate1dResult
+from silx.io import h5py_utils
+from silx.io.dictdump import dicttonx
+from silx.io.url import DataUrl
+
+_logger = logging.getLogger(__name__)
+
+
+RETRY_OPTIONS = {"retry_timeout": 2 * 60, "retry_period": 1}
+"""Retry options used both for reading and writing"""
+
+
+@h5py_utils.retry()
+def _open_h5_file(filename: str, mode: str = "r"):
+    """Open a HDF5 file and retries if it fails"""
+    return h5py.File(filename, mode)
+
+
+class TxsResultsWriter:
+    """Writes txs results to a HDF5 group.
+
+    :param scan_nxentry_url: URL of the HDF5 group of the scan
+    :param results_nxentry_url: URL of the HDF5 group where to write the results
+    """
+
+    FLUSH_PERIOD = 3.0
+    """Period at which to write to the HDF5 file (seconds)"""
+
+    def __init__(
+        self,
+        scan_nxentry_url: DataUrl,
+        results_nxentry_url: DataUrl,
+    ):
+        self._scan_nxentry_url = scan_nxentry_url
+        self._results_nxentry_url = results_nxentry_url
+
+        self._results_buffer: list[Integrate1dResult] = []
+        self._results_timestamp: list[float] = []
+        self._chunk_length: int | None = None
+        self._nxdata_url: DataUrl | None = None
+
+    def __del__(self):
+        self.flush(all=True)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.flush(all=True)
+
+    @property
+    def nxdata_url(self) -> DataUrl | None:
+        """URL of the HDF5 group storing the NXdata, None if not yet created"""
+        return self._nxdata_url
+
+    def add_result(self, result: Integrate1dResult, timestamp: float):
+        """Append data from txs result to the HDF5 datasets"""
+        self._results_buffer.append(result)
+        self._results_timestamp.append(timestamp)
+
+        if timestamp - self._results_timestamp[0] < self.FLUSH_PERIOD:
+            return
+
+        if (
+            self._chunk_length is None
+            or len(self._results_buffer) >= self._chunk_length
+        ):
+            self.flush()
+
+    def _create_result_nxentry(self, result: Integrate1dResult) -> DataUrl:
+        # Create the output result group and create folders and HDF5 file if needed
+        nexus.create_url(self._results_nxentry_url, **RETRY_OPTIONS)
+        result_filename = self._results_nxentry_url.file_path()
+
+        # Use a relative path for the external links
+        scan_filename = os.path.relpath(
+            self._scan_nxentry_url.file_path(),
+            os.path.dirname(result_filename),
+        )
+        scan_group_name = self._scan_nxentry_url.data_path()
+
+        radial_name, radial_unit = result.unit.name.split("_")
+
+        with _open_h5_file(result_filename, mode="a", **RETRY_OPTIONS) as h5file:
+            dicttonx(
+                {
+                    # Add links to some of the scan entries
+                    "instrument": h5py.ExternalLink(
+                        scan_filename, f"{scan_group_name}/instrument"
+                    ),
+                    "measurement": h5py.ExternalLink(
+                        scan_filename, f"{scan_group_name}/measurement"
+                    ),
+                    "sample": h5py.ExternalLink(
+                        scan_filename, f"{scan_group_name}/sample"
+                    ),
+                    "title": h5py.ExternalLink(
+                        scan_filename, f"{scan_group_name}/title"
+                    ),
+                    # NXProcess group storing txs results
+                    "@default": "integrate",
+                    "integrate": {
+                        "@NX_class": "NXprocess",
+                        # NXData group storing integrated patterns
+                        "@default": "integrated",
+                        "integrated": {
+                            "@NX_class": "NXdata",
+                            "@signal": "intensity",
+                            "@axes": [".", radial_name],
+                            radial_name: result.radial,
+                            f"{radial_name}@units": radial_unit,
+                        },
+                        "program": "txs",
+                        "version": txs.__version__,
+                    },
+                },
+                h5file,
+                self._results_nxentry_url.data_path(),
+                update_mode="modify",
+            )
+
+            nxdata_path = (
+                f"{self._results_nxentry_url.data_path()}/integrate/integrated"
+            )
+
+            # Create intensity and errors datasets
+            npt_rad = len(result.radial)
+
+            nxdata_group = h5file[nxdata_path]
+
+            intensity_dataset = nxdata_group.create_dataset(
+                "intensity",
+                dtype=result.intensity.dtype,
+                shape=(0, npt_rad),
+                chunks=(self._chunk_length, npt_rad),
+                maxshape=(None, npt_rad),
+                compression="gzip",
+            )
+            intensity_dataset.attrs["interpretation"] = "spectrum"
+
+            if result.sigma is not None:
+                nxdata_group.create_dataset(
+                    "intensity_errors",
+                    dtype=result.sigma.dtype,
+                    shape=(0, npt_rad),
+                    chunks=(self._chunk_length, npt_rad),
+                    maxshape=(None, npt_rad),
+                    compression="gzip",
+                )
+
+            return DataUrl(file_path=result_filename, data_path=nxdata_path)
+
+    def _guess_chunk_length(self) -> int:
+        if len(self._results_timestamp) > 1:
+            # expects regular framerate
+            average_frame_rate = 1.0 / np.mean(np.diff(self._results_timestamp))
+            chunk_length = int(average_frame_rate * self.FLUSH_PERIOD)
+        else:
+            chunk_length = len(self._results_timestamp)
+        return max(min(chunk_length, 32), 1)
+
+    def flush(self, all: bool = False) -> None:
+        if len(self._results_buffer) == 0:
+            return
+
+        if self._chunk_length is None:
+            self._chunk_length = self._guess_chunk_length()
+
+        if all:
+            write_length = len(self._results_buffer)
+        else:
+            write_length = (
+                len(self._results_buffer) // self._chunk_length * self._chunk_length
+            )
+        if write_length == 0:
+            return
+
+        if self._nxdata_url is None:
+            # Creates hdf5 entry lazily from first received result
+            self._nxdata_url = self._create_result_nxentry(self._results_buffer[0])
+
+        with _open_h5_file(
+            self._nxdata_url.file_path(), mode="a", **RETRY_OPTIONS
+        ) as h5file:
+            nxdata_group = h5file[self._nxdata_url.data_path()]
+            intensity_dataset = nxdata_group["intensity"]
+
+            write_offset = len(intensity_dataset)
+            dataset_length = write_offset + write_length
+
+            intensity_dataset.resize(dataset_length, axis=0)
+            intensity_dataset[write_offset:dataset_length] = [
+                result.intensity for result in self._results_buffer[:write_length]
+            ]
+
+            intensity_errors_group = nxdata_group.get("intensity_errors")
+            if intensity_errors_group is not None:
+                intensity_errors_group.resize(dataset_length, axis=0)
+                intensity_errors_group[write_offset:dataset_length] = [
+                    result.sigma for result in self._results_buffer[:write_length]
+                ]
+
+            self._results_buffer = self._results_buffer[write_length:]
+
+            if all:
+                nxdata_group["points"] = np.arange(dataset_length)
+
+                axes = nxdata_group.attrs["axes"]
+                axes[0] = "points"
+                nxdata_group.attrs["axes"] = axes
+
+
+def detector_frames(
+    scan_key: str | None,
+    filename: str | None,
+    scan_number: int,
+    detector: str,
+) -> Generator[tuple[float, np.ndarray]]:
+    """Generator of detector frames from a scan retrieved either through redis or from file
+
+    At least one of scan_key and filename must not be None or empty.
+
+    :scan_key: blissdata key of the scan
+    :filename: Path of the HDF5 raw data file to read
+    :scan_entry_name: HDF5 path in the file of the group containing the scan data
+    :detector: name of the detector
+    """
+    if not scan_key and not filename:
+        raise ValueError("At least one of scan_key and filename must not None or empty")
+
+    if scan_key:  # Try using redis first
+        # TODO rework
+        try:
+            data_store = DataStore(BeaconData().get_redis_data_db())
+        except Exception:
+            _logger.info("Cannot connect to beacon host or redis")
+            _logger.debug("Backtrace", exc_info=True)
+        else:
+            try:
+                _ = data_store.load_scan(scan_key)
+            except (ScanNotFoundError, ScanValidationError):
+                _logger.info(f"Cannot retrieve scan from redis: {scan_key}")
+                _logger.debug("Backtrace", exc_info=True)
+            else:
+                _logger.info("Retrieve frames through redis")
+                for data in iter_bliss_scan_data_from_memory(
+                    scan_key,
+                    lima_names=[detector],
+                    counter_names=["elapsed_time"],
+                    **RETRY_OPTIONS,
+                ):
+                    yield data["elapsed_time"], data[detector]
+                return
+
+    if not filename:
+        raise RuntimeError("Cannot connect to redis or retrieve the scan")
+
+    _logger.info("Read frames from file")
+    for data in iter_bliss_scan_data(
+        filename,
+        scan_number,
+        lima_names=[detector],
+        # One counter is needed here to make sure to iterate over the right number of frames
+        counter_names=["elapsed_time"],
+        **RETRY_OPTIONS,
+    ):
+        _logger.info(f"Read image for {data['elapsed_time']}")
+        yield data["elapsed_time"], data[detector]

ewokstxs-1.0.0/src/ewokstxs/tests/test_TxsTask.py

@@ -0,0 +1,85 @@
+import logging
+
+import h5py
+import numpy as np
+import pytest
+from ewoks import execute_graph
+from silx.io.dictdump import dicttonx
+from silx.io.url import DataUrl
+
+
+@pytest.fixture
+def h5_scan_file(tmp_path):
+    """Create a temporary HDF5 file with a minimal structure for testing."""
+
+    file_path = tmp_path / "dataset.h5"
+
+    h5_file_content = {
+        "@NX_class": "NXentry",
+        "start_time": "2023-07-04T23:10:56.747201+02:00",
+        "end_time": "2023-07-04T23:13:55.143782+02:00",
+        "title": "test_scan_command",
+        "instrument": {
+            "@NX_class": "NXinstrument",
+            "rayonix": {
+                "@NX_class": "NXdetector",
+                ">data": "image",
+                "image": np.random.randint(
+                    low=10, high=1000, size=(3, 1920, 1920), dtype=np.uint16
+                ),
+            },
+        },
+        "measurement": {
+            "@NX_class": "NXcollection",
+            "elapsed_time": [0.0, 1.0, 2.0],
+            ">rayonix": "../instrument/rayonix/data",
+        },
+        "sample": {
+            "@NX_class": "NXsample",
+            "name": "Test",
+        },
+    }
+    with h5py.File(file_path, "w") as h5_file:
+        dicttonx(h5_file_content, h5_file, h5path="1.1")
+
+    return file_path
+
+
+def test_task(tmp_path, h5_scan_file):
+    workflow = {
+        "graph": {"id": "txs"},
+        "nodes": [
+            {
+                "id": "txs",
+                "task_type": "class",
+                "task_identifier": "ewokstxs.tasks.txs.TxsTask",
+            },
+        ],
+    }
+
+    output_filename = str(tmp_path.absolute() / "output.h5")
+    scan_number = 1
+
+    parameters = {
+        "scan_key": None,
+        "filename": str(h5_scan_file),
+        "scan": scan_number,
+        "energy": 18000,
+        "distance": 0.3,
+        "center": (960.0, 960.0),
+        "detector": "rayonix",
+        "binning": (2, 2),
+        "output_filename": output_filename,
+    }
+
+    inputs = [
+        {"id": "txs", "name": name, "value": value}
+        for name, value in parameters.items()
+    ]
+
+    logging.debug(f"worflow parameters: {parameters}")
+    result = execute_graph(workflow, inputs=inputs)
+    logging.debug(f"workflow result: {result}")
+    assert DataUrl(result["nxdata_url"]) == DataUrl(
+        file_path=output_filename, data_path=f"/{scan_number}.1/integrate/integrated"
+    )

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

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: ewokstxs
+Version: 1.0.0
+Summary: Data processing workflows for ID09
+Author-email: ESRF <dau-pydev@esrf.fr>
+License-Expression: MIT
+Project-URL: Homepage, https://gitlab.esrf.fr/workflow/ewoksapps/ewokstxs/
+Project-URL: Documentation, https://ewokstxs.readthedocs.io/
+Project-URL: Repository, https://gitlab.esrf.fr/workflow/ewoksapps/ewokstxs/
+Project-URL: Issues, https://gitlab.esrf.fr/workflow/ewoksapps/ewokstxs/issues
+Project-URL: Changelog, https://gitlab.esrf.fr/workflow/ewoksapps/ewokstxs/-/blob/main/CHANGELOG.md
+Keywords: ewoks
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: blissdata>=2.3.0
+Requires-Dist: ewoks
+Requires-Dist: ewokscore
+Requires-Dist: ewoksdata[online]
+Requires-Dist: ewoksutils
+Requires-Dist: pytxs
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: pyqt5; extra == "test"
+Provides-Extra: dev
+Requires-Dist: ewokstxs[test]; extra == "dev"
+Requires-Dist: bandit; extra == "dev"
+Requires-Dist: black>=26; extra == "dev"
+Requires-Dist: flake8>=4; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Provides-Extra: doc
+Requires-Dist: ewokstxs[test]; extra == "doc"
+Requires-Dist: sphinx>=4.5; extra == "doc"
+Requires-Dist: pydata_sphinx_theme; extra == "doc"
+Requires-Dist: ewokssphinx; extra == "doc"
+Requires-Dist: sphinx-copybutton; extra == "doc"
+Dynamic: license-file
+
+# ewokstxs
+
+Ewoks tasks for the [txs package](https://gitlab.esrf.fr/levantin/txs).
+
+## Resources
+
+- [Package on pypi.org](https://pypi.org/project/ewokstxs/)
+- [Documentation](https://ewokstxs.readthedocs.io/)
+- [Contributing](CONTRIBUTING.md)
+- [Changelog](CHANGELOG.md)
+

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

@@ -0,0 +1,16 @@
+LICENSE.md
+README.md
+pyproject.toml
+src/ewokstxs/__init__.py
+src/ewokstxs/__main__.py
+src/ewokstxs.egg-info/PKG-INFO
+src/ewokstxs.egg-info/SOURCES.txt
+src/ewokstxs.egg-info/dependency_links.txt
+src/ewokstxs.egg-info/entry_points.txt
+src/ewokstxs.egg-info/requires.txt
+src/ewokstxs.egg-info/top_level.txt
+src/ewokstxs/tasks/__init__.py
+src/ewokstxs/tasks/txs.py
+src/ewokstxs/tasks/utils.py
+src/ewokstxs/tests/__init__.py
+src/ewokstxs/tests/test_TxsTask.py

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

@@ -0,0 +1 @@
+

ewokstxs-1.0.0/src/ewokstxs.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[ewoks.tasks.class]
+ewokstxs.tasks.* = ewokstxs

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

@@ -0,0 +1,25 @@
+blissdata>=2.3.0
+ewoks
+ewokscore
+ewoksdata[online]
+ewoksutils
+pytxs
+
+[dev]
+ewokstxs[test]
+bandit
+black>=26
+flake8>=4
+isort
+mypy
+
+[doc]
+ewokstxs[test]
+sphinx>=4.5
+pydata_sphinx_theme
+ewokssphinx
+sphinx-copybutton
+
+[test]
+pytest>=7
+pyqt5

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

@@ -0,0 +1 @@
+ewokstxs