bec-server 2.4.2__tar.gz → 2.5.0__tar.gz

bec_server-2.5.0/.gitignore

@@ -0,0 +1,180 @@
+**/*_venv
+**/.idea
+*.log
+**/__pycache__
+**/.DS_Store
+**/out
+**/.vscode
+**/.pytest_cache
+**/*.egg*
+
+# recovery_config files
+recovery_config_*
+
+# file writer data
+**.h5
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/**/_build/
+docs/**/autodoc/
+docs/**/_autosummary/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+**.prof
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

bec_server-2.5.0/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.3
+Name: bec-server
+Version: 2.5.0
+Summary: BEC server
+Project-URL: Bug Tracker, https://gitlab.psi.ch/bec/bec/issues
+Project-URL: Homepage, https://gitlab.psi.ch/bec/bec
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Requires-Dist: bec-lib
+Requires-Dist: cytoolz
+Requires-Dist: h5py
+Requires-Dist: libtmux
+Requires-Dist: lmfit
+Requires-Dist: msgpack
+Requires-Dist: numpy
+Requires-Dist: ophyd
+Requires-Dist: ophyd-devices
+Requires-Dist: py-scibec
+Requires-Dist: pydantic
+Requires-Dist: python-dotenv
+Requires-Dist: pyyaml
+Requires-Dist: rich
+Requires-Dist: xmltodict
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: coverage; extra == 'dev'
+Requires-Dist: isort; extra == 'dev'
+Requires-Dist: pylint; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-random-order; extra == 'dev'
+Requires-Dist: pytest-timeout; extra == 'dev'

bec_server-2.5.0/pyproject.toml

@@ -0,0 +1,63 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "bec-server"
+version = "2.5.0"
+description = "BEC server"
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering",
+]
+dependencies = [
+    "bec-lib",
+    "cytoolz",
+    "h5py",
+    "libtmux",
+    "lmfit",
+    "msgpack",
+    "numpy",
+    "ophyd",
+    "ophyd_devices",
+    "pydantic",
+    "py-scibec",
+    "pyyaml",
+    "python-dotenv",
+    "rich",
+    "xmltodict",
+]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "isort",
+    "coverage",
+    "pylint",
+    "pytest",
+    "pytest-random-order",
+    "pytest-timeout",
+]
+
+[project.scripts]
+bec-dap = "bec_server.data_processing:main"
+bec-device-server = "bec_server.device_server:main"
+bec-file-writer = "bec_server.file_writer:main"
+bec-scan-server = "bec_server.scan_server:main"
+bec-scan-bundler = "bec_server.scan_bundler:main"
+bec-scihub = "bec_server.scihub:main"
+bec-server = "bec_server:main"
+
+
+[project.urls]
+"Bug Tracker" = "https://gitlab.psi.ch/bec/bec/issues"
+Homepage = "https://gitlab.psi.ch/bec/bec"
+
+[tool.hatch.build.targets.wheel]
+include = ["*"]
+
+[tool.black]
+line-length = 100
+skip-magic-trailing-comma = true

bec_server-2.5.0/tests/tests_bec_server_utils/test_main.py

@@ -0,0 +1,68 @@
+from unittest import mock
+
+from bec_server.bec_server_utils.launch import main
+
+
+def test_main_start():
+    with mock.patch("bec_server.bec_server_utils.launch.ServiceHandler") as mock_service_handler:
+        with mock.patch("bec_server.bec_server_utils.launch.argparse") as mock_argparse:
+            mock_argparse.ArgumentParser().parse_args.return_value = mock.MagicMock(
+                command="start", config=None
+            )
+            main()
+            mock_service_handler.assert_called_once_with(
+                bec_path=mock.ANY, config_path=None, no_tmux=False
+            )
+            mock_service_handler().start.assert_called_once()
+
+
+def test_main_stop():
+    with mock.patch("bec_server.bec_server_utils.launch.ServiceHandler") as mock_service_handler:
+        with mock.patch("bec_server.bec_server_utils.launch.argparse") as mock_argparse:
+            mock_argparse.ArgumentParser().parse_args.return_value = mock.MagicMock(
+                command="stop", config=None
+            )
+            main()
+            mock_service_handler.assert_called_once_with(
+                bec_path=mock.ANY, config_path=None, no_tmux=False
+            )
+            mock_service_handler().stop.assert_called_once()
+
+
+def test_main_restart():
+    with mock.patch("bec_server.bec_server_utils.launch.ServiceHandler") as mock_service_handler:
+        with mock.patch("bec_server.bec_server_utils.launch.argparse") as mock_argparse:
+            mock_argparse.ArgumentParser().parse_args.return_value = mock.MagicMock(
+                command="restart", config=None
+            )
+            main()
+            mock_service_handler.assert_called_once_with(
+                bec_path=mock.ANY, config_path=None, no_tmux=False
+            )
+            mock_service_handler().restart.assert_called_once()
+
+
+def test_main_start_with_config():
+    with mock.patch("bec_server.bec_server_utils.launch.ServiceHandler") as mock_service_handler:
+        with mock.patch("bec_server.bec_server_utils.launch.argparse") as mock_argparse:
+            mock_argparse.ArgumentParser().parse_args.return_value = mock.MagicMock(
+                command="start", config="/path/to/config"
+            )
+            main()
+            mock_service_handler.assert_called_once_with(
+                bec_path=mock.ANY, config_path="/path/to/config", no_tmux=False
+            )
+            mock_service_handler().start.assert_called_once()
+
+
+def test_main_restart_with_config():
+    with mock.patch("bec_server.bec_server_utils.launch.ServiceHandler") as mock_service_handler:
+        with mock.patch("bec_server.bec_server_utils.launch.argparse") as mock_argparse:
+            mock_argparse.ArgumentParser().parse_args.return_value = mock.MagicMock(
+                command="restart", config="/path/to/config"
+            )
+            main()
+            mock_service_handler.assert_called_once_with(
+                bec_path=mock.ANY, config_path="/path/to/config", no_tmux=False
+            )
+            mock_service_handler().restart.assert_called_once()

bec_server-2.5.0/tests/tests_bec_server_utils/test_service_handler.py

@@ -0,0 +1,64 @@
+from unittest import mock
+
+from bec_server.bec_server_utils.service_handler import ServiceHandler
+
+
+def test_service_handler():
+    bec_path = "/path/to/bec"
+    config_path = "/path/to/config"
+
+    with mock.patch("bec_server.bec_server_utils.service_handler.sys") as mock_sys:
+        mock_sys.platform = "linux"
+        service_handler = ServiceHandler(bec_path, config_path)
+        assert service_handler.interface == "tmux"
+
+
+def test_service_handler_start():
+    bec_path = "/path/to/bec"
+    config_path = "/path/to/config"
+
+    with mock.patch("bec_server.bec_server_utils.service_handler.sys") as mock_sys:
+        mock_sys.platform = "linux"
+        service_handler = ServiceHandler(bec_path, config_path)
+
+        with mock.patch(
+            "bec_server.bec_server_utils.service_handler.tmux_start"
+        ) as mock_tmux_start:
+            service_handler.start()
+            mock_tmux_start.assert_called_once_with(bec_path, config_path, service_handler.SERVICES)
+
+
+def test_service_handler_stop():
+    with mock.patch("bec_server.bec_server_utils.service_handler.tmux_stop") as mock_tmux_stop:
+        service_handler = ServiceHandler("/path/to/bec", "/path/to/config")
+        service_handler.stop()
+        mock_tmux_stop.assert_called_once()
+
+
+def test_service_handler_restart():
+    bec_path = "/path/to/bec"
+    config_path = "/path/to/config"
+
+    with mock.patch("bec_server.bec_server_utils.service_handler.sys") as mock_sys:
+        mock_sys.platform = "linux"
+        service_handler = ServiceHandler(bec_path, config_path)
+
+        with mock.patch("bec_server.bec_server_utils.service_handler.tmux_stop") as mock_tmux_stop:
+            with mock.patch(
+                "bec_server.bec_server_utils.service_handler.tmux_start"
+            ) as mock_tmux_start:
+                service_handler.restart()
+                mock_tmux_stop.assert_called_once()
+                mock_tmux_start.assert_called_once_with(
+                    bec_path, config_path, service_handler.SERVICES
+                )
+
+
+def test_service_handler_services():
+    service_handler = ServiceHandler("/path/to/bec", "/path/to/config")
+    assert (
+        service_handler.SERVICES["scan_server"]["path"].substitute(base_path="/path/to/bec")
+        == "/path/to/bec/scan_server"
+    )
+
+    assert service_handler.SERVICES["scan_server"]["command"] == "bec-scan-server"

bec_server-2.5.0/tests/tests_bec_server_utils/test_tmux_launch.py

@@ -0,0 +1,47 @@
+from string import Template
+from unittest import mock
+
+from bec_server.bec_server_utils.tmux_launch import tmux_start, tmux_stop
+
+
+def test_tmux_start():
+    with mock.patch("bec_server.bec_server_utils.tmux_launch.libtmux") as mock_libtmux_server:
+        tmux_start(
+            "/path/to/bec",
+            "/path/to/config",
+            {
+                "scan_server": {
+                    "path": Template("$base_path/scan_server"),
+                    "command": "bec-scan-server",
+                },
+                "scan_bundler": {
+                    "path": Template("$base_path/scan_bundler"),
+                    "command": "bec-scan-bundler",
+                },
+            },
+        )
+        mock_libtmux_server.Server().new_session.assert_called_once_with(
+            "bec", window_name="BEC server. Use `ctrl+b d` to detach.", kill_session=True
+        )
+        assert (
+            mock_libtmux_server.Server().new_session().attached_window.select_layout.call_count == 2
+        )
+
+        assert mock_libtmux_server.Server().new_session().set_option.call_count == 1
+        assert mock_libtmux_server.Server().new_session().set_option.call_args[0][0] == "mouse"
+        assert mock_libtmux_server.Server().new_session().set_option.call_args[0][1] == "on"
+
+
+def test_tmux_stop_without_sessions():
+    with mock.patch("bec_server.bec_server_utils.tmux_launch.libtmux") as mock_libtmux_server:
+        mock_libtmux_server.Server().sessions.filter.return_value = []
+        tmux_stop()
+        mock_libtmux_server.Server().kill_server.assert_not_called()
+
+
+def test_tmux_stop_with_sessions():
+    session = mock.MagicMock()
+    with mock.patch("bec_server.bec_server_utils.tmux_launch.libtmux") as mock_libtmux_server:
+        mock_libtmux_server.Server().sessions.filter.return_value = [session]
+        tmux_stop()
+        session.kill_session.assert_called_once()

bec_server-2.5.0/tests/tests_data_processing/conftest.py

@@ -0,0 +1,12 @@
+import pytest
+
+from bec_lib import bec_logger
+
+# overwrite threads_check fixture from bec_lib,
+# to have it in autouse
+
+
+@pytest.fixture(autouse=True)
+def threads_check(threads_check):
+    yield
+    bec_logger.logger.remove()

bec_server-2.5.0/tests/tests_data_processing/test_dap_cli_launch.py

@@ -0,0 +1,40 @@
+from unittest import mock
+
+from bec_server.data_processing.cli.launch import main
+
+
+def test_main():
+    with mock.patch("bec_server.data_processing.cli.launch.argparse.ArgumentParser") as mock_parser:
+        with mock.patch("bec_server.data_processing.cli.launch.ServiceConfig") as mock_config:
+            with mock.patch(
+                "bec_server.data_processing.dap_server.DAPServer"
+            ) as mock_data_processing:
+                with mock.patch(
+                    "bec_server.data_processing.cli.launch.threading.Event"
+                ) as mock_event:
+                    main()
+                    mock_parser.assert_called_once()
+                    mock_config.assert_called_once()
+                    mock_data_processing.assert_called_once()
+                    mock_event.assert_called_once()
+
+
+def test_main_shutdown():
+    with mock.patch("bec_server.data_processing.cli.launch.argparse.ArgumentParser") as mock_parser:
+        with mock.patch("bec_server.data_processing.cli.launch.ServiceConfig") as mock_config:
+            with mock.patch(
+                "bec_server.data_processing.dap_server.DAPServer"
+            ) as mock_data_processing:
+                with mock.patch(
+                    "bec_server.data_processing.cli.launch.threading.Event"
+                ) as mock_event:
+                    mock_event.return_value.wait.side_effect = KeyboardInterrupt()
+                    try:
+                        main()
+                    except KeyboardInterrupt:
+                        pass
+                    mock_parser.assert_called_once()
+                    mock_config.assert_called_once()
+                    mock_data_processing.assert_called_once()
+                    mock_event.assert_called_once()
+                    mock_data_processing.return_value.shutdown.assert_called_once()

bec_server-2.5.0/tests/tests_data_processing/test_dap_server.py

@@ -0,0 +1,13 @@
+from unittest import mock
+
+from bec_lib import ServiceConfig
+from bec_server.data_processing.dap_server import DAPServer
+from bec_server.data_processing.dap_service import DAPServiceBase
+
+
+def test_dap_server():
+    config = ServiceConfig()
+    server = DAPServer(
+        config=config, connector_cls=mock.MagicMock(), provided_services=DAPServiceBase, forced=True
+    )
+    assert server._service_id == "DAPServiceBase"

bec_server-2.5.0/tests/tests_data_processing/test_dap_service_manager.py

@@ -0,0 +1,115 @@
+from unittest import mock
+
+import pytest
+
+from bec_lib import messages
+from bec_lib.redis_connector import MessageObject
+from bec_server.data_processing.dap_service import DAPServiceBase
+from bec_server.data_processing.dap_service_manager import DAPServiceManager
+
+
+class ServiceMock(DAPServiceBase):
+    def configure(self, *args, **kwargs):
+        pass
+
+    def process(self, *args, **kwargs):
+        pass
+
+    def on_scan_status_update(self, *args, **kwargs):
+        pass
+
+    @classmethod
+    def get_class_doc_string(cls, *args, **kwargs):
+        return "class_doc"
+
+
+@pytest.fixture
+def service_manager():
+    dap_service_manager = DAPServiceManager(services=ServiceMock)
+    dap_service_manager.start(client=mock.MagicMock())
+    yield dap_service_manager
+    dap_service_manager.shutdown()
+
+
+def test_DAPServiceManager_init(service_manager):
+    assert service_manager.services == [ServiceMock]
+    assert service_manager.available_dap_services == {
+        "ServiceMock": {
+            "class": "ServiceMock",
+            "user_friendly_name": "ServiceMock",
+            "class_doc": "class_doc",
+            "run_doc": None,
+            "run_name": "run",
+            "signature": [
+                {
+                    "name": "args",
+                    "kind": "VAR_POSITIONAL",
+                    "default": "_empty",
+                    "annotation": "_empty",
+                },
+                {
+                    "name": "kwargs",
+                    "kind": "VAR_KEYWORD",
+                    "default": "_empty",
+                    "annotation": "_empty",
+                },
+            ],
+            "params": {},
+            "auto_run_supported": False,
+            "class_args": [],
+            "class_kwargs": {},
+        }
+    }
+
+
+@pytest.mark.parametrize(
+    "msg, process_called",
+    [
+        (messages.DAPRequestMessage(dap_cls="dap_cls", dap_type="on_demand", config={}), True),
+        (messages.ScanStatusMessage(scan_id="scan_id", status="open", info={}), False),
+    ],
+)
+def test_DAPServiceManager_request_callback(service_manager, msg, process_called):
+    msg_obj = MessageObject(value=msg, topic="topic")
+    with mock.patch.object(service_manager, "process_dap_request") as mock_process_dap_request:
+        service_manager._dap_request_callback(msg_obj)
+        if process_called:
+            mock_process_dap_request.assert_called_once_with(msg)
+
+
+@pytest.mark.parametrize(
+    "msg, raised_exception, error_msg",
+    [
+        (
+            messages.DAPRequestMessage(
+                dap_cls="ServiceMock",
+                dap_type="continuous",
+                config={"auto_fit": True, "class_args": [], "class_kwargs": {}},
+            ),
+            False,
+            "",
+        ),
+        (
+            messages.DAPRequestMessage(
+                dap_cls="ServiceMock", dap_type="continuous", config={"auto_fit": False}
+            ),
+            False,
+            "",
+        ),
+        (
+            messages.DAPRequestMessage(dap_cls="ServiceMock", dap_type="on_demand", config={}),
+            False,
+            "",
+        ),
+    ],
+)
+def test_process_dap_request(service_manager, msg, raised_exception, error_msg):
+    if raised_exception:
+        with mock.patch.object(service_manager, "send_dap_response") as mock_send_dap_response:
+            service_manager.process_dap_request(msg)
+            mock_send_dap_response.assert_called_once_with(
+                msg, success=False, error=error_msg, metadata=msg.metadata
+            )
+        return
+
+    service_manager.process_dap_request(msg)