def __init__(self, parentnode, name,
obj=None, title="",
byteorder=None, _log=True, _atom=None):
self._v_version = None
"""The object version of this array."""
self._v_new = new = obj is not None
"""Is this the first time the node has been created?"""
self._v_new_title = title
"""New title for this node."""
self._obj = obj
"""The object to be stored in the array. It can be any of numpy,
list, tuple, string, integer of floating point types, provided
that they are regular (i.e. they are not like ``[[1, 2], 2]``).
.. versionchanged:: 3.0
Renamed form *_object* into *_obj*.
"""
self._v_convert = True
"""Whether the ``Array`` object must be converted or not."""
# Miscellaneous iteration rubbish.
self._start = None
"""Starting row for the current iteration."""
self._stop = None
"""Stopping row for the current iteration."""
self._step = None
"""Step size for the current iteration."""
self._nrowsread = None
"""Number of rows read up to the current state of iteration."""
self._startb = None
"""Starting row for current buffer."""
self._stopb = None
"""Stopping row for current buffer. """
self._row = None
"""Current row in iterators (sentinel)."""
self._init = False
"""Whether we are in the middle of an iteration or not (sentinel)."""
self.listarr = None
"""Current buffer in iterators."""
# Documented (*public*) attributes.
self.atom = _atom
"""An Atom (see :ref:`AtomClassDescr`) instance representing the *type*
and *shape* of the atomic objects to be saved.
"""
self.shape = None
"""The shape of the stored array."""
self.nrow = None
"""On iterators, this is the index of the current row."""
self.extdim = -1 # ordinary arrays are not enlargeable
"""The index of the enlargeable dimension."""
# Ordinary arrays have no filters: leaf is created with default ones.
super(Array, self).__init__(parentnode, name, new, Filters(),
byteorder, _log)
def filters(self):
"""Filter properties for this leaf.
See Also
--------
Filters
"""
return Filters._from_leaf(self)
def filters(self):
"""Filter properties for this leaf.
See Also
--------
Filters
"""
return Filters._from_leaf(self)
def __getattr__(self, name):
"""Get the attribute named "name"."""
# If attribute does not exist, raise AttributeError
if not name in self._v_attrnames:
raise AttributeError("Attribute '%s' does not exist in node: " "'%s'" % (name, self._v__nodepath))
# Read the attribute from disk. This is an optimization to read
# quickly system attributes that are _string_ values, but it
# takes care of other types as well as for example NROWS for
# Tables and EXTDIM for EArrays
format_version = self._v__format_version
value = self._g_getattr(self._v_node, name)
# Check whether the value is pickled
# Pickled values always seems to end with a "."
maybe_pickled = (
isinstance(value, numpy.generic)
and value.dtype.type == numpy.bytes_ # NumPy scalar?
and value.itemsize > 0 # string type?
and value.endswith(b".")
)
if maybe_pickled and value in [b"0", b"0."]:
# Workaround for a bug in many versions of Python (starting
# somewhere after Python 2.6.1). See ticket #253.
retval = value
elif maybe_pickled and _field_fill_re.match(name) and format_version == (1, 5):
# This format was used during the first 1.2 releases, just
# for string defaults.
try:
retval = cPickle.loads(value)
retval = numpy.array(retval)
except ImportError:
retval = None # signal error avoiding exception
elif maybe_pickled and name == "FILTERS" and format_version < (2, 0):
# This is a big hack, but we don't have other way to recognize
# pickled filters of PyTables 1.x files.
value = _old_filters_re.sub(_new_filters_sub, value, 1)
retval = cPickle.loads(value) # pass unpickling errors through
elif maybe_pickled:
try:
retval = cPickle.loads(value)
# except cPickle.UnpicklingError:
# It seems that pickle may raise other errors than UnpicklingError
# Perhaps it would be better just an "except:" clause?
# except (cPickle.UnpicklingError, ImportError):
# Definitely (see SF bug #1254636)
except UnicodeDecodeError:
# Object maybe pickled on python 2 and unpickled on python 3.
# encoding='bytes' was added in python 3.4 to resolve this.
# Ref: http://bugs.python.org/issue6784
try:
retval = cPickle.loads(value, encoding="bytes")
except:
retval = value
except:
# catch other unpickling errors:
# ivb (2005-09-07): It is too hard to tell
# whether the unpickling failed
# because of the string not being a pickle one at all,
# because of a malformed pickle string,
# or because of some other problem in object reconstruction,
# thus making inconvenient even the issuing of a warning here.
# The documentation contains a note on this issue,
# explaining how the user can tell where the problem was.
retval = value
# Additional check for allowing a workaround for #307
if isinstance(retval, unicode) and retval == u"":
retval = numpy.array(retval)[()]
elif name == "FILTERS" and format_version >= (2, 0):
retval = Filters._unpack(value)
elif name == "TITLE" and not isinstance(value, str):
if sys.version_info[0] < 3:
# unicode is OK for TITLE
retval = value
else:
retval = value.decode("utf-8")
elif (
issysattrname(name)
and isinstance(value, (bytes, unicode))
and not isinstance(value, str)
and not _field_fill_re.match(name)
):
# system attributes should always be str
if sys.version_info[0] < 3:
retval = value.encode()
else:
# python 3, bytes and not "FIELD_[0-9]+_FILL"
retval = value.decode("utf-8")
else:
retval = value
# Put this value in local directory
self.__dict__[name] = retval
return retval
def filters(self):
"""Filter properties for this leaf."""
return Filters._from_leaf(self)
def filters(self):
"""Filter properties for this leaf."""
return Filters._from_leaf(self)
def _g_getfilters(self):
filters = getattr(self._v_attrs, 'FILTERS', None)
if filters is None:
filters = Filters()
return filters
def __init__(self, parentNode, name,
object=None, title="",
byteorder=None, _log=True, _atom=None):
"""
Create an `Array` instance.
`object`
The array or scalar to be saved. Accepted types are NumPy
arrays and scalars, ``numarray`` arrays and string arrays,
Numeric arrays and scalars, as well as native Python
sequences and scalars, provided that values are regular
(i.e. they are not like ``[[1,2],2]``) and homogeneous
(i.e. all the elements are of the same type).
`title`
A description for this node (it sets the ``TITLE`` HDF5
attribute on disk).
`byteorder`
The byteorder of the data *on disk*, specified as 'little'
or 'big'. If this is not specified, the byteorder is that
of the given `object`.
"""
self._v_version = None
"""The object version of this array."""
self._v_new = new = object is not None
"""Is this the first time the node has been created?"""
self._v_new_title = title
"""New title for this node."""
self._object = object
"""
The object to be stored in the array. It can be any of
``numpy``, ``numarray``, ``numeric``, list, tuple, string,
integer of floating point types, provided that they are
regular (i.e. they are not like ``[[1, 2], 2]``).
"""
self._v_convert = True
"""Whether the ``Array`` object must be converted or not."""
# Miscellaneous iteration rubbish.
self._start = None
"""Starting row for the current iteration."""
self._stop = None
"""Stopping row for the current iteration."""
self._step = None
"""Step size for the current iteration."""
self._nrowsread = None
"""Number of rows read up to the current state of iteration."""
self._startb = None
"""Starting row for current buffer."""
self._stopb = None
"""Stopping row for current buffer. """
self._row = None
"""Current row in iterators (sentinel)."""
self._init = False
"""Whether we are in the middle of an iteration or not (sentinel)."""
self.listarr = None
"""Current buffer in iterators."""
# Documented (*public*) attributes.
self.atom = _atom
"""
An `Atom` instance representing the *type* and *shape* of the
atomic objects to be saved.
"""
self.shape = None
"""The shape of the stored array."""
self.nrow = None
"""On iterators, this is the index of the current row."""
self.extdim = -1 # ordinary arrays are not enlargeable
"""The index of the enlargeable dimension."""
# Ordinary arrays have no filters: leaf is created with default ones.
super(Array, self).__init__(parentNode, name, new, Filters(),
byteorder, _log)
def __getattr__(self, name):
"""Get the attribute named "name"."""
# If attribute does not exist, raise AttributeError
if not name in self._v_attrnames:
raise AttributeError, \
"Attribute '%s' does not exist in node: '%s'" % \
(name, self._v__nodePath)
# Read the attribute from disk. This is an optimization to read
# quickly system attributes that are _string_ values, but it
# takes care of other types as well as for example NROWS for
# Tables and EXTDIM for EArrays
format_version = self._v__format_version
value = self._g_getAttr(self._v_node, name)
# Check whether the value is pickled
# Pickled values always seems to end with a "."
maybe_pickled = (
isinstance(value, numpy.generic) and # NumPy scalar?
value.dtype.type == numpy.string_ and # string type?
value.itemsize > 0 and value[-1] == '.' )
if ( maybe_pickled and _field_fill_re.match(name)
and format_version == (1, 5) ):
# This format was used during the first 1.2 releases, just
# for string defaults.
try:
retval = cPickle.loads(value)
retval = numpy.array(retval)
except ImportError:
retval = None # signal error avoiding exception
elif maybe_pickled and name == 'FILTERS' and format_version < (2, 0):
# This is a big hack, but we don't have other way to recognize
# pickled filters of PyTables 1.x files.
value = _old_filters_re.sub(_new_filters_sub, value, 1)
retval = cPickle.loads(value) # pass unpickling errors through
elif maybe_pickled:
try:
retval = cPickle.loads(value)
#except cPickle.UnpicklingError:
# It seems that cPickle may raise other errors than UnpicklingError
# Perhaps it would be better just an "except:" clause?
#except (cPickle.UnpicklingError, ImportError):
# Definitely (see SF bug #1254636)
except:
# ivb (2005-09-07): It is too hard to tell
# whether the unpickling failed
# because of the string not being a pickle one at all,
# because of a malformed pickle string,
# or because of some other problem in object reconstruction,
# thus making inconvenient even the issuing of a warning here.
# The documentation contains a note on this issue,
# explaining how the user can tell where the problem was.
retval = value
elif name == 'FILTERS' and format_version >= (2, 0):
retval = Filters._unpack(value)
else:
retval = value
# Put this value in local directory
self.__dict__[name] = retval
return retval
def __getattr__(self, name):
"""Get the attribute named "name"."""
# If attribute does not exist, raise AttributeError
if not name in self._v_attrnames:
raise AttributeError("Attribute '%s' does not exist in node: "
"'%s'" % (name, self._v__nodepath))
# Read the attribute from disk. This is an optimization to read
# quickly system attributes that are _string_ values, but it
# takes care of other types as well as for example NROWS for
# Tables and EXTDIM for EArrays
format_version = self._v__format_version
value = self._g_getattr(self._v_node, name)
# Check whether the value is pickled
# Pickled values always seems to end with a "."
maybe_pickled = (
isinstance(value, numpy.generic) and # NumPy scalar?
value.dtype.type == numpy.bytes_ and # string type?
value.itemsize > 0 and value.endswith(b'.'))
if (maybe_pickled and value in [b"0", b"0."]):
# Workaround for a bug in many versions of Python (starting
# somewhere after Python 2.6.1). See ticket #253.
retval = value
elif (maybe_pickled and _field_fill_re.match(name)
and format_version == (1, 5)):
# This format was used during the first 1.2 releases, just
# for string defaults.
try:
retval = cPickle.loads(value)
retval = numpy.array(retval)
except ImportError:
retval = None # signal error avoiding exception
elif maybe_pickled and name == 'FILTERS' and format_version < (2, 0):
# This is a big hack, but we don't have other way to recognize
# pickled filters of PyTables 1.x files.
value = _old_filters_re.sub(_new_filters_sub, value, 1)
retval = cPickle.loads(value) # pass unpickling errors through
elif maybe_pickled:
try:
retval = cPickle.loads(value)
# except cPickle.UnpicklingError:
# It seems that pickle may raise other errors than UnpicklingError
# Perhaps it would be better just an "except:" clause?
# except (cPickle.UnpicklingError, ImportError):
# Definitely (see SF bug #1254636)
except:
# ivb (2005-09-07): It is too hard to tell
# whether the unpickling failed
# because of the string not being a pickle one at all,
# because of a malformed pickle string,
# or because of some other problem in object reconstruction,
# thus making inconvenient even the issuing of a warning here.
# The documentation contains a note on this issue,
# explaining how the user can tell where the problem was.
retval = value
# Additional check for allowing a workaround for #307
if isinstance(retval, unicode) and retval == u'':
retval = numpy.array(retval)[()]
elif name == 'FILTERS' and format_version >= (2, 0):
retval = Filters._unpack(value)
elif (issysattrname(name) and isinstance(value, (bytes, unicode)) and
not isinstance(value, str) and not _field_fill_re.match(name)):
# system attributes should always be str
if sys.version_info[0] < 3:
retval = value.encode()
else:
# python 3, bytes and not "FIELD_[0-9]+_FILL"
retval = value.decode('utf-8')
else:
retval = value
# Put this value in local directory
self.__dict__[name] = retval
return retval
