def getDataPriority(self, data, info):
data = self.normalizeData(data)
if not info.isInvalidNXdata:
return DataView.UNSUPPORTED
if info.hasNXdata:
self._msg = "NXdata seems valid, but cannot be displayed "
self._msg += "by any existing plot widget."
else:
nx_class = get_attr_as_unicode(data, "NX_class")
if nx_class == "NXdata":
# invalid: could not even be parsed by NXdata
self._msg = "Group has @NX_class = NXdata, but could not be interpreted"
self._msg += " as valid NXdata."
elif nx_class == "NXentry":
self._msg = "NXentry group provides a @default attribute,"
default_nxdata_name = data.attrs["default"]
if default_nxdata_name not in data:
self._msg += " but no corresponding NXdata group exists."
elif get_attr_as_unicode(data[default_nxdata_name],
"NX_class") != "NXdata":
self._msg += " but the corresponding item is not a "
self._msg += "NXdata group."
else:
self._msg += " but the corresponding NXdata seems to be"
self._msg += " malformed."
elif nx_class == "NXroot" or silx.io.is_file(data):
default_entry = data[data.attrs["default"]]
default_nxdata_name = default_entry.attrs["default"]
self._msg = "NXroot group provides a @default attribute "
self._msg += "pointing to a NXentry which defines its own "
self._msg += "@default attribute, "
if default_nxdata_name not in default_entry:
self._msg += " but no corresponding NXdata group exists."
elif get_attr_as_unicode(default_entry[default_nxdata_name],
"NX_class") != "NXdata":
self._msg += " but the corresponding item is not a "
self._msg += "NXdata group."
else:
self._msg += " but the corresponding NXdata seems to be"
self._msg += " malformed."
return 100
def getDataPriority(self, data, info):
data = self.normalizeData(data)
if not info.isInvalidNXdata:
return DataView.UNSUPPORTED
if info.hasNXdata:
self._msg = "NXdata seems valid, but cannot be displayed "
self._msg += "by any existing plot widget."
else:
nx_class = get_attr_as_unicode(data, "NX_class")
if nx_class == "NXdata":
# invalid: could not even be parsed by NXdata
self._msg = "Group has @NX_class = NXdata, but could not be interpreted"
self._msg += " as valid NXdata."
elif nx_class == "NXroot" or silx.io.is_file(data):
default_entry = data[data.attrs["default"]]
default_nxdata_name = default_entry.attrs["default"]
self._msg = "NXroot group provides a @default attribute "
self._msg += "pointing to a NXentry which defines its own "
self._msg += "@default attribute, "
if default_nxdata_name not in default_entry:
self._msg += " but no corresponding NXdata group exists."
elif get_attr_as_unicode(default_entry[default_nxdata_name],
"NX_class") != "NXdata":
self._msg += " but the corresponding item is not a "
self._msg += "NXdata group."
else:
self._msg += " but the corresponding NXdata seems to be"
self._msg += " malformed."
else:
self._msg = "Group provides a @default attribute,"
default_nxdata_name = data.attrs["default"]
if default_nxdata_name not in data:
self._msg += " but no corresponding NXdata group exists."
elif get_attr_as_unicode(data[default_nxdata_name], "NX_class") != "NXdata":
self._msg += " but the corresponding item is not a "
self._msg += "NXdata group."
else:
self._msg += " but the corresponding NXdata seems to be"
self._msg += " malformed."
return 100
def __init__(self, data):
data = self.normalizeData(data)
self.isArray = False
self.interpretation = None
self.isNumeric = False
self.isVoid = False
self.isComplex = False
self.isBoolean = False
self.isRecord = False
self.hasNXdata = False
self.isInvalidNXdata = False
self.shape = tuple()
self.dim = 0
self.size = 0
if data is None:
return
if silx.io.is_group(data):
nxd = nxdata.get_default(data)
nx_class = get_attr_as_unicode(data, "NX_class")
if nxd is not None:
self.hasNXdata = True
# can we plot it?
is_scalar = nxd.signal_is_0d or nxd.interpretation in [
"scalar", "scaler"
]
if not (is_scalar or nxd.is_curve or nxd.is_x_y_value_scatter
or nxd.is_image or nxd.is_stack):
# invalid: cannot be plotted by any widget
self.isInvalidNXdata = True
elif nx_class == "NXdata":
# group claiming to be NXdata could not be parsed
self.isInvalidNXdata = True
elif nx_class == "NXentry" and "default" in data.attrs:
# entry claiming to have a default NXdata could not be parsed
self.isInvalidNXdata = True
elif nx_class == "NXroot" or silx.io.is_file(data):
# root claiming to have a default entry
if "default" in data.attrs:
def_entry = data.attrs["default"]
if def_entry in data and "default" in data[def_entry].attrs:
# and entry claims to have default NXdata
self.isInvalidNXdata = True
if isinstance(data, numpy.ndarray):
self.isArray = True
elif silx.io.is_dataset(data) and data.shape != tuple():
self.isArray = True
else:
self.isArray = False
if silx.io.is_dataset(data):
if "interpretation" in data.attrs:
self.interpretation = get_attr_as_unicode(
data, "interpretation")
else:
self.interpretation = None
elif self.hasNXdata:
self.interpretation = nxd.interpretation
else:
self.interpretation = None
if hasattr(data, "dtype"):
if numpy.issubdtype(data.dtype, numpy.void):
# That's a real opaque type, else it is a structured type
self.isVoid = data.dtype.fields is None
self.isNumeric = numpy.issubdtype(data.dtype, numpy.number)
self.isRecord = data.dtype.fields is not None
self.isComplex = numpy.issubdtype(data.dtype,
numpy.complexfloating)
self.isBoolean = numpy.issubdtype(data.dtype, numpy.bool_)
elif self.hasNXdata:
self.isNumeric = numpy.issubdtype(nxd.signal.dtype, numpy.number)
self.isComplex = numpy.issubdtype(nxd.signal.dtype,
numpy.complexfloating)
self.isBoolean = numpy.issubdtype(nxd.signal.dtype, numpy.bool_)
else:
self.isNumeric = isinstance(data, numbers.Number)
self.isComplex = isinstance(data, numbers.Complex)
self.isBoolean = isinstance(data, bool)
self.isRecord = False
if hasattr(data, "shape"):
self.shape = data.shape
elif self.hasNXdata:
self.shape = nxd.signal.shape
else:
self.shape = tuple()
if self.shape is not None:
self.dim = len(self.shape)
if hasattr(data, "size"):
self.size = int(data.size)
else:
self.size = 1
def __init__(self, data):
data = self.normalizeData(data)
self.isArray = False
self.interpretation = None
self.isNumeric = False
self.isVoid = False
self.isComplex = False
self.isBoolean = False
self.isRecord = False
self.hasNXdata = False
self.isInvalidNXdata = False
self.shape = tuple()
self.dim = 0
self.size = 0
if data is None:
return
if silx.io.is_group(data):
nxd = nxdata.get_default(data)
nx_class = get_attr_as_unicode(data, "NX_class")
if nxd is not None:
self.hasNXdata = True
# can we plot it?
is_scalar = nxd.signal_is_0d or nxd.interpretation in ["scalar", "scaler"]
if not (is_scalar or nxd.is_curve or nxd.is_x_y_value_scatter or
nxd.is_image or nxd.is_stack):
# invalid: cannot be plotted by any widget
self.isInvalidNXdata = True
elif nx_class == "NXdata":
# group claiming to be NXdata could not be parsed
self.isInvalidNXdata = True
elif nx_class == "NXroot" or silx.io.is_file(data):
# root claiming to have a default entry
if "default" in data.attrs:
def_entry = data.attrs["default"]
if def_entry in data and "default" in data[def_entry].attrs:
# and entry claims to have default NXdata
self.isInvalidNXdata = True
elif "default" in data.attrs:
# group claiming to have a default NXdata could not be parsed
self.isInvalidNXdata = True
if isinstance(data, numpy.ndarray):
self.isArray = True
elif silx.io.is_dataset(data) and data.shape != tuple():
self.isArray = True
else:
self.isArray = False
if silx.io.is_dataset(data):
if "interpretation" in data.attrs:
self.interpretation = get_attr_as_unicode(data, "interpretation")
else:
self.interpretation = None
elif self.hasNXdata:
self.interpretation = nxd.interpretation
else:
self.interpretation = None
if hasattr(data, "dtype"):
if numpy.issubdtype(data.dtype, numpy.void):
# That's a real opaque type, else it is a structured type
self.isVoid = data.dtype.fields is None
self.isNumeric = numpy.issubdtype(data.dtype, numpy.number)
self.isRecord = data.dtype.fields is not None
self.isComplex = numpy.issubdtype(data.dtype, numpy.complexfloating)
self.isBoolean = numpy.issubdtype(data.dtype, numpy.bool_)
elif self.hasNXdata:
self.isNumeric = numpy.issubdtype(nxd.signal.dtype,
numpy.number)
self.isComplex = numpy.issubdtype(nxd.signal.dtype, numpy.complexfloating)
self.isBoolean = numpy.issubdtype(nxd.signal.dtype, numpy.bool_)
else:
self.isNumeric = isinstance(data, numbers.Number)
self.isComplex = isinstance(data, numbers.Complex)
self.isBoolean = isinstance(data, bool)
self.isRecord = False
if hasattr(data, "shape"):
self.shape = data.shape
elif self.hasNXdata:
self.shape = nxd.signal.shape
else:
self.shape = tuple()
if self.shape is not None:
self.dim = len(self.shape)
if hasattr(data, "shape") and data.shape is None:
# This test is expected to avoid to fall done on the h5py issue
# https://github.com/h5py/h5py/issues/1044
self.size = 0
elif hasattr(data, "size"):
self.size = int(data.size)
else:
self.size = 1
def getDataPriority(self, data, info):
data = self.normalizeData(data)
if silx.io.is_group(data):
nxd = nxdata.get_default(data)
nx_class = get_attr_as_unicode(data, "NX_class")
if nxd is None:
if nx_class == "NXdata":
# invalid: could not even be parsed by NXdata
self._msg = "Group has @NX_class = NXdata, but could not be interpreted"
self._msg += " as valid NXdata."
return 100
elif nx_class == "NXentry":
if "default" not in data.attrs:
# no link to NXdata, no problem
return DataView.UNSUPPORTED
self._msg = "NXentry group provides a @default attribute,"
default_nxdata_name = data.attrs["default"]
if default_nxdata_name not in data:
self._msg += " but no corresponding NXdata group exists."
elif get_attr_as_unicode(data[default_nxdata_name], "NX_class") != "NXdata":
self._msg += " but the corresponding item is not a "
self._msg += "NXdata group."
else:
self._msg += " but the corresponding NXdata seems to be"
self._msg += " malformed."
return 100
elif nx_class == "NXroot" or silx.io.is_file(data):
if "default" not in data.attrs:
# no link to NXentry, no problem
return DataView.UNSUPPORTED
default_entry_name = data.attrs["default"]
if default_entry_name not in data:
# this is a problem, but not NXdata related
return DataView.UNSUPPORTED
default_entry = data[default_entry_name]
if "default" not in default_entry.attrs:
# no NXdata specified, no problemo
return DataView.UNSUPPORTED
default_nxdata_name = default_entry.attrs["default"]
self._msg = "NXroot group provides a @default attribute "
self._msg += "pointing to a NXentry which defines its own "
self._msg += "@default attribute, "
if default_nxdata_name not in default_entry:
self._msg += " but no corresponding NXdata group exists."
elif get_attr_as_unicode(default_entry[default_nxdata_name],
"NX_class") != "NXdata":
self._msg += " but the corresponding item is not a "
self._msg += "NXdata group."
else:
self._msg += " but the corresponding NXdata seems to be"
self._msg += " malformed."
return 100
else:
# Not pretending to be NXdata, no problem
return DataView.UNSUPPORTED
is_scalar = nxd.signal_is_0d or nxd.interpretation in ["scalar", "scaler"]
if not (is_scalar or nxd.is_curve or nxd.is_x_y_value_scatter or
nxd.is_image or nxd.is_stack):
# invalid: cannot be plotted by any widget (I cannot imagine a case)
self._msg = "NXdata seems valid, but cannot be displayed "
self._msg += "by any existing plot widget."
return 100
return DataView.UNSUPPORTED
def __init__(self, data):
data = self.normalizeData(data)
self.isArray = False
self.interpretation = None
self.isNumeric = False
self.isVoid = False
self.isComplex = False
self.isBoolean = False
self.isRecord = False
self.hasNXdata = False
self.shape = tuple()
self.dim = 0
self.size = 0
if data is None:
return
if silx.io.is_group(data):
nxd = nxdata.get_default(data)
if nxd is not None:
self.hasNXdata = True
if isinstance(data, numpy.ndarray):
self.isArray = True
elif silx.io.is_dataset(data) and data.shape != tuple():
self.isArray = True
else:
self.isArray = False
if silx.io.is_dataset(data):
if "interpretation" in data.attrs:
self.interpretation = get_attr_as_unicode(data, "interpretation")
else:
self.interpretation = None
elif self.hasNXdata:
self.interpretation = nxd.interpretation
else:
self.interpretation = None
if hasattr(data, "dtype"):
if numpy.issubdtype(data.dtype, numpy.void):
# That's a real opaque type, else it is a structured type
self.isVoid = data.dtype.fields is None
self.isNumeric = numpy.issubdtype(data.dtype, numpy.number)
self.isRecord = data.dtype.fields is not None
self.isComplex = numpy.issubdtype(data.dtype, numpy.complexfloating)
self.isBoolean = numpy.issubdtype(data.dtype, numpy.bool_)
elif self.hasNXdata:
self.isNumeric = numpy.issubdtype(nxd.signal.dtype,
numpy.number)
self.isComplex = numpy.issubdtype(nxd.signal.dtype, numpy.complexfloating)
self.isBoolean = numpy.issubdtype(nxd.signal.dtype, numpy.bool_)
else:
self.isNumeric = isinstance(data, numbers.Number)
self.isComplex = isinstance(data, numbers.Complex)
self.isBoolean = isinstance(data, bool)
self.isRecord = False
if hasattr(data, "shape"):
self.shape = data.shape
elif self.hasNXdata:
self.shape = nxd.signal.shape
else:
self.shape = tuple()
if self.shape is not None:
self.dim = len(self.shape)
if hasattr(data, "size"):
self.size = int(data.size)
else:
self.size = 1