diff --git a/.bumpversion.cfg b/.bumpversion.cfg index 11c0d4b9f9..be2e956cc8 100644 --- a/.bumpversion.cfg +++ b/.bumpversion.cfg @@ -3,7 +3,7 @@ commit = True message = Bump version {current_version} to {new_version} tag = False tag_name = {new_version} -current_version = 3.0.3 +current_version = 3.1.0 parse = (?P\d+)\.(?P\d+)\.(?P\d+)(\-(?P[a-z]+))? serialize = {major}.{minor}.{patch}-{release} diff --git a/.github/workflows/tests.yaml b/.github/workflows/tests.yaml new file mode 100644 index 0000000000..44c2aba30e --- /dev/null +++ b/.github/workflows/tests.yaml @@ -0,0 +1,23 @@ +name: CI tests + +on: [pull_request] + +jobs: + tests: + runs-on: ubuntu-latest + container: + image: reszelaz/sardana-test + options: -h sardana-test + steps: + - uses: actions/checkout@v2 + - name: Install sardana + run: python3 setup.py install + - name: Start servers + run: | + /usr/bin/supervisord + sleep 10 + supervisorctl start Pool + supervisorctl start MacroServer + - name: Run tests + run: xvfb-run -s '-screen 0 1920x1080x24' /bin/bash -c "pytest /usr/local/lib/python3.5/dist-packages/sardana-*.egg/sardana" + diff --git a/.gitlab-ci-alba.yml b/.gitlab-ci-alba.yml deleted file mode 100644 index 90f768f8bc..0000000000 --- a/.gitlab-ci-alba.yml +++ /dev/null @@ -1,8 +0,0 @@ -# This file is for configuring the CI/CD for creating (unofficial) -# debian packages for sardana at ALBA -# It has no efect unless you configure your gitlab instance to use it. -# TODO: generalise this so that it does not depend on ALBA's infrastructure - -include: -- https://git.cells.es/ctpkg/ci/ctpipeline/raw/master/ctjobdefs-ci.yml -- https://git.cells.es/ctpkg/ci/ctpipeline/raw/master/ctpipeline.yml diff --git a/.travis.yml b/.travis.yml index 00a476ccca..c3456c4a4e 100644 --- a/.travis.yml +++ b/.travis.yml @@ -16,8 +16,8 @@ env: - secure: "p/0UgVZzPKJQqcvQ/97qMgo9kPCE0cZ6vI+308YEJ2o9xj4a3FsfHCZ/vWtjdsrp1sQbtKVDesx+xmK4CLDzQeC2+Xskv8OZDjaG2jYkHcVosZEM3EGW8rLVKzoDWLr6cTy2wexLgjHPCsmrjukPs49/i5p+WU0no64YoLlZdp9TT+gvWSQJLIk6R4eqt4FHMszPybLv0pvb1SEiCzimlX1WM1pBrE0LHgchd2ZBYSUWTTwe+Koi4HCS4Bads8j20K2e3fFKcmR2u9DfmU+7Mf5HRJsj1LYJgBUF76lUG2/fZfpoDe8sWi+eUewTa3zNM4bhRLpV+pmG0ypplM4pIcdvwiHV03nGSGu6XK6OGQ/Mgsw0fmud4JR4f5g9DgEfERlyJKI4A9mPZQ327OmEwOOl33x2AFJAL05Qvm0yXCkf1dwgYXnZl44SQbAczY1NHFL90t6xbHtmTitJrE2Xb+4BLzMe3OOZj6j/0QeiXA4z1FnZr1s8UoAsm68iW194IuFg1RRG9FTISFWaBew5wzwvAJak0DxkpG0k43VkHiVC7sPHqr5CxXMXO/MuaptK2ti6iLK9xBAEUpO9HluOkeJq5WDIIxBiBS9tPi0i3vIpq87RjHkdw5n7pdIqnuJ1nXUjpWsuUyV3fLkY12fFxSbZgqmNhIE5/o9c5VP/69Y=" matrix: - - TEST="flake8" - - TEST="testsuite" DOCKER_IMG=reszelaz/sardana-test + # - TEST="flake8" + # - TEST="testsuite" DOCKER_IMG=reszelaz/sardana-test - TEST="doc" DOCKER_IMG=reszelaz/sardana-test @@ -53,3 +53,15 @@ script: # build docs - if [ $TEST == "doc" ]; then docker exec -t sardana-test /bin/bash -c "cd /sardana ; sphinx-build -W doc/source/ build/sphinx/html" ; fi - if [ $TEST == "doc" ]; then docker exec -t sardana-test /bin/bash -c "touch /sardana/build/sphinx/html/.nojekyll" ; fi + +deploy: + - provider: pages + local_dir: build/sphinx/html + repo: sardana-org/sardana-doc + skip_cleanup: true + github_token: $GITHUB_TOKEN # Set in the settings page of your repository, as a secure variable + keep_history: true + fqdn: sardana-controls.org # Set custom domain + on: + branch: develop + condition: "$TEST == doc" diff --git a/CHANGELOG.md b/CHANGELOG.md index 29c271e292..6cb2ee1b98 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,106 @@ All notable changes to this project will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org/). This file follows the formats and conventions from [keepachangelog.com] +## [3.1.0] 2021-05-17 + +### Added + +* _H5 write session_ to avoid file locking problems and to introduce SWMR mode support (#1124, #1457) + * `h5_start_session`, `h5_start_session_path`, `h5_end_session`, `h5_end_session_path` + and `h5_ls_session` macros + * `h5_write_session` context manager +* `shape` controller axis parameter (plugin), `shape` experimental channel + attribute (kernel) and `Shape` Tango attribute to the experimental channels + (#1296, #1466) +* *scan information* and *scan point* forms to the *showscan online* widget (#1386, #1477, #1479) +* `ScanPlotWidget`, `ScanPlotWindow`, `ScanInfoForm`, `ScanPointForm` and `ScanWindow` + widget classes for easier composition of custom GUIs involving online scan plotting (#1386) +* Handle `pre-move` and `post-move` hooks by: `mv`, `mvr`, `umv`, `umvr`, `br`, `ubr` (#1471, #1480) + * `motors` attribute to these macros which contains list of motors that will be moved + * `sardanacustomettings.PRE_POST_MOVE_HOOK_IN_MV` for disabling these hooks +* Include trigger/gate elements in the per-measurement preparation (#1432, #1443, #1468) + * Add `PrepareOne()` to TriggerGate controller. + * Call TriggerGate controller preparation methods in the _acquision action_ +* Add `ScanUser` environment variable (#1355) +* Support `PosFormat` _ViewOption_ in `umv` macro (#176, #1555) +* Allow to programmatically disable *deterministic scan* optimization (#1426, #1427) +* Initial delay in position domain to the synchronization description + in *ct* like continuous scans (#1428) +* Avoid double printing of user units in PMTV: read widget and units widget (#1424) +* Allowed hooks to macro description in Spock (#1523) +* Assert motor sign is -1 or 1 (#1345, #1507) +* _last macro_ concept to the `MacroExecutor` (kernel) #1559 +* Documentation on how to write 1D and 2D controllers (#1494) +* Mechanism to call `SardanaDevice.sardana_init_hook()` before entering in the server event loop (#674, #1545) +* Missing documentation of SEP18 concepts to how-to counter/timer controller (#995, #1492) +* Document how to properly deal with exceptions in macros in order to not interfer + with macro stopping/aborting (#1461) +* Documentation on how to start Tango servers on fixed IP - ORBendPoint (#1470) +* Documentation example on how to more efficiently access Tango with PyTango + in macros/controllers (#1456) +* "What's new?" section to docs (#1584) +* More clear installation instructions (#727, #1580) +* napoleon extension to the sphinx configuration (#1533) +* LICENSE file to python source distribution (#1490) + +### Changed + +* Experimental channel shape is now considered as a result of the configuration + and not part of the measurement group configuration (#1296, #1466) +* Use `LatestDeviceImpl` (currently `Device_5Impl`) for as a base class of the Sardana Tango + devices (#1214, #1301, #1531) +* Read experimental channel's `value` in serial mode to avoid involvement of a worker thread (#1512) +* Bump taurus requirement to >= 4.7.1.1 on Windows (#1583) + +### Removed + +* `shape` from the measurement group configuration and `expconf` (#1296, #1466) + +### Fixed + +* Subscribing to Pool's Elements attribute at Sardana server startup (#674, #1545) +* Execute per measurement preparation in `mesh` scan macro (#1437) +* Continously read value references in hardware synchronized acquisition + instead of reading only at the end (#1442, #1448) +* Ensure order of moveables is preserved in Motion object (#1505) +* Avoid problems when defining different, e.g. shape, standard attributes, + e.g. pseudo counter's value, in controllers (#1440, #1446) +* Storing string values in PreScanSnapshot in NXscanH5_FileRecorder (#1486) +* Storing string values as custom data in NXscanH5_FileRecorder (#1485) +* Stopping/aborting grouped movement when backlash correction would be applied (#1421, #1474, #1539) +* Storing string datasets with `h5py` > 3 (#1510) +* Fill parent_macro in case of executing XML hooks e.g. in sequencer (#1497) +* Remove redundant print of positions at the end of umv (#1526) +* Problems with macro id's when `sequencer` executes from _plain text_ files (#1215, #1216) +* `sequencer` loading of plain text sequences in spock syntax with macro functions (#1422) +* MacroServer crash at exit on Windows by avoiding the abort of the already finished macro (#1077, #1559) +* Allow running Spock without Qt bindings (#1462, #1463) +* Spock issues at startup on Windows (#536) +* Fix getting macroserver from remote door in Sardana-Taurus Door extension (#1506) +* MacroServer opening empty environment files used with dumb backend (#1425, #1514, #1517, #1520) +* Respect timer/monitor passed in measurement group configuration (#1516, #1521) +* Setting `Hookable.hooks` to empty list (#1522) +* `Macro.hasResult()` and `Macro.hasParams()` what avoids adding empty _Parameters_ and _Result_ + sections in the macro description in Spock (#1524) +* Apply position formatting (configured with `PosFormat` _view option_) + to the limits in the `wm` macro (#1529, #1530) +* Prompt in QtSpock when used with new versions of the `traitlets` package (#1566) +* Use equality instead of identity checks for numbers and strings (#1491) +* Docstring of QtSpockWidget (#1484) +* Recorders tests helpers (#1439) +* Disable flake8 job in travis CI (#1455) +* `createMacro()` and `prepareMacro()` docstring (#1460, #1444) +* Make write of MeasurementGroup (Taurus extension) integration time more robust (#1473) +* String formatting when rising exceptions in pseudomotors (#1469) +* h5storage tests so they pass on Windows and mark the `test_VDS` as xfail (#1562, #1563). +* Recorder test on Windows - use `os.pathsep` as recorder paths separator (#1556) +* Measurement group tango tests - wrong full name composition (#1557) +* Avoid crashes of certain combinations of tests on Windows at process exit (#1558) +* Skip execution of Pool's `DeleteElement` Tango command in tests for Windows in order to + avoid server crashes (#540, #1567) +* Skip QtSpock `test_get_value` test if qtconsole >= 4.4.0 (#1564) +* Increase timeout for QtSpock tests (#1568) + ## [3.0.3] 2020-09-18 ### Added @@ -947,7 +1047,7 @@ Main improvements since sardana 1.5.0 (aka Jan15): [keepachangelog.com]: http://keepachangelog.com -[Unreleased]: https://github.com/sardana-org/sardana/compare/3.0.3...HEAD +[3.1.0]: https://github.com/sardana-org/sardana/compare/3.1.0...3.0.3 [3.0.3]: https://github.com/sardana-org/sardana/compare/3.0.3...2.8.6 [2.8.6]: https://github.com/sardana-org/sardana/compare/2.8.6...2.8.5 [2.8.5]: https://github.com/sardana-org/sardana/compare/2.8.5...2.8.4 diff --git a/MANIFEST.in b/MANIFEST.in index 6f5eef71c1..8ca9272ff2 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -12,3 +12,4 @@ exclude .ropeproject exclude build_* include CHANGELOG.md +include LICENSE diff --git a/doc/source/_static/showscan-online-infopanels.png b/doc/source/_static/showscan-online-infopanels.png new file mode 100644 index 0000000000..8fb460471c Binary files /dev/null and b/doc/source/_static/showscan-online-infopanels.png differ diff --git a/doc/source/conf.py b/doc/source/conf.py index 9392b1c373..39e8d2c97a 100644 --- a/doc/source/conf.py +++ b/doc/source/conf.py @@ -77,6 +77,7 @@ def type_getattr(self, name): 'sardanaextension', 'ipython_console_highlighting', 'spock_console_highlighting', + 'sphinxcontrib.napoleon' ] try: diff --git a/doc/source/devel/api/api_controller.rst b/doc/source/devel/api/api_controller.rst index f77e55bff9..be81875ddf 100644 --- a/doc/source/devel/api/api_controller.rst +++ b/doc/source/devel/api/api_controller.rst @@ -13,6 +13,7 @@ Controller API reference * :class:`ZeroDController` - 0D controller API * :class:`PseudoMotorController` - PseudoMotor controller API * :class:`PseudoCounterController` - PseudoCounter controller API + * :class:`TriggerGateController` - Trigger/Gate controller API * :class:`IORegisterController` - IORegister controller API .. _sardana-controller-data-type: diff --git a/doc/source/devel/api/api_macro.rst b/doc/source/devel/api/api_macro.rst index 3ac6de1219..810ad1bff1 100644 --- a/doc/source/devel/api/api_macro.rst +++ b/doc/source/devel/api/api_macro.rst @@ -42,3 +42,23 @@ imacro decorator :members: :undoc-members: +StopException +------------- + +.. autoclass:: StopException + :members: + :undoc-members: + +AbortException +-------------- + +.. autoclass:: AbortException + :members: + :undoc-members: + +InterruptException +------------------ + +.. autoclass:: InterruptException + :members: + :undoc-members: diff --git a/doc/source/devel/api/sardana/macroserver/macros.rst b/doc/source/devel/api/sardana/macroserver/macros.rst index 5701f1f48f..546be9945f 100644 --- a/doc/source/devel/api/sardana/macroserver/macros.rst +++ b/doc/source/devel/api/sardana/macroserver/macros.rst @@ -16,6 +16,7 @@ env expconf expert + h5storage hkl ioregister lists diff --git a/doc/source/devel/api/sardana/macroserver/macros/h5storage.rst b/doc/source/devel/api/sardana/macroserver/macros/h5storage.rst new file mode 100644 index 0000000000..6e415dd394 --- /dev/null +++ b/doc/source/devel/api/sardana/macroserver/macros/h5storage.rst @@ -0,0 +1,6 @@ +:mod:`~sardana.macroserver.macros.h5storage` +============================================ + +.. automodule:: sardana.macroserver.macros.h5storage + :imported-members: + :members: \ No newline at end of file diff --git a/doc/source/devel/api/sardana/macroserver/scan.rst b/doc/source/devel/api/sardana/macroserver/scan.rst index 2a969b062e..0663819c11 100644 --- a/doc/source/devel/api/sardana/macroserver/scan.rst +++ b/doc/source/devel/api/sardana/macroserver/scan.rst @@ -26,8 +26,8 @@ GScan :show-inheritance: :members: -GScan ------ +Scan +---- .. inheritance-diagram:: SScan :parts: 1 diff --git a/doc/source/devel/api/sardana/pool/controller.rst b/doc/source/devel/api/sardana/pool/controller.rst index 4d0f9c79df..cef9637a52 100644 --- a/doc/source/devel/api/sardana/pool/controller.rst +++ b/doc/source/devel/api/sardana/pool/controller.rst @@ -25,6 +25,7 @@ :columns: 3 * :class:`Readable` + * :class:`Referable` * :class:`Startable` * :class:`Stopable` * :class:`Loadable` @@ -44,6 +45,7 @@ * :class:`OneDController` * :class:`TwoDController` * :class:`PseudoCounterController` + * :class:`TriggerGateController` * :class:`IORegisterController` @@ -58,6 +60,17 @@ Readable interface :members: :undoc-members: +Referable interface +------------------- + +.. inheritance-diagram:: Referable + :parts: 1 + +.. autoclass:: Referable + :show-inheritance: + :members: + :undoc-members: + Startable interface ------------------- @@ -216,6 +229,17 @@ Pseudo Counter Controller API :undoc-members: +Trigger/Gate Controller API +--------------------------- + +.. inheritance-diagram:: TriggerGateController + :parts: 1 + +.. autoclass:: TriggerGateController + :show-inheritance: + :members: + :undoc-members: + IO Register Controller API ---------------------------- diff --git a/doc/source/devel/api/sardana/taurus/core/tango/sardana.rst b/doc/source/devel/api/sardana/taurus/core/tango/sardana.rst index 9912a909b5..65e6b75b8e 100644 --- a/doc/source/devel/api/sardana/taurus/core/tango/sardana.rst +++ b/doc/source/devel/api/sardana/taurus/core/tango/sardana.rst @@ -22,6 +22,7 @@ pool macroserver + macro .. autofunction:: registerExtensions .. autofunction:: unregisterExtensions diff --git a/doc/source/devel/api/sardana/taurus/core/tango/sardana/macro.rst b/doc/source/devel/api/sardana/taurus/core/tango/sardana/macro.rst new file mode 100644 index 0000000000..9b14d3b524 --- /dev/null +++ b/doc/source/devel/api/sardana/taurus/core/tango/sardana/macro.rst @@ -0,0 +1,37 @@ +.. currentmodule:: sardana.taurus.core.tango.sardana.macro + + +:mod:`~sardana.taurus.core.tango.sardana.macro` +=============================================== + +.. automodule:: sardana.taurus.core.tango.sardana.macro + +.. rubric:: Classes + +.. hlist:: + :columns: 4 + + * :class:`Macro` + * :class:`MacroInfo` + +Macro +----- + +.. inheritance-diagram:: Macro + :parts: 1 + +.. autoclass:: Macro + :show-inheritance: + :members: + :undoc-members: + +MacroInfo +--------- + +.. inheritance-diagram:: MacroInfo + :parts: 1 + +.. autoclass:: MacroInfo + :show-inheritance: + :members: + :undoc-members: diff --git a/doc/source/devel/guide_migration/2to3.rst b/doc/source/devel/guide_migration/2to3.rst index 8e4f3939c3..2788143042 100644 --- a/doc/source/devel/guide_migration/2to3.rst +++ b/doc/source/devel/guide_migration/2to3.rst @@ -45,6 +45,10 @@ Sardana v3 was reduced by long time ago deprecated features. You can find a list of them together with the suggested substitutes in this `table `_. +For migrating the measurement group configurations (non-URI model names) you +can use the `upgrade_mntgrp.py `_ +script. + diff --git a/doc/source/devel/howto_controllers/howto_1dcontroller.rst b/doc/source/devel/howto_controllers/howto_1dcontroller.rst index 634654e76f..f044c39de5 100644 --- a/doc/source/devel/howto_controllers/howto_1dcontroller.rst +++ b/doc/source/devel/howto_controllers/howto_1dcontroller.rst @@ -1,16 +1,130 @@ .. currentmodule:: sardana.pool.controller -.. _sardana-1dcontroller-howto-basics: +.. _sardana-1dcontroller-howto: ============================ How to write a 1D controller ============================ -The basics ----------- +This chapter provides the necessary information to write a one dimensional (1D) +experimental channel controller in Sardana. + +.. contents:: Table of contents + :depth: 3 + :backlinks: entry + +.. _sardana-1dcontroller-general-guide: + +General guide +------------- + +:ref:`1D experimental channels ` +together with :ref:`2D experimental channels ` +and :ref:`counter/timers ` +belong to the same family of *timerable* experimental channels. + +To write a 1D controller class you can follow +the :ref:`sardana-countertimercontroller` guide keeping in mind +differences explained in continuation. + +.. _sardana-1dcontroller-general-guide-shape: + +Get 1D shape +~~~~~~~~~~~~ + +1D controller should provide a shape of the spectrum which will be produced by +acquisition. The shape can be either static e.g. defined by the detector's +sensor size or dynamic e.g. depending on the detector's (or an intermediate +control software layer e.g. `LImA`_) configuration like :term:`RoI` or binning. + +In any case you should provide the shape in the format of a one-element sequence +with the length of the spectrum using +the :meth:`~sardana.pool.controller.Controller.GetAxisPar` method. + +Here is an example of the possible implementation of +:meth:`~sardana.pool.controller.Controller.GetAxisPar`: + +.. code-block:: python + + class SpringfieldOneDController(TwoDController): + + def GetAxisPar(self, axis, par): + if par == "shape": + return self.springfield.getShape(axis) + +For backwards compatibility, in case of not implementing the ``shape`` axis +parameter, shape will be determined from the ``MaxDimSize`` of the ``Value`` +attribute, currently (4096,). + +.. _sardana-1dcontroller-differences-countertimer: + +Differences with counter/timer controller +----------------------------------------- + +Class definition +~~~~~~~~~~~~~~~~ + +:ref:`The basics of the counter/timer controller ` +chapter explains how to define the counter/timer controller class. +Here you need to simply inherit from the +`~sardana.pool.controller.OneDController` class: + +.. code-block:: python + :emphasize-lines: 3 + + from sardana.pool.controller import OneDController + + class SpringfieldOneDController(OneDController): + + def __init__(self, inst, props, *args, **kwargs): + super().__init__(inst, props, *args, **kwargs) + +.. _sardana-1dcontroller-getvalue: + +Get 1D value +~~~~~~~~~~~~ + +:ref:`Get counter value ` chapter +explains how to read a counter/timer value +using the :meth:`~sardana.pool.controller.Readable.ReadOne` method. +Here you need to implement the same method but its return value +must be a one-dimensional `numpy.array` (or eventually +a `~sardana.sardanavalue.SardanaValue` object) containing the spectrum instead +of a scalar value. + +.. _sardana-1dcontroller-getvalues: + +Get 1D values +~~~~~~~~~~~~~ + +:ref:`Get counter values ` +chapter explains how to read counter/timer values +using the :meth:`~sardana.pool.controller.Readable.ReadOne` method while +acquiring with external (hardware) synchronization. +Here you need to implement the same method but its return value +must be a sequence with one-dimensional `numpy.array` objects (or eventually +with :obj:`~sardana.sardanavalue.SardanaValue` objects) containing spectrums +instead of scalar values. + +Advanced topics +--------------- + +.. _sardana-1dcontroller-valuereferencing: + +Working with value referencing +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +1D experimental channels may produce significant arrays of data at high +frame rate. Reading this data and storing it using sardana +is not always optimal. `SEP2`_ introduced data saving duality, optionally, +leaving the data storage at the responsibility of the detector +(or an intermediate software layer e.g. `LImA`_). In this case sardana +just deals with the reference to the data. + +Please refer to :ref:`sardana-2dcontroller-valuereferencing` chapter from +:ref:`sardana-2dcontroller-howto` guide in order to implement this feature for 1D +controller. -.. todo:: document 1D controller howto - .. _ALBA: http://www.cells.es/ .. _ANKA: http://http://ankaweb.fzk.de/ .. _ELETTRA: http://http://www.elettra.trieste.it/ @@ -35,3 +149,5 @@ The basics .. _numpy: http://numpy.scipy.org/ .. _SPEC: http://www.certif.com/ .. _EPICS: http://www.aps.anl.gov/epics/ +.. _SEP2: http://www.sardana-controls.org/sep/?SEP2.md +.. _LImA: https://lima1.readthedocs.io/en/latest/ diff --git a/doc/source/devel/howto_controllers/howto_2dcontroller.rst b/doc/source/devel/howto_controllers/howto_2dcontroller.rst index bc73fceb67..fa6d42d80b 100644 --- a/doc/source/devel/howto_controllers/howto_2dcontroller.rst +++ b/doc/source/devel/howto_controllers/howto_2dcontroller.rst @@ -1,16 +1,221 @@ .. currentmodule:: sardana.pool.controller -.. _sardana-2dcontroller-howto-basics: +.. _sardana-2dcontroller-howto: ============================ How to write a 2D controller ============================ -The basics ----------- +This chapter provides the necessary information to write a two dimensional (2D) +experimental channel controller in Sardana. + +.. contents:: Table of contents + :depth: 3 + :backlinks: entry + +.. _sardana-2dcontroller-general-guide: + +General guide +------------- + +:ref:`2D experimental channels ` +together with :ref:`1D experimental channels ` +and :ref:`counter/timers ` +belong to the same family of *timerable* experimental channels. + +To write a 2D controller class you can follow +the :ref:`sardana-countertimercontroller` guide keeping in mind +differences explained in continuation. + +.. _sardana-2dcontroller-general-guide-shape: + +Get 2D shape +~~~~~~~~~~~~ + +2D controller should provide a shape of the image which will be produced by +acquisition. The shape can be either static e.g. defined by the detector's +sensor size or dynamic e.g. depending on the detector's (or an intermediate +control software layer e.g. `LImA`_) configuration like :term:`RoI` or binning. + +In any case you should provide the shape in the format of a two-element sequence +with horizontal and vertical dimensions using +the :meth:`~sardana.pool.controller.Controller.GetAxisPar` method. + +Here is an example of the possible implementation of +:meth:`~sardana.pool.controller.Controller.GetAxisPar`: + +.. code-block:: python + + class SpringfieldTwoDController(TwoDController): + + def GetAxisPar(self, axis, par): + if par == "shape": + return self.springfield.getShape(axis) + +For backwards compatibility, in case of not implementing the ``shape`` axis +parameter, shape will be determined frm the ``MaxDimSize`` of the ``Value`` +attribute, currently (4096, 4096). + +.. _sardana-2dcontroller-differences-countertimer: + +Differences with counter/timer controller +----------------------------------------- + +Class definition +~~~~~~~~~~~~~~~~ + +:ref:`The basics of the counter/timer controller ` +chapter explains how to define the counter/timer controller class. +Here you need to simply inherit from the +`~sardana.pool.controller.TwoDController` class: + +.. code-block:: python + :emphasize-lines: 3 + + from sardana.pool.controller import TwoDController + + class SpringfieldTwoDController(TwoDController): + + def __init__(self, inst, props, *args, **kwargs): + super().__init__(inst, props, *args, **kwargs) + +.. _sardana-2dcontroller-getvalue: + +Get 2D value +~~~~~~~~~~~~ + +:ref:`Get counter value ` chapter +explains how to read a counter/timer value +using the :meth:`~sardana.pool.controller.Readable.ReadOne` method. +Here you need to implement the same method but its return value +must be a two-dimensional `numpy.array` (or eventually +a `~sardana.sardanavalue.SardanaValue` object) containing an image instead +of a scalar value. + +.. _sardana-2dcontroller-getvalues: + +Get 2D values +~~~~~~~~~~~~~ + +:ref:`Get counter values ` +chapter explains how to read counter/timer values +using the :meth:`~sardana.pool.controller.Readable.ReadOne` method while +acquiring with external (hardware) synchronization. +Here you need to implement the same method but its return value +must be a sequence with two-dimensional `numpy.array` objects (or eventually +with :obj:`~sardana.sardanavalue.SardanaValue` objects) containing the images +instead of a scalar values. + +Advanced topics +--------------- + +.. _sardana-2dcontroller-valuereferencing: + +Working with value referencing +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +2D experimental channels may produce big arrays of data at high +frame rate. Reading this data and storing it using sardana +is not always optimal. `SEP2`_ introduced data saving duality, optionally, +leaving the data storage at the responsibility of the detector +(or an intermediate software layer e.g. `LImA`_). In this case sardana +just deals with the reference to the data. + +In order to announce the referencing capability the 2D controller must +additionally inherit from the `~sardana.pool.controller.Referable` class: + +.. code-block:: python + :emphasize-lines: 3 + + from sardana.pool.controller import TwoDController, Referable + + class SpringfieldTwoDController(TwoDController, Referable): + + def __init__(self, inst, props, *args, **kwargs): + super().__init__(inst, props, *args, **kwargs) + +.. _sardana-2dcontroller-getvaluereference: + +Get 2D value reference +"""""""""""""""""""""" + +To get the 2D value reference, sardana calls the +:meth:`~sardana.pool.controller.Referable.RefOne` method. This method +receives an axis as parameter and should return a URI (`str`) +pointing to the value. + +Here is an example of the possible implementation of +:meth:`~sardana.pool.controller.Referable.RefOne`: + +.. code-block:: python + :emphasize-lines: 3 + + class SpringfieldTwoDController(TwoDController): + + def RefOne(self, axis): + value_ref = self.springfield.getValueRef(axis) + return value_ref + +.. _sardana-2dcontroller-getvaluesreferences: + +Get 2D values references +"""""""""""""""""""""""" + +:ref:`Get counter values ` +chapter explains how to read counter/timer values +using the :meth:`~sardana.pool.controller.Readable.ReadOne` method while +acquiring with external (hardware) synchronization. +Here you need to implement the :meth:`~sardana.pool.controller.Referable.RefOne` +method and its return value must be a sequence with URIs (`str`) +pointing to the values. + +.. _sardana-2dcontroller-configvaluereference: + +Configure 2D value reference +"""""""""""""""""""""""""""" + +Two axis parameters: ``value_ref_pattern`` (`str`) +and ``value_ref_enabled`` (`bool`) are foreseen for configuring where to store +the values and whether to use the value referencing. Here you need to implement +the :meth:`~sardana.pool.controller.Controller.SetAxisPar` method. + +Here is an example of the possible implementation of +:meth:`~sardana.pool.controller.Controller.SetAxisPar`: + +.. code-block:: python + + class SpringfieldTwoDController(TwoDController): + + def SetAxisPar(self, axis, par, value): + if par == "value_ref_pattern": + self.springfield.setValueRefPattern(axis, value) + elif par == "value_ref_enabled": + self.springfield.setValueRefEnabled(axis, value) + +.. hint:: + Use `Python Format String Syntax `_ + e.g. ``file:///tmp/sample1_{index:02d}`` to configure a dynamic value + referencing using the acquisition index or any other parameter + (acquisition index can be reset in the + :ref:`per measurement preparation `. + phase) + +When value referencing is used +"""""""""""""""""""""""""""""" + +Sardana will :ref:`sardana-2dcontroller-getvaluereference` when: + + - channel has referencing capability and it is enabled + +Sardana will :ref:`sardana-2dcontroller-getvalue` when any of these +conditions applies: + + - channel does not have referencing capability + - channel has referencing capability but it is disabled + - there is a pseudo counter based on this channel + +Hence, in some configurations, both methods may be used simultaneously. -.. todo:: document 2D controller howto - .. _ALBA: http://www.cells.es/ .. _ANKA: http://http://ankaweb.fzk.de/ .. _ELETTRA: http://http://www.elettra.trieste.it/ @@ -35,3 +240,5 @@ The basics .. _numpy: http://numpy.scipy.org/ .. _SPEC: http://www.certif.com/ .. _EPICS: http://www.aps.anl.gov/epics/ +.. _SEP2: http://www.sardana-controls.org/sep/?SEP2.md +.. _LImA: https://lima1.readthedocs.io/en/latest/ diff --git a/doc/source/devel/howto_controllers/howto_countertimercontroller.rst b/doc/source/devel/howto_controllers/howto_countertimercontroller.rst index 6d4f751265..2631aef696 100644 --- a/doc/source/devel/howto_controllers/howto_countertimercontroller.rst +++ b/doc/source/devel/howto_controllers/howto_countertimercontroller.rst @@ -1,16 +1,19 @@ .. currentmodule:: sardana.pool.controller -.. _sardana-countertimercontroller-howto-basics: +.. _sardana-countertimercontroller: ======================================= How to write a counter/timer controller ======================================= -.. important:: - Counter/timer controller :term:`API` was extended in SEP18_ but this is - still not documented in this chapter. Please check the said SEP for more - information about the additional :term:`API` or eventual changes. +This chapter provides the necessary information to write a counter/timer +controller in Sardana. + +.. contents:: Table of contents + :depth: 3 + :backlinks: entry +.. _sardana-countertimercontroller-howto-basics: The basics ---------- @@ -216,10 +219,15 @@ Here is an example of the possible implementation of def AbortOne(self, axis): self.springfield.AbortChannel(axis) +.. _sardana-countertimercontroller-howto-advanced: + +Advanced topics +--------------- + .. _sardana-countertimercontroller-howto-timermonitor: Timer and monitor roles ------------------------ +~~~~~~~~~~~~~~~~~~~~~~~ Usually counters can work in either of two modes: timer or monitor. In both of them, one counter in a group is assigned a special role to control when @@ -234,11 +242,6 @@ parameter ``acquisition_mode``. Controller may announce its default timer axis with the :obj:`~sardana.pool.controller.Loadable.default_timer` class attribute. -.. _sardana-countertimercontroller-howto-advanced: - -Advanced topics ---------------- - .. _sardana-countertimercontroller-howto-timestamp-value: Timestamp a counter value @@ -330,7 +333,9 @@ implementation of all other start methods is optional and their default implementation does nothing (:meth:`~sardana.pool.controller.Startable.PreStartOne` actually returns ``True``). -So, actually, the algorithm for counter acquisition start in sardana is:: +So, actually, the algorithm for counter acquisition start in sardana is: + +.. code-block:: text /FOR/ Each controller(s) implied in the acquisition - Call PreStartAll() @@ -408,8 +413,10 @@ We can modify our counter controller to take profit of this hardware feature: def StartAll(self): self.springfield.startCounters(self._counters_info) -Hardware synchronization -~~~~~~~~~~~~~~~~~~~~~~~~ +.. _sardana-countertimercontroller-howto-external-synchronization: + +External (hardware) synchronization +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The synchronization achieved in :ref:`sardana-countertimercontroller-howto-mutliple-acquisition` may not be enough when it comes to acquiring with multiple controllers at the @@ -446,8 +453,10 @@ Here is an example of the possible implementation of SynchMap = { AcqSynch.SoftwareTrigger : 1, AcqSynch.SoftwareGate : 2, - AcqSynch.HardwareTrigger: 3, - AcqSynch.HardwareGate: 4 + AcqSynch.SoftwareStart : 3, + AcqSynch.HardwareTrigger: 4, + AcqSynch.HardwareGate: 5, + AcqSynch.HardwareStart: 6 } def SetCtrlPar(self, name, value): @@ -463,7 +472,7 @@ Multiple acquisitions It is a very common scenario to execute multiple hardware synchronized acquisitions in a row. One example of this type of measurements are the :ref:`sardana-users-scan-continuous`. The controller receives the number of -acquisitions via the third argument of the +acquisitions via the ``repetitions`` argument of the :meth:`~sardana.pool.controller.Loadable.LoadOne` method. Here is an example of the possible implementation of @@ -479,6 +488,62 @@ Here is an example of the possible implementation of self.springfield.SetRepetitions(repetitions) return value +In order to make the acquisition flow smoothly the synchronizer and +the counter/timer controllers needs to agree on the synchronization pace. +The counter/timer controller manifest what is the maximum allowed pace for him +by means of the ``latency_time`` controller parameter (in seconds). This parameter +corresponds to the minimum time necessary by the hardware controller to re-arm +for the next acquisition. + +Here is an example of the possible implementation of +:meth:`~sardana.pool.controller.Controller.GetCtrlPar`: + +.. code-block:: python + :emphasize-lines: 3 + + class SpringfieldCounterTimerController(CounterTimerController): + + def GetCtrlPar(self, name): + if name == "latency_time": + return self.springfield.GetLatencyTime() + +.. warning:: + By default, the `~sardana.pool.controller.CounterTimerController` + base classes return zero latency time controller parameter. + If in your controller you override + the :meth:`~sardana.pool.controller.Controller.GetCtrlPar` method + remember to always call the super class method as fallback: + + .. code-block:: python + :emphasize-lines: 5 + + def GetCtrlPar(self, name): + if name == "some_par": + return "some_val" + else: + return super().GetCtrlPar(name) + + +In the case of the :attr:`~sardana.pool.pooldefs.AcqSynch.HardwareStart` or +:attr:`~sardana.pool.pooldefs.AcqSynch.SoftwareStart` synchronizations +the counter/timer hardware *auto* triggers itself during the measurement process. +In order to fully configure the hardware and set the re-trigger pace you can +use the ``latency`` argument (in seconds) +of the :meth:`~sardana.pool.controller.Loadable.LoadOne` method: + +.. code-block:: python + :emphasize-lines: 3 + + class SpringfieldCounterTimerController(CounterTimerController): + + def LoadOne(self, axis, value, repetitions, latency): + self.springfield.LoadChannel(axis, value) + self.springfield.SetRepetitions(repetitions) + self.springfield.SetLatency(latency) + return value + +.. _sardana-countertimercontroller-howto-external-synchronization-get-values: + Get counter values """""""""""""""""" @@ -501,13 +566,42 @@ can be: :attr:`~sardana.pool.pooldefs.AcqSynch.SoftwareGate` synchronization - a sequence of counter values: either :class:`float` or :obj:`~sardana.sardanavalue.SardanaValue` - in case of the :attr:`~sardana.pool.pooldefs.AcqSynch.HardwareTrigger` or - :attr:`~sardana.pool.pooldefs.AcqSynch.HardwareGate` synchronization + in case of the :attr:`~sardana.pool.pooldefs.AcqSynch.HardwareTrigger`, + :attr:`~sardana.pool.pooldefs.AcqSynch.HardwareGate`, + :attr:`~sardana.pool.pooldefs.AcqSynch.HardwareStart` or + :attr:`~sardana.pool.pooldefs.AcqSynch.SoftwareStart` + synchronization Sardana assumes that the counter values are returned in the order of acquisition and that there are no gaps in between them. -.. todo:: document how to skip the readouts while acquiring +.. _sardana-countertimercontroller-per-measurement-preparation: + +Per measurement preparation +~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Since SEP18_ counter/timer controllers may take a profit from the per measurement +preparation and reserve resources for a sequence of +:attr:`~sardana.pool.pooldefs.AcqSynch.SoftwareTrigger` +or :attr:`~sardana.pool.pooldefs.AcqSynch.SoftwareGate` acquisitions +already in the :meth:`~sardana.pool.controller.Loadable.PrepareOne` method. +This method is called only once at the beginning of the measurement e.g. +:ref:`Deterministic step scans ` +or :ref:`sardana-users-scan-continuous`. +It enables an opportunity for significant dead time optimization thanks to the +single per measurement configuration instead of the multiple per acquisition +preparation using the :meth:`~sardana.pool.controller.Loadable.LoadOne`. + +Here is an example of the possible implementation of +:meth:`~sardana.pool.controller.Loadable.PrepareOne`: + +.. code-block:: python + :emphasize-lines: 3 + + class SpringfieldCounterTimerController(CounterTimerController): + + def PrepareOne(self, value, repetitions, latency, nb_starts): + return self.springfield.SetNbStarts() .. _ALBA: http://www.cells.es/ diff --git a/doc/source/devel/howto_controllers/howto_pseudocountercontroller.rst b/doc/source/devel/howto_controllers/howto_pseudocountercontroller.rst index cf08f43da5..1a55a4b862 100644 --- a/doc/source/devel/howto_controllers/howto_pseudocountercontroller.rst +++ b/doc/source/devel/howto_controllers/howto_pseudocountercontroller.rst @@ -73,6 +73,8 @@ negative. The value close to the zero indicates the beam centered in the middle. Similarly behaves the horizontal pseudo counter. The total pseudo counter is the mean value of all the four sensors and indicates the beam intensity. +.. _sardana-pseudocountercontroller-howto-changing-interface: + Changing default interface -------------------------- @@ -80,23 +82,48 @@ Pseudo counters instantiated from your controller will have a default interface, which among others, comprises the *value* attribute. This attribute is feed with the result of the :meth:`~sardana.pool.controller.PseudoCounterController.calc` method and by -default it expects values of ``float`` type and scalar shape. You can easily +default it expects values of ``float`` type and scalar format. You can easily :ref:`change the default interface `. -This way you could program a pseudo counter to obtain an image :term:`ROI` +This way you could program a pseudo counter to obtain an image :term:`RoI` of a :ref:`2D experimental channel `. -Here is an example of how to change *value* attribute's shape to an image +Here is an example of how to change *value* attribute's format to an image and specify its maximum dimension of 1024 x 1024 pixels: .. code-block:: python - def GetAxisAttributes(self, axis): + def GetAxisAttributes(self, axis): axis_attrs = PseudoCounterController.GetAxisAttributes(self, axis) axis_attrs = dict(axis_attrs) axis_attrs['Value'][Type] = ((float, ), ) axis_attrs['Value'][MaxDimSize] = (1024, 1024) return axis_attrs +Get pseudo counter shape +------------------------ + +If you change the pseudo counter format to spectrum or image then you +controller should provide the shape of the calculation result in either +of the formats: + +- one-element sequence with the length of the spectrum +- two-element sequence with the horizontal and vertical dimensions of the image + +using the :meth:`~sardana.pool.controller.Controller.GetAxisPar` method. + +Here is an example of the possible implementation of +:meth:`~sardana.pool.controller.Controller.GetAxisPar`: + +.. code-block:: python + + def GetAxisPar(self, axis, par): + if par == "shape": + return [1024, 1024] + + +For backwards compatibility, in case of not implementing the ``shape`` axis +parameter, shape will be determined from the ``MaxDimSize`` of the ``Value`` +attribute as defined in :ref:`sardana-pseudocountercontroller-howto-changing-interface`. Including external variables in the calculation ----------------------------------------------- diff --git a/doc/source/devel/howto_controllers/howto_triggergatecontroller.rst b/doc/source/devel/howto_controllers/howto_triggergatecontroller.rst index c1516526f8..0b89a2e1c1 100644 --- a/doc/source/devel/howto_controllers/howto_triggergatecontroller.rst +++ b/doc/source/devel/howto_controllers/howto_triggergatecontroller.rst @@ -89,6 +89,18 @@ The state should be a member of :obj:`~sardana.sardanadefs.State` (For backward compatibility reasons, it is also supported to return one of :class:`PyTango.DevState`). The status could be any string. +.. _sardana-TriggerGateController-howto-prepare: + +Prepare for measurement +~~~~~~~~~~~~~~~~~~~~~~~ + +To prepare a trigger for a measurement you can use the +:meth:`~sardana.pool.controller.TriggerGateController.PrepareOne` method which +receives as an argument the number of starts of the whole measurement. +This information may be used to prepare the hardware for generating +multiple events (triggers or gates) in a complex measurement +e.g. :ref:`sardana-macros-scanframework-determscan`. + .. _sardana-TriggerGateController-howto-load: Load synchronization description diff --git a/doc/source/devel/howto_macros/macros_general.rst b/doc/source/devel/howto_macros/macros_general.rst index f8e1cb08c7..07cda863ed 100644 --- a/doc/source/devel/howto_macros/macros_general.rst +++ b/doc/source/devel/howto_macros/macros_general.rst @@ -13,6 +13,10 @@ Writing macros This chapter provides the necessary information to write macros in sardana. The complete macro :term:`API` can be found :ref:`here `. +.. contents:: Table of contents + :depth: 3 + :backlinks: entry + What is a macro --------------- @@ -866,6 +870,55 @@ of user's interruption you must override the withing the :meth:`~sardana.macroserver.macro.Macro.on_stop` or :meth:`~sardana.macroserver.macro.Macro.on_abort`. +.. _sardana-macro-exception-handling: + +Handling exceptions +------------------- + +Please refer to the +`Python Errors and Exceptions `_ +documentation on how to deal with exceptions in your macro code. + +.. important:: + :ref:`sardana-macro-handling-macro-stop-and-abort` is internally implemented + using Python exceptions. So, your ``except`` clause can not simply catch any + exception type without re-raising it - this would ignore the macro stop/abort + request done in the ``try ... except`` block. If you still would like to + use the broad catching, you need to catch and raise the stop/abort exception + first: + + .. code-block:: python + :emphasize-lines: 7 + + import time + + from sardana.macroserver.macro import macro, StopException + + @macro() + def exception_macro(self): + self.output("Starting stoppable process") + try: + for i in range(10): + self.output("In iteration: {}".format(i)) + time.sleep(1) + except StopException: + raise + except Exception: + self.warning("Exception, but we continue") + self.output("After 'try ... except' block") + + If you do not program lines 12-13 and you stop your macro within + the ``try ... except`` block then the macro will continue and print the + output from line 16. + + You may choose to catch and re-raise: + `~sardana.macroserver.macro.StopException`, + `~sardana.macroserver.macro.AbortException` or + `~sardana.macroserver.macro.InterruptException`. The last one will + take care of stopping and aborting at the same time. + + + .. _sardana-macro-adding-hooks-support: Adding hooks support @@ -965,6 +1018,36 @@ simplified usage you should use Taurus. If you strive for very optimal access to Tango and don't need these benefits then most probably PyTango will work better for you. +.. hint:: + If you go for PyTango and wonder if creating a new `tango.DeviceProxy` + in frequent macro executions is inefficient from the I/O point of view you + should not worry about it cause Tango (more precisely CORBA) is taking + care about recycling the connection during a period of 120 s (default). + + If you still would like to optimize your code in order to avoid creation + of a new `tango.DeviceProxy` you may consider using the + `functools.lru_cache` as a singleton cache mechanism:: + + import functools + import tango + from sardana.macroserver.macro import macro + + Device = functools.lru_cache(maxsize=1024)(tango.DeviceProxy) + + @macro() + def switch_states(self): + """Switch TangoTest device state""" + proxy = Device('sys/tg_test/1') + proxy.SwitchStates() + + Here you don't need to worry about the opened connection to the + Tango device server in case you don't execute the macro for a while. + Again, Tango (more precisely CORBA) will take care about it. + See more details about the CORBA scavanger thread in: + `Tango client threading `_ + and `CORBA idle connection shutdown `_. + + .. _sardana-macro-using-external-libraries: Using external python libraries diff --git a/doc/source/devel/howto_macros/scan_framework.rst b/doc/source/devel/howto_macros/scan_framework.rst index 23a2a5db7d..43567fac30 100644 --- a/doc/source/devel/howto_macros/scan_framework.rst +++ b/doc/source/devel/howto_macros/scan_framework.rst @@ -195,6 +195,7 @@ the most basic features of a continuous scan:: :: (with more elaborated waypoint generator), see the code of :class:`~sardana.macroserver.macros.scan.meshc` +.. _sardana-macros-scanframework-determscan: Deterministic scans ------------------- diff --git a/doc/source/devel/howto_recorders.rst b/doc/source/devel/howto_recorders.rst index 0b7c2d3748..053c1fd587 100644 --- a/doc/source/devel/howto_recorders.rst +++ b/doc/source/devel/howto_recorders.rst @@ -22,28 +22,6 @@ element which is also identified by its name. Recorders are developed as Python classes, and recorder libraries are just Python modules aggregating these classes. -Type of recorders ------------------ - -Sardana defines some standard recorders e.g. the Spock output recorder or the -SPEC file recorder. From the other hand users may define their custom recorders. -Sardana provides the following standard recorders (grouped by types): - -* file [*] - * FIO_FileRecorder - * NXscan_FileRecorder - * SPEC_FileRecorder - -* shared memory [*] - * SPSRecorder - * ShmRecorder - -* output - * JsonRecorder [*] - * OutputRecorder - -[*] Scan Framework provides mechanisms to enable and select this recorders using -the environment variables. Writing a custom recorder ------------------------- diff --git a/doc/source/docs.rst b/doc/source/docs.rst index b5ca06a091..f1f14e7003 100644 --- a/doc/source/docs.rst +++ b/doc/source/docs.rst @@ -17,6 +17,7 @@ scientific installations. users/index devel/index sep/index.rst + What's new? Glossary other_versions diff --git a/doc/source/glossary.rst b/doc/source/glossary.rst index 3e34bf868b..186604e130 100644 --- a/doc/source/glossary.rst +++ b/doc/source/glossary.rst @@ -430,8 +430,8 @@ Glossary dial See :term:`dial position` - ROI - *Region of interest* are samples within a data set identified for a + RoI + *Region of Interest* are samples within a data set identified for a particular purpose. .. _plug-in: http://en.wikipedia.org/wiki/Plug-in_(computing) diff --git a/doc/source/news.rst b/doc/source/news.rst new file mode 100644 index 0000000000..97bef3f18d --- /dev/null +++ b/doc/source/news.rst @@ -0,0 +1,99 @@ +########### +What's new? +########### + +Below you will find the most relevant news that brings the Sardana releases. +For a complete list of changes consult the Sardana `CHANGELOG.md \ +`_ file. + +************************** +What's new in Sardana 3.1? +************************** + +Date: 2021-05-17 (*Jan21* milestone) + +Type: biannual stable release + +It is backwards compatible and comes with new features, changes and bug fixes. + +.. note:: + + This release, in comparison to the previous ones, brings significant + user experience improvements when used on Windows. + +Added +===== + +- *HDF5 write session*, in order to avoid the file locking problems and to introduce + the SWMR mode support. It enables safe introspection e.g.: using data + analysis tools like PyMCA or silx, custom scripts, etc. of the scan data files + written in the `HDF5 data format `_ + while scanning. + You can control the session using e.g.: + `~sardana.macroserver.macros.h5storage.h5_start_session` and + `~sardana.macroserver.macros.h5storage.h5_end_session` macros + or the `~sardana.macroserver.macros.h5storage.h5_write_session` + context manager. + More information in the :ref:`NXscanH5_FileRecorder documentation \ + ` +- *scan information* and *scan point* forms to the *showscan online* widget. + See example in the :ref:`showscan online screenshot \ + `. +- Handle `pre-move` and `post-move` hooks by: `mv`, `mvr`, `umv`, `umvr`, + `br` and `ubr` macros. + You may use `~sardana.sardanacustomsettings.PRE_POST_MOVE_HOOK_IN_MV` + for disabling these hooks. +- Include trigger/gate (synchronizer) elements in the per-measurement preparation. + This enables possible dead time optimization in hardware synchronized step scans. + More information in the :ref:`How to write a trigger/gate controller documentation \ + `. +- :ref:`scanuser` environment variable. +- Support to `PosFormat` :ref:`ViewOption ` in `umv` macro. +- Avoid double printing of user units in :ref:`pmtv`: read widget and + units widget. +- Print of allowed :ref:`sardana-macros-hooks` when :ref:`sardana-spock-gettinghelp` + on macros in Spock. +- Documentation: + + - :ref:`sardana-1dcontroller-howto` and :ref:`sardana-2dcontroller-howto` + - :ref:`sardana-countertimercontroller` now contains the `SEP18 \ + `_ concepts. + - Properly :ref:`sardana-macro-exception-handling` in macros in order + to not interfere with macro stopping/aborting + - :ref:`faq_how_to_access_tango_from_macros_and_controllers` + - Update :ref:`Installation instructions ` + +Changed +======= + +- Experimental channel's shape is now considered as a result of the configuration + e.g. RoI, binning, etc. and not part of the measurement group configuration: + + - Added :ref:`shape controller axis parameter (plugin) `, + `shape` experimental channel attribute (kernel) + and `Shape` Tango attribute to the experimental channels + - **Removed** the *shape* column from the measurement group's configuration panel + in :ref:`expconf_ui`. + +Fixed +===== + +- Sardana server (standalone) startup is more robust. +- Storing string values in *datasets*, *pre-scan snapshot* and *custom data* + in :ref:`sardana-users-scan-data-storage-nxscanh5_filerecorder`. +- Stopping/aborting grouped movement when backlash correction would be applied. +- Randomly swapping target positions in grouped motion when moveables proceed + from various Device Pool's. +- Enables possible dead time optimization in `mesh` scan macro by executing + :ref:`per measurement preparation `. +- Continuously read experimental channel's value references in hardware + synchronized acquisition instead of reading only once at the end. +- Problems when :ref:`sardana-controller-howto-change-default-interface` of standard attributes + in controllers e.g. shape of the pseudo counter's Value attribute. +- :ref:`sequencer_ui` related bugs: + + * Fill Macro's `parent_macro` in case of executing XML hooks in sequencer + * Problems with macro id's when executing sequences loaded from *plain text* files with spock syntax + * Loading of sequences using macro functions from *plain text* files with spock syntax +- Apply position formatting (configured with `PosFormat` + :ref:`ViewOption `) to the limits in the `wm` macro. diff --git a/doc/source/users/adding_elements.rst b/doc/source/users/adding_elements.rst index 198d42732b..21353ee9f4 100644 --- a/doc/source/users/adding_elements.rst +++ b/doc/source/users/adding_elements.rst @@ -7,7 +7,8 @@ Adding real elements For the sake of demonstration, let's suppose you want to integrate a slit with IcePAP-based motors into Sardana. -Before doing anything else you should check the `controller plugin register `_. +Before doing anything else you should check the +`Sardana plugins catalogue `_. There's a high chance that somebody already wrote the plugin for your hardware. If not, you can :ref:`write the plugin yourself `. diff --git a/doc/source/users/configuration/server.rst b/doc/source/users/configuration/server.rst index f7cf79fe0e..6859fd8f6f 100644 --- a/doc/source/users/configuration/server.rst +++ b/doc/source/users/configuration/server.rst @@ -7,25 +7,30 @@ Sardana system can :ref:`run as one or many Tango device servers`. Tango device servers listens on a TCP port for the CORBA requests. Usually it is fine to use the randomly assigned port (default behavior) but sometimes -it may be necessary to use a fixed port number. For example, when the server -needs to be accessed from another isolated network and we want to open -connections only for the given ports. +it may be necessary to use a fixed port number or even IP address. +For example, when the server needs to be accessed from another isolated +network and we want to open connections only for the given ports or IPs. -There are three possibilities to assign the port explicitly (the order -indicates the precedence): +There are three possibilities to assign the IP and/or port in format of the +ORBendPoint explicitly (the order indicates the precedence): + +.. note:: + The ORBendPoint is in the following format: ``giop:tcp::`` + and both IP and port are optional, so you could only fix the IP, + only fix the port, fix both of them or none of them. - using OS environment variable ``ORBendPoint`` e.g. .. code-block:: bash - $ export ORBendPoint=28366 - $ Pool demo1 -ORBendPoint 28366 + $ export ORBendPoint=giop:tcp:192.168.0.100:28366 + $ Pool demo1 - using Tango device server command line argument ``-ORBendPoint`` .. code-block:: bash - $ Pool demo1 -ORBendPoint 28366 + $ Pool demo1 -ORBendPoint giop:tcp:192.168.0.100:28366 - using Tango DB free property with object name: ``ORBendPoint`` and property name: ``/``) @@ -34,7 +39,7 @@ indicates the precedence): import tango db = tango.Database() - db.put_property("ORBendPoint", {"Pool/demo1": 28366}) + db.put_property("ORBendPoint", {"Pool/demo1": "giop:tcp:192.168.0.100:28366"}) .. note:: diff --git a/doc/source/users/environment_variable_catalog.rst b/doc/source/users/environment_variable_catalog.rst index e66214594d..3ab08eaf15 100644 --- a/doc/source/users/environment_variable_catalog.rst +++ b/doc/source/users/environment_variable_catalog.rst @@ -300,6 +300,17 @@ be used). Recorder class is implicitly selected based on the file extension. For example "myexperiment.spec" will by default store data in SPEC compatible format. +.. _scanh5swmr: + +ScanH5SWMR +~~~~~~~~~~ + +*Not mandatory, set by user* + +Enable/disable HDF5 SWMR mode when using HDF5 *write sessions* with +:ref:`sardana-users-scan-data-storage-nxscanh5_filerecorder`. + + .. _scanrecorder: ScanRecorder @@ -308,7 +319,7 @@ ScanRecorder Its value may be either of type string or of list of strings. If ScanRecorder variable is defined, it explicitly indicates which recorder -class should be used and for which file defined by ScanFile (based on the +class should be used and for which file defined by ScanFile (based on the order). Example 1: @@ -381,6 +392,17 @@ For example:: 'min': 2.9802322387695312e-08, 'minpos': 0.0}}} +.. _scanuser: + +ScanUser +~~~~~~~~ +*Not mandatory, set by user* + +Its value is of type string. Its value is delivered to the recorders which +may use it, for example, as a user contact information. If not set, the OS +user executing the Sardana server (which executes the scan) will be passed to +the recorders instead. + .. _sharedmemory: SharedMemory diff --git a/doc/source/users/faq.rst b/doc/source/users/faq.rst index 221d85564d..77f69a8cc5 100644 --- a/doc/source/users/faq.rst +++ b/doc/source/users/faq.rst @@ -92,6 +92,8 @@ write Sardana controllers and pseudo controllers can be found This documentation also includes the :term:`API` which can be used to interface to the specific hardware item. +.. _faq_how_to_access_tango_from_macros_and_controllers: + How to access Tango from within macros or controllers -------------------------------------------------------------------------------- In your macros and controllers almost certainly you will need to access Tango diff --git a/doc/source/users/getting_started/installing.rst b/doc/source/users/getting_started/installing.rst index 6e2108a799..2201c05a91 100644 --- a/doc/source/users/getting_started/installing.rst +++ b/doc/source/users/getting_started/installing.rst @@ -5,8 +5,8 @@ Installing ========== -Installing with pip [1]_ (platform-independent) --------------------------------------------------------- +Installing with pip (platform-independent) +------------------------------------------ Sardana can be installed using pip. The following command will automatically download and install the latest release of Sardana (see @@ -18,86 +18,53 @@ You can test the installation by running:: python3 -c "import sardana; print(sardana.Release.version)" +Note: Installing sardana with pip3 on Linux requires building PyTango (one of +the sardana's dependencies). You could use :ref:`sardana-getting-started-installing-in-conda` +to avoid this. If you decide to continue with pip3, please refer to +`PyTango's installation guide `_. +On Debian this should work to prepare the build environment:: -Installing from PyPI manually [2]_ (platform-independent) ---------------------------------------------------------- - -You may alternatively install from a downloaded release package: - -#. Download the latest release of Sardana from http://pypi.python.org/pypi/sardana -#. Extract the downloaded source into a temporary directory and change to it -#. run:: - - python3 setup.py install - -You can test the installation by running:: - - python3 -c "import sardana; print(sardana.Release.version)" + apt-get install pkg-config libboost-python-dev libtango-dev Linux (Debian-based) -------------------- -Since v1.4, Sardana is part of the official repositories of Debian (and Ubuntu +Sardana is part of the official repositories of Debian (and Ubuntu and other Debian-based distros). You can install it and all its dependencies by doing (as root):: - aptitude install python-sardana - -You can test the installation by running:: - - python3 -c "import sardana; print(sardana.Release.version)" - -(see more detailed instructions in `this step-by-step howto -`__) - + apt-get install python3-sardana -Windows -------- +Note: `python3-sardana` package is available starting from the Debian 11 +(Bullseye) release. For previous releases you can use `python-sardana` +(compatible with Python 2 only). -#. Download the latest windows binary from https://github.com/sardana-org/sardana/releases -#. Run the installation executable -#. test the installation:: +.. _sardana-getting-started-installing-in-conda: - C:\Python35\python3 -c "import sardana; print(sardana.Release.version)" - -Windows installation shortcut -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -This chapter provides a quick shortcut to all windows packages which are -necessary to run Sardana on your windows machine +Installing in a conda environment (platform-independent) +-------------------------------------------------------- -#. Install all dependencies: +In a conda environment (we recommend creating one specifically for sardana):: - #. Download and install latest `PyTango`_ from `PyTango downdoad page `_ - #. Download and install latest `Taurus`_ from `Taurus downdoad page `_ - #. Download and install latest `lxml`_ from `lxml downdoad page `_ - #. Download and install latest itango from `itango download page `_ + conda install -c conda-forge sardana -#. Finally download and install latest Sardana from `Sardana downdoad page `_ +Note: for Windows, until PyTango is available on conda-forge, you may need to use +`pip3 install pytango` for installing it. -========================= -Working directly from Git -========================= +Working from Git source directly (in develop mode) +-------------------------------------------------- If you intend to do changes to Sardana itself, or want to try the latest developments, it is convenient to work directly from the git source in "develop" (aka "editable") mode, so that you do not need to re-install -on each change. - -You can clone sardana from the main git repository:: - - git clone https://github.com/sardana-org/sardana.git sardana - -Then, to work in editable mode, just do:: - - pip3 install -e ./sardana +on each change:: -Note that you can also fork the git repository in github to get your own -github-hosted clone of the sardana repository to which you will have full -access. This will create a new git repository associated to your personal account in -github, so that your changes can be easily shared and eventually merged -into the official repository. + # optional: if using a conda environment, pre-install dependencies with: + conda install --only-deps -c conda-forge sardana + # install sardana in develop mode + git clone https://github.com/sardana-org/sardana.git + pip3 install -e ./sardana # <-- Note the -e !! .. _dependencies: @@ -105,49 +72,33 @@ into the official repository. Dependencies ============ -Sardana has dependencies on some python libraries: +Sardana depends on PyTango_, Taurus_, lxml_, itango_ and click_. +However some Sardana features require additional dependencies. For example: -- Sardana uses Tango as the middleware so you need PyTango_ 9.2.5 or later - installed. You can check it by doing:: +- Using the Sardana Qt_ widgets, requires either PyQt_ (v4 or v5) + or PySide_ (v1 or v2). - python3 -c 'import tango; print(tango.__version__)' +- The macro plotting feature requires matplotlib_ -- Sardana clients are developed with Taurus so you need Taurus_ 4.5.4 or later - installed. You can check it by doing:: +- The showscan online widget requires pyqtgraph_ - python3 -c 'import taurus; print(taurus.Release.version)' +- The showscan offline widget requires PyMca5_. -- Sardana operate some data in the XML format and requires lxml_ library 2.3 or - later. You can check it by doing:: +- The HDF5 NeXus recorder requires h5py_ - python3 -c 'import lxml.etree; print(lxml.etree.LXML_VERSION)' +- The sardana editor widget requires spyder_. -- spock (Sardana CLI) requires itango 0.1.6 or later [3]_. - -.. rubric:: Footnotes - -.. [1] This command requires super user previledges on linux systems. If your - user has them you can usually prefix the command with *sudo*: - ``sudo pip3 -U sardana``. Alternatively, if you don't have - administrator previledges, you can install locally in your user - directory with: ``pip3 --user sardana`` - In this case the executables are located at /.local/bin. Make - sure the PATH is pointing there or you execute from there. - -.. [2] *setup.py install* requires user previledges on linux systems. If your - user has them you can usually prefix the command with *sudo*: - ``sudo python3 setup.py install``. Alternatively, if you don't have - administrator previledges, you can install locally in your user directory - with: ``python3 setup.py install --user`` - In this case the executables are located at /.local/bin. Make - sure the PATH is pointing there or you execute from there. - -.. [3] PyTango < 9 is compatible with itango >= 0.0.1 and < 0.1.0, - while higher versions with itango >= 0.1.6. - -.. _lxml: http://lxml.de -.. _SardanaPypi: http://pypi.python.org/pypi/sardana/ -.. _Tango: http://www.tango-controls.org/ .. _PyTango: http://pytango.readthedocs.io/ .. _Taurus: http://www.taurus-scada.org/ +.. _lxml: http://lxml.de +.. _itango: https://pytango.readthedocs.io/en/stable/itango.html +.. _click: https://pypi.org/project/click/ +.. _Qt: http://qt.nokia.com/products/ +.. _PyQt: http://www.riverbankcomputing.co.uk/software/pyqt/ +.. _PySide: https://wiki.qt.io/Qt_for_Python/ +.. _matplotlib: https://matplotlib.org/ +.. _pyqtgraph: http://www.pyqtgraph.org/ +.. _PyMca5: http://pymca.sourceforge.net/ +.. _h5py: https://www.h5py.org/ +.. _spyder: http://pythonhosted.org/spyder/ \ No newline at end of file diff --git a/doc/source/users/overview.rst b/doc/source/users/overview.rst index ac5e88907c..54df2bfe3b 100644 --- a/doc/source/users/overview.rst +++ b/doc/source/users/overview.rst @@ -7,7 +7,11 @@ Overview Sardana is the control program initially developed at ALBA_. Our mission statement: - `Produce a modular, high performance, robust, and generic user environment for control applications in large and small installations. Make Sardana the generic user environment distributed in the Tango project and the standard basis of collaborations in control.` + Produce a modular, high performance, robust, and generic user environment + for control applications in large and small installations. + Make Sardana the generic user environment distributed in the Tango project + and the standard basis of collaborations in control. + Up to now, control applications in large installations have been notoriously difficult to share. Inspired by the success of the Tango_ collaboration, ALBA_ diff --git a/doc/source/users/scan.rst b/doc/source/users/scan.rst index 29c7236c12..adcb0b8f89 100644 --- a/doc/source/users/scan.rst +++ b/doc/source/users/scan.rst @@ -187,6 +187,69 @@ Scans are highly configurable using the environment variables Variables, check the :ref:`Environment Variable Catalog ` +.. _sardana-users-scan-data-storage: + +Data storage +------------ + +Data being produced by scans can be optionally handled by *recorders* and +sent to a variety of destinations. Typical use case is to store the scan data +in a file. + +Built-in recorders +^^^^^^^^^^^^^^^^^^ + +Sardana defines some standard recorders e.g. the Spock output recorder or the +SPEC file recorder. From the other hand users may define their custom recorders. +Sardana provides the following standard recorders (grouped by types): + +* file [*] + * FIO_FileRecorder + * NXscanH5_FileRecorder + * SPEC_FileRecorder + +* shared memory [*] + * SPSRecorder + * ShmRecorder + +* output + * JsonRecorder [*] + * OutputRecorder + +[*] Scan Framework provides mechanisms to enable and select this recorders +using the environment variables. + +.. _sardana-users-scan-data-storage-nxscanh5_filerecorder: + +NXscanH5_FileRecorder +""""""""""""""""""""" + +NXscanH5_FileRecorder is a scan recorder which writes the scan data according +to the NXscan `NeXus `_ application definition +in the `HDF5 `_ file format. + +Sardana scan recorders are instantiated per scan execution and therefore this +recorder opens and closes the HDF5 file for writing when the scan starts +and ends respectively. This may cause file locking issues with reading +applications opened in between the scans. To overcome this issue +the *write session* concept, with optional support of SWMR mode, +was introduced for this particular recorder. + +The write sessions use case scenarios: + +* Manual session control with macros + To start and end the session you can use + `~sardana.macroserver.macros.h5storage.h5_start_session` / + `~sardana.macroserver.macros.h5storage.h5_start_session_path` and + `~sardana.macroserver.macros.h5storage.h5_end_session` / + `~sardana.macroserver.macros.h5storage.h5_end_session_path` macros. + You can list the active sessions with + `~sardana.macroserver.macros.h5storage.h5_ls_session` macro. +* Programmatic session control with context manager (for macro developers) + You can use the `~sardana.macroserver.macros.h5storage.h5_write_session` + context manager to ensure that the write session is only active over a + specific part of your macro code. + .. _sardana-users-scan-snapshot: Scan snapshots diff --git a/doc/source/users/spock.rst b/doc/source/users/spock.rst index 13652d1125..72abfbc6d6 100644 --- a/doc/source/users/spock.rst +++ b/doc/source/users/spock.rst @@ -231,6 +231,8 @@ Exiting spock To exit spock type :kbd:`Control+d` or :samp:`exit()` inside a spock console. +.. _sardana-spock-gettinghelp: + Getting help ------------ @@ -479,6 +481,8 @@ Example accesing scan data:
+.. _sardana-spock-viewoptions: + Changing appearance with View Options ------------------------------------- diff --git a/doc/source/users/standard_macro_catalog.rst b/doc/source/users/standard_macro_catalog.rst index bd9f1e2731..b88289b125 100644 --- a/doc/source/users/standard_macro_catalog.rst +++ b/doc/source/users/standard_macro_catalog.rst @@ -224,3 +224,8 @@ scan related macros * :class:`~sardana.macroserver.macros.standard.where` * :class:`~sardana.macroserver.macros.standard.pic` * :class:`~sardana.macroserver.macros.standard.cen` + * :class:`~sardana.macroserver.macros.h5storage.h5_ls_session` + * :class:`~sardana.macroserver.macros.h5storage.h5_start_session` + * :class:`~sardana.macroserver.macros.h5storage.h5_start_session_path` + * :class:`~sardana.macroserver.macros.h5storage.h5_end_session` + * :class:`~sardana.macroserver.macros.h5storage.h5_end_session_path` diff --git a/doc/source/users/taurus/experimentconfiguration.rst b/doc/source/users/taurus/experimentconfiguration.rst index 25fe0a7308..0c82b245a7 100644 --- a/doc/source/users/taurus/experimentconfiguration.rst +++ b/doc/source/users/taurus/experimentconfiguration.rst @@ -75,7 +75,6 @@ a given channel or its controller: process. * output - whether the channel acquisition results should be printed, for example, by the output recorder during the scan. Can be either True or False. -* shape - shape of the data * data type - type of the data * plot type - select the online scan plot type for the channel. Can have one of the following values: diff --git a/doc/source/users/taurus/poolchanneltv.rst b/doc/source/users/taurus/poolchanneltv.rst index 848c042238..8e3c7c139c 100644 --- a/doc/source/users/taurus/poolchanneltv.rst +++ b/doc/source/users/taurus/poolchanneltv.rst @@ -1,3 +1,5 @@ +.. _pctv: + PoolChannelTV User’s Interface ------------------------------ diff --git a/doc/source/users/taurus/poolmotortv.rst b/doc/source/users/taurus/poolmotortv.rst index 6a7d7ef772..9aeecf70ca 100644 --- a/doc/source/users/taurus/poolmotortv.rst +++ b/doc/source/users/taurus/poolmotortv.rst @@ -1,3 +1,5 @@ +.. _pmtv: + PoolMotorTV User’s Interface ----------------------------- diff --git a/doc/source/users/taurus/qtspock.rst b/doc/source/users/taurus/qtspock.rst index c5579cd2bc..d4690b8302 100644 --- a/doc/source/users/taurus/qtspock.rst +++ b/doc/source/users/taurus/qtspock.rst @@ -20,7 +20,7 @@ as a standalone application .. code-block:: console - python3 -m sardana.taurua.qt.qtgui.extran_sardana.qtspock + python3 -m sardana.taurus.qt.qtgui.extra_sardana.qtspock or embedded in the :ref:`taurusgui_ui`: (when :ref:`panelcreation` use: `sardana.taurus.qt.qtgui.extra_sardana.qtspock` module and diff --git a/doc/source/users/taurus/showscan.rst b/doc/source/users/taurus/showscan.rst index df040ed9e4..1556278968 100644 --- a/doc/source/users/taurus/showscan.rst +++ b/doc/source/users/taurus/showscan.rst @@ -48,6 +48,17 @@ plot per curve or group curves by the selected x axis Showscan online plotting three physical counters against the motor's position on separate plots. +Finally, the *scan point* and the *scan information* panels are available +and offer online updates on the channel values of the current scan point +and some general scan information e.g. scan file, start and end time, etc. +respectively. + +.. _showscan-online-infopanels-figure: + +.. figure:: /_static/showscan-online-infopanels.png + + Showscan online plotting with separate plots and information panels. + ---------------- Showscan offline ---------------- diff --git a/scripts/upgrade/upgrade_mntgrp.py b/scripts/upgrade/upgrade_mntgrp.py new file mode 100644 index 0000000000..1154520e03 --- /dev/null +++ b/scripts/upgrade/upgrade_mntgrp.py @@ -0,0 +1,106 @@ +""" This serves to upgrade MeasurementGroups from Sardana 2 to Sardana 3: + +To get usage help: python3 upgrade_mntgrp.py --help +""" + +import re +import sys +try: + import argparse +except ImportError: + from taurus.external import argparse +try: + from itertools import zip_longest +except ImportError: + from itertools import izip_longest as zip_longest + +import tango +import taurus +from sardana.taurus.core.tango.sardana import registerExtensions + + +def grouper(iterable, n, fillvalue=None): + """Collect data into fixed-length chunks or blocks""" + # grouper('ABCDEFG', 3, 'x') --> ABC DEF Gxx" + args = [iter(iterable)] * n + return zip_longest(*args, fillvalue=fillvalue) + + +def replace_tango_db(tango_db_pqdn, tango_db_fqdn, s): + # first step: pqdn -> fqdn + new_s = re.sub(tango_db_pqdn, tango_db_fqdn, s) + # second step: add missing scheme + new_s = re.sub("(?=9.2.5', 'itango>=0.1.6', 'taurus>=4.7.0', + 'taurus>=4.7.1.1 ; platform_system=="Windows"', 'lxml>=2.3', 'click', ] @@ -72,9 +73,6 @@ def get_release_info(): "Sardana = sardana.tango:main", "sardanatestsuite = sardana.test.testsuite:main", "spock = sardana.spock:main", -] - -gui_scripts = [ "diffractometeralignment = sardana.taurus.qt.qtgui.extra_hkl.diffractometeralignment:main", "hklscan = sardana.taurus.qt.qtgui.extra_hkl.hklscan:main", "macroexecutor = sardana.taurus.qt.qtgui.extra_macroexecutor.macroexecutor:main", @@ -89,7 +87,6 @@ def get_release_info(): entry_points = { 'console_scripts': console_scripts, - 'gui_scripts': gui_scripts, 'taurus.form.item_factories': form_factories, } diff --git a/src/sardana/macroserver/macro.py b/src/sardana/macroserver/macro.py index 728ef8a85a..5179c4a598 100644 --- a/src/sardana/macroserver/macro.py +++ b/src/sardana/macroserver/macro.py @@ -33,7 +33,8 @@ __all__ = ["OverloadPrint", "PauseEvent", "Hookable", "ExecMacroHook", "MacroFinder", "Macro", "macro", "iMacro", "imacro", "MacroFunc", "Type", "Table", "List", "ViewOption", - "LibraryError", "Optional"] + "LibraryError", "Optional", "StopException", "AbortException", + "InterruptException"] __docformat__ = 'restructuredtext' @@ -60,7 +61,7 @@ from sardana.macroserver.msparameter import Type, ParamType, Optional from sardana.macroserver.msexception import StopException, AbortException, \ ReleaseException, MacroWrongParameterType, UnknownEnv, UnknownMacro, \ - LibraryError + LibraryError, InterruptException from sardana.macroserver.msoptions import ViewOption from sardana.taurus.core.tango.sardana.pool import PoolElement @@ -256,17 +257,19 @@ def hooks(self, hooks): contains the hooks that don't provide hints """ - if not isinstance(hooks, list): - self.error( - 'the hooks must be passed as a list>') - return - if len(self.hooks) > 0: msg = ("This macro defines its own hooks. Previously defined " "hooks, including the general ones, would be only called " "if these own hooks were added using the appendHook " "method or appended to the self.hooks.") self.warning(msg) + self._setHooks(hooks) + + def _setHooks(self, hooks): + if not isinstance(hooks, list): + self.error( + 'the hooks must be passed as a list>') + return # store self._hooks, making sure it is of type: # list> self._hooks = [] @@ -282,6 +285,8 @@ def hooks(self, hooks): # delete _hookHintsDict to force its recreation on the next access if hasattr(self, '_hookHintsDict'): del self._hookHintsDict + if len(self._hooks) == 0: + return # create _hookHintsDict self._getHookHintsDict()['_ALL_'] = list(zip(*self._hooks))[0] nohints = self._hookHintsDict['_NOHINTS_'] @@ -387,13 +392,24 @@ def my_macro1(self): def where_moveable(self, moveable): self.output("Moveable %s is at %s", moveable.getName(), moveable.getPosition())""" + param_def = [] + result_def = [] + env = () + hints = {} + interactive = False + def __init__(self, param_def=None, result_def=None, env=None, hints=None, interactive=None): - self.param_def = param_def - self.result_def = result_def - self.env = env - self.hints = hints - self.interactive = interactive + if param_def is not None: + self.param_def = param_def + if result_def is not None: + self.result_def = result_def + if env is not None: + self.env = env + if hints is not None: + self.hints = hints + if interactive is not None: + self.interactive = interactive def __call__(self, fn): fn.macro_data = {} @@ -526,6 +542,8 @@ def __init__(self, *args, **kwargs): self._id = kwargs.get('id') self._desc = "Macro '%s'" % self._macro_line self._macro_status = {'id': self._id, + 'name': self._name, + 'macro_line': self._macro_line, 'range': (0.0, 100.0), 'state': 'start', 'step': 0.0} @@ -1121,35 +1139,35 @@ def createMacro(self, *pars): Several different parameter formats are supported:: # several parameters: - self.execMacro('ascan', 'th', '0', '100', '10', '1.0') - self.execMacro('mv', [[motor.getName(), '0']]) - self.execMacro('mv', motor.getName(), '0') # backwards compatibility - see note - self.execMacro('ascan', 'th', 0, 100, 10, 1.0) - self.execMacro('mv', [[motor.getName(), 0]]) - self.execMacro('mv', motor.getName(), 0) # backwards compatibility - see note + self.createMacro('ascan', 'th', '0', '100', '10', '1.0') + self.createMacro('mv', [[motor.getName(), '0']]) + self.createMacro('mv', motor.getName(), '0') # backwards compatibility - see note + self.createMacro('ascan', 'th', 0, 100, 10, 1.0) + self.createMacro('mv', [[motor.getName(), 0]]) + self.createMacro('mv', motor.getName(), 0) # backwards compatibility - see note th = self.getObj('th') - self.execMacro('ascan', th, 0, 100, 10, 1.0) - self.execMacro('mv', [[th, 0]]) - self.execMacro('mv', th, 0) # backwards compatibility - see note + self.createMacro('ascan', th, 0, 100, 10, 1.0) + self.createMacro('mv', [[th, 0]]) + self.createMacro('mv', th, 0) # backwards compatibility - see note # a sequence of parameters: - self.execMacro(['ascan', 'th', '0', '100', '10', '1.0') - self.execMacro(['mv', [[motor.getName(), '0']]]) - self.execMacro(['mv', motor.getName(), '0']) # backwards compatibility - see note - self.execMacro(('ascan', 'th', 0, 100, 10, 1.0)) - self.execMacro(['mv', [[motor.getName(), 0]]]) - self.execMacro(['mv', motor.getName(), 0]) # backwards compatibility - see note + self.createMacro(['ascan', 'th', '0', '100', '10', '1.0']) + self.createMacro(['mv', [[motor.getName(), '0']]]) + self.createMacro(['mv', motor.getName(), '0']) # backwards compatibility - see note + self.createMacro(('ascan', 'th', 0, 100, 10, 1.0)) + self.createMacro(['mv', [[motor.getName(), 0]]]) + self.createMacro(['mv', motor.getName(), 0]) # backwards compatibility - see note th = self.getObj('th') - self.execMacro(['ascan', th, 0, 100, 10, 1.0]) - self.execMacro(['mv', [[th, 0]]]) - self.execMacro(['mv', th, 0]) # backwards compatibility - see note + self.createMacro(['ascan', th, 0, 100, 10, 1.0]) + self.createMacro(['mv', [[th, 0]]]) + self.createMacro(['mv', th, 0]) # backwards compatibility - see note # a space separated string of parameters (this is not compatible # with multiple or nested repeat parameters, furthermore the repeat # parameter must be the last one): - self.execMacro('ascan th 0 100 10 1.0') - self.execMacro('mv %s 0' % motor.getName()) + self.createMacro('ascan th 0 100 10 1.0') + self.createMacro('mv %s 0' % motor.getName()) .. note:: From Sardana 2.0 the repeat parameter values must be passed as lists of items. An item of a repeat parameter containing more @@ -1192,34 +1210,34 @@ def prepareMacro(self, *args, **kwargs): Several different parameter formats are supported:: # several parameters: - self.execMacro('ascan', 'th', '0', '100', '10', '1.0') - self.execMacro('mv', [[motor.getName(), '0']]) - self.execMacro('mv', motor.getName(), '0') # backwards compatibility - see note - self.execMacro('ascan', 'th', 0, 100, 10, 1.0) - self.execMacro('mv', [[motor.getName(), 0]]) - self.execMacro('mv', motor.getName(), 0) # backwards compatibility - see note + self.prepareMacro('ascan', 'th', '0', '100', '10', '1.0') + self.prepareMacro('mv', [[motor.getName(), '0']]) + self.prepareMacro('mv', motor.getName(), '0') # backwards compatibility - see note + self.prepareMacro('ascan', 'th', 0, 100, 10, 1.0) + self.prepareMacro('mv', [[motor.getName(), 0]]) + self.prepareMacro('mv', motor.getName(), 0) # backwards compatibility - see note th = self.getObj('th') - self.execMacro('ascan', th, 0, 100, 10, 1.0) - self.execMacro('mv', [[th, 0]]) - self.execMacro('mv', th, 0) # backwards compatibility - see note + self.prepareMacro('ascan', th, 0, 100, 10, 1.0) + self.prepareMacro('mv', [[th, 0]]) + self.prepareMacro('mv', th, 0) # backwards compatibility - see note # a sequence of parameters: - self.execMacro(['ascan', 'th', '0', '100', '10', '1.0']) - self.execMacro(['mv', [[motor.getName(), '0']]]) - self.execMacro(['mv', motor.getName(), '0']) # backwards compatibility - see note - self.execMacro(('ascan', 'th', 0, 100, 10, 1.0)) - self.execMacro(['mv', [[motor.getName(), 0]]]) - self.execMacro(['mv', motor.getName(), 0]) # backwards compatibility - see note + self.prepareMacro(['ascan', 'th', '0', '100', '10', '1.0']) + self.prepareMacro(['mv', [[motor.getName(), '0']]]) + self.prepareMacro(['mv', motor.getName(), '0']) # backwards compatibility - see note + self.prepareMacro(('ascan', 'th', 0, 100, 10, 1.0)) + self.prepareMacro(['mv', [[motor.getName(), 0]]]) + self.prepareMacro(['mv', motor.getName(), 0]) # backwards compatibility - see note th = self.getObj('th') - self.execMacro(['ascan', th, 0, 100, 10, 1.0]) - self.execMacro(['mv', [[th, 0]]]) - self.execMacro(['mv', th, 0]) # backwards compatibility - see note + self.prepareMacro(['ascan', th, 0, 100, 10, 1.0]) + self.prepareMacro(['mv', [[th, 0]]]) + self.prepareMacro(['mv', th, 0]) # backwards compatibility - see note # a space separated string of parameters (this is not compatible # with multiple or nested repeat parameters, furthermore the repeat # parameter must be the last one): - self.execMacro('ascan th 0 100 10 1.0') - self.execMacro('mv %s 0' % motor.getName()) + self.prepareMacro('ascan th 0 100 10 1.0') + self.prepareMacro('mv %s 0' % motor.getName()) .. note:: From Sardana 2.0 the repeat parameter values must be passed as lists of items. An item of a repeat parameter containing more @@ -1766,17 +1784,24 @@ def getInstrument(self, name): # Handle macro environment #-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- + def _getEnv(self, key=None, macro_name=None, door_name=None): + door_name = door_name or self.getDoorName() + macro_name = macro_name or self._name + + return self.macro_server.get_env(key=key, macro_name=macro_name, + door_name=door_name) + @mAPI def getEnv(self, key=None, macro_name=None, door_name=None): """**Macro API**. Gets the local environment matching the given parameters: - - door_name and macro_name define the context where to look for - the environment. If both are None, the global environment is - used. If door name is None but macro name not, the given macro - environment is used and so on... - - If key is None it returns the complete environment, otherwise - key must be a string containing the environment variable name. + - door_name and macro_name define the context where to look for + the environment. If both are None, the global environment is + used. If door name is None but macro name not, the given macro + environment is used and so on... + - If key is None it returns the complete environment, otherwise + key must be a string containing the environment variable name. :raises: UnknownEnv @@ -1794,11 +1819,7 @@ def getEnv(self, key=None, macro_name=None, door_name=None): :return: a :obj:`dict` containing the environment :rtype: :obj:`dict`""" - door_name = door_name or self.getDoorName() - macro_name = macro_name or self._name - - return self.macro_server.get_env(key=key, macro_name=macro_name, - door_name=door_name) + return self._getEnv(key=key, macro_name=macro_name, door_name=door_name) @mAPI def getGlobalEnv(self): @@ -2322,6 +2343,12 @@ def exec_(self): # make sure a 0.0 progress is sent yield macro_status + # Avoid repeating same information on subsequent events. If, in the + # future, clients that connect in the middle of macro execution need + # this information, just simply remove the lines below + del macro_status['name'] + del macro_status['macro_line'] + # allow any macro to be paused at the beginning of its execution self.pausePoint() diff --git a/src/sardana/macroserver/macros/demo.py b/src/sardana/macroserver/macros/demo.py index afc591891f..9aaecf2a48 100644 --- a/src/sardana/macroserver/macros/demo.py +++ b/src/sardana/macroserver/macros/demo.py @@ -226,15 +226,6 @@ def sar_demo(self): self.print("DONE!") -@macro([["motor", Type.Moveable, None, '']]) -def mym2(self, pm): - self.output(pm.getMotorNames()) - elements = list(map(self.getMoveable, pm.elements)) - self.output(elements) - self.output(type(pm)) - self.output(type(elements[0])) - - @macro() def clear_sar_demo_hkl(self): """Undoes changes done with sar_demo""" diff --git a/src/sardana/macroserver/macros/env.py b/src/sardana/macroserver/macros/env.py index e267ae432a..cdae90f1f6 100644 --- a/src/sardana/macroserver/macros/env.py +++ b/src/sardana/macroserver/macros/env.py @@ -86,7 +86,7 @@ class setvo(Macro): - **ShowDial**: used by macro wm, pwm and wa. Default value ``False`` - **ShowCtrlAxis**: used by macro wm, pwm and wa. Default value ``False`` - - **PosFormat**: used by macro wm, pwm and wa. Default value ``-1`` + - **PosFormat**: used by macro wm, pwm, wa and umv. Default value ``-1`` - **OutputBlock**: used by scan macros. Default value ``False`` - **DescriptionLength**: used by lsdef. Default value ``60`` @@ -113,7 +113,7 @@ class usetvo(Macro): - **ShowDial**: used by macro wm, pwm and wa. Default value ``False`` - **ShowCtrlAxis**: used by macro wm, pwm and wa. Default value ``False`` - - **PosFormat**: used by macro wm, pwm and wa. Default value ``-1`` + - **PosFormat**: used by macro wm, pwm, wa and umv. Default value ``-1`` - **OutputBlock**: used by scan macros. Default value ``False`` - **DescriptionLength**: used by lsdef. Default value ``60`` diff --git a/src/sardana/macroserver/macros/h5storage.py b/src/sardana/macroserver/macros/h5storage.py new file mode 100644 index 0000000000..6dfdcde376 --- /dev/null +++ b/src/sardana/macroserver/macros/h5storage.py @@ -0,0 +1,186 @@ +############################################################################## +## +# This file is part of Sardana +## +# http://www.sardana-controls.org/ +## +# Copyright 2011 CELLS / ALBA Synchrotron, Bellaterra, Spain +## +# Sardana is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +## +# Sardana is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +## +# You should have received a copy of the GNU Lesser General Public License +# along with Sardana. If not, see . +## +############################################################################## + +"""HDF5 storage macros""" +import os +import contextlib + +from sardana.sardanautils import is_non_str_seq +from sardana.macroserver.macro import macro, Type, Optional +from sardana.macroserver.msexception import UnknownEnv +from sardana.macroserver.recorders.h5storage import NXscanH5_FileRecorder +from sardana.macroserver.recorders.h5util import _h5_file_handler + + +def _get_h5_scan_files(macro): + scan_dir = macro._getEnv("ScanDir") + scan_files = macro._getEnv("ScanFile") + if not is_non_str_seq(scan_files): + scan_files = [scan_files] + h5_scan_files = [] + for scan_file in scan_files: + file_name, file_ext = os.path.splitext(scan_file) + if file_ext not in NXscanH5_FileRecorder.formats.values(): + continue + h5_scan_files.append(os.path.join(scan_dir, scan_file)) + return h5_scan_files + + +def _h5_start_session(macro, path=None, swmr_mode=None): + if path is None: + paths = _get_h5_scan_files(macro) + else: + paths = [path] + if swmr_mode is None: + try: + swmr_mode = macro._getEnv("ScanH5SWMR") + except UnknownEnv: + swmr_mode = False + for file_path in paths: + fd = _h5_file_handler.open_file(file_path, swmr_mode) + macro.print("H5 session open for '{}'".format(file_path)) + macro.print("\t SWMR mode: {}".format(swmr_mode)) + macro.print("\t HDF5 version compatibility: {}".format(fd.libver)) + + +@macro([["swmr_mode", Type.Boolean, Optional, "Enable SWMR mode"]]) +def h5_start_session(self, swmr_mode): + """Start write session for HDF5 scan file(s) + + Open HDF5 scan files in write mode and keep them for the needs of + recorders until the session is closed by ``h5_end_session``. + + The session file path is obtained by inspecting ScanDir and ScanFile + environment variables. If you want to use a different file path, use + ``h5_start_session_path`` + + Optionally, enable SWMR mode (either with ``swmr_mode`` parameter or + with ``ScanH5SWMR`` environment variable) + """ + sessions = _h5_file_handler.files + if sessions: + self.print("Session(s) already started. Can be ended with: ") + for p in sessions: + self.print("\th5_end_session_path " + p ) + self.print("") + _h5_start_session(self, None, swmr_mode) + + +@macro([["path", Type.String, None, + "File name for which the session should be started"], + ["swmr_mode", Type.Boolean, Optional, "Enable SWMR mode"]]) +def h5_start_session_path(self, path, swmr_mode): + """Start write session for HDF5 file path + + Open HDF5 files in write mode and keep them for the needs of + recorders until the session is closed by ``h5_end_session``. + + Optionally, enable SWMR mode (either with ``swmr_mode`` parameter or + with ``ScanH5SWMR`` environment variable) + """ + sessions = _h5_file_handler.files + if sessions: + self.print("Session(s) already started. Can be ended with: ") + for p in sessions: + self.print("\th5_end_session_path " + p) + self.print("") + _h5_start_session(self, path, swmr_mode) + + +def _h5_end_session(macro, path=None): + if path is None: + paths = _get_h5_scan_files(macro) + else: + paths = [path] + for file_path in paths: + _h5_file_handler.close_file(file_path) + + +@macro() +def h5_end_session(self): + """End write session for HDF5 scan file(s) + + Close previously opened HDF5 scan files with the use ``h5_start_session`` + or ``h5_start_session_path``. + + The session file path is obtained by inspecting ScanDir and ScanFile + environment variables. If you want to close a different file path, use + ``h5_end_session_path`` + """ + _h5_end_session(self, path=None) + + +@macro([["path", Type.String, Optional, + "File name for which the session should be ended"]]) +def h5_end_session_path(self, path): + """End write session for HDF5 file path + + Close previously opened HDF5 scan files with the use ``h5_start_session`` + or ``h5_start_session_path``. + """ + _h5_end_session(self, path) + + +@macro() +def h5_ls_session(self): + """List scan files opened for write session with ``h5_start_session`` + """ + for file_path in _h5_file_handler.files: + self.print(file_path) + + +@contextlib.contextmanager +def h5_write_session(macro, path=None, swmr_mode=False): + """Context manager for HDF5 file write session. + + Maintains HDF5 file opened for the context lifetime. + Optionally, open the file as SWMR writer. + + Resolve configured H5 scan file names by inspecting ScanDir and ScanFile + environment variables. + + Example of macro executing multiple scans within the same write session:: + + @macro() + def experiment(self): + with h5_write_session(macro=self, swmr_mode=True): + for i in range(10) + self.execMacro("ascan", "mot01", 0, 10, 10, 0.1) + + :param macro: macro object + :type macro: `~sardana.macroserver.macro.Macro` + :param path: file path (or None to use ScanDir and ScanFile) + :type path: str + :param swmr_mode: Use SWMR write mode + :type swmr_mode: bool + """ + _h5_start_session(macro, path, swmr_mode) + try: + yield None + finally: + _h5_end_session(macro, path) + + + + + diff --git a/src/sardana/macroserver/macros/hkl.py b/src/sardana/macroserver/macros/hkl.py index 1f08299ade..45e24b0ecb 100644 --- a/src/sardana/macroserver/macros/hkl.py +++ b/src/sardana/macroserver/macros/hkl.py @@ -48,7 +48,7 @@ import numpy as np from sardana.sardanautils import py2_round -from sardana.macroserver.macro import Macro, iMacro, Type +from sardana.macroserver.macro import Hookable, Macro, iMacro, Type from sardana.macroserver.macros.scan import aNscan from sardana.macroserver.msexception import UnknownEnv @@ -120,10 +120,9 @@ def prepare(self): self.type = v self.angle_device_names = {} - i = 0 - for motor in motor_list: + + for i, motor in enumerate(motor_list): self.angle_device_names[self.angle_names[i]] = motor.split(' ')[0] - i = i + 1 # TODO: it should not be necessary to implement on_stop methods in the # macros in order to stop the moveables. Macro API should provide this kind @@ -197,13 +196,14 @@ def fl(self, ch, if mat: return regx.sub(repl, ch) -class br(Macro, _diffrac): +class br(Macro, _diffrac, Hookable): """Move the diffractometer to the reciprocal space coordinates given by H, K and L. If a fourth parameter is given, the combination of angles to be set is the correspondig to the given index. The index of the angles combinations are then changed.""" + hints = {'allowsHooks': ('pre-move', 'post-move')} param_def = [ ['H', Type.String, None, "H value"], ['K', Type.String, None, "K value"], @@ -217,6 +217,9 @@ class br(Macro, _diffrac): def prepare(self, H, K, L, AnglesIndex, FlagNotBlocking, FlagPrinting): _diffrac.prepare(self) + self.motors = [] + for motor_name in self.angle_device_names.values(): + self.motors.append(self.getMotor(motor_name)) def run(self, H, K, L, AnglesIndex, FlagNotBlocking, FlagPrinting): h_idx = 0 @@ -259,7 +262,9 @@ def run(self, H, K, L, AnglesIndex, FlagNotBlocking, FlagPrinting): cmd = cmd + " " + str(angle) if FlagPrinting == 1: cmd = "u" + cmd - self.execMacro(cmd) + mv, _ = self.createMacro(cmd) + mv._setHooks(self.hooks) + self.runMacro(mv) else: for name, angle in zip(self.angle_names, angles_list): angle_dev = self.getObj(self.angle_device_names[name]) @@ -269,11 +274,11 @@ def run(self, H, K, L, AnglesIndex, FlagNotBlocking, FlagPrinting): hkl_values[l_idx], self.diffrac.WaveLength]) -class ubr(Macro, _diffrac): +class ubr(Macro, _diffrac, Hookable): """Move the diffractometer to the reciprocal space coordinates given by H, K and L und update. """ - + hints = {'allowsHooks': ('pre-move', 'post-move')} param_def = [ ["hh", Type.String, "Not set", "H position"], ["kk", Type.String, "Not set", "K position"], @@ -283,10 +288,15 @@ class ubr(Macro, _diffrac): def prepare(self, hh, kk, ll, AnglesIndex): _diffrac.prepare(self) + self.motors = [] + for motor_name in self.angle_device_names.values(): + self.motors.append(self.getMotor(motor_name)) def run(self, hh, kk, ll, AnglesIndex): if ll != "Not set": - self.execMacro("br", hh, kk, ll, AnglesIndex, 0, 1) + br, _ = self.prepareMacro("br", hh, kk, ll, AnglesIndex, 0, 1) + br._setHooks(self.hooks) + self.runMacro(br) else: self.output("usage: ubr H K L [Trajectory]") diff --git a/src/sardana/macroserver/macros/lists.py b/src/sardana/macroserver/macros/lists.py index e137453bff..33ae623299 100644 --- a/src/sardana/macroserver/macros/lists.py +++ b/src/sardana/macroserver/macros/lists.py @@ -143,7 +143,7 @@ def obj2Row(self, o, cols=None): def run(self, filter): objs = self.objs(filter) nb = len(objs) - if nb is 0: + if nb == 0: if self.subtype is Macro.All: if isinstance(self.type, str): t = self.type.lower() diff --git a/src/sardana/macroserver/macros/scan.py b/src/sardana/macroserver/macros/scan.py index 57e9aa22fa..0f48477711 100644 --- a/src/sardana/macroserver/macros/scan.py +++ b/src/sardana/macroserver/macros/scan.py @@ -709,6 +709,7 @@ def prepare(self, m1, m1_start_pos, m1_final_pos, m1_nr_interv, self.starts = numpy.array([m1_start_pos, m2_start_pos], dtype='d') self.finals = numpy.array([m1_final_pos, m2_final_pos], dtype='d') self.nr_intervs = numpy.array([m1_nr_interv, m2_nr_interv], dtype='i') + self.nb_points = (m1_nr_interv + 1) * (m2_nr_interv + 1) self.integ_time = integ_time self.bidirectional_mode = bidirectional diff --git a/src/sardana/macroserver/macros/standard.py b/src/sardana/macroserver/macros/standard.py index 7be0178ebd..990bc62012 100755 --- a/src/sardana/macroserver/macros/standard.py +++ b/src/sardana/macroserver/macros/standard.py @@ -45,6 +45,7 @@ from sardana.macroserver.msexception import StopException, UnknownEnv from sardana.macroserver.scan.scandata import Record from sardana.macroserver.macro import Optional +from sardana import sardanacustomsettings ########################################################################## # @@ -328,6 +329,36 @@ class wm(Macro): None, 'List of motor to show'], ] + @staticmethod + def format_value(fmt, str_fmt, value): + """ + Formats given value following the fmt and/or str_fmt rules. + + Parameters + ---------- + fmt : str + The value format. + + str_fmt : str + The string format. + + value : float + The value to be formatted. + + Returns + ------- + str + The string formatted value. + """ + + if fmt is not None: + fmt_value = fmt % value + fmt_value = str_fmt % fmt_value + else: + fmt_value = str_fmt % value + + return fmt_value + def prepare(self, motor_list, **opts): self.table_opts = {} @@ -362,15 +393,17 @@ def run(self, motor_list): posObj = motor.getPositionObj() if pos_format > -1: fmt = '%c.%df' % ('%', int(pos_format)) + else: + fmt = None - try: - val1 = fmt % motor.getPosition(force=True) - val1 = str_fmt % val1 - except: - val1 = str_fmt % motor.getPosition(force=True) + val1 = motor.getPosition(force=True) + val1 = self.format_value(fmt, str_fmt, val1) - val2 = str_fmt % posObj.getMaxRange().magnitude - val3 = str_fmt % posObj.getMinRange().magnitude + val2 = posObj.getMaxRange().magnitude + val2 = self.format_value(fmt, str_fmt, val2) + + val3 = posObj.getMinRange().magnitude + val3 = self.format_value(fmt, str_fmt, val3) if show_ctrlaxis: valctrl = str_fmt % (ctrl_name) @@ -459,9 +492,10 @@ def run(self, motor_list): self.execMacro('wm', motor_list, **Table.PrettyOpts) -class mv(Macro): +class mv(Macro, Hookable): """Move motor(s) to the specified position(s)""" + hints = {'allowsHooks': ('pre-move', 'post-move')} param_def = [ ['motor_pos_list', [['motor', Type.Moveable, None, 'Motor to move'], @@ -470,20 +504,35 @@ class mv(Macro): ] def run(self, motor_pos_list): - motors, positions = [], [] + self.motors, positions = [], [] for m, p in motor_pos_list: - motors.append(m) + self.motors.append(m) positions.append(p) + + enable_hooks = getattr(sardanacustomsettings, + 'PRE_POST_MOVE_HOOK_IN_MV', + True) + + if enable_hooks: + for preMoveHook in self.getHooks('pre-move'): + preMoveHook() + + for m, p in zip(self.motors, positions): self.debug("Starting %s movement to %s", m.getName(), p) - motion = self.getMotion(motors) + + motion = self.getMotion(self.motors) state, pos = motion.move(positions) if state != DevState.ON: self.warning("Motion ended in %s", state.name) msg = [] - for motor in motors: + for motor in self.motors: msg.append(motor.information()) self.info("\n".join(msg)) + if enable_hooks: + for postMoveHook in self.getHooks('post-move'): + postMoveHook() + class mstate(Macro): """Prints the state of a motor""" @@ -494,17 +543,20 @@ def run(self, motor): self.info("Motor %s" % str(motor.stateObj.read().rvalue)) -class umv(Macro): +class umv(Macro, Hookable): """Move motor(s) to the specified position(s) and update""" + hints = {'allowsHooks': ('pre-move', 'post-move')} param_def = mv.param_def def prepare(self, motor_pos_list, **opts): self.all_names = [] self.all_pos = [] + self.motors = [] self.print_pos = False for motor, pos in motor_pos_list: self.all_names.append([motor.getName()]) + self.motors.append(motor) pos, posObj = motor.getPosition(force=True), motor.getPositionObj() self.all_pos.append([pos]) posObj.subscribeEvent(self.positionChanged, motor) @@ -512,13 +564,14 @@ def prepare(self, motor_pos_list, **opts): def run(self, motor_pos_list): self.print_pos = True try: - self.execMacro('mv', motor_pos_list) + mv, _ = self.createMacro('mv', motor_pos_list) + mv._setHooks(self.hooks) + self.runMacro(mv) finally: self.finish() def finish(self): self._clean() - self.printAllPos() def _clean(self): for motor, pos in self.getParameters()[0]: @@ -536,16 +589,21 @@ def positionChanged(self, motor, position): self.printAllPos() def printAllPos(self): - motor_width = 10 - table = Table(self.all_pos, elem_fmt=['%*.4f'], + motor_width = 10 + pos_format = self.getViewOption(ViewOption.PosFormat) + fmt = '%*.4f' + if pos_format > -1: + fmt = '%c*.%df' % ('%', int(pos_format)) + table = Table(self.all_pos, elem_fmt=[fmt], col_head_str=self.all_names, col_head_width=motor_width) self.outputBlock(table.genOutput()) self.flushOutput() -class mvr(Macro): +class mvr(Macro, Hookable): """Move motor(s) relative to the current position(s)""" + hints = {'allowsHooks': ('pre-move', 'post-move')} param_def = [ ['motor_disp_list', [['motor', Type.Moveable, None, 'Motor to move'], @@ -554,34 +612,41 @@ class mvr(Macro): ] def run(self, motor_disp_list): - motor_pos_list = [] + self.motors, motor_pos_list = [], [] for motor, disp in motor_disp_list: pos = motor.getPosition(force=True) + self.motors.append(motor) if pos is None: self.error("Cannot get %s position" % motor.getName()) return else: pos += disp motor_pos_list.append([motor, pos]) - self.execMacro('mv', motor_pos_list) + mv, _ = self.createMacro('mv', motor_pos_list) + mv._setHooks(self.hooks) + self.runMacro(mv) -class umvr(Macro): +class umvr(Macro, Hookable): """Move motor(s) relative to the current position(s) and update""" + hints = {'allowsHooks': ('pre-move', 'post-move')} param_def = mvr.param_def def run(self, motor_disp_list): - motor_pos_list = [] + self.motors, motor_pos_list = [], [] for motor, disp in motor_disp_list: pos = motor.getPosition(force=True) + self.motors.append(motor) if pos is None: self.error("Cannot get %s position" % motor.getName()) return else: pos += disp motor_pos_list.append([motor, pos]) - self.execMacro('umv', motor_pos_list) + umv, _ = self.createMacro('umv', motor_pos_list) + umv._setHooks(self.hooks) + self.runMacro(umv) # TODO: implement tw macro with param repeats in order to be able to pass # multiple motors and multiple deltas. Also allow to pass the integration time diff --git a/src/sardana/macroserver/msdoor.py b/src/sardana/macroserver/msdoor.py index 1eb06fd24d..3d9659170f 100644 --- a/src/sardana/macroserver/msdoor.py +++ b/src/sardana/macroserver/msdoor.py @@ -129,8 +129,15 @@ def get_running_macro(self): running_macro = property(get_running_macro) + def get_last_macro(self): + return self.macro_executor.getLastMacro() + + last_macro = property(get_last_macro) + def get_macro_data(self): macro = self.running_macro + if macro is None: + macro = self.last_macro if macro is None: raise MacroServerException("No macro has run so far " + "or the macro data was not preserved.") diff --git a/src/sardana/macroserver/msenvmanager.py b/src/sardana/macroserver/msenvmanager.py index ac43dd5c20..46da8b5056 100644 --- a/src/sardana/macroserver/msenvmanager.py +++ b/src/sardana/macroserver/msenvmanager.py @@ -53,7 +53,7 @@ def _dbm_dumb(filename): return dbm.dumb.open(filename, "c") -def _dbm_shelve(filename, backend): +def _create_dbm(filename, backend): if backend is None: try: return _dbm_gnu(filename) @@ -143,22 +143,22 @@ def setEnvironmentDb(self, f_name): self.error("Creating environment: %s" % ose.strerror) self.debug("Details:", exc_info=1) raise ose - if os.path.exists(f_name) or os.path.exists(f_name + ".dat"): - try: - self._env = shelve.open(f_name, flag='w', writeback=False) - except Exception: - self.error("Failed to access environment in %s", f_name) - self.debug("Details:", exc_info=1) - raise - else: + if not os.path.exists(f_name) and not os.path.exists(f_name + ".dat"): backend = getattr(sardanacustomsettings, "MS_ENV_SHELVE_BACKEND", None) try: - self._env = shelve.Shelf(_dbm_shelve(f_name, backend)) + dbm = _create_dbm(f_name, backend) + dbm.close() except Exception: self.error("Failed to create environment in %s", f_name) self.debug("Details:", exc_info=1) raise + try: + self._env = shelve.open(f_name, flag='w', writeback=False) + except Exception: + self.error("Failed to access environment in %s", f_name) + self.debug("Details:", exc_info=1) + raise self.info("Environment is being stored in %s", f_name) diff --git a/src/sardana/macroserver/msmacromanager.py b/src/sardana/macroserver/msmacromanager.py index 7b95b8fd7c..73c96f7d34 100644 --- a/src/sardana/macroserver/msmacromanager.py +++ b/src/sardana/macroserver/msmacromanager.py @@ -1089,6 +1089,7 @@ def __init__(self, door): self._macro_stack = [] self._xml_stack = [] self._macro_pointer = None + self._last_macro = None self._abort_thread = None self._aborted = False self._stop_thread = None @@ -1399,6 +1400,9 @@ def prepareMacro(self, pars, init_opts={}, prepare_opts={}): def getRunningMacro(self): return self._macro_pointer + def getLastMacro(self): + return self._last_macro + def clearRunningMacro(self): """Clear pointer to the running macro. @@ -1613,8 +1617,9 @@ def __runStatelessXML(self, xml=None): def __runXMLMacro(self, xml): assert xml.tag == 'macro' + parent_macro = self.getRunningMacro() try: - macro_obj, _ = self._prepareXMLMacro(xml) + macro_obj, _ = self._prepareXMLMacro(xml, parent_macro) except AbortException as ae: raise ae except Exception as e: @@ -1725,11 +1730,13 @@ def runMacro(self, macro_obj): preserve_macro_data = macro_obj.getEnv(env_var_name) except UnknownEnv: preserve_macro_data = True - if not preserve_macro_data: + if preserve_macro_data: + self._last_macro = self._macro_pointer + else: self.debug('Macro data will not be preserved. ' + 'Set "%s" environment variable ' % env_var_name + 'to True in order to change it.') - self._macro_pointer = None + self._macro_pointer = None log_macro_manager.disable() diff --git a/src/sardana/macroserver/recorders/h5storage.py b/src/sardana/macroserver/recorders/h5storage.py index 2b34d5abe7..ff2f137657 100644 --- a/src/sardana/macroserver/recorders/h5storage.py +++ b/src/sardana/macroserver/recorders/h5storage.py @@ -42,6 +42,9 @@ from sardana.sardanautils import is_pure_str from sardana.taurus.core.tango.sardana import PlotType from sardana.macroserver.scan.recorder import BaseFileRecorder, SaveModes +from sardana.macroserver.recorders.h5util import _h5_file_handler, \ + _open_h5_file + VDS_available = True try: @@ -66,7 +69,11 @@ class NXscanH5_FileRecorder(BaseFileRecorder): """ formats = {'h5': '.h5'} # from http://docs.h5py.org/en/latest/strings.html - str_dt = h5py.special_dtype(vlen=str) # Variable-length UTF-8 + try: + str_dt = h5py.string_dtype() + except AttributeError: + # h5py < 3 + str_dt = h5py.special_dtype(vlen=str) # Variable-length UTF-8 byte_dt = h5py.special_dtype(vlen=bytes) # Variable-length UTF-8 supported_dtypes = ('float32', 'float64', 'int8', 'int16', 'int32', 'int64', 'uint8', @@ -97,6 +104,7 @@ def __init__(self, filename=None, macro=None, overwrite=False, **pars): + '($|(?=[/#?])))?(?P%(path)s)$') self.pattern = pattern % dict(scheme=scheme, authority=authority, path=path) + self._close = False def getFormat(self): return 'HDF5::NXscan' @@ -123,10 +131,14 @@ def _openFile(self, fname): """Open the file with given filename (create if it does not exist) Populate the root of the file with some metadata from the NXroot definition""" - if os.path.exists(fname): - fd = h5py.File(fname, mode='r+') - else: - fd = h5py.File(fname, mode='w-') + try: + fd = _h5_file_handler[fname] + except KeyError: + fd = _open_h5_file(fname) + self._close = True + try: + fd.attrs['NX_class'] + except KeyError: fd.attrs['NX_class'] = 'NXroot' fd.attrs['file_name'] = fname fd.attrs['file_time'] = datetime.now().isoformat() @@ -254,7 +266,8 @@ def _startRecordList(self, recordlist): pass self._createPreScanSnapshot(env) - + self._populateInstrumentInfo() + self._createNXData() self.fd.flush() def _compression(self, shape, compfilter='gzip'): @@ -296,6 +309,7 @@ def _createPreScanSnapshot(self, env): self.debug('Pre-scan snapshot of %s will be stored as type %s', dd.name, dtype) elif dd.dtype == 'str': + dtype = NXscanH5_FileRecorder.str_dt dd.dtype = NXscanH5_FileRecorder.str_dt if dtype in self.supported_dtypes: @@ -349,9 +363,6 @@ def _endRecordList(self, recordlist): if self.filename is None: return - self._populateInstrumentInfo() - self._createNXData() - env = self.currentlist.getEnviron() nxentry = self.fd[self.entryname] @@ -361,8 +372,12 @@ def _endRecordList(self, recordlist): # If h5file scheme is used: Creation of a Virtual Dataset if dd.value_ref_enabled: measurement = nxentry['measurement'] - first_reference = measurement[label][0] - + try: + dataset = measurement[label].asstr() + except AttributeError: + # h5py < 3 + dataset = measurement[label] + first_reference = dataset[0] group = re.match(self.pattern, first_reference) if group is None: msg = 'Unsupported reference %s' % first_reference @@ -388,7 +403,7 @@ def _endRecordList(self, recordlist): dtype=dd_env.dtype) for i in range(nb_points): - reference = measurement[label][i] + reference = dataset[i] group = re.match(self.pattern, reference) if group is None: msg = 'Unsupported reference %s' % first_reference @@ -396,8 +411,10 @@ def _endRecordList(self, recordlist): continue uri_groups = group.groupdict() filename = uri_groups["filepath"] - dataset = uri_groups.get("dataset", "dataset") - vsource = h5py.VirtualSource(filename, dataset, + remote_dataset_name = uri_groups["dataset"] + if remote_dataset_name is None: + remote_dataset_name = "dataset" + vsource = h5py.VirtualSource(filename, remote_dataset_name, shape=(dim_1, dim_2)) layout[i] = vsource @@ -416,7 +433,8 @@ def _endRecordList(self, recordlist): self.fd.flush() self.debug('Finishing recording %d on file %s:', env['serialno'], self.filename) - self.fd.close() + if self._close: + self.fd.close() self.currentlist = None def writeRecordList(self, recordlist): @@ -578,7 +596,7 @@ def _addCustomData(self, value, name, nxpath=None, dtype=None, **kwargs): if numpy.isscalar(value): dtype = numpy.dtype(type(value)).name if numpy.issubdtype(dtype, str): - dtype = 'char' + dtype = NXscanH5_FileRecorder.str_dt if dtype == 'bool': value, dtype = int(value), 'int8' else: diff --git a/src/sardana/macroserver/recorders/h5util.py b/src/sardana/macroserver/recorders/h5util.py new file mode 100644 index 0000000000..d502479f65 --- /dev/null +++ b/src/sardana/macroserver/recorders/h5util.py @@ -0,0 +1,85 @@ +#!/usr/bin/env python + +############################################################################## +## +# This file is part of Sardana +## +# http://www.sardana-controls.org/ +## +# Copyright 2011 CELLS / ALBA Synchrotron, Bellaterra, Spain +## +# Sardana is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +## +# Sardana is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +## +# You should have received a copy of the GNU Lesser General Public License +# along with Sardana. If not, see . +## +############################################################################## + +""" +This module provides a recorder for NXscans implemented with h5py (no nxs) +""" + +import os +import h5py +import atexit + + +def _open_h5_file(fname, libver='earliest'): + mode = 'w-' + if os.path.exists(fname): + mode = 'r+' + fd = h5py.File(fname, mode=mode, libver=libver) + return fd + + +class _H5FileHandler: + + def __init__(self): + self._files = {} + + def __getitem__(self, fname): + return self._files[fname] + + @property + def files(self): + return self._files.keys() + + def open_file(self, fname, swmr_mode=False): + if swmr_mode: + try: + fd = _open_h5_file(fname, libver='latest') + fd.swmr_mode = True + except ValueError as e: + raise ValueError( + "Cannot open '{}' in swmr mode".format(fname) + ) from e + else: + fd = _open_h5_file(fname) + if not self._files: + atexit.register(self.clean_up) + self._files[fname] = fd + return fd + + def close_file(self, fname): + try: + fd = self._files.pop(fname) + except KeyError: + raise ValueError('{} is not opened'.format(fname)) + if not self._files: + atexit.unregister(self.clean_up) + fd.close() + + def clean_up(self): + for file in self.files: + self.close_file(file) + + +_h5_file_handler = _H5FileHandler() diff --git a/src/sardana/macroserver/recorders/test/test_h5storage.py b/src/sardana/macroserver/recorders/test/test_h5storage.py index 413f4e4797..65e5da7c26 100644 --- a/src/sardana/macroserver/recorders/test/test_h5storage.py +++ b/src/sardana/macroserver/recorders/test/test_h5storage.py @@ -27,17 +27,55 @@ import os import tempfile +import contextlib +import multiprocessing from datetime import datetime import h5py import numpy -from unittest import TestCase +import pytest +from unittest import TestCase, mock from sardana.macroserver.scan import ColumnDesc from sardana.macroserver.recorders.h5storage import NXscanH5_FileRecorder +from sardana.macroserver.recorders.h5util import _h5_file_handler + + +@contextlib.contextmanager +def h5_write_session(fname, swmr_mode=False): + """Context manager for HDF5 file write session. + + Maintains HDF5 file opened for the context lifetime. + It optionally can open the file as SWRM writer. + + :param fname: Path of the file to be opened + :type fname: str + :param swmr_mode: Use SWMR write mode + :type swmr_mode: bool + """ + fd = _h5_file_handler.open_file(fname, swmr_mode) + try: + yield fd + finally: + _h5_file_handler.close_file(fname) + COL1_NAME = "col1" +ENV = { + "serialno": 0, + "starttime": None, + "title": "test", + "user": "user", + "datadesc": None, + "endtime": None +} + +@pytest.fixture +def recorder(tmpdir): + path = str(tmpdir / "file.h5") + return NXscanH5_FileRecorder(filename=path) + class RecordList(dict): @@ -55,141 +93,222 @@ def __init__(self, data, recordno=0): self.recordno = recordno -class TestNXscanH5_FileRecorder(TestCase): +def test_dtype_float64(recorder): + """Test creation of dataset with float64 data type""" + nb_records = 1 + # create description of channel data + data_desc = [ + ColumnDesc(name=COL1_NAME, label=COL1_NAME, dtype="float64", + shape=tuple()) + ] + environ = ENV.copy() + environ["datadesc"] = data_desc + + # simulate sardana scan + environ["starttime"] = datetime.now() + record_list = RecordList(environ) + recorder._startRecordList(record_list) + for i in range(nb_records): + record = Record({COL1_NAME: 0.1}, i) + recorder._writeRecord(record) + environ["endtime"] = datetime.now() + recorder._endRecordList(record_list) + + # assert if reading datasets from the sardana file access to the + # dataset of the partial files + file_ = h5py.File(recorder.filename) + for i in range(nb_records): + expected_data = 0.1 + data = file_["entry0"]["measurement"][COL1_NAME][i] + msg = "data does not match" + assert data == expected_data, msg + - def setUp(self): - self.dir_name = tempfile.gettempdir() - self.path = os.path.join(self.dir_name, "test.h5") +def test_value_ref(recorder): + """Test creation of dataset with str data type""" + nb_records = 1 + # create description of channel data + data_desc = [ + ColumnDesc(name=COL1_NAME, label=COL1_NAME, dtype="float64", + shape=(1024, 1024), value_ref_enabled=True) + ] + environ = ENV.copy() + environ["datadesc"] = data_desc + + # simulate sardana scan + environ["starttime"] = datetime.now() + record_list = RecordList(environ) + recorder._startRecordList(record_list) + for i in range(nb_records): + record = Record({COL1_NAME: "file:///tmp/test.edf"}, i) + recorder._writeRecord(record) + environ["endtime"] = datetime.now() + recorder._endRecordList(record_list) + + # assert if reading datasets from the sardana file access to the + # dataset of the partial files + file_ = h5py.File(recorder.filename) + for i in range(nb_records): + expected_data = "file:///tmp/test.edf" try: - os.remove(self.path) # remove file just in case - except OSError: - pass - - self.env = { - "serialno": 0, - "starttime": None, - "title": "test", - "user": "user", - "datadesc": None, - "endtime": None - } - self.record_list = RecordList(self.env) - - def test_dtype_float64(self): - """Test creation of dataset with float64 data type""" - nb_records = 1 - # create description of channel data - data_desc = [ - ColumnDesc(name=COL1_NAME, label=COL1_NAME, dtype="float64", - shape=tuple()) - ] - self.env["datadesc"] = data_desc + dataset = file_["entry0"]["measurement"][COL1_NAME].asstr() + except AttributeError: + # h5py < 3 + dataset = file_["entry0"]["measurement"][COL1_NAME] + data = dataset[i] + msg = "data does not match" + assert data == expected_data, msg - # simulate sardana scan - recorder = NXscanH5_FileRecorder(filename=self.path) - self.env["starttime"] = datetime.now() - recorder._startRecordList(self.record_list) - for i in range(nb_records): - record = Record({COL1_NAME: 0.1}, i) - recorder._writeRecord(record) - self.env["endtime"] = datetime.now() - recorder._endRecordList(self.record_list) - # assert if reading datasets from the sardana file access to the - # dataset of the partial files - file_ = h5py.File(self.path) - for i in range(nb_records): - expected_data = 0.1 - data = file_["entry0"]["measurement"][COL1_NAME][i] - msg = "data does not match" - self.assertEqual(data, expected_data, msg) - - def test_value_ref(self): - """Test creation of dataset with str data type""" - nb_records = 1 +@pytest.mark.xfail(os.name == "nt", reason="VDS are buggy on Windows") +@pytest.mark.skipif(not hasattr(h5py, "VirtualLayout"), + reason="VDS not available in this version of h5py") +def test_VDS(recorder): + """Test creation of VDS when channel reports URIs (str) of h5file + scheme in a simulated sardana scan (3 points). + """ + nb_records = 3 + # create partial files + part_file_name_pattern = "test_vds_part{0}.h5" + part_file_paths = [] + for i in range(nb_records): + path = os.path.join(os.path.dirname(recorder.filename), + part_file_name_pattern.format(i)) + part_file_paths.append(path) + part_file = h5py.File(path, "w") + img = numpy.array([[i, i], [i, i]]) + dataset = "dataset" + part_file.create_dataset(dataset, data=img) + part_file.flush() + part_file.close() + try: # create description of channel data data_desc = [ ColumnDesc(name=COL1_NAME, label=COL1_NAME, dtype="float64", - shape=(1024, 1024), value_ref_enabled=True) + shape=(2, 2), value_ref_enabled=True) ] - self.env["datadesc"] = data_desc + environ = ENV.copy() + environ["datadesc"] = data_desc # simulate sardana scan - recorder = NXscanH5_FileRecorder(filename=self.path) - self.env["starttime"] = datetime.now() - recorder._startRecordList(self.record_list) + environ["starttime"] = datetime.now() + record_list = RecordList(environ) + recorder._startRecordList(record_list) for i in range(nb_records): - record = Record({COL1_NAME: "file:///tmp/test.edf"}, i) + ref = "h5file://" + part_file_paths[i] + "::" + dataset + record = Record({COL1_NAME: ref}, i) recorder._writeRecord(record) - self.env["endtime"] = datetime.now() - recorder._endRecordList(self.record_list) + environ["endtime"] = datetime.now() + recorder._endRecordList(record_list) # assert if reading datasets from the sardana file access to the # dataset of the partial files - file_ = h5py.File(self.path) + file_ = h5py.File(recorder.filename) for i in range(nb_records): - expected_data = "file:///tmp/test.edf" - data = file_["entry0"]["measurement"][COL1_NAME][i] - msg = "data does not match" - self.assertEqual(data, expected_data, msg) - - def test_VDS(self): - """Test creation of VDS when channel reports URIs (str) of h5file - scheme in a simulated sardana scan (3 points). - """ + expected_img = numpy.array([[i, i], [i, i]]) + img = file_["entry0"]["measurement"][COL1_NAME][i] + msg = "VDS extracted image does not match" + # TODO: check if this assert works well + numpy.testing.assert_array_equal(img, expected_img, msg) + finally: + # remove partial files + for path in part_file_paths: + os.remove(path) + + +@pytest.mark.parametrize("custom_data", [8, True]) +def test_addCustomData(recorder, custom_data): + name = "custom_data_name" + recorder.addCustomData(custom_data, name) + with h5py.File(recorder.filename) as fd: + assert fd["entry"]["custom_data"][name][()] == custom_data + + +def test_addCustomData_str(recorder): + name = "custom_data_name" + custom_data = "str_custom_data" + recorder.addCustomData(custom_data, name) + with h5py.File(recorder.filename) as fd: try: - h5py.VirtualLayout + dset = fd["entry"]["custom_data"][name].asstr() except AttributeError: - self.skipTest("VDS not available in this version of h5py") - nb_records = 3 - # create partial files - part_file_name_pattern = "test_vds_part{0}.h5" - part_file_paths = [] - for i in range(nb_records): - path = os.path.join(self.dir_name, - part_file_name_pattern.format(i)) - part_file_paths.append(path) - part_file = h5py.File(path, "w") - img = numpy.array([[i, i], [i, i]]) - dataset = "dataset" - part_file.create_dataset(dataset, data=img) - part_file.flush() - part_file.close() + dset = fd["entry"]["custom_data"][name] + assert dset[()] == custom_data + + +def _scan(path, serialno=0): + env = ENV.copy() + env["serialno"] = serialno + record_list = RecordList(env) + nb_records = 2 + # create description of channel data + data_desc = [ + ColumnDesc(name=COL1_NAME, + label=COL1_NAME, + dtype="float64", + shape=()) + ] + env["datadesc"] = data_desc + # simulate sardana scan + recorder = NXscanH5_FileRecorder(filename=path) + env["starttime"] = datetime.now() + recorder._startRecordList(record_list) + for i in range(nb_records): + record = Record({COL1_NAME: 0.1}, i) + recorder._writeRecord(record) + env["endtime"] = datetime.now() + recorder._endRecordList(record_list) + + +def read_file(path, ready, done): + with h5py.File(path, mode="r"): + ready.set() + done.wait() + + +def test_swmr_with_h5_session(tmpdir): + path = str(tmpdir / "file.h5") + reader_is_ready = multiprocessing.Event() + writer_is_done = multiprocessing.Event() + reader = multiprocessing.Process( + target=read_file, args=(path, reader_is_ready, writer_is_done) + ) + with h5_write_session(path): + _scan(path, serialno=0) + reader.start() + reader_is_ready.wait() try: - # create description of channel data - data_desc = [ - ColumnDesc(name=COL1_NAME, label=COL1_NAME, dtype="float64", - shape=(2, 2), value_ref_enabled=True) - ] - self.env["datadesc"] = data_desc - - # simulate sardana scan - recorder = NXscanH5_FileRecorder(filename=self.path) - self.env["starttime"] = datetime.now() - recorder._startRecordList(self.record_list) - for i in range(nb_records): - ref = "h5file://" + part_file_paths[i] + "::" + dataset - record = Record({COL1_NAME: ref}, i) - recorder._writeRecord(record) - self.env["endtime"] = datetime.now() - recorder._endRecordList(self.record_list) - - # assert if reading datasets from the sardana file access to the - # dataset of the partial files - file_ = h5py.File(self.path) - for i in range(nb_records): - expected_img = numpy.array([[i, i], [i, i]]) - img = file_["entry0"]["measurement"][COL1_NAME][i] - msg = "VDS extracted image does not match" - # TODO: check if this assert works well - numpy.testing.assert_array_equal(img, expected_img, msg) + _scan(path, serialno=1) finally: - # remove partial files - for path in part_file_paths: - os.remove(path) + writer_is_done.set() + reader.join() - def tearDown(self): - try: - os.remove(self.path) - except OSError: - pass + +@mock.patch.dict(os.environ, {"HDF5_USE_FILE_LOCKING": "FALSE"}) +def read_file_without_file_locking(path, ready, done): + with h5py.File(path, mode="r"): + ready.set() + done.wait() + + +@pytest.mark.xfail( + condition=h5py.version.hdf5_version_tuple < (1, 10, 1), + reason="HDF5_USE_FILE_LOCKING not supported by hdf5<1.10.1" +) +def test_swmr_without_h5_session(tmpdir): + path = str(tmpdir / "file.h5") + reader_is_ready = multiprocessing.Event() + writer_is_done = multiprocessing.Event() + reader = multiprocessing.Process( + target=read_file_without_file_locking, + args=(path, reader_is_ready, writer_is_done) + ) + + _scan(path, serialno=0) + reader.start() + reader_is_ready.wait() + try: + _scan(path, serialno=1) + finally: + writer_is_done.set() + reader.join() diff --git a/src/sardana/macroserver/scan/gscan.py b/src/sardana/macroserver/scan/gscan.py index eacd779395..afcad7e31d 100644 --- a/src/sardana/macroserver/scan/gscan.py +++ b/src/sardana/macroserver/scan/gscan.py @@ -83,6 +83,32 @@ class ScanException(MacroServerException): pass +def _get_shape(channel): + # internal Sardana channel + if isinstance(channel, PyTango.DeviceProxy): + try: + shape = channel.shape + except Exception: + return None + if shape is None: # in PyTango empty spectrum is None + return [] + return shape + # external channel (Tango attribute) + elif isinstance(channel, PyTango.AttributeProxy): + try: + attr_conf = channel.get_config() + except Exception: + return None + if attr_conf.data_format == PyTango.AttrDataFormat.SCALAR: + return [] + try: + value = channel.read().value + except Exception: + return [n for n in (attr_conf.max_dim_x, + attr_conf.max_dim_y) if n > 0] + return list(np.shape(value)) + + class ExtraData(object): def __init__(self, **kwargs): @@ -639,11 +665,16 @@ def _setupEnvironment(self, additional_env): serialno = 1 self.macro.setEnv("ScanID", serialno) + try: + user = self.macro.getEnv("ScanUser") + except UnknownEnv: + user = USER_NAME + env = ScanDataEnvironment( {'serialno': serialno, # TODO: this should be got from # self.measurement_group.getChannelsInfo() - 'user': USER_NAME, + 'user': user, 'title': self.macro.getCommand()}) # Initialize the data_desc list (and add the point number column) @@ -670,16 +701,24 @@ def _setupEnvironment(self, additional_env): counters = [] for ci in channels_info: full_name = ci.full_name + shape = None + instrument = '' try: # Use DeviceProxy instead of taurus to avoid crashes in Py3 # See: tango-controls/pytango#292 # channel = taurus.Device(full_name) channel = PyTango.DeviceProxy(full_name) - instrument = channel.instrument except Exception: - # full_name of external channels is the name of the attribute - # external channels are not assigned to instruments - instrument = '' + try: + channel = PyTango.AttributeProxy(full_name) + except Exception: + channel = None + if channel: + shape = _get_shape(channel) + try: + instrument = channel.instrument + except Exception: + instrument = '' try: instrumentFullName = self.macro.findObjs( instrument, type_class=Type.Instrument)[0].getFullName() @@ -687,6 +726,10 @@ def _setupEnvironment(self, additional_env): raise except Exception: instrumentFullName = '' + if shape is None: + self.warning("unknown shape of {}, assuming scalar".format( + ci.name)) + shape = [] # substitute the axis placeholder by the corresponding moveable. plotAxes = [] i = 0 @@ -708,7 +751,7 @@ def _setupEnvironment(self, additional_env): column = ColumnDesc(name=ci.full_name, label=ci.label, dtype=ci.data_type, - shape=ci.shape, + shape=shape, instrument=instrumentFullName, source=ci.source, output=ci.output, @@ -1058,24 +1101,52 @@ def do_restore(self): class SScan(GScan): """Step scan""" + def __init__(self, macro, generator=None, moveables=[], env={}, + constraints=[], extrainfodesc=[]): + GScan.__init__(self, macro, generator=generator, moveables=moveables, + env=env, constraints=constraints, + extrainfodesc=extrainfodesc) + self._deterministic_scan = None + + @property + def deterministic_scan(self): + """Check if the scan is a deterministic scan. + + Scan is considered as deterministic scan if + the `~sardana.macroserver.macro.Macro` specialization owning + the scan object contains ``nb_points`` and ``integ_time`` attributes. + + Scan flow depends on this property (some optimizations are applied). + These can be disabled by setting this property to `False`. + """ + if self._deterministic_scan is None: + macro = self.macro + if hasattr(macro, "nb_points") and hasattr(macro, "integ_time"): + self._deterministic_scan = True + else: + self._deterministic_scan = False + return self._deterministic_scan + + @deterministic_scan.setter + def deterministic_scan(self, value): + self._deterministic_scan = value + def scan_loop(self): lstep = None macro = self.macro scream = False - self._deterministic_scan = False if hasattr(macro, "nb_points"): nb_points = float(macro.nb_points) - if hasattr(macro, "integ_time"): - integ_time = macro.integ_time - self.measurement_group.putIntegrationTime(integ_time) - self.measurement_group.setNbStarts(nb_points) - self.measurement_group.prepare() - self._deterministic_scan = True scream = True else: yield 0.0 + if self.deterministic_scan: + self.measurement_group.putIntegrationTime(macro.integ_time) + self.measurement_group.setNbStarts(macro.nb_points) + self.measurement_group.prepare() + self._sum_motion_time = 0 self._sum_acq_time = 0 @@ -1157,7 +1228,7 @@ def stepUp(self, n, step, lstep): # Acquire data self.debug("[START] acquisition") try: - if self._deterministic_scan: + if self.deterministic_scan: state, data_line = mg.count_raw() else: state, data_line = mg.count(integ_time) @@ -2366,8 +2437,10 @@ def _go_through_waypoints(self): initial_position = start total_time = abs(total_position) / path.max_vel delay_time = path.max_vel_time + delay_position = start - path.initial_user_pos synch = [ - {SynchParam.Delay: {SynchDomain.Time: delay_time}, + {SynchParam.Delay: {SynchDomain.Time: delay_time, + SynchDomain.Position: delay_position}, SynchParam.Initial: {SynchDomain.Position: initial_position}, SynchParam.Active: {SynchDomain.Position: active_position, SynchDomain.Time: active_time}, diff --git a/src/sardana/macroserver/scan/test/helper.py b/src/sardana/macroserver/scan/test/helper.py index d3bdefb8f7..b4fa2007bc 100644 --- a/src/sardana/macroserver/scan/test/helper.py +++ b/src/sardana/macroserver/scan/test/helper.py @@ -12,7 +12,7 @@ import time -from datetime import date +import datetime import threading import numpy import os @@ -47,7 +47,7 @@ def run(self): if skip: continue time.sleep(t) - _dict = dict(data=v, index=idx, label=self.name) + _dict = dict(value=v, index=idx, label=self.name) self.scan_data.addData(_dict) def get_obj(self): @@ -69,7 +69,7 @@ def createScanDataEnvironment(columns, scanDir='/tmp/', env['ScanFile'] = scanFile env['total_scan_intervals'] = -1.0 - today = date.today() + today = datetime.datetime.fromtimestamp(time.time()) env['datetime'] = today env['starttime'] = today env['endtime'] = today diff --git a/src/sardana/macroserver/test/res/macros/testmacros.py b/src/sardana/macroserver/test/res/macros/testmacros.py index 638315865b..450db21879 100644 --- a/src/sardana/macroserver/test/res/macros/testmacros.py +++ b/src/sardana/macroserver/test/res/macros/testmacros.py @@ -88,7 +88,6 @@ def run(self, *args): params = (99, 1., 2.) expected_params = (99, [1., 2.]) - self.runMacro(macro) macro, pars = self.createMacro('pt6_base', *params) self.runMacro(macro) result = macro.data diff --git a/src/sardana/macroserver/test/test_macro.py b/src/sardana/macroserver/test/test_macro.py new file mode 100644 index 0000000000..7f21ce2c32 --- /dev/null +++ b/src/sardana/macroserver/test/test_macro.py @@ -0,0 +1,37 @@ +#!/usr/bin/env python + +############################################################################## +## +# This file is part of Sardana +## +# http://www.sardana-controls.org/ +## +# Copyright 2011 CELLS / ALBA Synchrotron, Bellaterra, Spain +## +# Sardana is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +## +# Sardana is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +## +# You should have received a copy of the GNU Lesser General Public License +# along with Sardana. If not, see . +## +############################################################################## + +from sardana.macroserver.macro import Hookable + + +def test_Hookable(): + hookable = Hookable() + assert len(hookable.hooks) == 0 + hooks = hookable.getHooks("unexisting-hook-place") + assert len(hooks) == 0 + hookable.hooks = [] + assert len(hookable.hooks) == 0 + hooks = hookable.getHooks("unexisting-hook-place") + assert len(hooks) == 0 diff --git a/src/sardana/macroserver/test/test_msparameter.py b/src/sardana/macroserver/test/test_msparameter.py index 3151081d39..07f2ece2bf 100644 --- a/src/sardana/macroserver/test/test_msparameter.py +++ b/src/sardana/macroserver/test/test_msparameter.py @@ -1,3 +1,28 @@ +#!/usr/bin/env python + +############################################################################## +## +# This file is part of Sardana +## +# http://www.sardana-controls.org/ +## +# Copyright 2011 CELLS / ALBA Synchrotron, Bellaterra, Spain +## +# Sardana is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +## +# Sardana is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +## +# You should have received a copy of the GNU Lesser General Public License +# along with Sardana. If not, see . +## +############################################################################## + import unittest from taurus.test import insertTest diff --git a/src/sardana/macroserver/test/test_msrecordermanager.py b/src/sardana/macroserver/test/test_msrecordermanager.py index f9c91e328f..e6ca874a99 100644 --- a/src/sardana/macroserver/test/test_msrecordermanager.py +++ b/src/sardana/macroserver/test/test_msrecordermanager.py @@ -48,7 +48,8 @@ extra_recorders=1) @insertTest(helper_name='getRecorderPath', recorder_path=["/tmp/foo", "#/tmp/foo2"], expected_num_path=2) -@insertTest(helper_name='getRecorderPath', recorder_path=["/tmp/foo:/tmp/foo2"], +@insertTest(helper_name='getRecorderPath', + recorder_path=["/tmp/foo" + os.pathsep + "/tmp/foo2"], expected_num_path=3) @insertTest(helper_name='getRecorderPath', recorder_path=["/tmp/foo"], expected_num_path=2) diff --git a/src/sardana/pool/controller.py b/src/sardana/pool/controller.py index fc24d05030..260c4ebac7 100644 --- a/src/sardana/pool/controller.py +++ b/src/sardana/pool/controller.py @@ -878,6 +878,8 @@ class CounterTimerController(Controller, Readable, Startable, Stopable, # TODO: in case of Tango ValueBuffer type is overridden by DevEncoded 'ValueBuffer': {'type': str, 'description': 'Value buffer', }, + 'Shape': {'type': (int,), + 'description': 'Shape of the value, it is an empty array'} } standard_axis_attributes.update(Controller.standard_axis_attributes) @@ -912,6 +914,19 @@ class TriggerGateController(Controller, Synchronizer, Stopable, Startable): def __init__(self, inst, props, *args, **kwargs): Controller.__init__(self, inst, props, *args, **kwargs) + # TODO: Implement a Preparable interface and move this method + # and the Loadable.PrepareOne() there. + def PrepareOne(self, axis, nb_starts): + """**Controller API**. Override if necessary. + Called to prepare the trigger/gate axis with the measurement + parameters. + Default implementation does nothing. + + :param int axis: axis + :param int nb_starts: number of starts + """ + pass + class ZeroDController(Controller, Readable, Stopable): """Base class for a 0D controller. Inherit from this class to @@ -928,6 +943,8 @@ class ZeroDController(Controller, Readable, Stopable): # TODO: in case of Tango ValueBuffer type is overridden by DevEncoded 'ValueBuffer': {'type': str, 'description': 'Value buffer', }, + 'Shape': {'type': (int,), + 'description': 'Shape of the value, it is an empty array'} } standard_axis_attributes.update(Controller.standard_axis_attributes) @@ -960,6 +977,9 @@ class OneDController(Controller, Readable, Startable, Stopable, Loadable): # TODO: in case of Tango ValueBuffer type is overridden by DevEncoded 'ValueBuffer': {'type': str, 'description': 'Value buffer', }, + 'Shape': {'type': (int,), + 'description': 'Shape of the value, it is an array with ' + '1 element - X dimension'} } standard_axis_attributes.update(Controller.standard_axis_attributes) @@ -1005,6 +1025,9 @@ class TwoDController(Controller, Readable, Startable, Stopable, Loadable): # TODO: in case of Tango ValueBuffer type is overridden by DevEncoded 'ValueBuffer': {'type': str, 'description': 'Value buffer', }, + 'Shape': {'type': (int,), + 'description': 'Shape of the value, it is an array with ' + '2 elements: X and Y dimensions'} } standard_axis_attributes.update(Controller.standard_axis_attributes) @@ -1251,6 +1274,8 @@ class PseudoCounterController(Controller): # TODO: in case of Tango ValueBuffer type is overridden by DevEncoded 'ValueBuffer': {'type': str, 'description': 'Data', }, + 'Shape': {'type': (int,), + 'description': 'Shape of the value, it is an empty array'} } #: A :obj:`str` representing the controller gender diff --git a/src/sardana/pool/poolacquisition.py b/src/sardana/pool/poolacquisition.py index 224fb6ce1f..457b78fc97 100644 --- a/src/sardana/pool/poolacquisition.py +++ b/src/sardana/pool/poolacquisition.py @@ -499,6 +499,9 @@ def prepare(self, config, acq_mode, value, synch_description=None, config.changed = False + # Call synchronizer controllers prepare method + self._prepare_synch_ctrls(ctrls_synch, nb_starts) + # Call hardware and software start controllers prepare method ctrls = ctrls_hw + ctrls_sw_start self._prepare_ctrls(ctrls, value, repetitions, latency, @@ -510,6 +513,7 @@ def prepare(self, config, acq_mode, value, synch_description=None, self._prepare_ctrls(ctrls_sw, value, repetitions, latency, nb_starts) + @staticmethod def _prepare_ctrls(ctrls, value, repetitions, latency, nb_starts): for ctrl in ctrls: @@ -518,6 +522,14 @@ def _prepare_ctrls(ctrls, value, repetitions, latency, nb_starts): pool_ctrl.ctrl.PrepareOne(axis, value, repetitions, latency, nb_starts) + @staticmethod + def _prepare_synch_ctrls(ctrls, nb_starts): + for ctrl in ctrls: + for chn in ctrl.get_channels(): + axis = chn.axis + pool_ctrl = ctrl.element + pool_ctrl.ctrl.PrepareOne(axis, nb_starts) + def is_running(self): """Checks if acquisition is running. @@ -812,6 +824,30 @@ def _raw_read_ctrl_value_ref(self, ret, pool_ctrl): finally: self._value_info.finish_one() + def _process_value_buffer(self, acquirable, value, final=False): + final_str = "final " if final else "" + if is_value_error(value): + self.error("Loop %sread value error for %s" % (final_str, + acquirable.name)) + msg = "Details: " + "".join( + traceback.format_exception(*value.exc_info)) + self.debug(msg) + acquirable.put_value(value, propagate=2) + else: + acquirable.extend_value_buffer(value, propagate=2) + + def _process_value_ref_buffer(self, acquirable, value_ref, final=False): + final_str = "final " if final else "" + if is_value_error(value_ref): + self.error("Loop read ref %svalue error for %s" % + (final_str, acquirable.name)) + msg = "Details: " + "".join( + traceback.format_exception(*value_ref.exc_info)) + self.debug(msg) + acquirable.put_value_ref(value_ref, propagate=2) + else: + acquirable.extend_value_ref_buffer(value_ref, propagate=2) + def in_acquisition(self, states): """Determines if we are in acquisition or if the acquisition has ended based on the current unit trigger modes and states returned by the @@ -1056,15 +1092,10 @@ def action_loop(self): if not i % nb_states_per_value: self.read_value(ret=values) for acquirable, value in list(values.items()): - if is_value_error(value): - self.error("Loop read value error for %s" % - acquirable.name) - msg = "Details: " + "".join( - traceback.format_exception(*value.exc_info)) - self.debug(msg) - acquirable.put_value(value) - else: - acquirable.extend_value_buffer(value) + self._process_value_buffer(acquirable, value) + self.read_value_ref(ret=value_refs) + for acquirable, value_ref in list(value_refs.items()): + self._process_value_ref_buffer(acquirable, value_ref) time.sleep(nap) i += 1 @@ -1076,24 +1107,11 @@ def action_loop(self): for acquirable, state_info in list(states.items()): if acquirable in values: value = values[acquirable] - if is_value_error(value): - self.error("Loop final read value error for: %s" % - acquirable.name) - msg = "Details: " + "".join( - traceback.format_exception(*value.exc_info)) - self.debug(msg) - acquirable.put_value(value) - else: - acquirable.extend_value_buffer(value, propagate=2) + self._process_value_buffer(acquirable, value, final=True) if acquirable in value_refs: value_ref = value_refs[acquirable] - if is_value_error(value_ref): - self.error("Loop final read value ref error for: %s" % - acquirable.name) - msg = "Details: " + "".join( - traceback.format_exception(*value_ref.exc_info)) - self.debug(msg) - acquirable.extend_value_ref_buffer(value_ref, propagate=2) + self._process_value_ref_buffer(acquirable, value_ref, + final=True) state_info = acquirable._from_ctrl_state_info(state_info) set_state_info = functools.partial(acquirable.set_state_info, state_info, diff --git a/src/sardana/pool/poolbasechannel.py b/src/sardana/pool/poolbasechannel.py index 29f739bad9..f35370881c 100644 --- a/src/sardana/pool/poolbasechannel.py +++ b/src/sardana/pool/poolbasechannel.py @@ -30,7 +30,7 @@ __docformat__ = 'restructuredtext' -from sardana.sardanadefs import AttrQuality +from sardana.sardanadefs import AttrQuality, ElementType from sardana.sardanaattribute import SardanaAttribute from sardana.sardanabuffer import SardanaBuffer from sardana.pool.poolelement import PoolElement @@ -120,6 +120,7 @@ def __init__(self, **kwargs): acq_name = "%s.Acquisition" % self._name self.set_action_cache(self.AcquisitionClass(self, name=acq_name)) self._integration_time = 0 + self._shape = None def has_pseudo_elements(self): """Informs whether this channel forms part of any pseudo element @@ -240,7 +241,7 @@ def read_value(self): value :rtype: :class:`~sardana.sardanavalue.SardanaValue`""" - return self.acquisition.read_value()[self] + return self.acquisition.read_value(serial=True)[self] def put_value(self, value, quality=AttrQuality.Valid, propagate=1): """Sets a value. @@ -645,6 +646,71 @@ def set_integration_time(self, integration_time, propagate=1): integration_time = property(get_integration_time, set_integration_time, doc="channel integration time") + # ------------------------------------------------------------------------- + # shape + # ------------------------------------------------------------------------- + + def _get_shape_from_max_dim_size(self): + # MaxDimSize could actually become a standard fallback + # in case the shape controller parameters is not implemented + # reconsider it whenever backwards compatibility with reading the value + # is about to be removed + try: + from sardana.pool.controller import MaxDimSize + controller = self.controller + axis_attr_info = controller.get_axis_attributes(self.axis) + value_info = axis_attr_info["Value"] + shape = value_info[MaxDimSize] + except Exception as e: + raise RuntimeError( + "can not provide backwards compatibility, you must" + "implement shape axis parameter") from e + return shape + + def get_shape(self, cache=True, propagate=1): + if not cache or self._shape is None: + shape = self.read_shape() + self._set_shape(shape, propagate=propagate) + return self._shape + + def _set_shape(self, shape, propagate=1): + self._shape = shape + if not propagate: + return + self.fire_event( + EventType("shape", priority=propagate), shape) + + def read_shape(self): + try: + shape = self.controller.get_axis_par(self.axis, "shape") + except Exception: + shape = None + if shape is None: + # backwards compatibility for controllers not implementing + # shape axis par + if self.get_type() in (ElementType.OneDExpChannel, + ElementType.TwoDExpChannel): + self.warning( + "not implementing shape axis parameter in 1D and 2D " + "controllers is deprecated since 3.1.0") + value = self.value.value + if value is None: + self.debug("could not get shape from value") + shape = self._get_shape_from_max_dim_size() + else: + import numpy + try: + shape = numpy.shape(value) + except Exception: + self.debug("could not get shape from value") + shape = self._get_shape_from_max_dim_size() + # scalar channel + else: + shape = [] + return shape + + shape = property(get_shape, doc="channel value shape") + def _prepare(self): # TODO: think of implementing the preparation in the software # acquisition action, similarly as it is done for the global diff --git a/src/sardana/pool/poolbasegroup.py b/src/sardana/pool/poolbasegroup.py index c7f456bc14..3eb182aac9 100644 --- a/src/sardana/pool/poolbasegroup.py +++ b/src/sardana/pool/poolbasegroup.py @@ -357,6 +357,8 @@ def stop(self): for ctrl, elements in list(self.get_physical_elements().items()): self.debug("Stopping %s %s", ctrl.name, [e.name for e in elements]) + for el in elements: + el._stopped = True try: error_elements = ctrl.stop_elements(elements=elements) if len(error_elements) > 0: diff --git a/src/sardana/pool/poolcontrollers/DummyOneDController.py b/src/sardana/pool/poolcontrollers/DummyOneDController.py index 88f4e38ac5..0009cc67c6 100644 --- a/src/sardana/pool/poolcontrollers/DummyOneDController.py +++ b/src/sardana/pool/poolcontrollers/DummyOneDController.py @@ -44,6 +44,7 @@ def __init__(self, idx): self.active = True self.amplitude = BaseValue('1.0') self._counter = 0 + self.roi = [0, 0] class BaseValue(object): @@ -89,7 +90,15 @@ class DummyOneDController(OneDController): FGet: 'getAmplitude', FSet: 'setAmplitude', Description: 'Amplitude. Maybe a number or a tango attribute(must start with tango://)', - DefaultValue: '1.0'}, + DefaultValue: '1.0' + }, + 'RoI': { + Type: (int,), + FGet: 'getRoI', + FSet: 'setRoI', + Description: "Region of Interest of spectrum (begin, end)", + DefaultValue: [0, 0] + } } def __init__(self, inst, props, *args, **kwargs): @@ -170,7 +179,11 @@ def _updateChannelValue(self, axis, elapsed_time): t = self.integ_time x = numpy.linspace(-10, 10, self.BufferSize[0]) amplitude = axis * t * channel.amplitude.get() - channel.value = gauss(x, 0, amplitude, 4) + spectrum = gauss(x, 0, amplitude, 4) + roi = channel.roi + if roi != [0, 0]: + spectrum = spectrum[roi[0]:roi[1]] + channel.value = spectrum elif self._synchronization in (AcqSynch.HardwareTrigger, AcqSynch.HardwareGate): if self.integ_time is not None: @@ -277,3 +290,39 @@ def setAmplitude(self, axis, value): if value.startswith("tango://"): klass = TangoValue channel.amplitude = klass(value) + + def getRoI(self, axis): + idx = axis - 1 + channel = self.channels[idx] + return channel.roi + + def setRoI(self, axis, value): + idx = axis - 1 + channel = self.channels[idx] + try: + value = value.tolist() + except AttributeError: + pass + if len(value) != 2: + raise ValueError("RoI is not a list of two elements") + if any(not isinstance(v, int) for v in value): + raise ValueError("RoI is not a list of integers") + if value != [0, 0] and value[1] <= value[0]: + raise ValueError("RoI[1] is lower or equal than RoI[0]") + dim = self.BufferSize[0] + if value[0] > (dim - 1): + raise ValueError( + "RoI[0] exceeds detector dimension - 1 ({})".format(dim - 1)) + if value[1] > dim: + raise ValueError( + "RoI[1] exceeds detector dimension ({})".format(dim)) + channel.roi = value + + def GetAxisPar(self, axis, par): + idx = axis - 1 + channel = self.channels[idx] + if par == "shape": + roi = channel.roi + if roi == [0, 0]: + return self.BufferSize + return [roi[1] - roi[0]] diff --git a/src/sardana/pool/poolcontrollers/DummyTriggerGateController.py b/src/sardana/pool/poolcontrollers/DummyTriggerGateController.py index f2795057b6..bd746ed8ac 100644 --- a/src/sardana/pool/poolcontrollers/DummyTriggerGateController.py +++ b/src/sardana/pool/poolcontrollers/DummyTriggerGateController.py @@ -72,6 +72,9 @@ def StateOne(self, axis): print(e) return sta, status + def PrepareOne(self, axis, nb_starts): + self._log.debug('PrepareOne(%d): entering...' % axis) + def PreStartAll(self): pass diff --git a/src/sardana/pool/poolcontrollers/DummyTwoDController.py b/src/sardana/pool/poolcontrollers/DummyTwoDController.py index fdd543b933..d648a3f5dc 100644 --- a/src/sardana/pool/poolcontrollers/DummyTwoDController.py +++ b/src/sardana/pool/poolcontrollers/DummyTwoDController.py @@ -107,6 +107,7 @@ def __init__(self, idx): self.saving_enabled = False self.value_ref_pattern = "h5file:///tmp/dummy2d_default_{index}.h5" self.value_ref_enabled = False + self.roi = [0, 0, 0, 0] class BaseValue(object): @@ -164,7 +165,16 @@ class BasicDummyTwoDController(TwoDController): FSet: 'setAmplitude', Description: ("Amplitude. Maybe a number or a tango attribute " "(must start with tango://)"), - DefaultValue: '1.0'} + DefaultValue: '1.0' + }, + 'RoI': { + Type: (int,), + FGet: 'getRoI', + FSet: 'setRoI', + Description: ("Region of Interest of image " + "(begin_x, end_x, begin_y, end_y)"), + DefaultValue: [0, 0, 0, 0] + } } def __init__(self, inst, props, *args, **kwargs): @@ -284,6 +294,9 @@ def _updateChannelValue(self, axis, elapsed_time): y_size = self.BufferSize[1] amplitude = axis * self.integ_time * channel.amplitude.get() img = generate_img(x_size, y_size, amplitude) + roi = channel.roi + if roi != [0, 0, 0, 0]: + img = img[roi[0]:roi[1], roi[2]:roi[3]] if self._synchronization == AcqSynch.SoftwareTrigger: channel.value = img channel.acq_idx += 1 @@ -368,6 +381,45 @@ def setAmplitude(self, axis, value): klass = TangoValue channel.amplitude = klass(value) + def getRoI(self, axis): + idx = axis - 1 + channel = self.channels[idx] + return channel.roi + + def setRoI(self, axis, value): + idx = axis - 1 + channel = self.channels[idx] + try: + value = value.tolist() + except AttributeError: + pass + if len(value) != 4: + raise ValueError("RoI is not a list of four elements") + if any(not isinstance(v, int) for v in value): + raise ValueError("RoI is not a list of integers") + if value != [0, 0, 0, 0]: + if value[1] <= value[0]: + raise ValueError("RoI[1] is lower or equal than RoI[0]") + if value[3] <= value[2]: + raise ValueError("RoI[3] is lower or equal than RoI[2]") + x_dim = self.BufferSize[0] + if value[0] > (x_dim - 1): + raise ValueError( + "RoI[0] exceeds detector X dimension - 1 ({})".format( + x_dim - 1)) + if value[1] > x_dim: + raise ValueError( + "RoI[1] exceeds detector X dimension ({})".format(x_dim)) + y_dim = self.BufferSize[1] + if value[2] > (y_dim - 1): + raise ValueError( + "RoI[2] exceeds detector Y dimension - 1 ({})".format( + y_dim - 1)) + if value[3] > y_dim: + raise ValueError( + "RoI[3] exceeds detector Y dimension ({})".format(y_dim)) + channel.roi = value + def GetCtrlPar(self, par): if par == "synchronization": return self._synchronization @@ -378,6 +430,15 @@ def SetCtrlPar(self, par, value): if par == "synchronization": self._synchronization = value + def GetAxisPar(self, axis, par): + idx = axis - 1 + channel = self.channels[idx] + if par == "shape": + roi = channel.roi + if roi == [0, 0, 0, 0]: + return self.BufferSize + return [roi[1] - roi[0], roi[3] - roi[2]] + def getSynchronizer(self): if self._synchronizer is None: return "None" @@ -436,7 +497,7 @@ def event_received(self, src, type_, value): e.g. start, active passive """ # for the moment only react on first trigger - if type_.name.lower() == "active" and value == 0: + if type_.name.lower() == "start": self._armed = False for axis, channel in self.counting_channels.items(): channel.is_counting = True @@ -488,6 +549,9 @@ def _updateChannelValue(self, axis, elapsed_time): y_size = self.BufferSize[1] amplitude = axis * self.integ_time * channel.amplitude.get() img = generate_img(x_size, y_size, amplitude) + roi = channel.roi + if roi != [0, 0, 0, 0]: + img = img[roi[0]:roi[1], roi[2]:roi[3]] if self._synchronization == AcqSynch.SoftwareTrigger: channel.value = img if channel.value_ref_enabled: diff --git a/src/sardana/pool/poolmeasurementgroup.py b/src/sardana/pool/poolmeasurementgroup.py index 6776a6f045..44dc34ac38 100644 --- a/src/sardana/pool/poolmeasurementgroup.py +++ b/src/sardana/pool/poolmeasurementgroup.py @@ -124,6 +124,40 @@ def _to_fqdn(name, logger=None): return full_name +def _filter_ctrls(ctrls, enabled=None): + if enabled is None: + return ctrls + + filtered_ctrls = [] + for ctrl in ctrls: + if ctrl.enabled == enabled: + filtered_ctrls.append(ctrl) + return filtered_ctrls + + +def _get_timerable_ctrls(ctrls, acq_synch=None, enabled=None): + timerable_ctrls = [] + if acq_synch is None: + for ctrls in list(ctrls.values()): + timerable_ctrls += ctrls + elif isinstance(acq_synch, list): + acq_synch_list = acq_synch + for acq_synch in acq_synch_list: + timerable_ctrls += ctrls[acq_synch] + else: + timerable_ctrls = list(ctrls[acq_synch]) + + return _filter_ctrls(timerable_ctrls, enabled) + + +def _get_timerable_channels(ctrls, acq_synch=None, enabled=None): + timerable_ctrls = _get_timerable_ctrls(ctrls, acq_synch, enabled) + timerable_channels = [] + for ctrl in timerable_ctrls: + timerable_channels.extend(ctrl.get_channels(enabled)) + return timerable_channels + + class ConfigurationItem(object): """Container of configuration attributes related to a given element. @@ -482,16 +516,6 @@ def get_acq_synch_by_controller(self, controller): controller = controller.element return self._ctrl_acq_synch[controller] - def _filter_ctrls(self, ctrls, enabled): - if enabled is None: - return ctrls - - filtered_ctrls = [] - for ctrl in ctrls: - if ctrl.enabled == enabled: - filtered_ctrls.append(ctrl) - return filtered_ctrls - def get_timerable_ctrls(self, acq_synch=None, enabled=None): """Return timerable controllers. @@ -512,18 +536,30 @@ def get_timerable_ctrls(self, acq_synch=None, enabled=None): :return: timerable controllers that fulfils the filtering criteria :rtype: list<:class:`~sardana.pool.poolmeasurementgroup.ControllerConfiguration`> # noqa """ - timerable_ctrls = [] - if acq_synch is None: - for ctrls in list(self._timerable_ctrls.values()): - timerable_ctrls += ctrls - elif isinstance(acq_synch, list): - acq_synch_list = acq_synch - for acq_synch in acq_synch_list: - timerable_ctrls += self._timerable_ctrls[acq_synch] - else: - timerable_ctrls = list(self._timerable_ctrls[acq_synch]) + return _get_timerable_ctrls(self._timerable_ctrls, acq_synch, enabled) - return self._filter_ctrls(timerable_ctrls, enabled) + def get_timerable_channels(self, acq_synch=None, enabled=None): + """Return timerable channels. + + Allow to filter channels based on acquisition synchronization or + whether these are enabled/disabled. + + :param acq_synch: (optional) filter controller based on acquisition + synchronization + :type acq_synch: :class:`~sardana.pool.pooldefs.AcqSynch` + :param enabled: (optional) filter controllers whether these are + enabled/disabled: + + - :obj:`True` - enabled only + - :obj:`False` - disabled only + - :obj:`None` - all + + :type enabled: :obj:`bool` or :obj:`None` + :return: timerable channels that fulfils the filtering criteria + :rtype: list<:class:`~sardana.pool.poolmeasurementgroup.ChannelConfiguration`> # noqa + """ + return _get_timerable_channels(self._timerable_ctrls, acq_synch, + enabled) def get_zerod_ctrls(self, enabled=None): """Return 0D controllers. @@ -541,7 +577,7 @@ def get_zerod_ctrls(self, enabled=None): :return: 0D controllers that fulfils the filtering criteria :rtype: list<:class:`~sardana.pool.poolmeasurementgroup.ControllerConfiguration`> # noqa """ - return self._filter_ctrls(self._zerod_ctrls, enabled) + return _filter_ctrls(self._zerod_ctrls, enabled) def get_synch_ctrls(self, enabled=None): """Return synchronizer (currently only trigger/gate) controllers. @@ -559,7 +595,7 @@ def get_synch_ctrls(self, enabled=None): :return: synchronizer controllers that fulfils the filtering criteria :rtype: list<:class:`~sardana.pool.poolmeasurementgroup.ControllerConfiguration`> # noqa """ - return self._filter_ctrls(self._synch_ctrls, enabled) + return _filter_ctrls(self._synch_ctrls, enabled) def get_master_timer_software(self): """Return master timer in software acquisition. @@ -601,8 +637,9 @@ def set_configuration_from_user(self, cfg): """Set measurement configuration from serializable data structure. Setting of the configuration includes the validation process. Setting - of invalid configuration raises an exception hence it is not necessary - that the client application does the validation. + of invalid configuration raises an exception and leaves the object + as it was before the setting process. Thanks to that it is not + necessary that the client application does the validation. The configuration parameters for given channels/controllers may differ depending on their types e.g. 0D channel does not support timer @@ -842,29 +879,46 @@ def set_configuration_from_user(self, cfg): # Fill user configuration with measurement group's timer & monitor # This is a backwards compatibility cause the measurement group's # timer & monitor are not used - if master_timer_sw is not None: + mnt_grp_timer = cfg.get('timer') + if mnt_grp_timer: + timerable_chs = _get_timerable_channels(timerable_ctrls, + enabled=True) + if len(timerable_chs) > 0: + if mnt_grp_timer in [ch.full_name for ch in timerable_chs]: + user_config['timer'] = mnt_grp_timer + else: + raise ValueError( + 'timer {} is not present/enabled'.format(mnt_grp_timer) + ) + elif master_timer_sw is not None: user_config['timer'] = master_timer_sw.full_name elif master_timer_sw_start is not None: user_config['timer'] = master_timer_sw_start.full_name - else: # Measurement Group with all channel synchronized by hardware - mnt_grp_timer = cfg.get('timer') - if mnt_grp_timer: - user_config['timer'] = mnt_grp_timer - else: - # for backwards compatibility use a random monitor - user_config['timer'] = user_config_ctrl['timer'] - - if master_monitor_sw is not None: + else: + # Measurement Group with all channel synchronized by hardware + # for backwards compatibility use a random monitor + user_config['timer'] = user_config_ctrl['timer'] + + mnt_grp_monitor = cfg.get('monitor') + if mnt_grp_monitor: + timerable_chs = _get_timerable_channels(timerable_ctrls, + enabled=True) + if len(timerable_chs) > 0: + if mnt_grp_monitor in [ch.full_name for ch in timerable_chs]: + user_config['monitor'] = mnt_grp_monitor + else: + raise ValueError( + 'monitor {} is not present/enabled'.format( + mnt_grp_monitor)) + elif master_monitor_sw is not None: user_config['monitor'] = master_monitor_sw.full_name elif master_monitor_sw_start is not None: user_config['monitor'] = master_monitor_sw_start.full_name - else: # Measurement Group with all channel synchronized by hardware - mnt_grp_monitor = cfg.get('monitor') - if mnt_grp_monitor: - user_config['monitor'] = mnt_grp_monitor - else: - # for backwards compatibility use a random monitor - user_config['monitor'] = user_config_ctrl['monitor'] + else: + # Measurement Group with all channel synchronized by hardware + # for backwards compatibility use a random monitor + user_config['monitor'] = user_config_ctrl['monitor'] + # Update internals values self._label = label @@ -953,7 +1007,7 @@ def _fill_channel_data(self, channel, channel_data): channel_data['normalization'] = channel_data.get('normalization', Normalization.No) # TODO: think of filling other keys: data_type, data_units, nexus_path - # shape here instead of feeling them on the Taurus extension level + # here instead of feeling them on the Taurus extension level if ctype != ElementType.External: ctrl_name = channel.controller.full_name diff --git a/src/sardana/pool/poolmotor.py b/src/sardana/pool/poolmotor.py index da281c21d3..bba40d11bc 100644 --- a/src/sardana/pool/poolmotor.py +++ b/src/sardana/pool/poolmotor.py @@ -417,6 +417,8 @@ def get_sign(self, cache=True): return self._sign def set_sign(self, sign, propagate=1): + assert sign in (-1, 1), \ + "sign must be either -1 or 1 (not {})".format(sign) old_sign = self._sign.value self._sign.set_value(sign, propagate=propagate) # invert lower with upper limit switches and send event in case of diff --git a/src/sardana/pool/poolpseudomotor.py b/src/sardana/pool/poolpseudomotor.py index 7819b4cdea..e63fb214ab 100644 --- a/src/sardana/pool/poolpseudomotor.py +++ b/src/sardana/pool/poolpseudomotor.py @@ -135,7 +135,7 @@ def get_physical_write_positions(self): # because of a cold start pos_attr.update(propagate=0) if pos_attr.in_error(): - raise PoolException("Cannot get '%' position" % pos_attr.obj.name, + raise PoolException("Cannot get '%s' position" % pos_attr.obj.name, exc_info=pos_attr.exc_info) value = pos_attr.value ret.append(value) @@ -149,7 +149,7 @@ def get_physical_positions(self): if not pos_attr.has_value(): pos_attr.update(propagate=0) if pos_attr.in_error(): - raise PoolException("Cannot get '%' position" % pos_attr.obj.name, + raise PoolException("Cannot get '%s' position" % pos_attr.obj.name, exc_info=pos_attr.exc_info) ret.append(pos_attr.value) return ret diff --git a/src/sardana/pool/test/test_acquisition.py b/src/sardana/pool/test/test_acquisition.py index cf0c1139e8..7b02dd8370 100644 --- a/src/sardana/pool/test/test_acquisition.py +++ b/src/sardana/pool/test/test_acquisition.py @@ -27,7 +27,7 @@ import numpy -from unittest import TestCase +from unittest import TestCase, mock from taurus.test import insertTest from sardana.sardanautils import is_number, is_pure_str @@ -567,6 +567,14 @@ def setUp(self): self.data_listener = AttributeListener(dtype=object, attr_name="valuebuffer") + def acquire(self, integ_time, repetitions, latency_time): + ctrl = self.channel_ctrl.ctrl + with mock.patch.object(ctrl, "ReadOne", + wraps=ctrl.ReadOne) as mock_ReadOne: + BaseAcquisitionHardwareTestCase.acquire(self, integ_time, + repetitions, latency_time) + assert mock_ReadOne.call_count > 1 + @insertTest(helper_name='acquire', integ_time=0.01, repetitions=10, latency_time=0.02) @@ -592,6 +600,14 @@ def _prepare(self, integ_time, repetitions, latency_time, nb_starts): axis = self.channel.axis self.channel_ctrl.set_axis_par(axis, "value_ref_enabled", True) + def acquire(self, integ_time, repetitions, latency_time): + ctrl = self.channel_ctrl.ctrl + with mock.patch.object(ctrl, "RefOne", + wraps=ctrl.RefOne) as mock_RefOne: + BaseAcquisitionHardwareTestCase.acquire(self, integ_time, + repetitions, latency_time) + assert mock_RefOne.call_count > 1 + @insertTest(helper_name='acquire', integ_time=0.01, repetitions=10, latency_time=0.02) @@ -610,6 +626,14 @@ def setUp(self): self.data_listener = AttributeListener(dtype=object, attr_name="valuebuffer") + def acquire(self, integ_time, repetitions, latency_time): + ctrl = self.channel_ctrl.ctrl + with mock.patch.object(ctrl, "ReadOne", + wraps=ctrl.ReadOne) as mock_ReadOne: + BaseAcquisitionHardwareTestCase.acquire(self, integ_time, + repetitions, latency_time) + assert mock_ReadOne.call_count > 1 + @insertTest(helper_name='acquire', integ_time=0.01, repetitions=10, latency_time=0.02) @@ -628,6 +652,14 @@ def setUp(self): self.data_listener = AttributeListener(dtype=object, attr_name="valuebuffer") + def acquire(self, integ_time, repetitions, latency_time): + ctrl = self.channel_ctrl.ctrl + with mock.patch.object(ctrl, "ReadOne", + wraps=ctrl.ReadOne) as mock_ReadOne: + BaseAcquisitionHardwareTestCase.acquire(self, integ_time, + repetitions, latency_time) + assert mock_ReadOne.call_count > 1 + @insertTest(helper_name='acquire', integ_time=0.01, repetitions=10, latency_time=0.02) @@ -652,6 +684,14 @@ def _prepare(self, integ_time, repetitions, latency_time, nb_starts): axis = self.channel.axis self.channel_ctrl.set_axis_par(axis, "value_ref_enabled", True) + def acquire(self, integ_time, repetitions, latency_time): + ctrl = self.channel_ctrl.ctrl + with mock.patch.object(ctrl, "RefOne", + wraps=ctrl.RefOne) as mock_RefOne: + BaseAcquisitionHardwareTestCase.acquire(self, integ_time, + repetitions, latency_time) + assert mock_RefOne.call_count > 1 + @insertTest(helper_name='acquire', integ_time=0.01, repetitions=10, latency_time=0.02) diff --git a/src/sardana/release.py b/src/sardana/release.py index c4d742b604..d9af23114a 100644 --- a/src/sardana/release.py +++ b/src/sardana/release.py @@ -47,7 +47,7 @@ # we use semantic versioning (http://semver.org/) and we update it using the # bumpversion script (https://github.com/peritus/bumpversion) -version = '3.0.3' +version = '3.1.0' description = "instrument control and data acquisition system" diff --git a/src/sardana/sardanacustomsettings.py b/src/sardana/sardanacustomsettings.py index 97c4859628..f535a34082 100644 --- a/src/sardana/sardanacustomsettings.py +++ b/src/sardana/sardanacustomsettings.py @@ -37,10 +37,13 @@ #: UnitTests Pool Device name: Pool Device to use in unit tests. UNITTEST_POOL_NAME = "pool/demo1/1" -#: Size and number of rotating backups of the log files. -#: The Pool and MacroServer Device servers will use these values for their -#: logs. +#: Size of rotating backups of the log files. +#: The Pool, MacroServer and Sardana device servers will use these values +#: for their logs. LOG_FILES_SIZE = 1e7 +#: Number of rotating backups of the log files. +#: The Pool, MacroServer and Sardana device servers will use these values +#: for their logs. LOG_BCK_COUNT = 5 #: Input handler for spock interactive macros. Accepted values are: @@ -92,7 +95,7 @@ #: - "dumb" - worst performance but directly available with Python 3. MS_ENV_SHELVE_BACKEND = None -#: macroexecutor maximum number of macros stored in the history. +#: macroexecutor maximum number of macros stored in the history. #: Available options: #: #: - None (or no setting) - unlimited history (may slow down the GUI operation @@ -100,3 +103,13 @@ #: - 0 - history will not be filled #: - - max number of macros stored in the history MACROEXECUTOR_MAX_HISTORY = 100 + +#: pre-move and post-move hooks applied in simple mv-based macros +#: Available options: +#: +#: - True (or no setting) - macros which are hooked to the pre-move and +#: post-move hook places are called before and/or after any move of a motor +#: - False - macros which are hooked to the pre-move and post-move hook +#: places are not called in simple mv-based macros but only in scan-based +#: macros +PRE_POST_MOVE_HOOK_IN_MV = True diff --git a/src/sardana/spock/inputhandler.py b/src/sardana/spock/inputhandler.py index 7b9b6f93c3..73add6ef0c 100644 --- a/src/sardana/spock/inputhandler.py +++ b/src/sardana/spock/inputhandler.py @@ -25,18 +25,10 @@ """Spock submodule. It contains an input handler""" -__all__ = ['SpockInputHandler', 'InputHandler'] +__all__ = ['SpockInputHandler'] __docformat__ = 'restructuredtext' -import sys -from multiprocessing import Process, Pipe - -from taurus.core import TaurusManager -from taurus.core.util.singleton import Singleton -from taurus.external.qt import Qt, compat -from taurus.qt.qtgui.dialog import TaurusMessageBox, TaurusInputDialog - from sardana.taurus.core.tango.sardana.macroserver import BaseInputHandler from sardana.spock import genutils @@ -67,103 +59,3 @@ def input(self, input_data=None): def input_timeout(self, input_data): print("SpockInputHandler input timeout") - - -class MessageHandler(Qt.QObject): - - messageArrived = Qt.pyqtSignal(compat.PY_OBJECT) - - def __init__(self, conn, parent=None): - Qt.QObject.__init__(self, parent) - self._conn = conn - self._dialog = None - self.messageArrived.connect(self.on_message) - - def handle_message(self, input_data): - self.messageArrived.emit(input_data) - - def on_message(self, input_data): - msg_type = input_data['type'] - if msg_type == 'input': - if 'macro_name' in input_data and 'title' not in input_data: - input_data['title'] = input_data['macro_name'] - self._dialog = dialog = TaurusInputDialog(input_data=input_data) - dialog.activateWindow() - dialog.exec_() - ok = dialog.result() - value = dialog.value() - ret = dict(input=None, cancel=False) - if ok: - ret['input'] = value - else: - ret['cancel'] = True - self._conn.send(ret) - elif msg_type == 'timeout': - dialog = self._dialog - if dialog: - dialog.close() - - -class InputHandler(Singleton, BaseInputHandler): - - def __init__(self): - # don't call super __init__ on purpose - pass - - def init(self, *args, **kwargs): - self._conn, child_conn = Pipe() - self._proc = proc = Process(target=self.safe_run, - name="SpockInputHandler", args=(child_conn,)) - proc.daemon = True - proc.start() - - def input(self, input_data=None): - # parent process - data_type = input_data.get('data_type', 'String') - if isinstance(data_type, str): - ms = genutils.get_macro_server() - interfaces = ms.getInterfaces() - if data_type in interfaces: - input_data['data_type'] = [ - elem.name for elem in list(interfaces[data_type].values())] - self._conn.send(input_data) - ret = self._conn.recv() - return ret - - def input_timeout(self, input_data): - # parent process - self._conn.send(input_data) - - def safe_run(self, conn): - # child process - try: - return self.run(conn) - except Exception as e: - msgbox = TaurusMessageBox(*sys.exc_info()) - conn.send((e, False)) - msgbox.exec_() - - def run(self, conn): - # child process - self._conn = conn - app = Qt.QApplication.instance() - if app is None: - app = Qt.QApplication(['spock']) - app.setQuitOnLastWindowClosed(False) - self._msg_handler = MessageHandler(conn) - TaurusManager().addJob(self.run_forever, None) - app.exec_() - conn.close() - print("Quit input handler") - - def run_forever(self): - # child process - message, conn = True, self._conn - while message: - message = conn.recv() - if not message: - continue - self._msg_handler.handle_message(message) - app = Qt.QApplication.instance() - if app: - app.quit() diff --git a/src/sardana/spock/ipython_01_00/genutils.py b/src/sardana/spock/ipython_01_00/genutils.py index 1c26d28af8..c92ca164df 100644 --- a/src/sardana/spock/ipython_01_00/genutils.py +++ b/src/sardana/spock/ipython_01_00/genutils.py @@ -82,7 +82,10 @@ from taurus.core.util.codecs import CodecFactory # make sure Qt is properly initialized -from taurus.external.qt import Qt +try: + from taurus.external.qt import Qt +except ImportError: + pass from sardana.spock import exception from sardana.spock import colors @@ -110,7 +113,11 @@ def get_gui_mode(): - return 'qt' + try: + import taurus.external.qt.Qt + return 'qt' + except ImportError: + return None def get_pylab_mode(): @@ -1159,7 +1166,8 @@ def out_prompt_tokens(self): term_app = config.TerminalIPythonApp term_app.display_banner = True term_app.gui = gui_mode - term_app.pylab = 'qt' + if gui_mode == 'qt': + term_app.pylab = 'qt' term_app.pylab_import_all = False #term_app.nosep = False #term_app.classic = True @@ -1280,8 +1288,16 @@ def mainloop(app=None, user_ns=None): def prepare_input_handler(): # initialize input handler as soon as possible - import sardana.spock.inputhandler - _ = sardana.spock.inputhandler.InputHandler() + + from sardana import sardanacustomsettings + + if getattr(sardanacustomsettings, "SPOCK_INPUT_HANDLER", "CLI") == "Qt": + + try: + import sardana.spock.qtinputhandler + _ = sardana.spock.qtinputhandler.InputHandler() + except ImportError: + raise Exception("Cannot use Spock Qt input handler!") def prepare_cmdline(argv=None): diff --git a/src/sardana/spock/magic.py b/src/sardana/spock/magic.py index 0f4b1c6126..f5578052e2 100644 --- a/src/sardana/spock/magic.py +++ b/src/sardana/spock/magic.py @@ -40,6 +40,15 @@ def expconf(self, parameter_s=''): """Launches a GUI for configuring the environment variables for the experiments (scans)""" + + try: + from taurus.external.qt import Qt + except ImportError: + print("Qt binding is not available. ExpConf cannot work without it." + "(hint: maybe you want to use experiment configuration macros? " + "https://sardana-controls.org/users/standard_macro_catalog.html#experiment-configuration-macros)") + return + try: from sardana.taurus.qt.qtgui.extra_sardana import ExpDescriptionEditor except: @@ -81,38 +90,20 @@ def showscan(self, parameter_s=''): Where *online* means plot the scan as it runs and *offline* means - extract the scan data from the file - works only with HDF5 files. """ + + try: + from taurus.external.qt import Qt + except ImportError: + print("Qt binding is not available. Showscan cannot work without it.") + return + params = parameter_s.split() door = get_door() scan_nb = None if len(params) > 0: if params[0].lower() == 'online': - try: - from sardana.taurus.qt.qtgui.extra_sardana import \ - ShowScanOnline - - except Exception as e: - print("Error importing ShowScanOnline") - print(e) - return - - doorname = get_door().fullname - # =============================================================== - # ugly hack to avoid ipython/qt thread problems #e.g. see - # https://sourceforge.net/p/sardana/tickets/10/ - # this hack does not allow inter-process communication and - # leaves the widget open after closing spock - # - # @todo: investigate cause of segfaults when using launching qt - # widgets from ipython - # - - # https://sourceforge.net/p/sardana/tickets/10/ import subprocess - import sys - fname = sys.modules[ShowScanOnline.__module__].__file__ - python_executable = which_python_executable() - args = [python_executable, fname, doorname, - '--taurus-log-level=error'] + args = ['showscan', '--taurus-log-level=error', get_door().fullname] subprocess.Popen(args) return else: @@ -121,6 +112,12 @@ def showscan(self, parameter_s=''): def spsplot(self, parameter_s=''): + try: + from taurus.external.qt import Qt + except ImportError: + print("Qt binding is not available. SPSplot cannot work without it.") + return + get_door().plot() diff --git a/src/sardana/spock/qtinputhandler.py b/src/sardana/spock/qtinputhandler.py new file mode 100644 index 0000000000..c1dea5d8eb --- /dev/null +++ b/src/sardana/spock/qtinputhandler.py @@ -0,0 +1,142 @@ +#!/usr/bin/env python + +############################################################################## +## +# This file is part of Sardana +## +# http://www.sardana-controls.org/ +## +# Copyright 2011 CELLS / ALBA Synchrotron, Bellaterra, Spain +## +# Sardana is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +## +# Sardana is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +## +# You should have received a copy of the GNU Lesser General Public License +# along with Sardana. If not, see . +## +############################################################################## + +"""Spock submodule. It contains an input handler""" + +__all__ = ['InputHandler'] + +__docformat__ = 'restructuredtext' + +import sys +from multiprocessing import Process, Pipe + +from taurus.core import TaurusManager +from taurus.core.util.singleton import Singleton +from taurus.external.qt import Qt, compat +from taurus.qt.qtgui.dialog import TaurusMessageBox, TaurusInputDialog + +from sardana.taurus.core.tango.sardana.macroserver import BaseInputHandler + +from sardana.spock import genutils + + +class MessageHandler(Qt.QObject): + + messageArrived = Qt.pyqtSignal(compat.PY_OBJECT) + + def __init__(self, conn, parent=None): + Qt.QObject.__init__(self, parent) + self._conn = conn + self._dialog = None + self.messageArrived.connect(self.on_message) + + def handle_message(self, input_data): + self.messageArrived.emit(input_data) + + def on_message(self, input_data): + msg_type = input_data['type'] + if msg_type == 'input': + if 'macro_name' in input_data and 'title' not in input_data: + input_data['title'] = input_data['macro_name'] + self._dialog = dialog = TaurusInputDialog(input_data=input_data) + dialog.activateWindow() + dialog.exec_() + ok = dialog.result() + value = dialog.value() + ret = dict(input=None, cancel=False) + if ok: + ret['input'] = value + else: + ret['cancel'] = True + self._conn.send(ret) + elif msg_type == 'timeout': + dialog = self._dialog + if dialog: + dialog.close() + + +class InputHandler(Singleton, BaseInputHandler): + + def __init__(self): + # don't call super __init__ on purpose + pass + + def init(self, *args, **kwargs): + self._conn, child_conn = Pipe() + self._proc = proc = Process(target=self.safe_run, + name="SpockInputHandler", args=(child_conn,)) + proc.daemon = True + proc.start() + + def input(self, input_data=None): + # parent process + data_type = input_data.get('data_type', 'String') + if isinstance(data_type, str): + ms = genutils.get_macro_server() + interfaces = ms.getInterfaces() + if data_type in interfaces: + input_data['data_type'] = [ + elem.name for elem in list(interfaces[data_type].values())] + self._conn.send(input_data) + ret = self._conn.recv() + return ret + + def input_timeout(self, input_data): + # parent process + self._conn.send(input_data) + + def safe_run(self, conn): + # child process + try: + return self.run(conn) + except Exception as e: + msgbox = TaurusMessageBox(*sys.exc_info()) + conn.send((e, False)) + msgbox.exec_() + + def run(self, conn): + # child process + self._conn = conn + app = Qt.QApplication.instance() + if app is None: + app = Qt.QApplication(['spock']) + app.setQuitOnLastWindowClosed(False) + self._msg_handler = MessageHandler(conn) + TaurusManager().addJob(self.run_forever, None) + app.exec_() + conn.close() + print("Quit input handler") + + def run_forever(self): + # child process + message, conn = True, self._conn + while message: + message = conn.recv() + if not message: + continue + self._msg_handler.handle_message(message) + app = Qt.QApplication.instance() + if app: + app.quit() diff --git a/src/sardana/spock/spockms.py b/src/sardana/spock/spockms.py index adbcf9853a..78c511c8c5 100644 --- a/src/sardana/spock/spockms.py +++ b/src/sardana/spock/spockms.py @@ -38,7 +38,6 @@ from sardana.sardanautils import is_pure_str, is_non_str_seq from sardana.spock import genutils from sardana.util.parser import ParamParser -from sardana.spock.inputhandler import SpockInputHandler, InputHandler from sardana import sardanacustomsettings CHANGE_EVTS = TaurusEventType.Change, TaurusEventType.Periodic @@ -290,7 +289,9 @@ def __init__(self, name, **kw): self.call__init__(BaseDoor, name, **kw) def create_input_handler(self): - return SpockInputHandler(self) + from sardana.spock.inputhandler import SpockInputHandler + + return SpockInputHandler() def get_color_mode(self): return genutils.get_color_mode() @@ -513,6 +514,11 @@ def processRecordData(self, data): and data['type'] == 'function'): func_name = data['func_name'] if func_name.startswith("pyplot."): + try: + from taurus.external.qt import Qt + except ImportError: + print("Qt binding is not available. Macro plotting cannot work without it.") + return func_name = self.MathFrontend + "." + func_name args = data['args'] kwargs = data['kwargs'] @@ -554,9 +560,6 @@ def _processRecordData(self, data): return BaseDoor._processRecordData(self, data) -from taurus.external.qt import Qt - - class QSpockDoor(SpockBaseDoor): def __init__(self, name, **kw): @@ -575,6 +578,9 @@ def recordDataReceived(self, s, t, v): return res def create_input_handler(self): + from sardana.spock.inputhandler import SpockInputHandler + from sardana.spock.qtinputhandler import InputHandler + inputhandler = getattr(sardanacustomsettings, 'SPOCK_INPUT_HANDLER', "CLI") diff --git a/src/sardana/tango/core/SardanaDevice.py b/src/sardana/tango/core/SardanaDevice.py index 3e496be7a2..5539b084b8 100644 --- a/src/sardana/tango/core/SardanaDevice.py +++ b/src/sardana/tango/core/SardanaDevice.py @@ -35,7 +35,7 @@ import threading import PyTango.constants -from PyTango import Device_4Impl, DeviceClass, Util, DevState, \ +from PyTango import LatestDeviceImpl, DeviceClass, Util, DevState, \ AttrQuality, TimeVal, ArgType, ApiUtil, DevFailed, WAttribute from taurus.core.util.threadpool import ThreadPool @@ -66,7 +66,7 @@ def get_thread_pool(): return __thread_pool -class SardanaDevice(Device_4Impl, Logger): +class SardanaDevice(LatestDeviceImpl, Logger): """SardanaDevice represents the base class for all Sardana :class:`PyTango.DeviceImpl` classes""" @@ -74,7 +74,7 @@ def __init__(self, dclass, name): """Constructor""" self.in_constructor = True try: - Device_4Impl.__init__(self, dclass, name) + LatestDeviceImpl.__init__(self, dclass, name) self.init(name) Logger.__init__(self, name) @@ -170,6 +170,14 @@ def init_device(self): non_detect_evts = () self.set_change_events(detect_evts, non_detect_evts) + def sardana_init_hook(self): + """Hook that is called before the server event loop. + + The idea behind this hook is to be equivalent to server_init_hook from + Tango. Similar behaviour can be archived using post_init_callback. + """ + pass + def _get_nodb_device_info(self): """Internal method. Returns the device info when tango database is not being used (example: in demos)""" @@ -512,7 +520,7 @@ def _get_class_properties(self): return dict(ProjectTitle="Sardana", Description="Generic description", doc_url="http://sardana-controls.org/", __icon=self.get_name().lower() + ".png", - InheritedFrom=["Device_4Impl"]) + InheritedFrom=["Device_5Impl"]) def write_class_property(self): """Write class properties ``ProjectTitle``, ``Description``, diff --git a/src/sardana/tango/core/util.py b/src/sardana/tango/core/util.py index 7f84681d03..0bb258dd84 100644 --- a/src/sardana/tango/core/util.py +++ b/src/sardana/tango/core/util.py @@ -1206,7 +1206,7 @@ def prepare_logging(options, args, tango_args, start_time=None, def prepare_rconsole(options, args, tango_args): port = options.rconsole_port - if port is None or port is 0: + if port is None or port == 0: return taurus.debug("Setting up rconsole on port %d...", port) try: @@ -1218,12 +1218,20 @@ def prepare_rconsole(options, args, tango_args): def run_tango_server(tango_util=None, start_time=None): + # Import here to avoid circular import + from sardana.tango.core.SardanaDevice import SardanaDevice + try: if tango_util is None: tango_util = Util(sys.argv) util = Util.instance() SardanaServer.server_state = State.Init util.server_init() + + for device in util.get_device_list("*"): + if isinstance(device, SardanaDevice): + device.sardana_init_hook() + SardanaServer.server_state = State.Running if start_time is not None: import datetime diff --git a/src/sardana/tango/macroserver/MacroServer.py b/src/sardana/tango/macroserver/MacroServer.py index b21c0f14c6..8b736a96d2 100644 --- a/src/sardana/tango/macroserver/MacroServer.py +++ b/src/sardana/tango/macroserver/MacroServer.py @@ -120,7 +120,6 @@ def init_device(self): macro_server.set_recorder_path(self.RecorderPath) macro_server.set_macro_path(self.MacroPath) - macro_server.set_pool_names(self.PoolNames) if self.RConsolePort: try: @@ -131,6 +130,9 @@ def init_device(self): self.debug("Details:", exc_info=1) self.set_state(DevState.ON) + def sardana_init_hook(self): + self.macro_server.set_pool_names(self.PoolNames) + def _calculate_name(self, name): if name is None: return None @@ -247,15 +249,17 @@ def is_Elements_allowed(self, req_type): is_TypeList_allowed = is_Elements_allowed def GetMacroInfo(self, macro_names): - """GetMacroInfo(list macro_names): + """Get macro information + + Returns a list of strings containing macro information. + Each string is a JSON encoded. + + Args: + macro_names (list(str)): macro(s) name(s) - Returns a list of string containing macro information. - Each string is a JSON encoded. + Returns: + list(str): macro(s) information - Params: - - macro_name: a list of strings with the macro(s) name(s) - Returns: - - a list of string containing macro information. """ macro_server = self.macro_server codec = CodecFactory().getCodec('json') diff --git a/src/sardana/tango/macroserver/test/macroexecutor.py b/src/sardana/tango/macroserver/test/macroexecutor.py index 9459301336..3a43d2aa74 100644 --- a/src/sardana/tango/macroserver/test/macroexecutor.py +++ b/src/sardana/tango/macroserver/test/macroexecutor.py @@ -25,6 +25,7 @@ import copy import time +import atexit import threading import PyTango from sardana.macroserver.macros.test import BaseMacroExecutor @@ -127,6 +128,8 @@ class TangoMacroExecutor(BaseMacroExecutor): Macro executor implemented using Tango communication with the Door device ''' + _api_util_cleanup_registered = False + def __init__(self, door_name=None): super(TangoMacroExecutor, self).__init__() if door_name is None: @@ -134,6 +137,10 @@ def __init__(self, door_name=None): self._door = PyTango.DeviceProxy(door_name) self._done_event = None self._started_event = None + if not TangoMacroExecutor._api_util_cleanup_registered: + # remove whenever PyTango#390 gets fixed + atexit.register(PyTango.ApiUtil.cleanup) + TangoMacroExecutor._api_util_cleanup_registered = True def _clean(self): '''Recreates threading Events in case the macro executor is reused.''' diff --git a/src/sardana/tango/pool/Pool.py b/src/sardana/tango/pool/Pool.py index e073abf4f4..54c0e29934 100644 --- a/src/sardana/tango/pool/Pool.py +++ b/src/sardana/tango/pool/Pool.py @@ -48,12 +48,12 @@ import collections -class Pool(PyTango.Device_4Impl, Logger): +class Pool(PyTango.LatestDeviceImpl, Logger): ElementsCache = None def __init__(self, cl, name): - PyTango.Device_4Impl.__init__(self, cl, name) + PyTango.LatestDeviceImpl.__init__(self, cl, name) Logger.__init__(self, name) self.init(name) self.init_device() @@ -1576,7 +1576,7 @@ def __init__(self, name): def _get_class_properties(self): return dict(ProjectTitle="Sardana", Description="Device Pool management class", doc_url="http://sardana-controls.org/", - InheritedFrom="Device_4Impl") + InheritedFrom="Device_5Impl") def write_class_property(self): util = PyTango.Util.instance() diff --git a/src/sardana/tango/pool/PoolDevice.py b/src/sardana/tango/pool/PoolDevice.py index ca4ce9b944..5ecd5ee59a 100644 --- a/src/sardana/tango/pool/PoolDevice.py +++ b/src/sardana/tango/pool/PoolDevice.py @@ -33,6 +33,7 @@ __docformat__ = 'restructuredtext' import time +from copy import deepcopy from PyTango import Util, DevVoid, DevLong64, DevBoolean, DevString,\ DevDouble, DevEncoded, DevVarStringArray, DispLevel, DevState, SCALAR, \ @@ -690,7 +691,9 @@ def _get_dynamic_attributes(self): attr_name_lower = attr_name.lower() if attr_name_lower in std_attrs_lower: data_info = DataInfo.toDataInfo(attr_name, attr_info) - tg_info = dev_class.standard_attr_list[attr_name] + # copy in order to leave the class attributes untouched + # the downstream code can append MaxDimSize to the attr. info + tg_info = deepcopy(dev_class.standard_attr_list[attr_name]) std_attrs[attr_name] = attr_name, tg_info, data_info else: data_info = DataInfo.toDataInfo(attr_name, attr_info) @@ -899,7 +902,7 @@ def _encode_value_ref_chunk(self, value_ref_chunk): def initialize_dynamic_attributes(self): attrs = PoolElementDevice.initialize_dynamic_attributes(self) - non_detect_evts = "integrationtime", + non_detect_evts = "integrationtime", "shape" for attr_name in non_detect_evts: if attr_name in attrs: @@ -938,6 +941,13 @@ def write_IntegrationTime(self, attr): :type attr: :class:`~PyTango.Attribute`""" self.element.integration_time = attr.get_write_value() + def read_Shape(self, attr): + """Reads the shape. + + :param attr: tango attribute + :type attr: :class:`~PyTango.Attribute`""" + attr.set_value(self.element.get_shape(cache=False)) + class PoolExpChannelDeviceClass(PoolElementDeviceClass): @@ -952,7 +962,14 @@ class PoolExpChannelDeviceClass(PoolElementDeviceClass): attr_list.update(PoolElementDeviceClass.attr_list) standard_attr_list = { - 'ValueBuffer': [[DevEncoded, SCALAR, READ]] + 'ValueBuffer': [[DevEncoded, SCALAR, READ]], + 'Shape': [[DevLong64, SPECTRUM, READ, 2], + {'label': "Shape (X,Y)", + 'description': "Shape of the value. It is an array with \n" + "at most 2 elements: X and Y dimensions. \n" + "0-element array - scalar\n" + "1-element array (X) - spectrum\n" + "2-element array (X, Y) - image"}], } standard_attr_list.update(PoolElementDeviceClass.standard_attr_list) diff --git a/src/sardana/tango/pool/PseudoCounter.py b/src/sardana/tango/pool/PseudoCounter.py index f1c422295a..9293d9cf6b 100644 --- a/src/sardana/tango/pool/PseudoCounter.py +++ b/src/sardana/tango/pool/PseudoCounter.py @@ -152,6 +152,8 @@ def _on_pseudo_counter_changed(self, event_source, event_type, else: value = event_value.value timestamp = event_value.timestamp + else: + value = event_value self.set_attribute(attr, value=value, w_value=w_value, timestamp=timestamp, quality=quality, diff --git a/src/sardana/tango/pool/test/base_sartest.py b/src/sardana/tango/pool/test/base_sartest.py index cbd7901501..28ff386303 100644 --- a/src/sardana/tango/pool/test/base_sartest.py +++ b/src/sardana/tango/pool/test/base_sartest.py @@ -23,6 +23,8 @@ ## ############################################################################## +import os + import PyTango import taurus @@ -168,7 +170,8 @@ def tearDown(self): if elem_name in f.tango_alias_devs: _cleanup_device(elem_name) try: - self.pool.DeleteElement(elem_name) + if os.name != "nt": + self.pool.DeleteElement(elem_name) except Exception as e: print(e) dirty_elems.append(elem_name) @@ -182,7 +185,8 @@ def tearDown(self): if ctrl_name in f.tango_alias_devs: _cleanup_device(ctrl_name) try: - self.pool.DeleteElement(ctrl_name) + if os.name != "nt": + self.pool.DeleteElement(ctrl_name) except: dirty_ctrls.append(ctrl_name) diff --git a/src/sardana/tango/pool/test/test_Motor.py b/src/sardana/tango/pool/test/test_Motor.py index 52f1d8f683..6c113bf4c3 100644 --- a/src/sardana/tango/pool/test/test_Motor.py +++ b/src/sardana/tango/pool/test/test_Motor.py @@ -24,6 +24,8 @@ ############################################################################## """Tests Read Position from Sardana using PyTango""" +import os + import PyTango import unittest from sardana.tango.pool.test import BasePoolTestCase @@ -70,6 +72,7 @@ def test_read_position_outside_sw_lim(self): def tearDown(self): """Remove motor element and motor controller """ - self.pool.DeleteElement(self.elem_name) - self.pool.DeleteElement(self.ctrl_name) + if os.name != "nt": + self.pool.DeleteElement(self.elem_name) + self.pool.DeleteElement(self.ctrl_name) super(ReadMotorPositionOutsideLim, self).tearDown() diff --git a/src/sardana/tango/pool/test/test_measurementgroup.py b/src/sardana/tango/pool/test/test_measurementgroup.py index 042db14541..6873aed7b0 100644 --- a/src/sardana/tango/pool/test/test_measurementgroup.py +++ b/src/sardana/tango/pool/test/test_measurementgroup.py @@ -27,6 +27,7 @@ import json import os import time +import atexit import threading # TODO: decide what to use: taurus or PyTango @@ -35,6 +36,7 @@ import unittest from taurus.test import insertTest from taurus.core.util import CodecFactory +from taurus.core.tango.tangovalidator import TangoDeviceNameValidator from sardana import sardanacustomsettings from sardana.pool import AcqSynchType, SynchDomain, SynchParam @@ -52,14 +54,8 @@ def _get_full_name(device_proxy, logger=None): host = device_proxy.get_db_host() # this is FQDN port = device_proxy.get_db_port() db_name = host + ":" + port - full_name = db_name + "/" + device_proxy.name() - # try to use Taurus 4 to retrieve FQDN - try: - from taurus.core.tango.tangovalidator import TangoDeviceNameValidator - full_name, _, _ = TangoDeviceNameValidator().getNames(full_name) - # if Taurus3 in use just continue - except ImportError: - pass + full_name = "//" + db_name + "/" + device_proxy.name() + full_name, _, _ = TangoDeviceNameValidator().getNames(full_name) return full_name @@ -108,10 +104,17 @@ def event_received(self, *args, **kwargs): class MeasSarTestTestCase(SarTestTestCase): """ Helper class to setup the need environmet for execute """ + _api_util_cleanup_registered = False + def setUp(self, pool_properties=None): SarTestTestCase.setUp(self, pool_properties) self.event_ids = {} self.mg_name = '_test_mg_1' + if not MeasSarTestTestCase._api_util_cleanup_registered: + # remove whenever PyTango#390 gets fixed + atexit.register(PyTango.ApiUtil.cleanup) + MeasSarTestTestCase._api_util_cleanup_registered = True + def create_meas(self, config): """ Create a meas with the given configuration @@ -279,7 +282,8 @@ def tearDown(self): channel.unsubscribe_event(event_id) try: # Delete the meas - self.pool.DeleteElement(self.mg_name) + if os.name != "nt": + self.pool.DeleteElement(self.mg_name) except Exception as e: print('Impossible to delete MeasurementGroup: %s' % self.mg_name) diff --git a/src/sardana/tango/pool/test/test_persistence.py b/src/sardana/tango/pool/test/test_persistence.py index cac52dc997..c2a2134bbf 100644 --- a/src/sardana/tango/pool/test/test_persistence.py +++ b/src/sardana/tango/pool/test/test_persistence.py @@ -22,6 +22,7 @@ # along with Sardana. If not, see . ## ############################################################################## +import os import PyTango import unittest @@ -86,11 +87,13 @@ def tearDown(self): cleanup_success = True if self.do_element_cleanup: try: - self.pool.DeleteElement(self.elem_name) + if os.name != "nt": + self.pool.DeleteElement(self.elem_name) except: cleanup_success = False try: - self.pool.DeleteElement(self.ctrl_name) + if os.name != "nt": + self.pool.DeleteElement(self.ctrl_name) except: cleanup_success = False BasePoolTestCase.tearDown(self) diff --git a/src/sardana/taurus/core/tango/sardana/macro.py b/src/sardana/taurus/core/tango/sardana/macro.py index d77feb4f91..5e3d112e07 100644 --- a/src/sardana/taurus/core/tango/sardana/macro.py +++ b/src/sardana/taurus/core/tango/sardana/macro.py @@ -32,6 +32,7 @@ import os import copy +import uuid import types import tempfile @@ -88,6 +89,9 @@ def _buildDoc(self): if self.hasResult(): doc += '\n\nResult:\n\t' doc += '\n\t'.join(self.getResultDescr()) + if self.allowsHooks(): + doc += '\n\nAllows hooks:\n\t' + doc += '\n\t'.join(self.getAllowedHooks()) self.doc = doc def _hasParamComplex(self, parameters=None): @@ -136,7 +140,7 @@ def hasParams(self): :return: (bool) True if the macro has parameters or False otherwise """ - return hasattr(self, 'parameters') + return hasattr(self, 'parameters') and len(self.parameters) > 0 def getParamList(self): """Returs the list of parameters @@ -222,7 +226,7 @@ def hasResult(self): :return: (bool) True if the macro has a result or False otherwise """ - return hasattr(self, 'result') + return hasattr(self, 'result') and len(self.result) > 0 def getResultList(self): """Returns the list of results @@ -298,6 +302,31 @@ def formatResult(self, result): else: return tuple(res) + def allowsHooks(self): + """Checks whether the macro allows hooks + + :return: True or False depending if the macro allows hooks + :rtype: bool + """ + try: + self.hints["allowsHooks"] + except KeyError: + return False + return True + + def getAllowedHooks(self): + """Gets allowed hooks + + :return: list with the allowed hooks or empty list if the macro + does not allow hooks + :rtype: list[str] + """ + try: + allowed_hooks = self.hints["allowsHooks"] + except KeyError: + return [] + return allowed_hooks + def __str__(self): return self.name @@ -833,7 +862,6 @@ def fromList(self, params): class MacroNode(BranchNode): """Class to represent macro element.""" - count = 0 def __init__(self, parent=None, name=None, params_def=None, macro_info=None): @@ -867,7 +895,7 @@ def id(self): """ Getter of macro's id property - :return: (int) + :return: (str) .. seealso: :meth:`MacroNode.setId`, assignId """ @@ -878,7 +906,7 @@ def setId(self, id): """ Setter of macro's id property - :param id: (int) new macro's id + :param id: (str) new macro's id See Also: id, assignId """ @@ -890,16 +918,13 @@ def assignId(self): If macro didn't have an assigned id it assigns it and return macro's id. - :return: (int) + :return: (str) See Also: id, setId """ - id = self.id() - if id is not None: - return id - MacroNode.count += 1 - self.setId(MacroNode.count) - return MacroNode.count + id_ = str(uuid.uuid1()) + self.setId(id_) + return id_ def name(self): return self._name @@ -1160,7 +1185,7 @@ def toXml(self, withId=True): if withId: id_ = self.id() if id_ is not None: - macroElement.set("id", str(self.id())) + macroElement.set("id", self.id()) for hookPlace in self.hookPlaces(): hookElement = etree.SubElement(macroElement, "hookPlace") hookElement.text = hookPlace diff --git a/src/sardana/taurus/core/tango/sardana/macroserver.py b/src/sardana/taurus/core/tango/sardana/macroserver.py index 8849c9ef81..783d558b5c 100644 --- a/src/sardana/taurus/core/tango/sardana/macroserver.py +++ b/src/sardana/taurus/core/tango/sardana/macroserver.py @@ -424,11 +424,10 @@ def macro_server(self): def _get_macroserver_for_door(self): """Returns the MacroServer device object in the same DeviceServer as this door""" - db = self.factory().getDatabase() + db = self.getParentObj() door_name = self.dev_name() server_list = list(db.get_server_list('MacroServer/*')) server_list += list(db.get_server_list('Sardana/*')) - server_devs = None for server in server_list: server_devs = db.get_device_class_list(server) devs, klasses = server_devs[0::2], server_devs[1::2] @@ -436,7 +435,8 @@ def _get_macroserver_for_door(self): if dev.lower() == door_name: for i, klass in enumerate(klasses): if klass == 'MacroServer': - return self.factory().getDevice(devs[i]) + full_name = db.getFullName() + "/" + devs[i] + return self.factory().getDevice(full_name) else: return None @@ -665,7 +665,7 @@ def _processInput(self, input_data): input_type = input_data['type'] if input_type == 'input': result = self._input_handler.input(input_data) - if result['input'] is '' and 'default_value' in input_data: + if result['input'] == '' and 'default_value' in input_data: result['input'] = input_data['default_value'] result = CodecFactory().encode('json', ('', result))[1] self.write_attribute('Input', result) diff --git a/src/sardana/taurus/core/tango/sardana/motion.py b/src/sardana/taurus/core/tango/sardana/motion.py index ace214903e..cc28ae9492 100644 --- a/src/sardana/taurus/core/tango/sardana/motion.py +++ b/src/sardana/taurus/core/tango/sardana/motion.py @@ -30,6 +30,7 @@ __docformat__ = 'restructuredtext' import time +from collections import OrderedDict from taurus.core.util.containers import CaselessDict @@ -270,7 +271,7 @@ def init_by_names(self, names, moveable_srcs, allow_repeat, allow_unknown): allow_repeat=allow_repeat, allow_unknown=allow_unknown) # map - ms_moveables = {} + ms_moveables = OrderedDict() for moveable_source, ms_names in list(ms_elem_names.items()): moveable = moveable_source.getMoveable(ms_names) ms_moveables[moveable_source] = moveable @@ -330,7 +331,7 @@ def getElemNamesByMoveableSource(self, names, moveable_sources, belong to the that motion source. """ - ms_elems = {} + ms_elems = OrderedDict() for name in names: moveable = None diff --git a/src/sardana/taurus/core/tango/sardana/pool.py b/src/sardana/taurus/core/tango/sardana/pool.py index 91c2bfa124..8f476ad29e 100644 --- a/src/sardana/taurus/core/tango/sardana/pool.py +++ b/src/sardana/taurus/core/tango/sardana/pool.py @@ -2460,8 +2460,8 @@ def setIntegrationTime(self, ctime): def putIntegrationTime(self, ctime): if self._last_integ_time == ctime: return - self._last_integ_time = ctime self.getIntegrationTimeObj().write(ctime) + self._last_integ_time = ctime def getAcquisitionModeObj(self): return self._getAttrEG('AcquisitionMode') diff --git a/src/sardana/taurus/core/tango/sardana/sardana.py b/src/sardana/taurus/core/tango/sardana/sardana.py index 1b0fc8c9b2..f14f94f80c 100644 --- a/src/sardana/taurus/core/tango/sardana/sardana.py +++ b/src/sardana/taurus/core/tango/sardana/sardana.py @@ -56,7 +56,7 @@ "PlotAxes", "Timer", "Monitor", "Synchronization", "ValueRefPattern", "ValueRefEnabled", "Conditioning", "Normalization", "NXPath", - "Shape", "DataType", "Unknown", "Synchronizer")) + "DataType", "Unknown", "Synchronizer")) PlotType = Enumeration("PlotType", ("No", "Spectrum", "Image")) diff --git a/src/sardana/taurus/core/tango/sardana/test/test_measgrpconf.py b/src/sardana/taurus/core/tango/sardana/test/test_measgrpconf.py index d7addfc2de..46f30d6eb3 100644 --- a/src/sardana/taurus/core/tango/sardana/test/test_measgrpconf.py +++ b/src/sardana/taurus/core/tango/sardana/test/test_measgrpconf.py @@ -1,3 +1,4 @@ +import os import uuid import unittest from taurus import Device @@ -90,7 +91,8 @@ def test_enabled(self, elements=["_test_ct_1_1", "_test_ct_1_2", self._assertResult(resutl, full_names, True) finally: mg.cleanUp() - self.pool.DeleteElement(mg_name) + if os.name != "nt": + self.pool.DeleteElement(mg_name) def test_output(self, elements=["_test_ct_1_1", "_test_ct_1_2", "_test_2d_1_3", @@ -145,7 +147,8 @@ def test_output(self, elements=["_test_ct_1_1", "_test_ct_1_2", self._assertResult(is_output, full_names, True) finally: mg.cleanUp() - self.pool.DeleteElement(mg_name) + if os.name != "nt": + self.pool.DeleteElement(mg_name) def test_PlotType(self, elements=["_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3", "_test_2d_1_3", @@ -193,7 +196,8 @@ def test_PlotType(self, elements=["_test_ct_1_1", "_test_ct_1_2", finally: mg.cleanUp() - self.pool.DeleteElement(mg_name) + if os.name != "nt": + self.pool.DeleteElement(mg_name) def test_PlotAxes(self, elements=["_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3", "_test_2d_1_3", @@ -267,7 +271,8 @@ def test_PlotAxes(self, elements=["_test_ct_1_1", "_test_ct_1_2", self._assertMultipleResults(result, full_names, expected_result) finally: mg.cleanUp() - self.pool.DeleteElement(mg_name) + if os.name != "nt": + self.pool.DeleteElement(mg_name) def test_Timer(self, elements=["_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3", @@ -279,8 +284,9 @@ def test_Timer(self, elements=["_test_ct_1_1", "_test_ct_1_2", mg = Device(mg_name) result = mg.getTimer("_test_mt_1_3/position") - with self.assertRaises(Exception): - mg.setTimer("_test_mt_1_3/position") + if os.name != "nt": + with self.assertRaises(Exception): + mg.setTimer("_test_mt_1_3/position") self._assertResult(result, ["_test_mt_1_3/position"], None) mg.setTimer('_test_ct_1_3') result = mg.getTimer(*elements) @@ -311,7 +317,8 @@ def test_Timer(self, elements=["_test_ct_1_1", "_test_ct_1_2", self._assertResult(result, full_names, "_test_ct_1_2") finally: mg.cleanUp() - self.pool.DeleteElement(mg_name) + if os.name != "nt": + self.pool.DeleteElement(mg_name) def test_Monitor(self, elements=["_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3", "_test_2d_1_1", @@ -323,8 +330,9 @@ def test_Monitor(self, elements=["_test_ct_1_1", "_test_ct_1_2", try: mg = Device(mg_name) - with self.assertRaises(Exception): - mg.setMonitor("_test_mt_1_3/position") + if os.name != "nt": + with self.assertRaises(Exception): + mg.setMonitor("_test_mt_1_3/position") mg.setMonitor('_test_2d_1_2') mg.setMonitor("_test_ct_1_3") @@ -352,7 +360,8 @@ def test_Monitor(self, elements=["_test_ct_1_1", "_test_ct_1_2", self._assertMultipleResults(result, full_names, expected) finally: mg.cleanUp() - self.pool.DeleteElement(mg_name) + if os.name != "nt": + self.pool.DeleteElement(mg_name) def test_Synchronizer(self, elements=["_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3", "_test_2d_1_1", @@ -365,8 +374,10 @@ def test_Synchronizer(self, elements=["_test_ct_1_1", "_test_ct_1_2", result = mg.getSynchronizer() expected = ['software', 'software', 'software', 'software', None] self._assertMultipleResults(result, elements, expected) - with self.assertRaises(Exception): - mg.setSynchronizer('_test_tg_1_2', "_test_mt_1_3/position") + + if os.name != "nt": + with self.assertRaises(Exception): + mg.setSynchronizer('_test_tg_1_2', "_test_mt_1_3/position") mg.setSynchronizer('_test_tg_1_2', "_test_ct_ctrl_1", "_test_2d_ctrl_1") @@ -400,7 +411,8 @@ def test_Synchronizer(self, elements=["_test_ct_1_1", "_test_ct_1_2", finally: mg.cleanUp() - self.pool.DeleteElement(mg_name) + if os.name != "nt": + self.pool.DeleteElement(mg_name) def test_Synchronization(self, elements=["_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3", "_test_2d_1_1", @@ -452,7 +464,8 @@ def test_Synchronization(self, elements=["_test_ct_1_1", "_test_ct_1_2", finally: mg.cleanUp() - self.pool.DeleteElement(mg_name) + if os.name != "nt": + self.pool.DeleteElement(mg_name) def test_ValueRefEnabled(self, elements=["_test_2d_1_1", "_test_2d_1_2", "_test_ct_1_3", @@ -512,7 +525,8 @@ def test_ValueRefEnabled(self, elements=["_test_2d_1_1", "_test_2d_1_2", self._assertResult(enabled, full_names, True) finally: mg.cleanUp() - self.pool.DeleteElement(mg_name) + if os.name != "nt": + self.pool.DeleteElement(mg_name) def test_ValueRefPattern(self, elements=["_test_2d_1_1", "_test_2d_1_2", "_test_ct_1_3", @@ -565,4 +579,5 @@ def test_ValueRefPattern(self, elements=["_test_2d_1_1", "_test_2d_1_2", finally: mg.cleanUp() - self.pool.DeleteElement(mg_name) + if os.name != "nt": + self.pool.DeleteElement(mg_name) diff --git a/src/sardana/taurus/core/tango/sardana/test/test_measgrpstress.py b/src/sardana/taurus/core/tango/sardana/test/test_measgrpstress.py index 5f751c7d4c..3c03c6604a 100644 --- a/src/sardana/taurus/core/tango/sardana/test/test_measgrpstress.py +++ b/src/sardana/taurus/core/tango/sardana/test/test_measgrpstress.py @@ -23,6 +23,7 @@ ## ############################################################################## +import os import uuid from unittest import TestCase @@ -67,6 +68,11 @@ def setUp(self): registerExtensions() def stress_count(self, elements, repeats, synchronizer, synchronization): + if (elements == ["_test_ct_1_1", "_test_0d_1_1"] + and synchronizer == "_test_tg_1_1" + and synchronization == AcqSynchType.Trigger + and os.name == "nt"): + self.skipTest("fails on Windows") mg_name = str(uuid.uuid1()) argin = [mg_name] + elements self.pool.CreateMeasurementGroup(argin) @@ -84,7 +90,8 @@ def stress_count(self, elements, repeats, synchronizer, synchronization): self.assertTrue(is_numerical(value), msg) finally: mg.cleanUp() - self.pool.DeleteElement(mg_name) + if os.name != "nt": + self.pool.DeleteElement(mg_name) def tearDown(self): SarTestTestCase.tearDown(self) diff --git a/src/sardana/taurus/core/tango/sardana/test/test_pool.py b/src/sardana/taurus/core/tango/sardana/test/test_pool.py index 292b4ef2aa..8166b01689 100644 --- a/src/sardana/taurus/core/tango/sardana/test/test_pool.py +++ b/src/sardana/taurus/core/tango/sardana/test/test_pool.py @@ -23,7 +23,7 @@ ## ############################################################################## - +import os import uuid import numpy @@ -78,7 +78,8 @@ def count(self, elements): self.assertTrue(is_numerical(value), msg) finally: mg.cleanUp() - self.pool.DeleteElement(mg_name) + if os.name != "nt": + self.pool.DeleteElement(mg_name) def tearDown(self): SarTestTestCase.tearDown(self) @@ -107,7 +108,8 @@ def test_value_ref_enabled(self): finally: channel.cleanUp() mg.cleanUp() - self.pool.DeleteElement(mg_name) + if os.name != "nt": + self.pool.DeleteElement(mg_name) def test_value_ref_disabled(self): mg_name = str(uuid.uuid1()) @@ -126,7 +128,8 @@ def test_value_ref_disabled(self): finally: channel.cleanUp() mg.cleanUp() - self.pool.DeleteElement(mg_name) + if os.name != "nt": + self.pool.DeleteElement(mg_name) def tearDown(self): SarTestTestCase.tearDown(self) diff --git a/src/sardana/taurus/qt/qtgui/extra_macroexecutor/macroexecutor.py b/src/sardana/taurus/qt/qtgui/extra_macroexecutor/macroexecutor.py index e1a4193a57..659cb60c6c 100644 --- a/src/sardana/taurus/qt/qtgui/extra_macroexecutor/macroexecutor.py +++ b/src/sardana/taurus/qt/qtgui/extra_macroexecutor/macroexecutor.py @@ -937,7 +937,6 @@ def onMacroStatusUpdated(self, data): "range"], data["step"], data["id"] if id is None: return - id = int(id) if id != self.macroId(): return macroName = macro.name diff --git a/src/sardana/taurus/qt/qtgui/extra_macroexecutor/sequenceeditor/sequenceeditor.py b/src/sardana/taurus/qt/qtgui/extra_macroexecutor/sequenceeditor/sequenceeditor.py index 45c6feab7c..0a49fd9353 100644 --- a/src/sardana/taurus/qt/qtgui/extra_macroexecutor/sequenceeditor/sequenceeditor.py +++ b/src/sardana/taurus/qt/qtgui/extra_macroexecutor/sequenceeditor/sequenceeditor.py @@ -727,7 +727,6 @@ def onMacroStatusUpdated(self, data): "range"], data["step"], data["id"] if id is None: return - id = int(id) if not id in self.macroIds(): return macroName = macro.name diff --git a/src/sardana/taurus/qt/qtgui/extra_pool/poolmotor.py b/src/sardana/taurus/qt/qtgui/extra_pool/poolmotor.py index a31d5db83c..b2ec6f8b48 100644 --- a/src/sardana/taurus/qt/qtgui/extra_pool/poolmotor.py +++ b/src/sardana/taurus/qt/qtgui/extra_pool/poolmotor.py @@ -595,6 +595,7 @@ def __init__(self, parent=None, designMode=False): self.layout().addLayout(limits_layout, 0, 0) self.lbl_read = TaurusLabel() + self.lbl_read.setFgRole('rvalue.magnitude') self.lbl_read.setBgRole('quality') self.lbl_read.setSizePolicy(Qt.QSizePolicy( Qt.QSizePolicy.Expanding, Qt.QSizePolicy.Fixed)) diff --git a/src/sardana/taurus/qt/qtgui/extra_sardana/measurementgroup.py b/src/sardana/taurus/qt/qtgui/extra_sardana/measurementgroup.py index e7c16f7e01..3d6171800e 100644 --- a/src/sardana/taurus/qt/qtgui/extra_sardana/measurementgroup.py +++ b/src/sardana/taurus/qt/qtgui/extra_sardana/measurementgroup.py @@ -136,7 +136,7 @@ def createChannelDict(channel, index=None, **kwargs): # If the channel is a Tango one, try to guess data_type, shape and # data_units attrproxy = attrconf = value = None - dtype = shape = None + dtype = None try: attrproxy = PyTango.AttributeProxy(source) attrconf = attrproxy.get_config() @@ -147,15 +147,9 @@ def createChannelDict(channel, index=None, **kwargs): print(str(e)) if value is not None: - shape = list(numpy.shape(value)) dtype = getattr(value, 'dtype', numpy.dtype(type(value))).name ret['data_units'] = attrconf.unit elif attrconf is not None: - if attrconf.data_format == PyTango.AttrDataFormat.SCALAR: - shape = [] - else: - shape = [n for n in (attrconf.max_dim_x, - attrconf.max_dim_y) if n > 0] dtype = FROM_TANGO_TO_STR_TYPE[attrconf.data_type] ret['data_units'] = attrconf.unit @@ -166,8 +160,6 @@ def createChannelDict(channel, index=None, **kwargs): # elif dtype == 'bool': # dtype='int8' ret['data_type'] = dtype - if shape is not None: - ret['shape'] = shape # now overwrite using the arguments ret.update(kwargs) @@ -179,13 +171,7 @@ def createChannelDict(channel, index=None, **kwargs): # Choose a default plot_type for the channel if 'plot_type' not in ret: - default_plot_type = {0: PlotType.Spectrum, - 2: PlotType.Image, None: PlotType.No} - try: - rank = len(ret['shape']) - except KeyError: - rank = None # if shape is not known, use the default plot_type - ret['plot_type'] = default_plot_type.get(rank, PlotType.No) + ret['plot_type'] = PlotType.No # And a default value for plot_axes if 'plot_axes' not in ret: @@ -248,8 +234,6 @@ def getElementTypeToolTip(t): return "Channel active or not" elif t == ChannelView.Output: return "Channel output active or not" - elif t == ChannelView.Shape: - return "Shape of the data (using numpy convention). For example, a scalar will have shape=(), a spectrum of 10 elements will have shape=(10,) and an image of 20x30 will be shape=(20,30)" elif t == ChannelView.DataType: return "Type of data for storing (valid types are: char, float32, float64, [u]int{8|16|32|64})", elif t == ChannelView.PlotType: @@ -305,7 +289,6 @@ class MntGrpChannelItem(BaseMntGrpChannelItem): itemdata_keys_map = {ChannelView.Channel: 'label', ChannelView.Enabled: 'enabled', ChannelView.Output: 'output', - ChannelView.Shape: 'shape', ChannelView.DataType: 'data_type', ChannelView.PlotType: 'plot_type', ChannelView.PlotAxes: 'plot_axes', @@ -334,8 +317,6 @@ def data(self, index): ret = Normalization[ret] elif taurus_role == ChannelView.PlotAxes: ret = "|".join(ret) - elif taurus_role == ChannelView.Shape: - ret = str(ret) return ret def setData(self, index, qvalue): @@ -363,16 +344,6 @@ def setData(self, index, qvalue): data = Normalization[qvalue] elif taurus_role == ChannelView.PlotAxes: data = [a for a in qvalue.split('|')] - elif taurus_role == ChannelView.Shape: - s = qvalue - try: - data = eval(s, {}, {}) - if not isinstance(data, (tuple, list)): - raise ValueError - except: - from taurus.core.util.log import Logger - Logger(self.__class__.__name__).error('Invalid shape %s', s) - data = () else: raise NotImplementedError('Unknown role') ch_data[key] = data @@ -394,13 +365,13 @@ class MntGrpUnitItem(TaurusBaseTreeItem): class BaseMntGrpChannelModel(TaurusBaseModel): - ColumnNames = ("Channel", "enabled", "output", "Shape", "Data Type", + ColumnNames = ("Channel", "enabled", "output", "Data Type", "Plot Type", "Plot Axes", "Timer", "Monitor", "Synchronizer", "Synchronization", "Ref Enabled", "Ref Pattern", "Conditioning", "Normalization", "NeXus Path") ColumnRoles = ((ChannelView.Channel, ChannelView.Channel), - ChannelView.Enabled, ChannelView.Output, ChannelView.Shape, + ChannelView.Enabled, ChannelView.Output, ChannelView.DataType, ChannelView.PlotType, ChannelView.PlotAxes, ChannelView.Timer, ChannelView.Monitor, ChannelView.Synchronizer, @@ -978,7 +949,7 @@ class MntGrpChannelEditor(TaurusBaseTableWidget): DftPerspective = "Channel" _simpleViewColumns = (ChannelView.Channel, ChannelView.Output, - ChannelView.Shape, ChannelView.PlotType, ChannelView.PlotAxes) + ChannelView.PlotType, ChannelView.PlotAxes) _simpleView = False def __init__(self, parent=None, designMode=False, with_filter_widget=True, perspective=None): diff --git a/src/sardana/taurus/qt/qtgui/extra_sardana/qtspock.py b/src/sardana/taurus/qt/qtgui/extra_sardana/qtspock.py index 54d8535170..2dfdfc41a3 100644 --- a/src/sardana/taurus/qt/qtgui/extra_sardana/qtspock.py +++ b/src/sardana/taurus/qt/qtgui/extra_sardana/qtspock.py @@ -36,6 +36,7 @@ import pickle import ast +import traitlets from IPython.core.profiledir import ProfileDirError, ProfileDir from taurus.external.qt import Qt @@ -145,9 +146,10 @@ class QtSpockWidget(RichJupyterWidget, TaurusBaseWidget): from taurus.external.qt import Qt from sardana.taurus.qt.qtgui.extra_sardana.qtspock import QtSpockWidget - app = Qt.QApplication([]) - widget = QtSpockWidget() + app = Qt.QApplication(["qtspock"]) + widget = QtSpockWidget(use_model_from_profile=True) widget.show() + widget.start_kernel() app.aboutToQuit.connect(widget.shutdown_kernel) app.exec_() """ @@ -179,6 +181,9 @@ def __init__( self._macro_server_alias = None self._door_name = None self._door_alias = None + self._config_passed_as_extra_arguments = False + + self.append_stream("Waiting for kernel to start") self.kernel_manager = SpockKernelManager(kernel_name=kernel) self.kernel_manager.kernel_about_to_launch.connect( @@ -204,6 +209,7 @@ def _extra_arguments(self): if not self.use_model_from_profile: if self._macro_server_name and self._door_name: + self._config_passed_as_extra_arguments = True extra_arguments.append("--Spock.macro_server={}".format( self._macro_server_name)) extra_arguments.append("--Spock.macro_server_alias={}".format( @@ -270,7 +276,15 @@ def _set_macro_server_name(self, door): self._macro_server_alias = None def _set_prompts(self): - var = "get_ipython().config.Spock.door_alias" + # If traitlets >= 5.0.0 then DeferredConfigString is used for values + # that are not listed in the configurable classes. Get its value. + if (traitlets.version_info >= (5, 0, 0) + and self._config_passed_as_extra_arguments): + self.kernel_client.execute( + "from sardana.spock.config import Spock", silent=True) + var = "get_ipython().config.Spock.door_alias.get_value(Spock.door_alias)" # noqa + else: + var = "get_ipython().config.Spock.door_alias" self._silent_exec_callback( var, self._set_prompts_callback) diff --git a/src/sardana/taurus/qt/qtgui/extra_sardana/showscanonline.py b/src/sardana/taurus/qt/qtgui/extra_sardana/showscanonline.py index 102eab1aae..44d7fbeaa7 100644 --- a/src/sardana/taurus/qt/qtgui/extra_sardana/showscanonline.py +++ b/src/sardana/taurus/qt/qtgui/extra_sardana/showscanonline.py @@ -23,21 +23,228 @@ ## ############################################################################## -"""This module contains a taurus ShowScanOnline widget.""" +""" +This module contains a taurus ShowScanWidget, ShowScanWindow and ShowScanOnline +widgets. +""" -__all__ = ["ShowScanOnline"] +__all__ = [ + "ScanInfoForm", "ScanPointForm", "ScanPlotWidget", + "ScanPlotWindow", "ScanWindow", "ShowScanOnline" +] import click +import pkg_resources +from taurus.external.qt import Qt, uic +from taurus.qt.qtgui.base import TaurusBaseWidget from taurus.qt.qtgui.taurusgui import TaurusGui -from sardana.taurus.qt.qtgui.macrolistener import (DynamicPlotManager, - assertPlotAvailability) +from sardana.taurus.qt.qtgui.macrolistener import ( + MultiPlotWidget, PlotManager, DynamicPlotManager, assertPlotAvailability +) + + +def set_text(label, field=None, data=None, default='---'): + if field is None and data is None: + value = default + elif field is None: + value = data + elif data is None: + value = field + else: + value = data.get(field, default) + if isinstance(value, (tuple, list)): + value = ', '.join(value) + elif isinstance(value, float): + value = '{:8.4f}'.format(value) + else: + value = str(value) + if len(value) > 60: + value = '...{}'.format(value[-57:]) + label.setText(value) + + +def resize_form(form, new_size): + layout = form.layout() + curr_size = layout.rowCount() + nb = new_size - curr_size + while nb > 0: + layout.addRow(Qt.QLabel(), Qt.QLabel()) + nb -= 1 + while nb < 0: + layout.removeRow(layout.rowCount() - 1) + nb += 1 + + +def fill_form(form, fields, offset=0): + resize_form(form, len(fields) + offset) + layout = form.layout() + result = [] + for row, field in enumerate(fields): + label, value = field + w_item = layout.itemAt(row + offset, Qt.QFormLayout.LabelRole) + w_label = w_item.widget() + set_text(w_label, label) + w_item = layout.itemAt(row + offset, Qt.QFormLayout.FieldRole) + w_field = w_item.widget() + set_text(w_field, value) + result.append((w_label, w_field)) + return result + + +def load_scan_info_form(widget): + ui_name = pkg_resources.resource_filename(__package__ + '.ui', + 'ScanInfoForm.ui') + uic.loadUi(ui_name, baseinstance=widget) + return widget + + +class ScanInfoForm(Qt.QWidget, TaurusBaseWidget): + + def __init__(self, parent=None): + super().__init__(parent) + load_scan_info_form(self) + + def setModel(self, doorname): + super().setModel(doorname) + if not doorname: + return + door = self.getModelObj() + door.recordDataUpdated.connect(self.onRecordDataUpdated) + + def onRecordDataUpdated(self, record_data): + data = record_data[1] + handler = self.event_handler.get(data.get("type")) + handler and handler(self, data['data']) + + def onStart(self, meta): + set_text(self.title_value, 'title', meta) + set_text(self.scan_nb_value, 'serialno', meta) + set_text(self.start_value, 'starttime', meta) + set_text(self.end_value, 'endtime', meta) + set_text(self.status_value, 'Running') + + directory = meta.get('scandir', '') + self.directory_groupbox.setEnabled(True if directory else False) + self.directory_groupbox.setTitle('Directory: {}'.format(directory)) + files = meta.get('scanfile', ()) + if isinstance(files, str): + files = files, + elif files is None: + files = () + files = [('File:', filename) for filename in files] + fill_form(self.directory_groupbox, files) + + def onEnd(self, meta): + set_text(self.end_value, 'endtime', meta) + set_text(self.status_value, 'Finished') + + event_handler = { + "data_desc": onStart, + "record_end": onEnd + } + + +def load_scan_point_form(widget): + ui_name = pkg_resources.resource_filename(__package__ + '.ui', + 'ScanPointForm.ui') + uic.loadUi(ui_name, baseinstance=widget) + return widget + + +class ScanPointForm(Qt.QWidget, TaurusBaseWidget): + + def __init__(self, parent=None): + super().__init__(parent) + load_scan_point_form(self) + self._in_scan = False + + def setModel(self, doorname): + super().setModel(doorname) + if not doorname: + return + door = self.getModelObj() + door.recordDataUpdated.connect(self.onRecordDataUpdated) + + def onRecordDataUpdated(self, record_data): + data = record_data[1] + handler = self.event_handler.get(data.get("type")) + handler and handler(self, data['data']) + + def onStart(self, meta): + set_text(self.scan_nb_value, 'serialno', meta) + cols = meta['column_desc'] + col_labels = [(c['label']+':', '') for c in cols] + fields = fill_form(self, col_labels, 1) + self.fields = {col['name']: field for col, field in zip(cols, fields)} + self._in_scan = True + + def onPoint(self, point): + if self._in_scan: + for name, value in point.items(): + set_text(self.fields[name][1], value) + + def onEnd(self, meta): + self._in_scan = False + + event_handler = { + "data_desc": onStart, + "record_data": onPoint, + "record_end": onEnd + } + + +class ScanPlotWidget(MultiPlotWidget): + + def __init__(self, parent=None): + super().__init__(parent) + self.manager = PlotManager(self) + self.setModel = self.manager.setModel + self.setGroupMode = self.manager.setGroupMode + + +class ScanPlotWindow(Qt.QMainWindow): + + def __init__(self, parent=None): + super().__init__() + plot_widget = ScanPlotWidget(parent=self) + self.setCentralWidget(plot_widget) + self.plotWidget = self.centralWidget + self.setModel = plot_widget.setModel + self.setGroupMode = plot_widget.setGroupMode + sbar = self.statusBar() + sbar.showMessage("Ready!") + plot_widget.manager.newShortMessage.connect(sbar.showMessage) + + +def load_scan_window(widget): + ui_name = pkg_resources.resource_filename(__package__ + '.ui', + 'ScanWindow.ui') + uic.loadUi(ui_name, baseinstance=widget) + return widget + + +class ScanWindow(Qt.QMainWindow): + + def __init__(self, parent=None): + super().__init__() + load_scan_window(self) + sbar = self.statusBar() + sbar.showMessage("Ready!") + self.plot_widget.manager.newShortMessage.connect(sbar.showMessage) + + def setModel(self, model): + self.plot_widget.setModel(model) + self.info_form.setModel(model) + self.point_form.setModel(model) + class ShowScanOnline(DynamicPlotManager): def __init__(self, parent): - DynamicPlotManager.__init__(self, parent) + DynamicPlotManager.__init__(self, parent=parent) + Qt.qApp.SDM.connectWriter("shortMessage", self, 'newShortMessage') def onExpConfChanged(self, expconf): DynamicPlotManager.onExpConfChanged(self, expconf) @@ -106,12 +313,10 @@ def main(group, taurus_log_level, door): assertPlotAvailability() - gui = TaurusGuiLite() - - widget = ShowScanOnline(gui) + widget = ScanWindow() + widget.plot_widget.setGroupMode(group) widget.setModel(door) - widget.setGroupMode(group) - gui.show() + widget.show() return app.exec_() diff --git a/src/sardana/taurus/qt/qtgui/extra_sardana/test/test_qtspock.py b/src/sardana/taurus/qt/qtgui/extra_sardana/test/test_qtspock.py index 126bb30a4c..71512dd22b 100644 --- a/src/sardana/taurus/qt/qtgui/extra_sardana/test/test_qtspock.py +++ b/src/sardana/taurus/qt/qtgui/extra_sardana/test/test_qtspock.py @@ -1,13 +1,14 @@ import re import os import tempfile +import qtconsole import numpy as np try: from unittest.mock import patch except ImportError: from mock import patch -from taurus.external.unittest import TestCase, main +from taurus.external.unittest import TestCase, main, skipIf from taurus.external import qt from taurus.external.qt import Qt from sardana.spock.ipython_01_00.genutils import _create_config_file, \ @@ -130,6 +131,9 @@ def predicate(): class CorrectProfileTestCase(QtSpockTestCase, CorrectProfileOutputMixin): + + @skipIf(qtconsole.version_info >= (4, 4, 0), + "blocking_client was removed in qtconsole#174") def test_get_value(self): msg_id = self.widget.blocking_client.execute( "a = arange(3)", silent=True) @@ -151,21 +155,21 @@ def predicate(): text = self.widget._control.toPlainText() matches = re.findall(r"^IPython \d\.\d", text, re.MULTILINE) return len(matches) == 1 - self.assertTrue(waitFor(predicate, 5000)) + self.assertTrue(waitFor(predicate, 10000)) def test_ipython_prompt(self): def predicate(): text = self.widget._control.toPlainText() matches = re.findall(r"^In.*\[(\d)\]", text, re.MULTILINE) return len(matches) == 1 and matches[0] == "1" - self.assertTrue(waitFor(predicate, 5000)) + self.assertTrue(waitFor(predicate, 10000)) def test_profile_error_info(self): def predicate(): text = self.widget._control.toPlainText() matches = re.findall(r"^Spock profile error", text, re.MULTILINE) return len(matches) == 1 - self.assertTrue(waitFor(predicate, 5000)) + self.assertTrue(waitFor(predicate, 10000)) class MissingProfileTestCase(QtSpockTestCase, ProfileErrorOutputMixin): @@ -193,7 +197,7 @@ def predicate(): text = cls.widget._control.toPlainText() matches = re.findall(r"\[1\]: $", text, re.MULTILINE) return len(matches) == 1 - assert waitFor(predicate, 5000) + assert waitFor(predicate, 10000) cls._create_profile() @@ -224,7 +228,7 @@ def predicate(): text = cls.widget._control.toPlainText() matches = re.findall(r"\[1\]: $", text, re.MULTILINE) return len(matches) == 1 - assert waitFor(predicate, 5000) + assert waitFor(predicate, 10000) # "Update" profile config_file = os.path.join( @@ -261,7 +265,7 @@ def predicate(): text = self.widget._control.toPlainText() matches = re.findall(r"^No door selected", text, re.MULTILINE) return len(matches) == 1 - self.assertTrue(waitFor(predicate, 5000)) + self.assertTrue(waitFor(predicate, 10000)) class QtSpockModelTestCase(QtSpockBaseTestCase, CorrectProfileOutputMixin): @@ -296,7 +300,7 @@ def predicate(): text = cls.widget._control.toPlainText() matches = re.findall(r"\[1\]: $", text, re.MULTILINE) return len(matches) == 1 - assert waitFor(predicate, 5000) + assert waitFor(predicate, 10000) cls.widget.setModel(UNITTEST_DOOR_NAME) @@ -318,7 +322,7 @@ def predicate(): text = cls.widget._control.toPlainText() matches = re.findall(r"\[1\]: $", text, re.MULTILINE) return len(matches) == 1 - assert waitFor(predicate, 5000) + assert waitFor(predicate, 10000) cls.widget.setModel("") diff --git a/src/sardana/taurus/qt/qtgui/extra_sardana/ui/ScanInfoForm.ui b/src/sardana/taurus/qt/qtgui/extra_sardana/ui/ScanInfoForm.ui new file mode 100644 index 0000000000..3784123163 --- /dev/null +++ b/src/sardana/taurus/qt/qtgui/extra_sardana/ui/ScanInfoForm.ui @@ -0,0 +1,141 @@ + + + Tiago Coutinho + scan_info_form + + + + 0 + 0 + 300 + 169 + + + + Form + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 3 + + + 3 + + + 0 + + + 0 + + + 0 + + + 0 + + + + + Scan #: + + + + + + + --- + + + + + + + Title: + + + + + + + --- + + + + + + + Start: + + + + + + + --- + + + + + + + End: + + + + + + + --- + + + + + + + Status: + + + + + + + --- + + + + + + + Directory:--- + + + + 6 + + + 3 + + + 6 + + + 6 + + + 6 + + + 6 + + + + + + + + + + diff --git a/src/sardana/taurus/qt/qtgui/extra_sardana/ui/ScanPointForm.ui b/src/sardana/taurus/qt/qtgui/extra_sardana/ui/ScanPointForm.ui new file mode 100644 index 0000000000..45056f10f3 --- /dev/null +++ b/src/sardana/taurus/qt/qtgui/extra_sardana/ui/ScanPointForm.ui @@ -0,0 +1,52 @@ + + + Form + + + + 0 + 0 + 400 + 291 + + + + Form + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 3 + + + 3 + + + 0 + + + 0 + + + 0 + + + 0 + + + + + Scan #: + + + + + + + + + + + diff --git a/src/sardana/taurus/qt/qtgui/extra_sardana/ui/ScanWindow.ui b/src/sardana/taurus/qt/qtgui/extra_sardana/ui/ScanWindow.ui new file mode 100644 index 0000000000..9c011166d6 --- /dev/null +++ b/src/sardana/taurus/qt/qtgui/extra_sardana/ui/ScanWindow.ui @@ -0,0 +1,150 @@ + + + MainWindow + + + + 0 + 0 + 891 + 600 + + + + + + 3 + + + 0 + + + 6 + + + 6 + + + 6 + + + + + + + + + + Scan point + + + 2 + + + + + 0 + + + 0 + + + 0 + + + 0 + + + + + + 250 + 0 + + + + QFrame::NoFrame + + + 0 + + + true + + + + + 0 + 0 + 250 + 240 + + + + + + + + + + + Scan information + + + 2 + + + + + 250 + 0 + + + + + + + QFrame::NoFrame + + + true + + + + + 0 + 0 + 232 + 276 + + + + + + + + + + + + ScanPointForm + QWidget +
sardana.taurus.qt.qtgui.extra_sardana.showscanonline
+ 1 + + + ScanInfoForm + QWidget +
sardana.taurus.qt.qtgui.extra_sardana.showscanonline
+ 1 + + + ScanPlotWidget + QWidget +
sardana.taurus.qt.qtgui.extra_sardana.showscanonline
+ 1 + + + + + diff --git a/src/sardana/taurus/qt/qtgui/macrolistener/macrolistener.py b/src/sardana/taurus/qt/qtgui/macrolistener/macrolistener.py index f06fbbe6a3..1a2e7a07c2 100644 --- a/src/sardana/taurus/qt/qtgui/macrolistener/macrolistener.py +++ b/src/sardana/taurus/qt/qtgui/macrolistener/macrolistener.py @@ -56,7 +56,10 @@ from sardana.taurus.core.tango.sardana import PlotType -__all__ = ['MacroBroker', 'DynamicPlotManager', 'assertPlotAvailability'] +__all__ = [ + 'MultiPlotWidget', 'MacroBroker', 'PlotManager', 'DynamicPlotManager', + 'assertPlotAvailability' +] __docformat__ = 'restructuredtext' @@ -91,6 +94,7 @@ class MultiPlotWidget(Qt.QWidget): def __init__(self, parent=None): super().__init__(parent) layout = Qt.QVBoxLayout(self) + layout.setContentsMargins(0, 0, 0, 0) self.win = pyqtgraph.GraphicsLayoutWidget() layout.addWidget(self.win) self._plots = {} @@ -177,16 +181,15 @@ def _end_update(self): self._timer = None -class DynamicPlotManager(Qt.QObject, TaurusBaseComponent): - '''This is a manager of plots related to the execution of macros. +class PlotManager(Qt.QObject, TaurusBaseComponent): + ''' + This is a manager of plots related to the execution of macros. It dynamically creates/removes plots according to the configuration made by an ExperimentConfiguration widget. Currently it supports only 1D scan trends (2D scans are only half-baked) - To use it simply instantiate it and pass it a door name as a model. You may - want to call :meth:`onExpConfChanged` to update the configuration being - used. + To use it simply instantiate it and pass it a door name as a model. ''' plots_available = pyqtgraph is not None @@ -196,16 +199,13 @@ class DynamicPlotManager(Qt.QObject, TaurusBaseComponent): Single = 'single' # each curve has its own plot XAxis = 'x-axis' # group curves with same X-Axis - def __init__(self, parent=None): + def __init__(self, plot=None, parent=None): Qt.QObject.__init__(self, parent) TaurusBaseComponent.__init__(self, self.__class__.__name__) self._group_mode = self.XAxis - Qt.qApp.SDM.connectWriter("shortMessage", self, 'newShortMessage') - self._plot = MultiPlotWidget() - self.createPanel( - self._plot, 'Scan plot', registerconfig=False, permanent=False) + self.plot = plot or MultiPlotWidget() def setGroupMode(self, group): assert group in (self.Single, self.XAxis) @@ -329,7 +329,7 @@ def prepare(self, data_desc): raise NotImplementedError nb_points = data.get('total_scan_intervals', 2**16 - 1) + 1 - self._plot.prepare(plots, nb_points=nb_points) + self.plot.prepare(plots, nb_points=nb_points) # build status message serialno = 'Scan #{}'.format(data.get('serialno', '?')) @@ -350,18 +350,35 @@ def prepare(self, data_desc): def newPoint(self, point): data = point['data'] - self._plot.onNewPoint(data) + self.plot.onNewPoint(data) point_nb = 'Point #{}'.format(data['point_nb']) msg = self.message_template.format(progress=point_nb) self.newShortMessage.emit(msg) def end(self, end_data): data = end_data['data'] - self._plot.onEnd(data) + self.plot.onEnd(data) progress = 'Ended {}'.format(data['endtime']) msg = self.message_template.format(progress=progress) self.newShortMessage.emit(msg) + +class DynamicPlotManager(PlotManager): + '''This is a manager of plots related to the execution of macros. + It dynamically creates/removes plots according to the configuration made by + an ExperimentConfiguration widget. + + Currently it supports only 1D scan trends (2D scans are only half-baked) + + To use it simply instantiate it and pass it a door name as a model. + ''' + + def __init__(self, *args, **kwargs): + PlotManager.__init__(self, *args, **kwargs) + self.__panels = {} + self.createPanel( + self.plot, 'Scan plot', registerconfig=False, permanent=False) + def createPanel(self, widget, name, **kwargs): '''Creates a "panel" from a widget. In this basic implementation this means that the widgets is shown as a non-modal top window @@ -414,12 +431,13 @@ class MacroBroker(DynamicPlotManager): def __init__(self, parent): '''Passing the parent object (the main window) is mandatory''' - DynamicPlotManager.__init__(self, parent) + DynamicPlotManager.__init__(self, parent=parent) self._createPermanentPanels() # connect the broker to shared data Qt.qApp.SDM.connectReader("doorName", self.setModel) + Qt.qApp.SDM.connectWriter("shortMessage", self, 'newShortMessage') def setModel(self, doorname): ''' Reimplemented from :class:`DynamicPlotManager`.''' diff --git a/src/sardana/util/test/test_funcgenerator.py b/src/sardana/util/test/test_funcgenerator.py index d816b8e76c..d76d3d8b37 100644 --- a/src/sardana/util/test/test_funcgenerator.py +++ b/src/sardana/util/test/test_funcgenerator.py @@ -37,18 +37,18 @@ configuration_negative = [{SynchParam.Initial: {SynchDomain.Position: 0.}, SynchParam.Delay: {SynchDomain.Time: 0.1}, - SynchParam.Active: {SynchDomain.Position: -.1, - SynchDomain.Time: .01, }, - SynchParam.Total: {SynchDomain.Position: -.2, + SynchParam.Active: {SynchDomain.Position: -.5, + SynchDomain.Time: .05, }, + SynchParam.Total: {SynchDomain.Position: -1, SynchDomain.Time: 0.1}, SynchParam.Repeats: 10}] configuration_positive = [{SynchParam.Initial: {SynchDomain.Position: 0.}, SynchParam.Delay: {SynchDomain.Time: 0.3}, - SynchParam.Active: {SynchDomain.Position: .1, - SynchDomain.Time: .01, }, - SynchParam.Total: {SynchDomain.Position: .2, - SynchDomain.Time: .02}, + SynchParam.Active: {SynchDomain.Position: .5, + SynchDomain.Time: .05, }, + SynchParam.Total: {SynchDomain.Position: 1, + SynchDomain.Time: 0.1}, SynchParam.Repeats: 10}] @@ -107,18 +107,23 @@ def _done(self, _): self.event.clear() def test_sleep(self): - delta = 0 if os.name == "nt": - delta = 0.02 - for i in [0.01, 0.13, 1.2]: - stmt = "fg.sleep(%f)" % i + # (period, delta) + tests = [(0.01, 0.02), (0.13, 0.05), (1.2, 0.2)] + else: + tests = [(0.01, 0.02), (0.13, 0.02), (1.2, 0.02)] + for period, delta in tests: + stmt = "fg.sleep(%f)" % period setup = "from sardana.util.funcgenerator import FunctionGenerator;\ fg = FunctionGenerator()" - period = timeit.timeit(stmt, setup, number=1) - period_ok = i - msg = "sleep period: %f, expected: %f +/- %f" % (period, period_ok, + period_measured = timeit.timeit(stmt, setup, number=1) + msg = "sleep period: %f, expected: %f +/- %f" % (period_measured, + period, delta) - self.assertAlmostEqual(period, period_ok, delta=0.02, msg=msg) + self.assertAlmostEqual(period_measured, + period, + delta=delta, + msg=msg) def test_run_time(self): self.func_generator.initial_domain = SynchDomain.Time @@ -159,8 +164,8 @@ def test_run_position_negative(self): self.thread_pool.add(self.func_generator.run, self._done) while not self.func_generator.is_running(): time.sleep(0.1) - self.thread_pool.add(position.run, None, 0, -2, -.01) - self.event.wait(3) + self.thread_pool.add(position.run, None, 0, -10, -.05) + self.event.wait(4) position.remove_listener(self.func_generator) active_event_ids = self.listener.active_event_ids active_event_ids_ok = list(range(0, 10)) @@ -179,8 +184,8 @@ def test_run_position_positive(self): self.thread_pool.add(self.func_generator.run, self._done) while not self.func_generator.is_running(): time.sleep(0.1) - self.thread_pool.add(position.run, None, 0, 2, .01) - self.event.wait(3) + self.thread_pool.add(position.run, None, 0, 10, .05) + self.event.wait(4) position.remove_listener(self.func_generator) active_event_ids = self.listener.active_event_ids active_event_ids_ok = list(range(0, 10)) @@ -193,12 +198,12 @@ def test_configuration_position(self): self.func_generator.active_domain = SynchDomain.Position self.func_generator.set_configuration(configuration_negative) active_events = self.func_generator.active_events - active_events_ok = numpy.arange(0, -2, -0.2).tolist() + active_events_ok = numpy.arange(0, -9, -1).tolist() msg = "Active events are wrong: %s" % active_events for a, b in zip(active_events, active_events_ok): self.assertAlmostEqual(a, b, 10, msg) passive_events = self.func_generator.passive_events - passive_events_ok = numpy.arange(-.1, -2.1, -0.2).tolist() + passive_events_ok = numpy.arange(-.5, -9.5, -1).tolist() msg = "Passive events are wrong: %s" % passive_events for a, b in zip(passive_events, passive_events_ok): self.assertAlmostEqual(a, b, 10, msg) @@ -208,13 +213,13 @@ def test_configuration_time(self): self.func_generator.active_domain = SynchDomain.Time self.func_generator.set_configuration(configuration_positive) active_events = self.func_generator.active_events - active_events_ok = numpy.arange(.3, .5, 0.02).tolist() + active_events_ok = numpy.arange(.3, 1.2, 0.1).tolist() msg = ("Active events mismatch, received: %s, expected: %s" % (active_events, active_events_ok)) for a, b in zip(active_events, active_events_ok): self.assertAlmostEqual(a, b, 10, msg) passive_events = self.func_generator.passive_events - passive_events_ok = numpy.arange(.31, 0.51, 0.02).tolist() + passive_events_ok = numpy.arange(.35, 1.25, 0.1).tolist() msg = ("Passive events mismatch, received: %s, expected: %s" % (passive_events, passive_events_ok)) for a, b in zip(passive_events, passive_events_ok): @@ -223,13 +228,13 @@ def test_configuration_time(self): def test_configuration_default(self): self.func_generator.set_configuration(configuration_positive) active_events = self.func_generator.active_events - active_events_ok = numpy.arange(0, 2, 0.2).tolist() + active_events_ok = numpy.arange(0, 9, 1).tolist() msg = ("Active events mismatch, received: %s, expected: %s" % (active_events, active_events_ok)) for a, b in zip(active_events, active_events_ok): self.assertAlmostEqual(a, b, 10, msg) passive_events = self.func_generator.passive_events - passive_events_ok = numpy.arange(.31, .51, 0.02).tolist() + passive_events_ok = numpy.arange(.35, 1.25, 0.1).tolist() msg = ("Passive events mismatch, received: %s, expected: %s" % (passive_events, passive_events_ok)) for a, b in zip(passive_events, passive_events_ok):