class GroupDataChunk(object):
""" A chunk of data for a group in a TDMS file
Can be indexed by channel name to get the data for a channel in this chunk.
For example::
channel_chunk = group_chunk[channel_name]
:ivar ~.name: Name of the group
"""
def __init__(self, tdms_file, group, raw_data_chunk, channel_offsets):
self.name = group.name
self._channels = OrderedDict(
(channel.name,
ChannelDataChunk(
tdms_file, channel,
raw_data_chunk.channel_data.get(channel.path,
RawChannelDataChunk.empty()),
channel_offsets[channel.path]))
for channel in group.channels())
def __getitem__(self, channel_name):
""" Get a chunk of data for a channel in this group
"""
return self._channels[channel_name]
def channels(self):
""" Returns chunks of channel data for all channels in this group
:rtype: List of :class:`ChannelDataChunk`
"""
return list(self._channels.values())
class DataChunk(object):
""" A chunk of data in a TDMS file
Can be indexed by group name to get the data for a group in this channel,
which can then be indexed by channel name to get the data for a channel in this chunk.
For example::
group_chunk = data_chunk[group_name]
channel_chunk = group_chunk[channel_name]
"""
def __init__(self, tdms_file, raw_data_chunk, channel_offsets):
self._groups = OrderedDict(
(group.name,
GroupDataChunk(tdms_file, group, raw_data_chunk, channel_offsets))
for group in tdms_file.groups())
def __getitem__(self, group_name):
""" Get a chunk of data for a group
"""
return self._groups[group_name]
def groups(self):
""" Returns chunks of data for all groups
:rtype: List of :class:`GroupDataChunk`
"""
return list(self._groups.values())
class TdmsFile(object):
"""Reads and stores data from a TDMS file.
:ivar objects: A dictionary of objects in the TDMS file, where the keys are
the object paths.
"""
def __init__(self, file, memmap_dir=None, read_metadata_only=False):
"""Initialise a new TDMS file object, reading all data.
:param file: Either the path to the tdms file to read or an already
opened file.
:param memmap_dir: The directory to store memmapped data files in,
or None to read data into memory. The data files are created
as temporary files and are deleted when the channel data is no
longer used. tempfile.gettempdir() can be used to get the default
temporary file directory.
:param read_metadata_only: If this parameter is enabled then the
metadata of the TDMS file will only be read.
"""
self.read_metadata_only = read_metadata_only
self.segments = []
self.objects = OrderedDict()
self.memmap_dir = memmap_dir
if hasattr(file, "read"):
# Is a file
self._read_segments(file)
else:
# Is path to a file
with open(file, 'rb') as open_file:
self._read_segments(open_file)
def _read_segments(self, open_file):
with Timer(log, "Read metadata"):
# Read metadata first to work out how much space we need
previous_segment = None
while True:
try:
segment = TdmsSegment(open_file, self)
except EOFError:
# We've finished reading the file
break
segment.read_metadata(open_file, self.objects,
previous_segment)
self.segments.append(segment)
previous_segment = segment
if segment.next_segment_pos is None:
break
else:
open_file.seek(segment.next_segment_pos)
if not self.read_metadata_only:
with Timer(log, "Allocate space"):
# Allocate space for data
for obj in self.objects.values():
obj._initialise_data(memmap_dir=self.memmap_dir)
with Timer(log, "Read data"):
# Now actually read all the data
for segment in self.segments:
segment.read_raw_data(open_file)
def object(self, *path):
"""Get a TDMS object from the file
:param path: The object group and channel. Providing no channel
returns a group object, and providing no channel or group
will return the root object.
:rtype: :class:`TdmsObject`
For example, to get the root object::
object()
To get a group::
object("group_name")
To get a channel::
object("group_name", "channel_name")
"""
object_path = components_to_path(*path)
try:
return self.objects[object_path]
except KeyError:
raise KeyError("Invalid object path: %s" % object_path)
def groups(self):
"""Return the names of groups in the file
Note that there is not necessarily a TDMS object associated with
each group name.
:rtype: List of strings.
"""
# Split paths into components and take the first (group) component.
object_paths = (path_components(path) for path in self.objects)
group_names = (path[0] for path in object_paths if len(path) > 0)
# Use an ordered dict as an ordered set to find unique
# groups in order.
groups_set = OrderedDict()
for group in group_names:
groups_set[group] = None
return list(groups_set)
def group_channels(self, group):
"""Returns a list of channel objects for the given group
:param group: Name of the group to get channels for.
:rtype: List of :class:`TdmsObject` objects.
"""
path = components_to_path(group)
return [
self.objects[p] for p in self.objects if p.startswith(path + '/')
]
def channel_data(self, group, channel):
"""Get the data for a channel
:param group: The name of the group the channel is in.
:param channel: The name of the channel to get data for.
:returns: The channel data.
:rtype: NumPy array.
"""
return self.object(group, channel).data
def as_dataframe(self, time_index=False, absolute_time=False):
"""
Converts the TDMS file to a DataFrame
:param time_index: Whether to include a time index for the dataframe.
:param absolute_time: If time_index is true, whether the time index
values are absolute times or relative to the start time.
:return: The full TDMS file data.
:rtype: pandas.DataFrame
"""
import pandas as pd
dataframe_dict = OrderedDict()
for key, value in self.objects.items():
if value.has_data:
index = value.time_track(absolute_time) if time_index else None
dataframe_dict[key] = pd.Series(data=value.data, index=index)
return pd.DataFrame.from_dict(dataframe_dict)
def as_hdf(self, filepath, mode='w', group='/'):
"""
Converts the TDMS file into an HDF5 file
:param filepath: The path of the HDF5 file you want to write to.
:param mode: The write mode of the HDF5 file. This can be w, a ...
:param group: A group in the HDF5 file that will contain the TDMS data.
"""
import h5py
# Groups in TDMS are mapped to the first level of the HDF5 hierarchy
# Channels in TDMS are then mapped to the second level of the HDF5
# hierarchy, under the appropriate groups.
# Properties in TDMS are mapped to attributes in HDF5.
# These all exist under the appropriate, channel group etc.
h5file = h5py.File(filepath, mode)
container_group = None
if group in h5file:
container_group = h5file[group]
else:
container_group = h5file.create_group(group)
# First write the properties at the root level
try:
root = self.object()
for property_name, property_value in root.properties.items():
container_group.attrs[property_name] = property_value
except KeyError:
# No root object present
pass
# Now iterate through groups and channels,
# writing the properties and data
for group_name in self.groups():
try:
group = self.object(group_name)
# Write the group's properties
for prop_name, prop_value in group.properties.items():
container_group[group_name].attrs[prop_name] = prop_value
except KeyError:
# No group object present
pass
# Write properties and data for each channel
for channel in self.group_channels(group_name):
for prop_name, prop_value in channel.properties.items():
container_group.attrs[prop_name] = prop_value
container_group[group_name + '/' +
channel.channel] = channel.data
return h5file
class TdmsFile(object):
""" Reads and stores data from a TDMS file.
There are two main ways to create a new TdmsFile object.
TdmsFile.read will read all data into memory::
tdms_file = TdmsFile.read(tdms_file_path)
or you can use TdmsFile.open to read file metadata but not immediately read all data,
for cases where a file is too large to easily fit in memory or you don't need to
read data for all channels::
with TdmsFile.open(tdms_file_path) as tdms_file:
# Use tdms_file
...
This class acts like a dictionary, where the keys are names of groups in the TDMS
files and the values are TdmsGroup objects.
A TdmsFile can be indexed by group name to access a group within the TDMS file, for example::
tdms_file = TdmsFile.read(tdms_file_path)
group = tdms_file[group_name]
Iterating over a TdmsFile produces the names of groups in this file,
or you can use the groups method to directly access all groups::
for group in tdms_file.groups():
# Use group
...
"""
@staticmethod
def read(file, memmap_dir=None):
""" Creates a new TdmsFile object and reads all data in the file
:param file: Either the path to the tdms file to read
as a string or pathlib.Path, or an already opened file.
:param memmap_dir: The directory to store memory mapped data files in,
or None to read data into memory. The data files are created
as temporary files and are deleted when the channel data is no
longer used. tempfile.gettempdir() can be used to get the default
temporary file directory.
"""
return TdmsFile(file, memmap_dir=memmap_dir)
@staticmethod
def open(file, memmap_dir=None):
""" Creates a new TdmsFile object and reads metadata, leaving the file open
to allow reading channel data
:param file: Either the path to the tdms file to read
as a string or pathlib.Path, or an already opened file.
:param memmap_dir: The directory to store memory mapped data files in,
or None to read data into memory. The data files are created
as temporary files and are deleted when the channel data is no
longer used. tempfile.gettempdir() can be used to get the default
temporary file directory.
"""
return TdmsFile(file,
memmap_dir=memmap_dir,
read_metadata_only=True,
keep_open=True)
@staticmethod
def read_metadata(file):
""" Creates a new TdmsFile object and only reads the metadata
:param file: Either the path to the tdms file to read
as a string or pathlib.Path, or an already opened file.
"""
return TdmsFile(file, read_metadata_only=True)
def __init__(self,
file,
memmap_dir=None,
read_metadata_only=False,
keep_open=False):
"""Initialise a new TdmsFile object
:param file: Either the path to the tdms file to read
as a string or pathlib.Path, or an already opened file.
:param memmap_dir: The directory to store memory mapped data files in,
or None to read data into memory. The data files are created
as temporary files and are deleted when the channel data is no
longer used. tempfile.gettempdir() can be used to get the default
temporary file directory.
:param read_metadata_only: If this parameter is enabled then only the
metadata of the TDMS file will read.
:param keep_open: Keeps the file open so data can be read if only metadata
is read initially.
"""
self._memmap_dir = memmap_dir
self._groups = OrderedDict()
self._properties = {}
self._channel_data = {}
self._reader = None
self.data_read = False
reader = TdmsReader(file)
try:
self._read_file(reader, read_metadata_only)
finally:
if keep_open:
self._reader = reader
else:
reader.close()
def groups(self):
"""Returns a list of the groups in this file
:rtype: List of TdmsGroup.
"""
return list(self._groups.values())
@_property_builtin
def properties(self):
""" Return the properties of this file as a dictionary
These are the properties associated with the root TDMS object.
"""
return self._properties
def as_dataframe(self,
time_index=False,
absolute_time=False,
scaled_data=True):
"""
Converts the TDMS file to a DataFrame. DataFrame columns are named using the TDMS object paths.
:param time_index: Whether to include a time index for the dataframe.
:param absolute_time: If time_index is true, whether the time index
values are absolute times or relative to the start time.
:param scaled_data: By default the scaled data will be used.
Set to False to use raw unscaled data.
For DAQmx data, there will be one column per DAQmx raw scaler and column names will include the scale id.
:return: The full TDMS file data.
:rtype: pandas.DataFrame
"""
return pandas_export.from_tdms_file(self, time_index, absolute_time,
scaled_data)
def as_hdf(self, filepath, mode='w', group='/'):
"""
Converts the TDMS file into an HDF5 file
:param filepath: The path of the HDF5 file you want to write to.
:param mode: The write mode of the HDF5 file. This can be 'w' or 'a'
:param group: A group in the HDF5 file that will contain the TDMS data.
"""
return hdf_export.from_tdms_file(self, filepath, mode, group)
def data_chunks(self):
""" A generator that streams chunks of data from disk.
This method may only be used when the TDMS file was opened without reading all data immediately.
:rtype: Generator that yields :class:`DataChunk` objects
"""
reader = self._get_reader()
channel_offsets = defaultdict(int)
for chunk in reader.read_raw_data():
yield DataChunk(self, chunk, channel_offsets)
for path, data in chunk.channel_data.items():
channel_offsets[path] += len(data)
def close(self):
""" Close the underlying file if it was opened by this TdmsFile
If this TdmsFile was initialised with an already open file
then the reference to it is released but the file is not closed.
"""
if self._reader is not None:
self._reader.close()
self._reader = None
def __len__(self):
""" Returns the number of groups in this file
"""
return len(self._groups)
def __iter__(self):
""" Returns an iterator over the names of groups in this file
"""
return iter(self._groups)
def __getitem__(self, group_name):
""" Retrieve a TDMS group from the file by name
"""
try:
return self._groups[group_name]
except KeyError:
raise KeyError("There is no group named '%s' in the TDMS file" %
group_name)
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
self.close()
def _get_reader(self):
if self._reader is None:
raise RuntimeError(
"Cannot read data after the underlying TDMS reader is closed")
return self._reader
def _read_file(self, tdms_reader, read_metadata_only):
tdms_reader.read_metadata()
# Use object metadata to build group and channel objects
group_properties = OrderedDict()
group_channels = OrderedDict()
for (path_string, obj) in tdms_reader.object_metadata.items():
path = ObjectPath.from_string(path_string)
if path.is_root:
# Root object provides properties for the whole file
self._properties = obj.properties
elif path.is_group:
group_properties[path.group] = obj.properties
else:
# Object is a channel
channel = TdmsChannel(self, path, obj.properties,
obj.data_type, obj.scaler_data_types,
obj.num_values)
if path.group in group_channels:
group_channels[path.group].append(channel)
else:
group_channels[path.group] = [channel]
# Create group objects containing channels and properties
for group_name, properties in group_properties.items():
try:
channels = group_channels[group_name]
except KeyError:
channels = []
group_path = ObjectPath(group_name)
self._groups[group_name] = TdmsGroup(group_path, properties,
channels)
for group_name, channels in group_channels.items():
if group_name not in self._groups:
# Group with channels but without any corresponding object metadata in the file:
group_path = ObjectPath(group_name)
self._groups[group_name] = TdmsGroup(group_path, {}, channels)
if not read_metadata_only:
self._read_data(tdms_reader)
def _read_data(self, tdms_reader):
with Timer(log, "Allocate space"):
# Allocate space for data
for group in self.groups():
for channel in group.channels():
self._channel_data[channel.path] = get_data_receiver(
channel, len(channel), self._memmap_dir)
with Timer(log, "Read data"):
# Now actually read all the data
for chunk in tdms_reader.read_raw_data():
for (path, data) in chunk.channel_data.items():
channel_data = self._channel_data[path]
if data.data is not None:
channel_data.append_data(data.data)
elif data.scaler_data is not None:
for scaler_id, scaler_data in data.scaler_data.items():
channel_data.append_scaler_data(
scaler_id, scaler_data)
for group in self.groups():
for channel in group.channels():
channel_data = self._channel_data[channel.path]
if channel_data is not None:
channel._set_raw_data(channel_data)
self.data_read = True
def _read_channel_data_chunks(self, channel):
reader = self._get_reader()
for chunk in reader.read_raw_data_for_channel(channel.path):
yield chunk
def _read_channel_data_chunk_for_index(self, channel, index):
return self._get_reader().read_channel_chunk_for_index(
channel.path, index)
def _read_channel_data(self, channel, offset=0, length=None):
if offset < 0:
raise ValueError("offset must be non-negative")
if length is not None and length < 0:
raise ValueError("length must be non-negative")
reader = self._get_reader()
with Timer(log, "Allocate space for channel"):
# Allocate space for data
if length is None:
num_values = len(channel) - offset
else:
num_values = min(length, len(channel) - offset)
num_values = max(0, num_values)
channel_data = get_data_receiver(channel, num_values,
self._memmap_dir)
with Timer(log, "Read data for channel"):
# Now actually read all the data
for chunk in reader.read_raw_data_for_channel(
channel.path, offset, length):
if chunk.data is not None:
channel_data.append_data(chunk.data)
if chunk.scaler_data is not None:
for scaler_id, scaler_data in chunk.scaler_data.items():
channel_data.append_scaler_data(scaler_id, scaler_data)
return channel_data
def object(self, *path):
"""(Deprecated) Get a TDMS object from the file
:param path: The object group and channel names. Providing no channel
returns a group object, and providing no channel or group
will return the root object.
:rtype: One of :class:`TdmsGroup`, :class:`TdmsChannel`, :class:`RootObject`
For example, to get the root object::
object()
To get a group::
object("group_name")
To get a channel::
object("group_name", "channel_name")
"""
_deprecated(
"TdmsFile.object",
"Use TdmsFile.properties to access properties of the root object, "
+ "TdmsFile[group_name] to access a group object and " +
"TdmsFile[group_name][channel_name] to access a channel object.")
def get_name(component):
try:
return component.name
except AttributeError:
return component
path = [get_name(c) for c in path]
object_path = ObjectPath(*path)
try:
return self.objects[str(object_path)]
except KeyError:
raise KeyError("Invalid object path: %s" % object_path)
def group_channels(self, group):
"""(Deprecated) Returns a list of channel objects for the given group
:param group: Group or name of the group to get channels for.
:rtype: List of :class:`TdmsObject` objects.
"""
_deprecated("TdmsFile.group_channels",
"Use TdmsFile[group_name].channels().")
if isinstance(group, TdmsGroup):
return group.channels()
return self._groups[group].channels()
def channel_data(self, group, channel):
"""(Deprecated) Get the data for a channel
:param group: The name of the group the channel is in.
:param channel: The name of the channel to get data for.
:returns: The channel data.
:rtype: NumPy array.
"""
_deprecated("TdmsFile.channel_data",
"Use TdmsFile[group_name][channel_name].data.")
if self._reader is None:
# Data should have already been loaded
return self[group][channel].data
else:
# Data must be lazily loaded
return self[group][channel].read_data()
@_property_builtin
def objects(self):
""" (Deprecated) A dictionary of objects in the TDMS file, where the keys are the object paths.
"""
_deprecated(
"TdmsFile.objects",
"Use TdmsFile.groups() to access all groups in the file, " +
"and group.channels() to access all channels in a group.")
objects = OrderedDict()
root_path = ObjectPath()
objects[str(root_path)] = RootObject(self._properties)
for group in self.groups():
objects[group.path] = group
for channel in group.channels():
objects[channel.path] = channel
return objects
class TdmsFile(object):
""" Reads and stores data from a TDMS file.
There are two main ways to create a new TdmsFile object.
TdmsFile.read will read all data into memory::
tdms_file = TdmsFile.read(tdms_file_path)
or you can use TdmsFile.open to read file metadata but not immediately read all data,
for cases where a file is too large to easily fit in memory or you don't need to
read data for all channels::
with TdmsFile.open(tdms_file_path) as tdms_file:
# Use tdms_file
...
This class acts like a dictionary, where the keys are names of groups in the TDMS
files and the values are TdmsGroup objects.
A TdmsFile can be indexed by group name to access a group within the TDMS file, for example::
tdms_file = TdmsFile.read(tdms_file_path)
group = tdms_file[group_name]
Iterating over a TdmsFile produces the names of groups in this file,
or you can use the groups method to directly access all groups::
for group in tdms_file.groups():
# Use group
...
"""
@staticmethod
def read(file, raw_timestamps=False, memmap_dir=None):
""" Creates a new TdmsFile object and reads all data in the file
:param file: Either the path to the tdms file to read
as a string or pathlib.Path, or an already opened file.
:param raw_timestamps: By default TDMS timestamps are read as numpy datetime64
but this loses some precision.
Setting this to true will read timestamps as a custom TdmsTimestamp type.
:param memmap_dir: The directory to store memory mapped data files in,
or None to read data into memory. The data files are created
as temporary files and are deleted when the channel data is no
longer used. tempfile.gettempdir() can be used to get the default
temporary file directory.
"""
return TdmsFile(file,
raw_timestamps=raw_timestamps,
memmap_dir=memmap_dir)
@staticmethod
def open(file, raw_timestamps=False, memmap_dir=None):
""" Creates a new TdmsFile object and reads metadata, leaving the file open
to allow reading channel data
:param file: Either the path to the tdms file to read
as a string or pathlib.Path, or an already opened file.
:param raw_timestamps: By default TDMS timestamps are read as numpy datetime64
but this loses some precision.
Setting this to true will read timestamps as a custom TdmsTimestamp type.
:param memmap_dir: The directory to store memory mapped data files in,
or None to read data into memory. The data files are created
as temporary files and are deleted when the channel data is no
longer used. tempfile.gettempdir() can be used to get the default
temporary file directory.
"""
return TdmsFile(file,
raw_timestamps=raw_timestamps,
memmap_dir=memmap_dir,
read_metadata_only=True,
keep_open=True)
@staticmethod
def read_metadata(file, raw_timestamps=False):
""" Creates a new TdmsFile object and only reads the metadata
:param file: Either the path to the tdms file to read
as a string or pathlib.Path, or an already opened file.
:param raw_timestamps: By default TDMS timestamps are read as numpy datetime64
but this loses some precision.
Setting this to true will read timestamps as a custom TdmsTimestamp type.
"""
return TdmsFile(file,
raw_timestamps=raw_timestamps,
read_metadata_only=True)
def __init__(self,
file,
raw_timestamps=False,
memmap_dir=None,
read_metadata_only=False,
keep_open=False):
"""Initialise a new TdmsFile object
:param file: Either the path to the tdms file to read
as a string or pathlib.Path, or an already opened file.
:param raw_timestamps: By default TDMS timestamps are read as numpy datetime64
but this loses some precision.
Setting this to true will read timestamps as a custom TdmsTimestamp type.
:param memmap_dir: The directory to store memory mapped data files in,
or None to read data into memory. The data files are created
as temporary files and are deleted when the channel data is no
longer used. tempfile.gettempdir() can be used to get the default
temporary file directory.
:param read_metadata_only: If this parameter is enabled then only the
metadata of the TDMS file will read.
:param keep_open: Keeps the file open so data can be read if only metadata
is read initially.
"""
self._memmap_dir = memmap_dir
self._raw_timestamps = raw_timestamps
self._groups = OrderedDict()
self._properties = OrderedDict()
self._channel_data = {}
self.data_read = False
self._reader = TdmsReader(file)
try:
self._read_file(self._reader, read_metadata_only)
finally:
if not keep_open:
self._reader.close()
def groups(self):
"""Returns a list of the groups in this file
:rtype: List of TdmsGroup.
"""
return list(self._groups.values())
@property
def properties(self):
""" Return the properties of this file as a dictionary
These are the properties associated with the root TDMS object.
"""
return self._properties
def as_dataframe(self,
time_index=False,
absolute_time=False,
scaled_data=True):
"""
Converts the TDMS file to a DataFrame. DataFrame columns are named using the TDMS object paths.
:param time_index: Whether to include a time index for the dataframe.
:param absolute_time: If time_index is true, whether the time index
values are absolute times or relative to the start time.
:param scaled_data: By default the scaled data will be used.
Set to False to use raw unscaled data.
For DAQmx data, there will be one column per DAQmx raw scaler and column names will include the scale id.
:return: The full TDMS file data.
:rtype: pandas.DataFrame
"""
return pandas_export.from_tdms_file(self, time_index, absolute_time,
scaled_data)
def as_hdf(self, filepath, mode='w', group='/'):
"""
Converts the TDMS file into an HDF5 file
:param filepath: The path of the HDF5 file you want to write to.
:param mode: The write mode of the HDF5 file. This can be 'w' or 'a'
:param group: A group in the HDF5 file that will contain the TDMS data.
"""
return hdf_export.from_tdms_file(self, filepath, mode, group)
def data_chunks(self):
""" A generator that streams chunks of data from disk.
This method may only be used when the TDMS file was opened without reading all data immediately.
:rtype: Generator that yields :class:`DataChunk` objects
"""
channel_offsets = defaultdict(int)
for chunk in self._reader.read_raw_data():
_convert_data_chunk(chunk, self._raw_timestamps)
yield DataChunk(self, chunk, channel_offsets)
for path, data in chunk.channel_data.items():
channel_offsets[path] += len(data)
def close(self):
""" Close the underlying file if it was opened by this TdmsFile
If this TdmsFile was initialised with an already open file
then the reference to it is released but the file is not closed.
"""
if self._reader is not None:
self._reader.close()
self._reader = None
def __len__(self):
""" Returns the number of groups in this file
"""
return len(self._groups)
def __iter__(self):
""" Returns an iterator over the names of groups in this file
"""
return iter(self._groups)
def __getitem__(self, group_name):
""" Retrieve a TDMS group from the file by name
"""
try:
return self._groups[group_name]
except KeyError:
raise KeyError("There is no group named '%s' in the TDMS file" %
group_name)
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
self.close()
def _read_file(self, tdms_reader, read_metadata_only):
tdms_reader.read_metadata()
# Use object metadata to build group and channel objects
group_properties = OrderedDict()
group_channels = OrderedDict()
object_properties = {
path_string: self._convert_properties(obj.properties)
for path_string, obj in tdms_reader.object_metadata.items()
}
try:
self._properties = object_properties['/']
except KeyError:
pass
for (path_string, obj) in tdms_reader.object_metadata.items():
properties = object_properties[path_string]
path = ObjectPath.from_string(path_string)
if path.is_root:
pass
elif path.is_group:
group_properties[path.group] = properties
else:
# Object is a channel
try:
channel_group_properties = object_properties[
path.group_path()]
except KeyError:
channel_group_properties = OrderedDict()
channel = TdmsChannel(path, obj.data_type,
obj.scaler_data_types, obj.num_values,
properties, channel_group_properties,
self._properties, tdms_reader,
self._raw_timestamps, self._memmap_dir)
if path.group in group_channels:
group_channels[path.group].append(channel)
else:
group_channels[path.group] = [channel]
# Create group objects containing channels and properties
for group_name, properties in group_properties.items():
try:
channels = group_channels[group_name]
except KeyError:
channels = []
group_path = ObjectPath(group_name)
self._groups[group_name] = TdmsGroup(group_path, properties,
channels)
for group_name, channels in group_channels.items():
if group_name not in self._groups:
# Group with channels but without any corresponding object metadata in the file:
group_path = ObjectPath(group_name)
self._groups[group_name] = TdmsGroup(group_path, {}, channels)
if not read_metadata_only:
self._read_data(tdms_reader)
def _read_data(self, tdms_reader):
with Timer(log, "Allocate space"):
# Allocate space for data
for group in self.groups():
for channel in group.channels():
self._channel_data[channel.path] = get_data_receiver(
channel, len(channel), self._raw_timestamps,
self._memmap_dir)
with Timer(log, "Read data"):
# Now actually read all the data
for chunk in tdms_reader.read_raw_data():
for (path, data) in chunk.channel_data.items():
channel_data = self._channel_data[path]
if data.data is not None:
channel_data.append_data(data.data)
elif data.scaler_data is not None:
for scaler_id, scaler_data in data.scaler_data.items():
channel_data.append_scaler_data(
scaler_id, scaler_data)
for group in self.groups():
for channel in group.channels():
channel_data = self._channel_data[channel.path]
if channel_data is not None:
channel._set_raw_data(channel_data)
self.data_read = True
def _convert_properties(self, properties):
def convert_prop(val):
if isinstance(val, TdmsTimestamp) and not self._raw_timestamps:
# Convert timestamps to numpy datetime64 if raw timestamps are not requested
return val.as_datetime64()
return val
return OrderedDict(
(k, convert_prop(v)) for (k, v) in properties.items())