sardana-nxsrecorder 3.13.2__py3-none-any.whl → 3.30.1__py3-none-any.whl

{sardana_nxsrecorder-3.13.2.dist-info → sardana_nxsrecorder-3.30.1.dist-info}/METADATA

@@ -1,19 +1,17 @@
 Metadata-Version: 2.1
 Name: sardana-nxsrecorder
-Version: 3.13.2
+Version: 3.30.1
 Summary: NeXus Sardana Scan Recorder
 Home-page: https://github.com/nexdatas/sardana-nxs-filerecorder/
 Author: Jan Kotanski
 Author-email: jankotan@gmail.com
 License: GNU GENERAL PUBLIC LICENSE v3
 Keywords: NeXus sardana scan recorder data
-Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Programming Language :: Python :: 2.7
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.4
 Classifier: Programming Language :: Python :: 3.5
@@ -23,6 +21,7 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: lxml
 Requires-Dist: numpy (>1.6.0)
 
@@ -77,7 +76,7 @@ Extract sources and run
 
 .. code-block:: console
 
-	  $ python setup.py install
+	  $ python3 setup.py install
 
 and add an *RecorderPath* property of *MacroServer* with its value
 defining the package location, e.g.
@@ -88,21 +87,22 @@ defining the package location, e.g.
 Debian packages
 """""""""""""""
 
-Debian Bookworm, Bullseye, Buster and Ubuntu Lunar, Jammy and Focal packages can be found in the HDRI repository.
+Debian Trixie, Bookworm, Bullseye and Ubuntu Questing, Noble Jammy packages can be found in the HDRI repository.
 
 To install the debian packages, add the PGP repository key
 
 .. code-block:: console
 
 	  $ sudo su
-	  $ wget -q -O - http://repos.pni-hdri.de/debian_repo.pub.gpg | apt-key add -
+	  $ curl -s http://repos.pni-hdri.de/debian_repo.pub.gpg | gpg --no-default-keyring --keyring gnupg-ring:/etc/apt/trusted.gpg.d/debian-hdri-repo.gpg --import
+	  $ chmod 644 /etc/apt/trusted.gpg.d/debian-hdri-repo.gpg
 
 and then download the corresponding source list
 
 .. code-block:: console
 
 	  $ cd /etc/apt/sources.list.d
-	  $ wget http://repos.pni-hdri.de/bookworm-pni-hdri.list
+	  $ wget http://repos.pni-hdri.de/trixie-pni-hdri.sources
 
 
 Finally, for python2.7
@@ -110,7 +110,7 @@ Finally, for python2.7
 .. code-block:: console
 
 	  $ apt-get update
-	  $ apt-get install python-sardana-nxsrecorder
+	  $ apt-get install python3-sardana-nxsrecorder
 
 and set the RecoderPath property of MacroServer with
 
@@ -118,34 +118,15 @@ and set the RecoderPath property of MacroServer with
 
 	  $ apt-get install sardana-nxsrecorder
 
-For python3
-
-.. code-block:: console
-
-	  $ apt-get update
-	  $ apt-get install python3-sardana-nxsrecorder
-	  $ apt-get install sardana-nxsrecorder3
 
 To instal other NexDaTaS packages
 
-.. code-block:: console
-
-	  $ apt-get install python-nxswriter nxsconfigserver-db python-nxsconfigserver nxsconfigtool python-nxstools nxswriter nxsconfigserver nxsrecselector
-
-or for python 3
-
 .. code-block:: console
 
 	  $ apt-get install python3-nxswriter nxsconfigserver-db python3-nxsconfigserver nxsconfigtool3 python3-nxstools nxswriter3 nxsconfigserver3
 
 and
 
-.. code-block:: console
-
-	  $ apt-get install python-nxsrecselector nxsrecselector nxselector
-
-or for python3
-
 .. code-block:: console
 
 	  $ apt-get install python3-nxsrecselector nxsrecselector3 nxselector3
@@ -237,6 +218,8 @@ The NeXus file recorder uses the following sardana environment variables
 
 * **ActiveMntGrp** *(str)* - active measurement group
 * **ScanID** *(int)* - the last scan identifier number, default: ``-1``
+* **ScanDir** *(str)* - the scan directory
+* **ScanFile** *(list)* - a list of scan files
 * **NeXusSelectorDevice** *(str)* - NXSRecSelector tango device if more installed, otherwise first one found
 
 * **NXSAppendSciCatDataset** *(bool)* - append scan name to scicat dataset list file, default: ``False``
@@ -246,5 +229,21 @@ The NeXus file recorder uses the following sardana environment variables
 * **SciCatDatasetListFilePrefix** *(str)* - scicat dataset list file prefix, default: ``"scicat-datasets-"``
 * **SciCatDatasetListFileExt** *(str)* - scicat dataset list file extension, default: ``".lst"``
 * **SciCatDatasetListFileLocal** *(bool)* - add the hostname to the scicat dataset list file extension, default: ``False``
+* **SciCatAutoGrouping** *(bool)* - group all scans with the measurement name set to the base scan filename, default: ``False``
+* **MetadataScript** *(str)* - a python module file name containing ``main()``  which provides a dictionary with user metadata stored in the INIT mode, default: ``""``
+* **ScicatMeasurements** *(dict)* - a dictionary of  measurement names indexed by ``ScanDir`` and  used by ``scingestor``, default: ``{}``
+* **CreateMeasurementFile** *(bool)* - create a measurement file with its filename releated to ``ScicatMeasurements`` or ``ScanFile``, default: ``False``
+* **NeXusWriterProperties** *(dict)* - a dictionary of TangoDataWriter (NXSDataWriter) properties (starting with a small letter)
+* **NeXusMeshScanID** *(int)* - ScanID used for composed scans e.g. mesh scan combined from many linear scans
+* **NeXusWriterModes** *(list)* - a list of strategy modes e.g. ``NOINIT``, ``NOSTEP``, ``NOFINAL``, ``MESH``, ``VDS``  separated by commas
+* **ScanNames** *(bool)* - special mode of using ScanName directories i.e.
+
+  * ``True``: the master file in the ScanName directory,
+
+  * ``False``: the master file in the grouping ScanName directory (e.g. without ScanID),
 
+  * ``None`` (or undefined):  standard mode where the master files are outside the ScanName directory
 
+* **ScanNamesNoGrouping** *(bool)* - do not perform grouping when ``ScanNames`` is ``False``
+* **ScanNamesNoMetadata** *(bool)* - do not perform master file metadata ingestion when ``ScanNames`` is ``False``
+ 

sardana_nxsrecorder-3.30.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+sardananxsrecorder/__init__.py,sha256=E5trFSG5M-GbgxeR_3kAvsnEtOAN4aKJbIHF0jDu95k,896
+sardananxsrecorder/nxsrecorder.py,sha256=YVH1Y92qGEviUno_j1TsGAGvEKgF2sRYOho72WMkuq4,67052
+sardana_nxsrecorder-3.30.1.dist-info/METADATA,sha256=ZVF0ds6Y9meFfEziBW8Th1lue3OeTOLZy5QxaLybsME,8256
+sardana_nxsrecorder-3.30.1.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+sardana_nxsrecorder-3.30.1.dist-info/top_level.txt,sha256=YdD3m417i-jlYyQWgiizgZ8lQQcOjM8y-bmUHrGkfY4,19
+sardana_nxsrecorder-3.30.1.dist-info/RECORD,,

{sardana_nxsrecorder-3.13.2.dist-info → sardana_nxsrecorder-3.30.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.34.2)
+Generator: bdist_wheel (0.38.4)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

sardananxsrecorder/__init__.py

@@ -20,4 +20,4 @@
 """ Sardana Scan Recorders """
 
 #: package version
-__version__ = "3.13.2"
+__version__ = "3.30.1"

sardananxsrecorder/nxsrecorder.py

@@ -22,10 +22,10 @@
 
 import os
 import re
+import sys
 
 import numpy
 import json
-import pytz
 import time
 import weakref
 import socket
@@ -35,6 +35,15 @@ try:
 except Exception:
     import PyTango as tango
 
+try:
+    NXSWRITER = True
+    try:
+        from nxstools import h5cppwriter as h5writer
+    except Exception:
+        from nxstools import h5pywriter as h5writer
+except Exception:
+    NXSWRITER = False
+
 
 from sardana.macroserver.scan.recorder.storage import BaseFileRecorder
 
@@ -90,8 +99,11 @@ class NXS_FileRecorder(BaseFileRecorder):
         :type macro: :class:`sardana.macroserver.macro.Macro`
         """
         BaseFileRecorder.__init__(self)
+        self.debug('__init__:  Init NXS_FileRecorder: %s' % str(filename))
         #: (:obj:`str`) base filename
         self.__base_filename = filename
+        #: (:obj:`str`) raw filename
+        self.__raw_filename = ""
         self.__macro = weakref.ref(macro) if macro else None
         #: (:class:`tango.Database`) tango database
         self.__db = tango.Database()
@@ -105,7 +117,8 @@ class NXS_FileRecorder(BaseFileRecorder):
         self.__nexussettings_device = None
 
         #: (:obj:`int`) device proxy timeout
-        self.__timeout = 100000
+        # self.__timeout = 100000
+        self.__timeout = 10000000
         #: (:obj:`dict` <:obj:`str`, :obj:`list` <:obj:`str`>
         #:     or :obj:`dict` <:obj:`str` , `any`> > ) Custom variables
         self.__vars = {"data": {},
@@ -140,19 +153,53 @@ class NXS_FileRecorder(BaseFileRecorder):
         #: (:obj:`str`) module lable
         self.__moduleLabel = 'module'
 
+        #: (:obj:`int`) serialno
+        self.__serial = 0
+
         #: (:obj:`dict` <:obj:`str` , :obj:`str`>) NeXus configuration
         self.__conf = {}
 
+        #: (:obj:`list` <:obj:`str`>) acquisition Modes
+        self.writerModes = self.__variableList(
+            "NeXusWriterModes")
+
+        #: (:obj:`dict` <:obj:`str` , `any`>) User data
+        self.__udata = None
+
         #: (:obj:`bool`) external measurement group
         self.__oddmntgrp = False
 
+        self.debug('__init__:  Set NeXus: %s' % str(filename))
         self.__setNexusDevices(onlyconfig=True)
 
+        self.debug('__init__:  Set Append Entry: %s' % str(filename))
         appendentry = self.__getConfVar("AppendEntry", True)
         scanID = self.__env["ScanID"] \
             if "ScanID" in self.__env.keys() else -1
-        appendentry = not self.__setFileName(
+        self.debug('__init__:  Set FileName: %s' % str(filename))
+        self.__setFileName(
             self.__base_filename, not appendentry, scanID)
+        self.debug('__init__:  Done: %s' % str(filename))
+
+    def _serial(self, scanID):
+        serial = None
+        if "NOINIT" in self.writerModes and \
+           "MESH" in self.writerModes:
+            if self.__macro:
+                serial = self.__macro().getEnv('NeXusMeshScanID', None)
+        if serial is None:
+            if scanID is None:
+                serial = self.recordlist.getEnvironValue('serialno')
+            elif scanID >= 0:
+                if isarver >= 304 or isarver == 0:
+                    serial = scanID
+                else:
+                    serial = scanID + 1
+        if "MESH" in self.writerModes and \
+           "NOINIT" not in self.writerModes:
+            if self.__macro:
+                self.__macro().setEnv('NeXusMeshScanID', serial)
+        return serial
 
     def __command(self, server, command, *args):
         """ execute tango server (or python object) command
@@ -326,10 +373,12 @@ class NXS_FileRecorder(BaseFileRecorder):
 
         :param filename: sardana scanfile name
         :type filename: :obj:`str`
-        :param numer: True if append scanID
-        :param numer: :obj:`bool`
+        :param number: True if append scanID
+        :param number: :obj:`bool`
         :param scanID: scanID to append
         :type scanID: :obj:`int`
+        :returns: True if append scanID
+        :rtype: :obj:`bool`
         """
         if scanID is not None and scanID < 0:
             return number
@@ -358,20 +407,26 @@ class NXS_FileRecorder(BaseFileRecorder):
 
         subs = (len([None for _ in list(re.finditer('%', filename))]) == 1)
         # construct the filename, e.g. : /dir/subdir/etcdir/prefix_00123.nxs
-        if subs or number:
-            if scanID is None:
-                serial = self.recordlist.getEnvironValue('serialno')
-            elif scanID >= 0:
-                if isarver >= 304 or isarver == 0:
-                    serial = scanID
-                else:
-                    serial = scanID + 1
+        self.__serial = self._serial(scanID)
+
         if subs:
             try:
                 #: output file name
-                self.filename = filename % serial
+                self.filename = filename % self.__serial
             except Exception:
                 subs = False
+        if not self.__raw_filename:
+            self.__raw_filename = self.__rawfilename(self.__serial)
+        self.debug('__setFileName:  '
+                   'Raw Filename: %s' % str(self.__raw_filename))
+        if not subs and self.__raw_filename and \
+           "{ScanID" in self.__raw_filename:
+            try:
+                self.filename = self.__raw_filename.format(
+                    ScanID=self.__serial)
+                subs = True
+            except Exception:
+                pass
 
         if not subs:
             if number:
@@ -379,10 +434,12 @@ class NXS_FileRecorder(BaseFileRecorder):
                    filename[-4].rpartition(".")[0] and \
                    filename[-4].rpartition(".")[2] in self.formats.keys():
                     tpl = filename[-4].rpartition(".")
-                    self.filename = "%s_%05d.%s.tmp" % (tpl[0], serial, tpl[2])
+                    self.filename = "%s_%05d.%s.tmp" % (
+                        tpl[0], self.__serial, tpl[2])
                 else:
                     tpl = filename.rpartition('.')
-                    self.filename = "%s_%05d.%s" % (tpl[0], serial, tpl[2])
+                    self.filename = "%s_%05d.%s" % (
+                        tpl[0], self.__serial, tpl[2])
             else:
                 self.filename = filename
 
@@ -403,6 +460,9 @@ class NXS_FileRecorder(BaseFileRecorder):
                            profile configuration of NXSRecSelector
         :type onlyconfig: :obj:`bool`
         """
+        self.debug(
+            '__setNexusDevices:  NXSRecSelector: %s'
+            % str(self.__raw_filename))
         vl = self.__getEnvVar("NeXusSelectorDevice", None)
         if vl is None:
             servers = self.__db.get_device_exported_for_class(
@@ -424,6 +484,8 @@ class NXS_FileRecorder(BaseFileRecorder):
                         "Cannot connect to '%s'" % servers[0])
         else:
             self.__nexussettings_device = None
+        self.debug('__setNexusDevices:  import profile: %s'
+                   % str(self.__raw_filename))
         if self.__nexussettings_device is None:
             from nxsrecconfig import Settings
             self.__nexussettings_device = Settings.Settings()
@@ -433,10 +495,13 @@ class NXS_FileRecorder(BaseFileRecorder):
             raise Exception("NXSRecSelector (%s) version below 2.0.0" %
                             (servers[0] if servers else "module"))
 
+        self.debug('__setNexusDevices:  set MG: %s' % str(self.__raw_filename))
         mntgrp = self.__getServerVar("mntGrp", None)
         amntgrp = self.__getEnvVar("ActiveMntGrp", None)
         if mntgrp and amntgrp != mntgrp:
             self.__nexussettings_device.mntgrp = amntgrp
+        self.debug('__setNexusDevices:  list profile: %s'
+                   % str(self.__raw_filename))
         if amntgrp not in self.__command(
                 self.__nexussettings_device, "availableProfiles"):
             if onlyconfig:
@@ -457,15 +522,29 @@ class NXS_FileRecorder(BaseFileRecorder):
                 self.info(
                     "NXS_FileRecorer: descriptive components will be reset")
             else:
+                self.debug('__setNexusDevices:  fetch profile: %s'
+                           % str(self.__raw_filename))
                 self.__command(self.__nexussettings_device, "fetchProfile")
+                self.debug('__setNexusDevices:  reset profile: %s'
+                           % str(self.__raw_filename))
                 self.__asynchcommand(self.__nexussettings_device,
                                      "resetPreselectedComponents")
+                self.debug('__setNexusDevices:  reset profile Done: %s'
+                           % str(self.__raw_filename))
             self.__oddmntgrp = True
         else:
+            self.debug('__setNexusDevices:  '
+                       'fetch profile 2: %s' % str(self.__raw_filename))
             self.__command(self.__nexussettings_device, "fetchProfile")
+            self.debug('__setNexusDevices:  fetch profile 2 Done: %s' %
+                       str(self.__raw_filename))
         self.__vars["vars"]["measurement_group"] = amntgrp
 
+        self.debug('__setNexusDevices:  '
+                   'profile config: %s' % str(self.__raw_filename))
         self.__conf = self.__getServerVar("profileConfiguration", {}, True)
+        self.debug('__setNexusDevices:  '
+                   'MG config: %s' % str(self.__raw_filename))
         if not self.__oddmntgrp and not onlyconfig:
             if "MntGrpConfiguration" in self.__conf.keys():
                 poolmg = self.__command(
@@ -475,9 +554,9 @@ class NXS_FileRecorder(BaseFileRecorder):
                 poolmg = None
                 profmg = None
             if not poolmg or not profmg or poolmg != profmg:
-                self.debug(
-                    "ActiveMntGrp created outside NXSRecSelector v3. "
-                    "Updating ActiveMntGrp")
+                self.debug("__setNexusDevices:  "
+                           "ActiveMntGrp created outside NXSRecSelector v3. "
+                           "Updating ActiveMntGrp")
                 if self.__macro:
                     self.__macro().debug(
                         "ActiveMntGrp created outside NXSRecSelector v3. "
@@ -485,6 +564,8 @@ class NXS_FileRecorder(BaseFileRecorder):
                 self.__command(self.__nexussettings_device, "importMntGrp")
                 self.__command(self.__nexussettings_device, "updateMntGrp")
 
+        self.debug('__setNexusDevices: '
+                   'Writer Device: %s' % str(self.__raw_filename))
         if not onlyconfig:
             vl = self.__getConfVar("WriterDevice", None)
             if not vl:
@@ -510,9 +591,24 @@ class NXS_FileRecorder(BaseFileRecorder):
             else:
                 self.__nexuswriter_device = None
 
+            self.debug('__setNexusDevices:  Writer Device Properties: %s'
+                       % str(self.__raw_filename))
             if self.__nexuswriter_device is None:
                 from nxswriter import TangoDataWriter
                 self.__nexuswriter_device = TangoDataWriter.TangoDataWriter()
+                try:
+                    properties = dict(
+                        self.__getEnvVar("NeXusWriterProperties", {}))
+                except Exception as e:
+                    self.warning(
+                        "Cannot load NeXusWriterProperties %s" % (str(e)))
+                    self.__macro().warning(
+                        "Cannot load NeXusWriterProperties %s" % (str(e)))
+                    properties = {}
+                for ky, vl in properties.items():
+                    if hasattr(self.__nexuswriter_device, ky):
+                        setattr(self.__nexuswriter_device, ky, vl)
+        self.debug('__setNexusDevices:  End: %s' % str(self.__raw_filename))
 
     def __get_alias(self, name):
         """ provides a device alias
@@ -538,6 +634,26 @@ class NXS_FileRecorder(BaseFileRecorder):
             alias = None
         return alias
 
+    def __short_name(self, name):
+        """ provides a device alias
+
+        :param name: device name
+        :type name: :obj:`str`
+        :returns: device alias
+        :rtype: :obj:`str`
+        """
+        # if name does not contain a "/" it's probably an alias
+        if name.startswith("tango://"):
+            name = name[8:]
+        if name.find("/") == -1:
+            return name
+
+        # haso107klx:10000/expchan/hasysis3820ctrl/1
+        if name.find(':') >= 0:
+            lst = name.split("/")
+            name = "/".join(lst[1:])
+        return name
+
     def __collectAliases(self, envRec):
         """ sets deviceAlaises and dynamicDataSources from env record
 
@@ -575,22 +691,30 @@ class NXS_FileRecorder(BaseFileRecorder):
                 else:
                     self.__dynamicDataSources[(str(elm.name))] = None
 
-    def __createDynamicComponent(self, dss, keys, nexuscomponents):
+    def __createDynamicComponent(self, dss, keys, udata, nexuscomponents):
         """ creates a dynamic component
 
         :param dss: datasource list
         :type dss: :obj:`list` <:obj:`str`>
         :param keys: keys without datasources
         :type keys: :obj:`list` <:obj:`str`>
+        :param udata: keys without datasources
+        :type udata: :obj:`dict` <:obj:`str`, `any`>
         :param nexuscomponents: nexus component list
         :type nexuscomponents: :obj:`list` <:obj:`str`>
         """
-        self.debug("Step DSs: %s" % dss)
-        self.debug("Init DSs: %s" % keys)
+        self.debug("__createDynamicComponent:  Step DSs: %s" % dss)
+        self.debug("__createDynamicComponent:  Init DSs: %s" % keys)
+        self.debug("__createDynamicComponent:  Init User Data: %s" % udata)
         envRec = self.recordlist.getEnviron()
         lddict = []
         tdss = [ds for ds in dss if not ds.startswith("tango://")
                 and ds not in nexuscomponents]
+        tgdss = [self.__short_name(ds)
+                 for ds in dss if ds.startswith("tango://")
+                 and ds not in nexuscomponents]
+
+        fields = []
         for dd in envRec['datadesc']:
             alias = self.__get_alias(str(dd.name))
             if alias in tdss and alias not in nexuscomponents:
@@ -598,11 +722,56 @@ class NXS_FileRecorder(BaseFileRecorder):
                 mdd["name"] = dd.name
                 mdd["shape"] = dd.shape
                 mdd["dtype"] = dd.dtype
+                mdd["strategy"] = 'STEP'
                 lddict.append(mdd)
+
+        fields = {}
+        for ky, vl in udata.items():
+            if "@" not in ky:
+                mdd = {}
+                mdd["name"] = ky
+                mdd["shape"] = numpy.shape(vl)
+                try:
+                    if mdd["shape"]:
+                        rank = len(mdd["shape"])
+                        for _ in range(rank):
+                            vl = vl[0]
+                    mdd["dtype"] = str(type(vl).__name__)
+                except Exception as e:
+                    self.warning("Cannot find a type of user data %s %s"
+                                 % (ky, str(e)))
+                    self.__macro().warning(
+                        "Cannot find a type of user data %s %s" % (ky, str(e)))
+                    mdd["dtype"] = 'string'
+                mdd["strategy"] = 'INIT'
+                fields[ky] = mdd
+
+        for ky, vl in udata.items():
+            if "@" in ky:
+                fld, att = ky.split("@")[:2]
+                if fld and att:
+                    if fld in fields.keys():
+                        fields[fld][att] = vl
+                    else:
+                        fields[fld] = {
+                            "name": fld,
+                            "dtype": "string",
+                            "shape": tuple(),
+                            att: vl}
+
+        for mdd in fields.values():
+            lddict.append(mdd)
+
+        tdss.extend(tgdss)
         jddict = json.dumps(lddict, cls=NXS_FileRecorder.numpyEncoder)
         jdss = json.dumps(tdss, cls=NXS_FileRecorder.numpyEncoder)
         jkeys = json.dumps(keys, cls=NXS_FileRecorder.numpyEncoder)
-        # self.debug("JDD: %s" % jddict)
+        self.debug("__createDynamicComponent:  "
+                   "tango STEP datasources: %s" % tdss)
+        self.debug("__createDynamicComponent:  "
+                   "sardana STEP datasources: %s" % jddict)
+        self.debug("__createDynamicComponent:  "
+                   "INIT datasources: %s" % jkeys)
         self.__dynamicCP = \
             self.__command(self.__nexussettings_device,
                            "createDynamicComponent",
@@ -646,6 +815,8 @@ class NXS_FileRecorder(BaseFileRecorder):
         :rtype: (`list` <:obj:`str`>, `list` <:obj:`str`>,
                  `list` <:obj:`str`>, `list` <:obj:`str`>)
         """
+        self.debug("__searchDataSources: Init: %s"
+                   % str([nexuscomponents, cfm, dyncp, userkeys]))
         dsFound = {}
         dsNotFound = []
 
@@ -661,6 +832,8 @@ class NXS_FileRecorder(BaseFileRecorder):
         else:
             cmps = list(set(nexuscomponents) &
                         set(self.__availableComponents()))
+        self.debug("__searchDataSources:  Get selected DSs: %s"
+                   % str([cfm, dyncp]))
         if self.__oddmntgrp:
             nds = []
         else:
@@ -668,15 +841,27 @@ class NXS_FileRecorder(BaseFileRecorder):
                                  "selectedDataSources")
         nds = nds if nds else []
         datasources = list(set(nds) | set(self.__deviceAliases.keys()))
+        self.debug("__searchDataSources:  Get components DSs: %s"
+                   % str([cfm, dyncp]))
         hascpsrcs = hasattr(self.__nexussettings_device, 'componentSources')
+        # aacpdss = json.loads(
+        #     self.__command(self.__nexussettings_device,
+        #                    "componentSources",
+        #                    cmps))
+        self.debug("__searchDataSources:  component loop: %s"
+                   % str([cfm, dyncp]))
         for cp in cmps:
+            self.debug("__searchDataSources:  component item: %s" % cp)
             try:
                 if hascpsrcs:
                     cpdss = json.loads(
                         self.__command(self.__nexussettings_device,
                                        "componentSources",
                                        [cp]))
-                    allcpdss.extend([ds["dsname"] for ds in cpdss])
+                    allcpdss.extend(
+                        [ds["dsname"] for ds in cpdss
+                         if ("parentobj" not in ds or
+                             ds["parentobj"] in ["field"])])
 
                 else:
                     cpdss = json.loads(
@@ -698,28 +883,38 @@ class NXS_FileRecorder(BaseFileRecorder):
                             "Component '%s' wrongly defined in DB!" % cp)
                         # self.__macro().warning("Error: '%s'" % str(e))
                 else:
-                    self.debug("Component '%s' wrongly defined in DB!" % cp)
+                    self.debug(
+                        "__searchDataSources:  "
+                        "Component '%s' wrongly defined in DB!" % cp)
                     self.warning("Error: '%s'" % str(e))
                     if self.__macro:
                         self.__macro().debug(
+                            "__searchDataSources:  "
                             "Component '%s' wrongly defined in DB!" % cp)
                     self.__macro.debug("Error: '%s'" % str(e))
                 dss = []
             if dss:
                 cdss = list(set(dss) & set(datasources))
                 for ds in cdss:
-                    self.debug("'%s' found in '%s'" % (ds, cp))
+                    self.debug("__searchDataSources:  '%s' found in '%s'"
+                               % (ds, cp))
                     if ds not in dsFound.keys():
                         dsFound[ds] = []
                     dsFound[ds].append(cp)
                     if cp not in cpReq.keys():
                         cpReq[cp] = []
                     cpReq[cp].append(ds)
+        self.debug("__searchDataSources:  "
+                   "component loop end: %s" % str([cfm, dyncp]))
         missingKeys = set(userkeys) - keyFound
 
+        self.debug("__searchDataSources:  "
+                   "dynamic component loop: %s" % str([cfm, dyncp]))
         datasources.extend(self.__dynamicDataSources.keys())
         #: get not found datasources
         for ds in datasources:
+            self.debug("__searchDataSources:  "
+                       " dynamic component item: %s" % ds)
             if ds not in dsFound.keys() and ds not in allcpdss:
                 dsNotFound.append(ds)
                 if not dyncp:
@@ -748,6 +943,8 @@ class NXS_FileRecorder(BaseFileRecorder):
                                 "It was not found in User Components!"
                                 " Consider setting: "
                                 "NeXusDynamicComponents=True" % ds)
+        self.debug("__searchDataSources:  "
+                   "dynamic component loop end: %s" % str([cfm, dyncp]))
         return (nds, dsNotFound, cpReq, list(missingKeys))
 
     def __createConfiguration(self, userdata):
@@ -758,14 +955,19 @@ class NXS_FileRecorder(BaseFileRecorder):
         :returns: configuration xml string
         :rtype: :obj:`str`
         """
+        self.debug("__createConfiguration:  Init: %s" % self.__oddmntgrp)
         cfm = self.__getConfVar("ComponentsFromMntGrp",
                                 False, pass_default=self.__oddmntgrp)
         dyncp = self.__getConfVar("DynamicComponents",
                                   True, pass_default=self.__oddmntgrp)
 
         envRec = self.recordlist.getEnviron()
+        self.debug("__createConfiguration:  CollectAllises: %s"
+                   % self.__oddmntgrp)
         self.__collectAliases(envRec)
 
+        self.debug("__createConfiguration:  Get Components: %s"
+                   % self.__oddmntgrp)
         mandatory = self.__command(self.__nexussettings_device,
                                    "mandatoryComponents")
         self.info("Default Components %s" % str(mandatory))
@@ -787,13 +989,19 @@ class NXS_FileRecorder(BaseFileRecorder):
         self.info("Available Components %s" % str(
             self.__availableComponents()))
 
+        self.debug("__createConfiguration:  Search DataSources: %s"
+                   % self.__oddmntgrp)
         nds, dsNotFound, cpReq, missingKeys = self.__searchDataSources(
             list(set(nexuscomponents) | set(mandatory)),
             cfm, dyncp, userdata.keys())
-
-        self.debug("DataSources Not Found : %s" % dsNotFound)
-        self.debug("Components required : %s" % cpReq)
-        self.debug("Missing User Data : %s" % missingKeys)
+        self.debug("__createConfiguration:  Get User data: %s"
+                   % self.__oddmntgrp)
+
+        self.debug("__createConfiguration:  DataSources Not Found : %s"
+                   % dsNotFound)
+        self.debug("__createConfiguration:  Components required : %s" % cpReq)
+        self.debug("__createConfiguration:  Missing User Data : %s"
+                   % missingKeys)
         if "InitDataSources" in self.__conf.keys():
             # compatibility with version 2
             ids = self.__getConfVar(
@@ -804,12 +1012,20 @@ class NXS_FileRecorder(BaseFileRecorder):
                 "DataSourcePreselection",
                 None, True, pass_default=self.__oddmntgrp)
             ids = [k for (k, vl) in idsdct.items() if vl] if idsdct else None
-        if ids:
-            missingKeys.extend(list(ids))
-        self.__vars["vars"]["nexus_init_datasources"] = " ".join(missingKeys)
+        self.__vars["vars"]["nexus_init_datasources"] = \
+            " ".join(missingKeys + list(ids or []))
+        udata = {str(re.sub('[^0-9a-zA-Z@_]+', "_", str(ky))): userdata[ky]
+                 for ky in missingKeys}
+        # udata = {ky: userdata[ky] for ky in missingKeys}
+        if userdata:
+            userdata.update(udata)
+        self.debug("__createConfiguration:  Create dynamic components: %s"
+                   % self.__oddmntgrp)
         self.__createDynamicComponent(
-            dsNotFound if dyncp else [], missingKeys, nexuscomponents)
+            dsNotFound if dyncp else [], ids or [], udata, nexuscomponents)
         nexuscomponents.append(str(self.__dynamicCP))
+        self.debug("__createConfiguration:  Add Components: %s"
+                   % self.__oddmntgrp)
 
         if cfm:
             self.info("Sardana Components %s" % cpReq.keys())
@@ -839,6 +1055,11 @@ class NXS_FileRecorder(BaseFileRecorder):
             self.__aliases = [ch for ch in och if ch in allcp]
             if self.__aliases:
                 self.__vars["vars"]["mgchannels"] = " ".join(self.__aliases)
+            timers = self.__command(self.__nexussettings_device,
+                                    "availableTimers")
+            if timers:
+                self.__vars["vars"]["timers"] = " ".join(timers)
+
             self.__vars["vars"]["nexus_components"] = " ".join(nexuscomponents)
             stepdss = [str(ds) for ds in envRec['ref_moveables']
                        if str(ds) in toswitch]
@@ -852,25 +1073,38 @@ class NXS_FileRecorder(BaseFileRecorder):
             if self.__macro:
                 self.__macro().debug(
                     "VAR %s" % self.__nexussettings_device.configVariables)
+            self.debug("__createConfiguration:  Update Config Varialels: %s"
+                       % self.__oddmntgrp)
             self.__command(self.__nexussettings_device,
                            "updateConfigVariables")
 
-            self.debug("Aliases: %s" % str(self.__aliases))
-            self.debug("Switching to STEP mode: %s" % stepdss)
+            self.debug("__createConfiguration:  Aliases: %s"
+                       % str(self.__aliases))
+            self.debug("__createConfiguration:  Switching to STEP mode: %s"
+                       % stepdss)
             oldtoswitch = self.__getServerVar("stepdatasources", "[]", False)
             stepdss = str(json.dumps(list(toswitch)))
+            self.debug("__createConfiguration:  Set STEP datasources: %s"
+                       % self.__oddmntgrp)
             self.__nexussettings_device.stepdatasources = stepdss
+            self.debug("__createConfiguration:   Set LINK datasources: %s"
+                       % self.__oddmntgrp)
             if hasattr(self.__nexussettings_device, "linkdatasources"):
                 self.__nexussettings_device.linkdatasources = stepdss
+            self.debug("__createConfiguration:  "
+                       "Create Writer configuration: %s" % self.__oddmntgrp)
             cnfxml = self.__command(
                 self.__nexussettings_device, "createWriterConfiguration",
                 nexuscomponents)
         finally:
+            self.debug("__createConfiguration:   Reset variables: %s"
+                       % self.__oddmntgrp)
             self.__nexussettings_device.configVariables = json.dumps(
                 nexusvariables)
             if oldtoswitch is not None:
                 self.__nexussettings_device.stepdatasources = oldtoswitch
 
+        self.debug("__createConfiguration:  End: %s" % self.__oddmntgrp)
         return cnfxml
 
     def _startRecordList(self, recordlist):
@@ -881,49 +1115,89 @@ class NXS_FileRecorder(BaseFileRecorder):
         :type recordlist: :class:`sardana.macroserver.scan.scandata.RecordList`
         """
         try:
+            self.debug('_startRecordList:  Start %s' % self.__base_filename)
             self.__env = self.__macro().getAllEnv() if self.__macro else {}
             if self.__base_filename is None:
                 return
+            self.__udata = None
 
+            self.debug('_startRecordList:  Set NeXus %s'
+                       % self.__base_filename)
             self.__setNexusDevices()
+            self.debug('_startRecordList:  Set Variables %s'
+                       % self.__base_filename)
 
             appendentry = self.__getConfVar("AppendEntry", True)
-
-            appendentry = not self.__setFileName(
+            appendscanid = not self.__setFileName(
                 self.__base_filename, not appendentry)
             envRec = self.recordlist.getEnviron()
-            self.__vars["vars"]["serialno"] = envRec["serialno"] \
-                if appendentry else ""
+            self.__vars["vars"]["serialno"] = ("_%05i" % self.__serial) \
+                if appendscanid else ""
             self.__vars["vars"]["scan_id"] = envRec["serialno"]
+            self.__vars["vars"]["acq_modes"] = \
+                ",".join(self.writerModes or [])
             self.__vars["vars"]["scan_title"] = envRec["title"]
+            if self.__macro:
+                if hasattr(self.__macro(), "integ_time"):
+                    self.__vars["vars"]["count_time"] = \
+                        self.__macro().integ_time
+                if hasattr(self.__macro(), "nb_points"):
+                    self.__vars["vars"]["npoints"] = \
+                        self.__macro().nb_points
+            self.__vars["vars"]["beamtime_id"] = self.beamtimeid()
             tzone = self.__getConfVar("TimeZone", self.__timezone)
             self.__vars["data"]["start_time"] = \
                 self.__timeToString(envRec['starttime'], tzone)
             self.__vars["vars"]["filename"] = str(self.filename)
 
             envrecord = self.__appendRecord(self.__vars, 'INIT')
+            self.debug('_startRecordList:  Create Configuration %s'
+                       % self.__base_filename)
+            cnfxml = self.__createConfiguration(envrecord["data"])
+            self.debug('_startRecordList:  Set Remove dynamic components %s'
+                       % self.__base_filename)
             rec = json.dumps(
                 envrecord, cls=NXS_FileRecorder.numpyEncoder)
-            cnfxml = self.__createConfiguration(envrecord["data"])
             # self.debug('XML: %s' % str(cnfxml))
             self.__removeDynamicComponent()
 
-            self.__vars["data"]["serialno"] = envRec["serialno"]
+            self.__vars["data"]["serialno"] = self.__serial
             self.__vars["data"]["scan_title"] = envRec["title"]
-
+            if self.__macro:
+                if hasattr(self.__macro(), "integ_time"):
+                    self.__vars["data"]["count_time"] = \
+                        self.__macro().integ_time
+                if hasattr(self.__macro(), "nb_points"):
+                    self.__vars["data"]["npoints"] = \
+                        self.__macro().nb_points
+            self.__vars["data"]["beamtime_id"] = \
+                self.__vars["vars"]["beamtime_id"]
+
+            self.debug('_startRecordList:  Init writer %s'
+                       % self.__base_filename)
             if hasattr(self.__nexuswriter_device, 'Init'):
                 self.__command(self.__nexuswriter_device, "Init")
             self.__nexuswriter_device.fileName = str(self.filename)
             self.__command(self.__nexuswriter_device, "openFile")
             self.__nexuswriter_device.xmlsettings = cnfxml
 
-            # self.debug('START_DATA: %s' % str(envRec))
+            if "DEBUG_INIT_DATA" in self.writerModes:
+                self.debug('_startRecordList:  INIT_DATA: %s' % str(envRec))
 
+            self.debug('_startRecordList: Set JSON %s' % self.__base_filename)
             self.__nexuswriter_device.jsonrecord = rec
+            self.writerModes = self.__variableList(
+                "NeXusWriterModes")
+            if "NOINIT" in self.writerModes:
+                self.__nexuswriter_device.skipAcquisition = True
+
+            self.debug('_startRecordList SE: Open Entry %s' %
+                       self.__base_filename)
             self.__command(self.__nexuswriter_device, "openEntry")
         except Exception:
             self.__removeDynamicComponent()
             raise
+        self.debug('_startRecordList SE: END %s' % self.__base_filename)
 
     def __appendRecord(self, var, mode=None):
         """ merges userdata with variable dictionary
@@ -945,6 +1219,38 @@ class NXS_FileRecorder(BaseFileRecorder):
         dct = self.__getConfVar("UserData", None, True)
         if isinstance(dct, dict):
             nexusrecord = dct
+
+        ms = None
+        msf = None
+        if not isinstance(self.__udata, dict):
+            if 'MetadataScript' in self.__env.keys():
+                msf = self.__env['MetadataScript']
+            # elif 'FioAdditions' in self.__env.keys():
+            #     msf = self.__env['FioAdditions']
+            if msf:
+                if not os.path.exists(msf):
+                    self.warning("NXS_FileRecorder: %s does not exist" % msf)
+                    if self.__macro:
+                        self.__macro().warning(
+                            "NXS_FileRecorder: %s does not exist" % msf)
+                else:
+                    import importlib.util
+                    spec = importlib.util.spec_from_file_location('', msf)
+                    msm = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(msm)
+                    ms = msm.main()
+                    if not isinstance(ms, dict):
+                        self.warning(
+                            "NXS_FileRecorder: bad output from %s" % msf)
+                        if self.__macro:
+                            self.__macro().warning(
+                                "NXS_FileRecorder: bad output from %s" % msf)
+                        self.__udata = {}
+                    else:
+                        self.__udata = ms
+        if isinstance(self.__udata, dict) and isinstance(ms, dict):
+            nexusrecord.update(self.__udata)
+
         record = dict(var)
         record["data"] = dict(var["data"], **nexusrecord)
         if mode == 'INIT':
@@ -974,10 +1280,13 @@ class NXS_FileRecorder(BaseFileRecorder):
             rec = json.dumps(
                 envrecord, cls=NXS_FileRecorder.numpyEncoder)
             self.__nexuswriter_device.jsonrecord = rec
+            if "NOSTEP" in self.writerModes:
+                self.__nexuswriter_device.skipAcquisition = True
 
-            # self.debug('DATA: {"data":%s}' % json.dumps(
-            #     record.data,
-            #     cls=NXS_FileRecorder.numpyEncoder))
+            if "DEBUG_STEP_DATA" in self.writerModes:
+                self.debug('_writeRecord DATA: {"data":%s}' % json.dumps(
+                    record.data,
+                    cls=NXS_FileRecorder.numpyEncoder))
 
             jsonString = '{"data":%s}' % json.dumps(
                 record.data,
@@ -998,8 +1307,16 @@ class NXS_FileRecorder(BaseFileRecorder):
         :returns: formatted time string
         :rtype: :obj:`str`
         """
+        fmt = '%Y-%m-%dT%H:%M:%S.%f%z'
         try:
-            tz = pytz.timezone(tzone)
+            if sys.version_info >= (3, 9):
+                import zoneinfo
+                tz = zoneinfo.ZoneInfo(tzone)
+                starttime = mtime.replace(tzinfo=tz)
+            else:
+                import pytz
+                tz = pytz.timezone(tzone)
+                starttime = tz.localize(mtime)
         except Exception:
             self.warning(
                 "Wrong TimeZone. "
@@ -1008,10 +1325,15 @@ class NXS_FileRecorder(BaseFileRecorder):
                 self.__macro().warning(
                     "Wrong TimeZone. "
                     "The time zone set to `%s`" % self.__timezone)
-            tz = pytz.timezone(self.__timezone)
+            if sys.version_info >= (3, 9):
+                import zoneinfo
+                tz = zoneinfo.ZoneInfo(self.__timezone)
+                starttime = mtime.replace(tzinfo=tz)
+            else:
+                import pytz
+                tz = pytz.timezone(self.__timezone)
+                starttime = tz.localize(mtime)
 
-        fmt = '%Y-%m-%dT%H:%M:%S.%f%z'
-        starttime = tz.localize(mtime)
         return str(starttime.strftime(fmt))
 
     def _endRecordList(self, recordlist):
@@ -1028,7 +1350,8 @@ class NXS_FileRecorder(BaseFileRecorder):
             self.__env = self.__macro().getAllEnv() if self.__macro else {}
             envRec = recordlist.getEnviron()
 
-            # self.debug('END_DATA: %s ' % str(envRec))
+            if "DEBUG_FINAL_DATA" in self.writerModes:
+                self.debug('_endRecordList:  FINAL_DATA: %s ' % str(envRec))
 
             tzone = self.__getConfVar("TimeZone", self.__timezone)
             self.__vars["data"]["end_time"] = \
@@ -1039,6 +1362,8 @@ class NXS_FileRecorder(BaseFileRecorder):
             rec = json.dumps(
                 envrecord, cls=NXS_FileRecorder.numpyEncoder)
             self.__nexuswriter_device.jsonrecord = rec
+            if "NOFINAL" in self.writerModes:
+                self.__nexuswriter_device.skipAcquisition = True
             self.__command(self.__nexuswriter_device, "closeEntry")
             self.__command(self.__nexuswriter_device, "closeFile")
         except Exception:
@@ -1048,6 +1373,9 @@ class NXS_FileRecorder(BaseFileRecorder):
             vl = self.__getEnvVar("NXSAppendSciCatDataset", None)
             if vl:
                 self.__appendSciCatDataset(vl)
+            cmf = self.__getEnvVar("CreateMeasurementFile", False)
+            if cmf and NXSWRITER:
+                self.__createMeasurementFile()
 
     def beamtime_id(self, bmtfpath, bmtfprefix, bmtfext):
         """ code for beamtimeid  datasource
@@ -1063,29 +1391,108 @@ class NXS_FileRecorder(BaseFileRecorder):
         """
         result = ""
         fpath = self.filename
-        if fpath.startswith(bmtfpath):
-            try:
+        try:
+            if fpath.startswith(bmtfpath):
                 if os.path.isdir(bmtfpath):
                     btml = [fl for fl in os.listdir(bmtfpath)
                             if (fl.startswith(bmtfprefix)
                                 and fl.endswith(bmtfext))]
                     result = btml[0][len(bmtfprefix):-len(bmtfext)]
+        except Exception:
+            pass
+        return result
+
+    def beamtimeid(self):
+        bmtfpath = self.__getEnvVar("BeamtimeFilePath", "/gpfs/current")
+        bmtfprefix = self.__getEnvVar(
+            "BeamtimeFilePrefix", "beamtime-metadata-")
+        bmtfext = self.__getEnvVar("BeamtimeFileExt", ".json")
+        beamtimeid = self.beamtime_id(bmtfpath, bmtfprefix, bmtfext)
+        return beamtimeid or "00000000"
+
+    def __variableList(self, variable='NeXusWriterModes'):
+        """ read variable list
+        """
+        try:
+            msvar = self.__macro().getEnv(variable)
+        except Exception:
+            msvar = []
+        if isinstance(msvar, str):
+            msvar = re.split(r"[-;,.\s]\s*", msvar)
+        if msvar:
+            self.debug('__variableList:   %s: %s' % (variable, str(msvar)))
+        return msvar
+
+    def __rawfilename(self, serial):
+        """ find scan name
+        """
+        try:
+            scan_file = self.__macro().getEnv('ScanFile')
+        except Exception:
+            scan_file = []
+        try:
+            scan_dir = self.__macro().getEnv('ScanDir')
+        except Exception:
+            scan_dir = "/"
+        if isinstance(scan_file, str):
+            scan_file = [scan_file]
+        bfilename = ""
+
+        for sfile in scan_file:
+            sfile = os.path.join(scan_dir, sfile)
+            try:
+                ffile = sfile.format(ScanID=serial)
+            except KeyError:
+                ffile = sfile
+            if ffile == self.__base_filename:
+                bfilename = sfile
+                break
+        bfilename = bfilename or self.__base_filename
+        return bfilename
+
+    def __scanname(self, serial, default=None):
+        """ find scan name
+        """
+        if not self.__raw_filename:
+            self.__raw_filename = self.__rawfilename(serial)
+        if default:
+            return default
+        bfilename = self.__raw_filename
+        _, bfname = os.path.split(bfilename)
+        if bfname.endswith(".tmp"):
+            bfname = bfname[:-4]
+        sname, fext = os.path.splitext(bfname)
+        scanname = os.path.commonprefix(
+            [sname.format(ScanID=11111111),
+             sname.format(ScanID=99999999)])
+        if '%' in scanname:
+            try:
+                scanname = os.path.commonprefix(
+                    [scanname % 11111111,
+                     scanname % 99999999])
             except Exception:
                 pass
-        return result
+        if scanname.endswith("_"):
+            scanname = scanname[:-1]
+        return scanname
 
     def __appendSciCatDataset(self, hostname=None):
         """ append dataset to SciCat ingestion list """
 
+        sid = self.__serial
         fdir, fname = os.path.split(self.filename)
+        snmode = self.__getEnvVar("ScanNames", None)
+        nometa = self.__getEnvVar("ScanNamesNoMetadata", False)
+        nogrouping = self.__getEnvVar("ScanNamesNoGrouping", False)
+        appendentry = self.__getConfVar("AppendEntry", False)
+        pdir = None
+        if snmode is not None:
+            if bool(snmode):
+                fdir = os.path.dirname(os.path.abspath(fdir))
+            elif appendentry is False:
+                fdir, pdir = os.path.split(os.path.abspath(fdir))
         sname, fext = os.path.splitext(fname)
-
-        bmtfpath = self.__getEnvVar("BeamtimeFilePath", "/gpfs/current")
-        bmtfprefix = self.__getEnvVar(
-            "BeamtimeFilePrefix", "beamtime-metadata-")
-        bmtfext = self.__getEnvVar("BeamtimeFileExt", ".json")
-        beamtimeid = self.beamtime_id(bmtfpath, bmtfprefix, bmtfext)
-        beamtimeid = beamtimeid or "00000000"
+        beamtimeid = self.beamtimeid()
         defprefix = "scicat-datasets-"
         defaulthost = self.__getEnvVar("SciCatDatasetListFileLocal", None)
         if defaulthost:
@@ -1097,8 +1504,131 @@ class NXS_FileRecorder(BaseFileRecorder):
         dslfile = "%s%s%s" % (dslprefix, beamtimeid, dslext)
         if fdir:
             dslfile = os.path.join(fdir, dslfile)
-        with open(dslfile, "a+") as fl:
-            fl.write("\n%s" % sname)
+
+        entryname = "scan"
+        appendentry = self.__getConfVar("AppendEntry", False)
+        variables = self.__getConfVar("ConfigVariables", None, True)
+        if isinstance(variables, dict) and "entryname" in variables:
+            entryname = variables["entryname"]
+
+        scanname = self.__scanname(sid, pdir)
+        # _, bfname = os.path.split(self.__base_filename)
+        # try:
+        #     scanname, _ = os.path.splitext(bfname % "")
+        # except Exception:
+        #     scanname, _ = os.path.splitext(bfname)
+
+        if appendentry is True and \
+                '%' not in self.__raw_filename and \
+                "{ScanID" not in self.__raw_filename:
+            sid = self.__serial
+            sname = "%s::/%s_%05i;%s_%05i" % (
+                scanname, entryname, sid, scanname, sid)
+        if pdir:
+            sname = "%s/%s" % (pdir, sname)
+        if "NOINIT" in self.writerModes:
+            sname = "%s:%s" % (sname, time.time())
+
+        # auto grouping
+        grouping = bool(self.__getEnvVar('SciCatAutoGrouping', False))
+
+        if grouping or pdir:
+            commands = []
+            try:
+                sm = dict(self.__getEnvVar('SciCatMeasurements', {}))
+                if not isinstance(sm, dict):
+                    sm = {}
+            except Exception:
+                sm = {}
+
+            if fdir in sm.keys():
+                cgrp = sm[fdir]
+                if cgrp != scanname:
+                    if not nogrouping and not nometa:
+                        commands.append("__command__ stop")
+                        commands.append("%s:%s" % (cgrp, time.time()))
+                        commands.append("__command__ start %s" % scanname)
+            else:
+                if not nogrouping and not nometa:
+                    commands.append("__command__ start %s" % scanname)
+            if not nometa:
+                commands.append(sname)
+            if not nogrouping and not nometa:
+                commands.append("__command__ stop")
+            if not nogrouping:
+                commands.append("%s:%s" % (scanname, time.time()))
+            sname = "\n".join(commands)
+
+            if not nogrouping and not nometa:
+                sm[fdir] = scanname
+            self.__env['SciCatMeasurements'] = sm
+
+        if sname:
+            with open(dslfile, "a+") as fl:
+                fl.write("\n%s" % sname)
+
+    def __createMeasurementFile(self):
+        """ create measurement file """
+
+        sid = self.__serial
+        fdir, fname = os.path.split(self.filename)
+        pdir = None
+        snmode = self.__getEnvVar("ScanNames", None)
+        appendentry = self.__getConfVar("AppendEntry", False)
+        if snmode is not None:
+            if bool(snmode):
+                fdir = os.path.dirname(os.path.abspath(fdir))
+            elif appendentry is False:
+                fdir, pdir = os.path.split(os.path.abspath(fdir))
+        sname, fext = os.path.splitext(fname)
+        # beamtimeid = self.beamtimeid()
+
+        scanname = self.__scanname(sid, pdir)
+        # _, bfname = os.path.split(self.__base_filename)
+        # try:
+        #     scanname, _ = os.path.splitext(bfname % "")
+        # except Exception:
+        #     scanname, _ = os.path.splitext(bfname)
+
+        try:
+            sm = dict(self.__getEnvVar('SciCatMeasurements', {}))
+            if not isinstance(sm, dict):
+                sm = {}
+        except Exception:
+            sm = {}
+
+        entryname = "scan"
+        appendentry = self.__getConfVar("AppendEntry", False)
+        variables = self.__getConfVar("ConfigVariables", None, True)
+        if isinstance(variables, dict) and "entryname" in variables:
+            entryname = variables["entryname"]
+        if appendentry is True:
+            if '%' not in self.__raw_filename and \
+               "{ScanID" not in self.__raw_filename:
+                sname = sname + ("_%05i" % sid)
+                entryname = entryname + ("_%05i" % sid)
+        mntname = scanname
+        if fdir in sm.keys() and sm[fdir]:
+            mntname = sm[fdir]
+        if not appendentry or mntname != scanname:
+            mntfile = os.path.join(fdir, mntname + fext)
+
+            if not os.path.exists(mntfile):
+                fl = h5writer.create_file(mntfile)
+                self.info("Measurement file '%s' created " % mntname)
+            else:
+                fl = h5writer.open_file(mntfile, readonly=False)
+            rt = fl.root()
+            if sname not in rt.names():
+                if pdir:
+                    h5writer.link("%s/%s:/%s" %
+                                  (pdir, fname, entryname), rt, sname)
+                else:
+                    h5writer.link("%s:/%s" % (fname, entryname), rt, sname)
+                self.debug("__createMeasurementFile:  "
+                           "Link  '%s' in '%s' created " % (sname, mntname))
+            rt.close()
+            fl.close()
 
     def _addCustomData(self, value, name, group="data", remove=False,
                        **kwargs):

sardana_nxsrecorder-3.13.2.dist-info/RECORD

@@ -1,6 +0,0 @@
-sardananxsrecorder/__init__.py,sha256=XdJ1vBb5H1uB31VjKJM3emVnHEFtPzRmGHnuRyECfeY,896
-sardananxsrecorder/nxsrecorder.py,sha256=zsQI4aTchCtmJMtVl0vaU6Oyp-lHrMOlqg3ALUaaPPI,44518
-sardana_nxsrecorder-3.13.2.dist-info/METADATA,sha256=ovBaBnwlE6a68yFUYl4I8CDENgd-H90GZl5qOJYcwP8,6993
-sardana_nxsrecorder-3.13.2.dist-info/WHEEL,sha256=g4nMs7d-Xl9-xC9XovUrsDHGXt-FT0E17Yqo92DEfvY,92
-sardana_nxsrecorder-3.13.2.dist-info/top_level.txt,sha256=YdD3m417i-jlYyQWgiizgZ8lQQcOjM8y-bmUHrGkfY4,19
-sardana_nxsrecorder-3.13.2.dist-info/RECORD,,