Source code for cis_interface.communication.AsciiTableComm

from cis_interface import serialize, backwards
from cis_interface.communication.AsciiFileComm import AsciiFileComm


[docs]class AsciiTableComm(AsciiFileComm): r"""Class for handling I/O from/to a file on disk. Args: name (str): The environment variable where communication address is stored. delimiter (str, optional): String that should be used to separate columns. If not provided and format_str is not set prior to I/O, this defaults to whitespace. use_astropy (bool, optional): If True and the astropy package is installed, it will be used to read/write the table. Defaults to False. **kwargs: Additional keywords arguments are passed to parent class. """ def _init_before_open(self, delimiter=None, use_astropy=False, serializer_kwargs=None, **kwargs): r"""Set up dataio and attributes.""" if serializer_kwargs is None: serializer_kwargs = {} self.header_was_read = False self.header_was_written = False serializer_kwargs.update(stype=3, use_astropy=use_astropy) kwargs['serializer_kwargs'] = serializer_kwargs super(AsciiTableComm, self)._init_before_open(**kwargs) if self.serializer.as_array: self.read_meth = 'read' else: self.read_meth = 'readline' if self.append: self.header_was_written = True if delimiter is None: delimiter = serialize._default_delimiter self.delimiter = backwards.unicode2bytes(delimiter)
[docs] def read_header(self): r"""Read header lines from the file and update serializer info.""" if self.header_was_read: return header_lines = [] header_size = 0 self.fd.seek(0) for line in self.fd: sline = backwards.unicode2bytes( line.replace(self.platform_newline, self.newline)) if not sline.startswith(self.comment): break header_size += len(line) header_lines.append(sline) # Parse header & set serializer attributes header = serialize.parse_header(header_lines) for k in ['format_str', 'field_names', 'field_units']: if header.get(k, False): setattr(self.serializer, k, header[k]) # Try to determine format from array without header str_fmt = backwards.unicode2bytes('%s') if (((self.serializer.format_str is None) or (str_fmt in self.serializer.format_str))): with open(self.address, self.open_mode) as fd: fd.seek(header_size) all_contents = fd.read() if len(all_contents) == 0: # pragma: debug return # In case the file has not been written arr = serialize.table_to_array(all_contents, names=self.serializer.field_names, comment=self.comment, delimiter=self.delimiter) self.serializer.field_names = arr.dtype.names if self.serializer.format_str is None: self.serializer.format_str = serialize.table2format( arr.dtype, delimiter=self.delimiter, comment=backwards.unicode2bytes(''), newline=self.newline) while str_fmt in self.serializer.format_str: ifld = self.serializer.field_formats.index(str_fmt) max_len = len(max(arr[self.serializer.field_names[ifld]], key=len)) new_str_fmt = backwards.unicode2bytes('%' + str(max_len) + 's') self.serializer.format_str = self.serializer.format_str.replace( str_fmt, new_str_fmt, 1) self.delimiter = self.serializer.table_info['delimiter'] # Seek to just after the header self.fd.seek(header_size) self.header_was_read = True
[docs] def write_header(self): r"""Write header lines to the file based on the serializer info.""" if self.header_was_written: return header_msg = serialize.format_header( format_str=self.serializer.format_str, field_names=self.serializer.field_names, field_units=self.serializer.field_units, comment=self.comment, newline=self.newline, delimiter=self.delimiter) self.fd.write(header_msg) self.header_was_written = True
def _send(self, msg): r"""Write message to a file. Args: msg (bytes, str): Data to write to the file. Returns: bool: Success or failure of writing to the file. """ if msg != self.eof_msg: self.write_header() return super(AsciiTableComm, self)._send(msg) def _recv(self, timeout=0, **kwargs): r"""Reads message from a file. Args: timeout (float, optional): Time in seconds to wait for a message. Defaults to self.recv_timeout. Unused. Returns: tuple(bool, str): Success or failure of reading from the file. """ self.read_header() return super(AsciiTableComm, self)._recv(timeout=timeout, **kwargs)