nxswriter 3.12.0__py3-none-any.whl → 3.14.0__py3-none-any.whl

nxswriter/EAttribute.py

@@ -57,6 +57,24 @@ class EAttribute(FElement):
         #: (:obj:`str`) trigger for asynchronous writting
         self.trigger = None
 
+    def setRank(self, rank):
+        """ sets dimension rank
+
+        :param index: dimension rank
+        :type index: :obj:`src`
+        """
+        self.rank = rank
+
+    def setLength(self, index, value):
+        """ sets lengths dict element
+
+        :param index: length index
+        :type index: :obj:`int`
+        :param value: length value
+        :type value: :obj:`int` or :obj:`str`
+        """
+        self.lengths[index] = value
+
     def store(self, xml=None, globalJSON=None):
         """ stores the tag content
 

nxswriter/EField.py

@@ -81,8 +81,6 @@ class EField(FElementWithAttr):
         self.shuffle = True
         #: (:obj:`bool`) grew flag
         self.__grew = True
-        #: (:obj:`str`) data format
-        self.__format = ''
 
     def __isgrowing(self):
         """ checks if it is growing in extra dimension
@@ -117,6 +115,24 @@ class EField(FElementWithAttr):
 
             raise XMLSettingSyntaxError("Field without a name")
 
+    def setRank(self, rank):
+        """ sets dimension rank
+
+        :param index: dimension rank
+        :type index: :obj:`src`
+        """
+        self.rank = rank
+
+    def setLength(self, index, value):
+        """ sets lengths dict element
+
+        :param index: length index
+        :type index: :obj:`int`
+        :param value: length value
+        :type value: :obj:`int` or :obj:`str`
+        """
+        self.lengths[index] = value
+
     def __getShape(self):
         """ provides shape
 

nxswriter/EVirtualField.py

@@ -0,0 +1,718 @@
+#!/usr/bin/env python
+#   This file is part of nexdatas - Tango Server for NeXus data writer
+#
+#    Copyright (C) 2012-2017 DESY, Jan Kotanski <jkotan@mail.desy.de>
+#
+#    nexdatas is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    nexdatas 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 General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with nexdatas.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+""" Definitions of field tag evaluation classes """
+
+import sys
+
+# import numpy
+import json
+
+from .DataHolder import DataHolder
+from .Element import Element
+from .FElement import FElementWithAttr
+from .Types import NTP
+from .Errors import (XMLSettingSyntaxError)
+
+from nxstools import filewriter as FileWriter
+
+
+class EVirtualSourceView(Element):
+
+    """ virtual source view tag element
+    """
+
+    def __init__(self, attrs, last, streams=None):
+        """ constructor
+
+        :param attrs: dictionary of the tag attributes
+        :type attrs: :obj:`dict` <:obj:`str`, :obj:`str`>
+        :param last: the last element from the stack
+        :type last: :class:`nxswriter.Element.Element`
+        :param streams: tango-like steamset class
+        :type streams: :class:`StreamSet` or :class:`tango.LatestDeviceImpl`
+        """
+        Element.__init__(self, "sourceview", attrs, last, streams=streams)
+        #: (:obj:`list` <:obj:`str`>) tag content
+        self.content = []
+
+    def setRank(self, rank):
+        """ sets dimension rank
+
+        :param index: dimension rank
+        :type index: :obj:`src`
+        """
+        self.last.setSourceRank(rank)
+
+    def setLength(self, index, value):
+        """ sets lengths dict element
+
+        :param index: length index
+        :type index: :obj:`int`
+        :param value: length value
+        :type value: :obj:`int` or :obj:`str`
+        """
+        self.last.setSourceLength(index, value)
+
+    def setSelection(self, index, value):
+        """ sets selection dict element
+
+        :param index: selection index
+        :type index: :obj:`int`
+        :param value: selection value
+        :type value: :obj:`int` or :obj:`str`
+        """
+        self.last.setSourceSelection(index, value)
+
+
+class EVirtualDataMap(Element):
+
+    """ layout map tag element
+    """
+
+    def __init__(self, attrs, last, streams=None):
+        """ constructor
+
+        :param attrs: dictionary of the tag attributes
+        :type attrs: :obj:`dict` <:obj:`str`, :obj:`str`>
+        :param last: the last element from the stack
+        :type last: :class:`nxswriter.Element.Element`
+        :param streams: tango-like steamset class
+        :type streams: :class:`StreamSet` or :class:`tango.LatestDeviceImpl`
+        """
+        Element.__init__(self, "map", attrs, last, streams=streams)
+        #: (:obj:`str`) rank of the field
+        self.rank = "0"
+        #: (:obj:`str`) rank of the source field view
+        self.srcrank = "0"
+        #: (:obj:`dict` <:obj:`str`, :obj:`str`>) \
+        #:        shape of the field, i.e. {index: length}
+        self.lengths = {}
+        #: (:obj:`dict` <:obj:`str`, :obj:`str`>) \
+        #:        selection of the field, i.e. {index: slice or hyperslab}
+        self.selection = {}
+        #: (:obj:`dict` <:obj:`str`, :obj:`str`>) \
+        #:        shape of the source field, i.e. {index: length}
+        self.srclengths = {}
+        #: (:obj:`dict` <:obj:`str`, :obj:`str`>) \
+        #:        source selection of the field,
+        #:        i.e. {index: slice or hyperslab}
+        self.srcselection = {}
+        #: (:obj:`list` <:obj:`str`>) tag content
+        self.content = []
+        #: (:class:`nxswriter.DataSources.DataSource`) data source
+        self.source = None
+        #: (:obj:`str`) strategy, i.e. INIT, STEP, FINAL
+        self.strategy = 'STEP'
+        #: (:obj:`str`) trigger for asynchronous writting
+        self.trigger = None
+        self.error = ""
+        # virtual layout map
+        self.__vmap = {}
+
+    def setLength(self, index, value):
+        """ sets lengths dict element
+
+        :param index: length index
+        :type index: :obj:`int`
+        :param value: length value
+        :type value: :obj:`int` or :obj:`str`
+        """
+        self.lengths[index] = value
+
+    def setRank(self, rank):
+        """ sets dimension rank
+
+        :param index: dimension rank
+        :type index: :obj:`src`
+        """
+        self.rank = rank
+
+    def setSourceRank(self, rank):
+        """ sets dimension rank
+
+        :param index: dimension rank
+        :type index: :obj:`src`
+        """
+        self.srcrank = rank
+
+    def setSelection(self, index, value):
+        """ sets selection dict element
+
+        :param index: selection index
+        :type index: :obj:`int`
+        :param value: selection value
+        :type value: :obj:`int` or :obj:`str`
+        """
+        self.selection[index] = value
+
+    def setSourceLength(self, index, value):
+        """ sets source lengths dict element
+
+        :param index: length index
+        :type index: :obj:`int`
+        :param value: length value
+        :type value: :obj:`int` or :obj:`str`
+        """
+        self.srclengths[index] = value
+
+    def setSourceSelection(self, index, value):
+        """ sets source selection dict element
+
+        :param index: selection index
+        :type index: :obj:`int`
+        :param value: selection value
+        :type value: :obj:`int` or :obj:`str`
+        """
+        self.srcselection[index] = value
+
+    def __getShape(self):
+        """ provides shape
+
+        :returns: object shape
+        :rtype: :obj:`list` <:obj:`int` >
+        """
+        shape = []
+        try:
+            if int(self.rank) > 0:
+                for i in range(int(self.rank)):
+                    si = str(i + 1)
+                    if self.lengths and si in self.lengths.keys() \
+                       and self.lengths[si] is not None:
+                        if int(self.lengths[si]) > 0:
+                            shape.append(int(self.lengths[si]))
+                    else:
+                        raise XMLSettingSyntaxError(
+                            "Dimensions not defined")
+                if len(shape) < int(self.rank):
+                    raise XMLSettingSyntaxError(
+                        "Too small dimension number")
+        except XMLSettingSyntaxError:
+            if self.rank and int(self.rank) >= 0:
+                shape = [0] * (int(self.rank))
+            else:
+                shape = [0]
+        return shape
+
+    def __getKey(self):
+        """ provides key
+
+        :returns: object key
+        :rtype: :obj:`list` <:obj:`int` >
+        """
+        key = []
+        try:
+            if int(self.rank) > 0:
+                for i in range(int(self.rank)):
+                    si = str(i + 1)
+                    if self.selection and si in self.selection.keys() \
+                       and self.selection[si] is not None:
+                        key.append(self.selection[si])
+                    else:
+                        key.append(None)
+        except XMLSettingSyntaxError:
+            pass
+        return key
+
+    def __getSourceShape(self):
+        """ provides source shape
+
+        :returns: object shape
+        :rtype: :obj:`list` <:obj:`int` >
+        """
+        shape = []
+        try:
+            if int(self.srcrank) > 0:
+                for i in range(int(self.srcrank)):
+                    si = str(i + 1)
+                    if self.srclengths and si in self.srclengths.keys() \
+                       and self.srclengths[si] is not None:
+                        if int(self.srclengths[si]) > 0:
+                            shape.append(int(self.srclengths[si]))
+                    else:
+                        raise XMLSettingSyntaxError(
+                            "Dimensions not defined")
+                if len(shape) < int(self.srcrank):
+                    raise XMLSettingSyntaxError(
+                        "Too small dimension number")
+        except XMLSettingSyntaxError:
+            if self.srcrank and int(self.srcrank) >= 0:
+                shape = [0] * (int(self.srcrank))
+            else:
+                shape = [0]
+        return shape or None
+
+    def __getSourceKey(self):
+        """ provides source key
+
+        :returns: object key
+        :rtype: :obj:`list` <:obj:`int` >
+        """
+        key = []
+        try:
+            if int(self.srcrank) > 0:
+                for i in range(int(self.srcrank)):
+                    si = str(i + 1)
+                    if self.srcselection and si in self.srcselection.keys() \
+                       and self.srcselection[si] is not None:
+                        key.append(self.srcselection[si])
+                    else:
+                        key.append(None)
+        except XMLSettingSyntaxError:
+            pass
+        return key or None
+
+    def store(self, xml=None, globalJSON=None):
+        """ stores the tag content
+
+        :param xml: xml setting
+        :type xml: :obj: `str`
+        :param globalJSON: global JSON string
+        :type globalJSON: \
+        :     :obj:`dict` <:obj:`str`, :obj:`dict` <:obj:`str`, any>>
+        """
+
+        shape = self.__getShape()
+        if shape:
+            self.__vmap["shape"] = shape
+        key = self.__getKey()
+        if key:
+            self.__vmap["key"] = key
+        srcshape = self.__getSourceShape()
+        if srcshape is not None:
+            self.__vmap["sourceshape"] = srcshape
+        srckey = self.__getSourceKey()
+        if srckey is not None:
+            self.__vmap["sourcekey"] = srckey
+        target = None
+        filename = None
+        fieldpath = None
+        if "name" in self._tagAttrs.keys():
+            self.__name = self._tagAttrs["name"]
+        if "target" in self._tagAttrs.keys():
+            if sys.version_info > (3,):
+                target = self._tagAttrs["target"]
+            else:
+                target = self._tagAttrs["target"].encode()
+            if target:
+                self.__vmap["target"] = target
+        if "filename" in self._tagAttrs.keys():
+            if sys.version_info > (3,):
+                filename = self._tagAttrs["filename"]
+            else:
+                filename = self._tagAttrs["filename"].encode()
+            if filename:
+                self.__vmap["filename"] = filename
+        if "fieldpath" in self._tagAttrs.keys():
+            if sys.version_info > (3,):
+                fieldpath = self._tagAttrs["fieldpath"]
+            else:
+                fieldpath = self._tagAttrs["fieldpath"].encode()
+            if fieldpath:
+                self.__vmap["fieldpath"] = fieldpath
+        if not self.source:
+            self.last.appendVmap(self.__vmap)
+        if self.source:
+            if self.source.isValid():
+                return self.strategy, self.trigger
+
+    def run(self):
+        """ runner
+
+        :brief: During its thread run it fetches the data from the source
+        """
+        try:
+            if self.source:
+                dt = self.source.getData()
+                if dt and isinstance(dt, dict):
+                    dh = DataHolder(streams=self._streams, **dt)
+                    val = dh.cast("string")
+                    self.last.appendVmap(val, self.__vmap)
+
+        except Exception:
+            info = sys.exc_info()
+            import traceback
+            message = self.setMessage(
+                str(info[1].__str__()) + "\n " + (" ").join(
+                    traceback.format_tb(sys.exc_info()[2])))
+            # message = self.setMessage(  sys.exc_info()[1].__str__()  )
+            del info
+            #: notification of error in the run method (defined in base class)
+            self.error = message
+            # self.error = sys.exc_info()
+        finally:
+            if self.error:
+                if self._streams:
+                    if self.canfail:
+                        self._streams.warn(
+                            "EField::run() - %s  " % str(self.error))
+                    else:
+                        self._streams.error(
+                            "EField::run() - %s  " % str(self.error))
+
+
+class EVirtualField(FElementWithAttr):
+
+    """ virtual field H5 tag element
+    """
+
+    def __init__(self, attrs, last, streams=None,
+                 reloadmode=False):
+        """ constructor
+
+        :param attrs: dictionary of the tag attributes
+        :type attrs: :obj:`dict` <:obj:`str`, :obj:`str`>
+        :param last: the last element from the stack
+        :type last: :class:`nxswriter.Element.Element`
+        :param streams: tango-like steamset class
+        :type streams: :class:`StreamSet` or :class:`tango.LatestDeviceImpl`
+        :param reloadmode: reload mode
+        :type reloadmode: :obj:`bool`
+        """
+        FElementWithAttr.__init__(self, "vds", attrs, last, streams=streams,
+                                  reloadmode=reloadmode)
+        #: (:obj:`str`) rank of the field
+        self.rank = "0"
+        #: (:obj:`dict` <:obj:`str`, :obj:`str`>) \
+        #:        shape of the field, i.e. {index: length}
+        self.lengths = {}
+        #: (:obj:`str`) strategy, i.e. INIT, STEP, FINAL, POSTRUN
+        self.strategy = 'FINAL'
+        #: (:obj:`str`) trigger for asynchronous writing
+        self.trigger = None
+        #: (:obj:`str`) field data type
+        self.__dtype = ""
+        #: (:obj:`str`) field name
+        self.__name = ""
+        #: (:obj:`list` <:obj:`int` >) shape
+        self.__shape = []
+        #: (:obj:`list` <:obj:`dict` >) vmap list
+        self.__vmaps = []
+
+    def setRank(self, rank):
+        """ sets dimension rank
+
+        :param index: dimension rank
+        :type index: :obj:`src`
+        """
+        self.rank = rank
+
+    def setLength(self, index, value):
+        """ sets lengths dict element
+
+        :param index: length index
+        :type index: :obj:`int`
+        :param value: length value
+        :type value: :obj:`int` or :obj:`str`
+        """
+        self.lengths[index] = value
+
+    def __typeAndName(self):
+        """ provides type and name of the field
+
+        :returns: (type, name) tuple
+        """
+        if "name" in self._tagAttrs.keys():
+            nm = self._tagAttrs["name"]
+            if "type" in self._tagAttrs.keys():
+                tp = NTP.nTnp[self._tagAttrs["type"]]
+            else:
+                tp = "string"
+            return tp, nm
+        else:
+            if self._streams:
+                self._streams.error(
+                    "FElement::__typeAndName() - Field without a name",
+                    std=False)
+
+            raise XMLSettingSyntaxError("Field without a name")
+
+    def __getShape(self):
+        """ provides shape
+
+        :returns: object shape
+        :rtype: :obj:`list` <:obj:`int` >
+        """
+        try:
+            shape = self._findShape(
+                self.rank, self.lengths,
+                False, 0, True, checkData=True)
+            return shape
+        except XMLSettingSyntaxError:
+            if self.rank and int(self.rank) >= 0:
+                shape = [0] * (int(self.rank))
+            else:
+                shape = [0]
+            return shape
+
+    def __setAttributes(self):
+        """ creates attributes
+
+        :brief: It creates attributes in h5Object
+        """
+        self._setAttributes(["name"])
+        self._createAttributes()
+
+        if self.strategy == "POSTRUN":
+            if sys.version_info > (3,):
+                self.h5Object.attributes.create(
+                    "postrun",
+                    "string", overwrite=True)[...] \
+                    = self.postrun.strip()
+            else:
+                self.h5Object.attributes.create(
+                    "postrun".encode(),
+                    "string".encode(), overwrite=True)[...] \
+                    = self.postrun.encode().strip()
+
+    def __setStrategy(self, name):
+        """ provides strategy or fill the value in
+
+        :param name: object name
+        :returns: strategy or strategy,trigger it trigger defined
+        """
+        if self.source:
+            if self.source.isValid():
+                return self.strategy, self.trigger
+        if sys.version_info > (3,):
+            val = ("".join(self.content)).strip()
+        else:
+            val = ("".join(self.content)).strip().encode()
+        if val:
+            lval = val.split("\n")
+            for el in lval:
+                if el.strip():
+                    self.__vmaps.append({"target": el.strip()})
+        return self.strategy, self.trigger
+
+    def store(self, xml=None, globalJSON=None):
+        """ stores the tag content
+
+        :param xml: xml setting
+        :type xml: :obj:`str`
+        :param globalJSON: global JSON string
+        :type globalJSON: \
+        :     :obj:`dict` <:obj:`str`, :obj:`dict` <:obj:`str`, any>>
+        :returns: (strategy, trigger)
+        :rtype: (:obj:`str`, :obj:`str`)
+        """
+
+        # type and name
+        self.__dtype, self.__name = self.__typeAndName()
+        # shape
+        self.__shape = self.__getShape()
+        return self.__setStrategy(self.__name)
+
+    def __cureKeys(self, key):
+        tkey = []
+        if isinstance(key, list):
+            try:
+                sk = list(set([len(ky) for ky in key]))
+            except Exception:
+                sk = []
+            if len(sk) == 1 and sk[0] == 4:
+                offset = []
+                block = []
+                count = []
+                stride = []
+                for ky in key:
+                    off, bl, cnt, std = ky
+                    offset.append(off)
+                    block.append(bl)
+                    count.append(cnt)
+                    stride.append(std)
+                return FileWriter.FTHyperslab(offset, block, count, stride)
+            for ky in key:
+                if isinstance(ky, list) and len(ky) > 0 and len(ky) < 4:
+                    tkey.append(slice(*ky))
+                else:
+                    if ky is None:
+                        ky = slice(None)
+                    tkey.append(ky)
+
+            return tuple(tkey)
+        return key
+
+    def appendVmap(self, values, base=None):
+        """ append virtual map items
+
+        :param values: a list of map items to append
+        :type values:  :obj:`str`  or :obj:`list`< :obj:`str` >
+                        or  :obj:`list`< :obj:`dict` >
+        :param base: base map item to append
+        :type base: :obj:`dict`
+        """
+        if hasattr(values, "shape") and values.shape == tuple():
+            values = str(values)
+        try:
+            if isinstance(values, str):
+                values = json.loads(values)
+            if not isinstance(values, list):
+                values = [values]
+        except Exception:
+            if hasattr(values, "flatten"):
+                values = values.flatten()
+            if isinstance(values, str):
+                values = [values]
+            val = values
+            values = []
+            for vl in val:
+                try:
+                    if isinstance(vl, str):
+                        vl = json.loads(vl)
+                    values.append(vl)
+                except Exception:
+                    values.append(str(vl).strip())
+        for vl in values:
+            if isinstance(base, dict):
+                fval = dict(base)
+            else:
+                fval = {}
+            if isinstance(vl, dict):
+                fval.update(vl)
+            else:
+                fval.update({"target": vl.strip()})
+            self.__vmaps.append(fval)
+        return len(self.__vmaps)
+
+    def __findShape(self, key, eshape=None, unlimited=True):
+        if isinstance(key, FileWriter.FTHyperslab):
+            if not unlimited:
+                count = [(ct if ct != FileWriter.writer.unlimited() else 1)
+                         for ct in key.count]
+
+                block = [(ct if ct != FileWriter.writer.unlimited() else 1)
+                         for ct in key.block]
+            else:
+                count = key.count
+                block = key.block
+            eshape = [bl * count[hi] for hi, bl in enumerate(block)]
+        if isinstance(key, tuple):
+            eshape = []
+            for ky in key:
+                if not unlimited and ky.stop == FileWriter.writer.unlimited():
+                    eshape.append(1)
+                elif isinstance(ky, slice) and ky.stop > 0:
+                    start = ky.start if ky.start is not None else 0
+                    step = ky.step if ky.step is not None else 1
+                    eshape.append((ky.stop - start) // step)
+                else:
+                    eshape.append(1)
+        return eshape
+
+    def __createVDS(self):
+        """ create the virtual field object
+        """
+        vlf = FileWriter.virtual_field_layout(
+            self.__shape, self.__dtype)
+        counter = 0
+        for vmap in self.__vmaps:
+            fieldpath = ""
+            filename = ""
+            edtype = vmap["dtype"] \
+                if "dtype" in vmap else self.__dtype
+            key = vmap["key"] if "key" in vmap else counter
+            key = self.__cureKeys(key)
+            if "shape" in vmap:
+                eshape = vmap["shape"]
+            elif isinstance(key, int):
+                eshape = list(self.__shape)
+                eshape[0] = 1
+            else:
+                eshape = [0] * len(self.__shape)
+            fieldpath = vmap["fieldpath"] \
+                if "fieldpath" in vmap else "/data"
+            filename = vmap["filename"] if "filename" in vmap else None
+            if "target" in vmap:
+                target = vmap["target"]
+                if target.startswith("h5file:/"):
+                    target = target[8:]
+                if "::" in target:
+                    filename, fieldpath = target.split("::")
+                elif ":/" in target:
+                    filename, fieldpath = target.split(":/")
+                else:
+                    fieldpath = target
+            obj = self._lastObject()
+            while filename is None:
+                par = obj.parent
+                if par is None:
+                    break
+                if hasattr(par, "root") and hasattr(par, "name"):
+                    filename = par.name
+                    break
+                else:
+                    obj = par
+            sourceshape = vmap["sourceshape"] \
+                if "sourceshape" in vmap else None
+            sourcekey = vmap["sourcekey"] \
+                if "sourcekey" in vmap else None
+            sourcekey = self.__cureKeys(sourcekey)
+            if not any(eshape):
+                eshape = self.__findShape(key, eshape, unlimited=False)
+            ef = FileWriter.target_field_view(
+                filename, fieldpath, eshape, edtype)
+            if eshape:
+                counter += eshape[0]
+            else:
+                counter += 1
+            # print("KEY", key, sourcekey, sourceshape, eshape)
+            vlf.add(key, ef, sourcekey, sourceshape)
+        self.h5Object = self._lastObject().create_virtual_field(
+            self.__name, vlf)
+
+    def run(self):
+        """ runner
+
+        :brief: During its thread run it fetches the data from the source
+        """
+        try:
+            if self.source:
+                dt = self.source.getData()
+                if dt and isinstance(dt, dict):
+                    dh = DataHolder(streams=self._streams, **dt)
+                    val = dh.cast("string")
+                    self.appendVmap(val)
+            # print("VMAPS", self.__vmaps)
+            # print("SHaPE", self.__shape)
+            # print("TYPE", self.__dtype)
+            # print("NAME", self.__name)
+            if self.__vmaps and self.__shape and self.__dtype and self.__name:
+                self.__createVDS()
+                self.__setAttributes()
+        except Exception:
+            info = sys.exc_info()
+            import traceback
+            message = self.setMessage(
+                str(info[1].__str__()) + "\n " + (" ").join(
+                    traceback.format_tb(sys.exc_info()[2])))
+            # message = self.setMessage(  sys.exc_info()[1].__str__()  )
+            del info
+            #: notification of error in the run method (defined in base class)
+            self.error = message
+            # self.error = sys.exc_info()
+        finally:
+            if self.error:
+                if self._streams:
+                    if self.canfail:
+                        self._streams.warn(
+                            "EField::run() - %s  " % str(self.error))
+                    else:
+                        self._streams.error(
+                            "EField::run() - %s  " % str(self.error))

nxswriter/FElement.py

@@ -195,7 +195,7 @@ class FElement(Element):
                 if sys.version_info > (3,):
                     val = ("".join(self.content)).strip()
                 else:
-                    val = ("".join(self.content)).strip().encode()
+                    val = ("".join(self.content)).strip().encode("utf8")
                 found = False
                 if checkData and self.source and self.source.isValid():
                     data = self.source.getData()
@@ -497,9 +497,12 @@ class FElementWithAttr(FElement):
                             ekey, "string", overwrite=True)[...] \
                             = self._tagAttrs[key].strip()
                     else:
+                        try:
+                            vl = self._tagAttrs[key].strip().encode()
+                        except Exception:
+                            vl = self._tagAttrs[key].strip().encode("utf8")
                         self.h5Object.attributes.create(
-                            ekey, "string", overwrite=True)[...] \
-                            = self._tagAttrs[key].strip().encode()
+                            ekey, "string", overwrite=True)[...] = vl
 
     def h5Attribute(self, name):
         """ provides attribute h5 object

nxswriter/H5Elements.py

@@ -19,6 +19,8 @@
 
 """ Definitions of tag evaluation classes """
 
+import json
+
 from .Element import Element
 from .FElement import FElement
 from .DataHolder import DataHolder
@@ -125,7 +127,27 @@ class EDimensions(Element):
         """
         Element.__init__(self, "dimensions", attrs, last, streams=streams)
         if "rank" in attrs.keys():
-            self.last.rank = attrs["rank"]
+            self.last.setRank(attrs["rank"])
+
+
+class ESelection(Element):
+
+    """ selection tag element
+    """
+
+    def __init__(self, attrs, last, streams=None):
+        """ constructor
+
+        :param attrs: dictionary of the tag attributes
+        :type attrs: :obj:`dict` <:obj:`str`, :obj:`str`>
+        :param last: the last element from the stack
+        :type last: :class:`nxswriter.Element.Element`
+        :param streams: tango-like steamset class
+        :type streams: :class:`StreamSet` or :class:`tango.LatestDeviceImpl`
+        """
+        Element.__init__(self, "selection", attrs, last, streams=streams)
+        if "rank" in attrs.keys():
+            self.last.setRank(attrs["rank"])
 
 
 class EDim(Element):
@@ -145,7 +167,147 @@ class EDim(Element):
         """
         Element.__init__(self, "dim", attrs, last, streams=streams)
         if ("index" in attrs.keys()) and ("value" in attrs.keys()):
-            self._beforeLast().lengths[attrs["index"]] = attrs["value"]
+            self._beforeLast().setLength(attrs["index"], attrs["value"])
+        #: (:obj:`str`) index attribute
+        self.__index = None
+        #: (:class:`nxswriter.DataSources.DataSource`) data source
+        self.source = None
+        #: (:obj:`list` <:obj:`str`>) tag content
+        self.content = []
+        if "index" in attrs.keys():
+            self.__index = attrs["index"]
+
+    def store(self, xml=None, globalJSON=None):
+        """ stores the tag content
+
+        :param xml: xml setting
+        :type xml: :obj: `str`
+        :param globalJSON: global JSON string
+        :type globalJSON: \
+        :     :obj:`dict` <:obj:`str`, :obj:`dict` <:obj:`str`, any>>
+        """
+        if self.__index is not None and self.source:
+            dt = self.source.getData()
+            if dt and isinstance(dt, dict):
+                dh = DataHolder(streams=self._streams, **dt)
+                if dh:
+                    self._beforeLast().setLength(self.__index,
+                                                 str(dh.cast("string")))
+
+
+class ESlab(Element):
+
+    """ slab tag element
+    """
+
+    def __init__(self, attrs, last, streams=None):
+        """ constructor
+
+        :param attrs: dictionary of the tag attributes
+        :type attrs: :obj:`dict` <:obj:`str`, :obj:`str`>
+        :param last: the last element from the stack
+        :type last: :class:`nxswriter.Element.Element`
+        :param streams: tango-like steamset class
+        :type streams: :class:`StreamSet` or :class:`tango.LatestDeviceImpl`
+        """
+        Element.__init__(self, "slab", attrs, last, streams=streams)
+        if ("index" in attrs.keys()):
+            offset = 0
+            block = 1
+            count = 1
+            stride = 1
+            if "offset" in attrs.keys() and attrs["offset"]:
+                try:
+                    offset = int(attrs["offset"])
+                except Exception:
+                    pass
+            if "block" in attrs.keys() and attrs["block"]:
+                try:
+                    block = int(attrs["block"])
+                except Exception:
+                    pass
+            if "count" in attrs.keys() and attrs["count"]:
+                try:
+                    count = int(attrs["count"])
+                except Exception:
+                    pass
+            if "stride" in attrs.keys() and attrs["stride"]:
+                try:
+                    stride = int(attrs["stride"])
+                except Exception:
+                    pass
+            self._beforeLast().setSelection(
+                attrs["index"], [offset, block, count, stride])
+        #: (:obj:`str`) index attribute
+        self.__index = None
+        #: (:class:`nxswriter.DataSources.DataSource`) data source
+        self.source = None
+        #: (:obj:`list` <:obj:`str`>) tag content
+        self.content = []
+        if "index" in attrs.keys():
+            self.__index = attrs["index"]
+
+    def store(self, xml=None, globalJSON=None):
+        """ stores the tag content
+
+        :param xml: xml setting
+        :type xml: :obj: `str`
+        :param globalJSON: global JSON string
+        :type globalJSON: \
+        :     :obj:`dict` <:obj:`str`, :obj:`dict` <:obj:`str`, any>>
+        """
+        if self.__index is not None and self.source:
+            dt = self.source.getData()
+            if dt and isinstance(dt, dict):
+                dh = DataHolder(streams=self._streams, **dt)
+                if dh:
+                    slab = json.loads(str(dh.cast("string")))
+                    if isinstance(slab, list):
+                        self._beforeLast().setSelection(self.__index, slab[:4])
+
+
+class ESlice(Element):
+
+    """ slice tag element
+    """
+
+    def __init__(self, attrs, last, streams=None):
+        """ constructor
+
+        :param attrs: dictionary of the tag attributes
+        :type attrs: :obj:`dict` <:obj:`str`, :obj:`str`>
+        :param last: the last element from the stack
+        :type last: :class:`nxswriter.Element.Element`
+        :param streams: tango-like steamset class
+        :type streams: :class:`StreamSet` or :class:`tango.LatestDeviceImpl`
+        """
+        Element.__init__(self, "slice", attrs, last, streams=streams)
+        if ("index" in attrs.keys()):
+            added = False
+            start = None
+            stop = None
+            step = None
+            if "start" in attrs.keys() and attrs["start"]:
+                try:
+                    start = int(attrs["start"])
+                    added = True
+                except Exception:
+                    pass
+            if "stop" in attrs.keys() and attrs["stop"]:
+                try:
+                    stop = int(attrs["stop"])
+                    added = True
+                except Exception:
+                    pass
+            if "step" in attrs.keys() and attrs["step"]:
+                try:
+                    step = int(attrs["step"])
+                    added = True
+                except Exception:
+                    pass
+            if added:
+                self._beforeLast().setSelection(
+                    attrs["index"], slice(start, stop, step))
         #: (:obj:`str`) index attribute
         self.__index = None
         #: (:class:`nxswriter.DataSources.DataSource`) data source
@@ -169,8 +331,10 @@ class EDim(Element):
             if dt and isinstance(dt, dict):
                 dh = DataHolder(streams=self._streams, **dt)
                 if dh:
-                    self._beforeLast().lengths[self.__index] = str(
-                        dh.cast("string"))
+                    lslice = json.loads(str(dh.cast("string")))
+                    if isinstance(lslice, list):
+                        self._beforeLast().setSelection(
+                            self.__index, slice(*lslice))
 
 
 class EFilter(Element):

nxswriter/NexusXMLHandler.py

@@ -28,11 +28,13 @@ from .Element import Element
 from .FElement import FElement
 from .EGroup import EGroup
 from .EField import EField
+from .EVirtualField import EVirtualField, EVirtualDataMap, EVirtualSourceView
 from .EAttribute import EAttribute
 from .EStrategy import EStrategy
 from .ELink import ELink
 from .H5Elements import (
-    EDoc, ESymbol, EDimensions, EDim, EFile, EFilter)
+    EDoc, ESymbol, EDimensions, EDim, EFile, EFilter, ESlab, ESlice,
+    ESelection)
 from .DataSourceFactory import DataSourceFactory
 from .ThreadPool import ThreadPool
 from .InnerXMLParser import InnerXMLHandler
@@ -121,7 +123,10 @@ class NexusXMLHandler(sax.ContentHandler):
             'symbols': Element, 'symbol': ESymbol,
             'dimensions': EDimensions, 'dim': EDim,
             'enumeration': Element, 'item': Element,
-            'strategy': EStrategy, 'filter': EFilter
+            'strategy': EStrategy, 'filter': EFilter,
+            'vds': EVirtualField, 'map': EVirtualDataMap,
+            'sourceview': EVirtualSourceView,
+            'slab': ESlab, 'slice': ESlice, 'selection': ESelection,
         }
 
         #: (:obj:`list` <:obj:`dict` <:obj:`str`, :obj:`str` > >) \
@@ -130,7 +135,7 @@ class NexusXMLHandler(sax.ContentHandler):
 
         #: (:obj:`dict` <:obj:`str`, :obj:`type` > ) \
         #: map of tag names to related classes
-        self.withAttr = ['group', 'field']
+        self.withAttr = ['group', 'field', 'vds']
 
         #: (:obj:`list` <:obj:`str`>) transparent tags
         self.transparentTags = ['definition']

nxswriter/Release.py

@@ -21,4 +21,4 @@
 
 
 #: package version
-__version__ = "3.12.0"
+__version__ = "3.14.0"

nxswriter/TangoDataWriter.py

@@ -71,6 +71,7 @@ DEFAULTWRITERS = ["h5cpp", "h5py", "h5redis"]
 #: (:obj:`bool`) tango bug #213 flag related to EncodedAttributes in python3
 PYTG_BUG_213 = False
 if sys.version_info > (3,):
+    unicode = str
     try:
         try:
             import tango
@@ -315,9 +316,12 @@ class TangoDataWriter(object):
         """
         self.__fetcher = FetchNameHandler(streams=self._streams)
         if sys.version_info > (3,):
-            sax.parseString(bytes(xmlset, 'utf-8'), self.__fetcher)
-        else:
             sax.parseString(xmlset, self.__fetcher)
+        else:
+            if isinstance(xmlset, unicode):
+                sax.parseString(xmlset.encode('utf-8'), self.__fetcher)
+            else:
+                sax.parseString(xmlset, self.__fetcher)
         self.__xmlsettings = xmlset
 
     def __delXML(self):
@@ -504,7 +508,15 @@ class TangoDataWriter(object):
             parser.setContentHandler(handler)
             parser.setErrorHandler(errorHandler)
             inpsrc = sax.InputSource()
-            inpsrc.setByteStream(StringIO(self.xmlsettings))
+            if sys.version_info > (3,):
+                inpsrc.setByteStream(StringIO(self.xmlsettings))
+            else:
+                if isinstance(self.xmlsettings, unicode):
+                    inpsrc.setByteStream(
+                        StringIO(self.xmlsettings.encode('utf-8')))
+                else:
+                    inpsrc.setByteStream(StringIO(self.xmlsettings))
+
             parser.parse(inpsrc)
 
             self.__initPool = handler.initPool

{nxswriter-3.12.0.dist-info → nxswriter-3.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nxswriter
-Version: 3.12.0
+Version: 3.14.0
 Summary: Nexus Data writer implemented as a Tango Server
 Home-page: https://github.com/nexdatas/nxsdatawriter
 Author: Jan Kotanski, Eugen Wintersberger , Halil Pasic
@@ -89,12 +89,12 @@ Extract sources and run
 
 .. code-block:: console
 
-	  $ python setup.py install
+	  $ python3 setup.py install
 
 Debian packages
 """""""""""""""
 
-Debian `bookworm`, `bullseye`, `buster`  or Ubuntu `lunar`, `jammy`, `focal`  packages can be found in the HDRI repository.
+Debian `bookworm`, `bullseye`, `buster`  or Ubuntu `oracular`,  `noble`, `jammy`  packages can be found in the HDRI repository.
 
 To install the debian packages, add the PGP repository key
 
@@ -175,7 +175,7 @@ To set up  NeXus Writer Server run
 
           $ nxsetup -x NXSDataWriter
 
-The *nxsetup* command comes from the **python-nxstools** package.
+The *nxsetup* command comes from the **python3-nxstools** package.
 
 -----------
 Client code

{nxswriter-3.12.0.dist-info → nxswriter-3.14.0.dist-info}/RECORD

@@ -5,33 +5,34 @@ nxswriter/DataSourceFactory.py,sha256=W0IirDjsu38KKvBxFbkvv-ghvqil2JJStQ3WMxo8Kh
 nxswriter/DataSourcePool.py,sha256=1bDOrHhYpG_ZFz8ut2IzkNSMeGxrCBcSCneM4h1AgDc,4574
 nxswriter/DataSources.py,sha256=l40n4WTfgRjLpFsJs7JoWjsER_dCVviRI_iolQ2fENM,5303
 nxswriter/DecoderPool.py,sha256=8nsKtzwyls-YLZUJAfxdGrqb2278Er1Y20NVq1XexvY,15052
-nxswriter/EAttribute.py,sha256=8i3EaIQbXWkt7zGOuu1RjGIZ7slbgxIgaGJDWVyUAOU,8434
-nxswriter/EField.py,sha256=ELCyQ9K6EhvLEJICnUMHzYTumMRM_b9xXHbXMqQOwgA,27653
+nxswriter/EAttribute.py,sha256=hADI-LeuQMZwVoTFM4qevoz173Ma_atrk0edqvsFXS0,8878
+nxswriter/EField.py,sha256=YLbdaykGccZ4cjqheS9te50FG6HQq5kfp7gg_OBkJ9k,28034
 nxswriter/EGroup.py,sha256=Y_PuTERckQXfUXGISbnpzHj7I4y2iFxM5CGByjVD6KA,4900
 nxswriter/ELink.py,sha256=FO7SRF1bpJhqRzK2FBSkRHhFwH1Mw5BRCgt8X8qJbr0,8820
 nxswriter/EStrategy.py,sha256=3RX8E6Ee-Klv9DGlMPvXJacdNDmuKWLQrcnuerR0IQI,3992
+nxswriter/EVirtualField.py,sha256=ZECzyGb4wZoBohHlwkcilpOtDHuA907VoruLDe9RN9k,24971
 nxswriter/Element.py,sha256=dnIUS_U0fqJK3FxV_raQBx6qTGPT7sUFkWVzxI5YuEY,3019
 nxswriter/ElementThread.py,sha256=gCZRpzjji8TRfWLkwFRXG_K55d0yUkv9Gzi2DZ22EyQ,2099
 nxswriter/Errors.py,sha256=dYXtJ7rVWv59kAalNMMZO4X3SxSplhoWICeCb3_rFGc,1660
-nxswriter/FElement.py,sha256=dwc9wkMjhlueIdVIPSFmELje4VHtHFwS2UwTWbJs7Is,20463
+nxswriter/FElement.py,sha256=ebQT2HHPmR6_J8H8ILa7G-gMDDNrEIUNh7sIfm9SF1I,20622
 nxswriter/FetchNameHandler.py,sha256=WbIJcxB9wjUHAIgXpZOzxBBAlWMhg-zYiLw_2sxcBIY,6829
-nxswriter/H5Elements.py,sha256=V5judPZZM6em5SgjILwZDfnND8Mk7JntAFIivAkgqL8,7420
+nxswriter/H5Elements.py,sha256=64BFlgfaPEuRzWyWjkdfMhwF6oMc_NzAqAoKaZGAigo,13263
 nxswriter/InnerXMLParser.py,sha256=Cr5Ih-51LGi8sKQi1qUUikL2K5hjwwilJo-j1kWHgds,4493
 nxswriter/Metadata.py,sha256=Qg5KdlreERGG5CTZrCRAJXwBXxg96toyZ8wkknmdB3s,3668
 nxswriter/NXSFromXML.py,sha256=932BivWZnf-3tnIkbpSRFwfGV0PTwcT9pYb2FMmVd_4,9077
 nxswriter/NXSWriter.py,sha256=raHykC9mpUXU8pPtsqePuz3CI-24qYjIUSoyux2zCgo,31345
-nxswriter/NexusXMLHandler.py,sha256=QxSB6Nwi-6ZWR0SxTOojfcF99kN4MBRVNIGKeN7p2Ug,13841
+nxswriter/NexusXMLHandler.py,sha256=IrZ2mWLuovdBIHcWTqKmr4HZxpMEWLun8A94O6pavr8,14131
 nxswriter/PyEvalSource.py,sha256=7-7Gc2_3CGd3XMHD3LBPCBOZx4Q6b1guzt1xgrSLxMs,11234
-nxswriter/Release.py,sha256=AiKg1e-Qya9xd3ncbA85-mBlhbX5H29NAYpU8wItvVg,900
+nxswriter/Release.py,sha256=qNmln5Ifl--7uY5SpcQDkGFLFbqPVDYTmjV_3yQqLQI,900
 nxswriter/StreamSet.py,sha256=sSvXJxoDufmt9_Xu5rFaQsp_4x9gww_zMv0NTiiyLlg,5799
-nxswriter/TangoDataWriter.py,sha256=ZYnOZm1OEgdybIlr3dYWfLmVXwrGS1ahR_cM7Pi9fAk,28263
+nxswriter/TangoDataWriter.py,sha256=yP6B3TVUhpHp8OBHKYQRNNtFer9xARoakNXuro4eVv8,28725
 nxswriter/TangoSource.py,sha256=jiFGUsoX2N5-i2gpBqkHi2KjmTBd46TI22Cjkt_2btw,29410
 nxswriter/ThreadPool.py,sha256=TKvOStVUUyuyHowk0MRaBM4GmRKtl0VPVVPdFHu332M,6039
 nxswriter/Types.py,sha256=CY_qw5-pbbDutRErgA6hbUTh903QA_IXc-CGSfuBje8,7676
 nxswriter/__init__.py,sha256=M0w3HGjZgfdqjMdQNaLcq5jazqQeRekx84YSbQCA8-0,1760
-nxswriter-3.12.0.data/scripts/NXSDataWriter,sha256=wO3opCCjYttfrY7CITNXHvirXv5W6rIQTY7vX5PmioI,905
-nxswriter-3.12.0.data/scripts/nxsfromxml,sha256=qxnJUtV_ueA3lGnne8ltaOF6yF5YtmzeFLIl3NWkAq8,61
-nxswriter-3.12.0.dist-info/METADATA,sha256=raxlRNa-5-2d-u4XbgmRboB-3Y3pQc-Jnz6y4f6WWzU,8958
-nxswriter-3.12.0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-nxswriter-3.12.0.dist-info/top_level.txt,sha256=29dYcOYN2MVz1NKpwobc4Zl4yjhd4VB62LDSuSy7x0Y,10
-nxswriter-3.12.0.dist-info/RECORD,,
+nxswriter-3.14.0.data/scripts/NXSDataWriter,sha256=wO3opCCjYttfrY7CITNXHvirXv5W6rIQTY7vX5PmioI,905
+nxswriter-3.14.0.data/scripts/nxsfromxml,sha256=qxnJUtV_ueA3lGnne8ltaOF6yF5YtmzeFLIl3NWkAq8,61
+nxswriter-3.14.0.dist-info/METADATA,sha256=53Fc3OKmRlNatTbdcs0-lhBae1UoQkkPWLDvY_KAshY,8964
+nxswriter-3.14.0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+nxswriter-3.14.0.dist-info/top_level.txt,sha256=29dYcOYN2MVz1NKpwobc4Zl4yjhd4VB62LDSuSy7x0Y,10
+nxswriter-3.14.0.dist-info/RECORD,,