hardbyte · felixdivo · Aug 6, 2018 · Jul 3, 2018 · Jul 3, 2018 · Jul 3, 2018
diff --git a/.gitignore b/.gitignore
@@ -1,4 +1,8 @@
-# https://github.com/github/gitignore/blob/da00310ccba9de9a988cc973ef5238ad2c1460e9/Python.gitignore
+test/__tempdir__/
+.pytest_cache/
+
+# -------------------------
+# below: https://github.com/github/gitignore/blob/da00310ccba9de9a988cc973ef5238ad2c1460e9/Python.gitignore
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

diff --git a/can/io/__init__.py b/can/io/__init__.py
@@ -18,4 +18,4 @@
 from .canutils import CanutilsLogReader, CanutilsLogWriter
 from .csv import CSVWriter, CSVReader
 from .sqlite import SqliteReader, SqliteWriter
-from .stdout import Printer
+from .printer import Printer
diff --git a/can/io/asc.py b/can/io/asc.py
@@ -4,7 +4,9 @@
 """
 Contains handling of ASC logging files.
 
-Example .asc file: https://bitbucket.org/tobylorenz/vector_asc/src/47556e1a6d32c859224ca62d075e1efcc67fa690/src/Vector/ASC/tests/unittests/data/CAN_Log_Trigger_3_2.asc?at=master&fileviewer=file-view-default
+Example .asc files:
+    - https://bitbucket.org/tobylorenz/vector_asc/src/47556e1a6d32c859224ca62d075e1efcc67fa690/src/Vector/ASC/tests/unittests/data/CAN_Log_Trigger_3_2.asc?at=master&fileviewer=file-view-default
+    - under `test/data/logfile.asc`
 """
 
 from __future__ import absolute_import
@@ -16,22 +18,28 @@
 from ..message import Message
 from ..listener import Listener
 from ..util import channel2int
+from .generic import BaseIOHandler
 
 CAN_MSG_EXT = 0x80000000
 CAN_ID_MASK = 0x1FFFFFFF
 
 logger = logging.getLogger('can.io.asc')
 
 
-class ASCReader(object):
+class ASCReader(BaseIOHandler):
     """
     Iterator of CAN messages from a ASC logging file.
 
     TODO: turn relative timestamps back to absolute form
     """
 
-    def __init__(self, filename):
-        self.file = open(filename, 'r')
+    def __init__(self, file):
+        """
+        :param file: a path-like object or as file-like object to read from
+                     If this is a file-like object, is has to opened in text
+                     read mode, not binary read mode.
+        """
+        super(ASCReader, self).__init__(file, mode='r')
 
     @staticmethod
     def _extract_can_id(str_can_id):
@@ -41,19 +49,19 @@ def _extract_can_id(str_can_id):
         else:
             is_extended = False
             can_id = int(str_can_id, 16)
-        logging.debug('ASCReader: _extract_can_id("%s") -> %x, %r', str_can_id, can_id, is_extended)
-        return (can_id, is_extended)
+        #logging.debug('ASCReader: _extract_can_id("%s") -> %x, %r', str_can_id, can_id, is_extended)
+        return can_id, is_extended
 
     def __iter__(self):
         for line in self.file:
-            logger.debug("ASCReader: parsing line: '%s'", line.splitlines()[0])
+            #logger.debug("ASCReader: parsing line: '%s'", line.splitlines()[0])
 
             temp = line.strip()
             if not temp or not temp[0].isdigit():
                 continue
 
             try:
-                (timestamp, channel, dummy) = temp.split(None, 2) # , frameType, dlc, frameData
+                timestamp, channel, dummy = temp.split(None, 2) # , frameType, dlc, frameData
             except ValueError:
                 # we parsed an empty comment
                 continue
@@ -74,8 +82,8 @@ def __iter__(self):
                 pass
 
             elif dummy[-1:].lower() == 'r':
-                (can_id_str, _) = dummy.split(None, 1)
-                (can_id_num, is_extended_id) = self._extract_can_id(can_id_str)
+                can_id_str, _ = dummy.split(None, 1)
+                can_id_num, is_extended_id = self._extract_can_id(can_id_str)
                 msg = Message(timestamp=timestamp,
                               arbitration_id=can_id_num & CAN_ID_MASK,
                               extended_id=is_extended_id,
@@ -86,10 +94,10 @@ def __iter__(self):
             else:
                 try:
                     # this only works if dlc > 0 and thus data is availabe
-                    (can_id_str, _, _, dlc, data) = dummy.split(None, 4)
+                    can_id_str, _, _, dlc, data = dummy.split(None, 4)
                 except ValueError:
                     # but if not, we only want to get the stuff up to the dlc
-                    (can_id_str, _, _, dlc      ) = dummy.split(None, 3)
+                    can_id_str, _, _, dlc       = dummy.split(None, 3)
                     # and we set data to an empty sequence manually
                     data = ''
 
@@ -99,24 +107,26 @@ def __iter__(self):
                 for byte in data[0:dlc]:
                     frame.append(int(byte, 16))
 
-                (can_id_num, is_extended_id) = self._extract_can_id(can_id_str)
+                can_id_num, is_extended_id = self._extract_can_id(can_id_str)
 
-                msg = Message(
-                            timestamp=timestamp,
-                            arbitration_id=can_id_num & CAN_ID_MASK,
-                            extended_id=is_extended_id,
-                            is_remote_frame=False,
-                            dlc=dlc,
-                            data=frame,
-                            channel=channel)
-                yield msg
+                yield Message(
+                    timestamp=timestamp,
+                    arbitration_id=can_id_num & CAN_ID_MASK,
+                    extended_id=is_extended_id,
+                    is_remote_frame=False,
+                    dlc=dlc,
+                    data=frame,
+                    channel=channel
+                )
+
+        self.stop()
 
 
-class ASCWriter(Listener):
+class ASCWriter(BaseIOHandler, Listener):
     """Logs CAN data to an ASCII log file (.asc).
 
     The measurement starts with the timestamp of the first registered message.
-    If a message has a timestamp smaller than the previous one (or 0 or None),
+    If a message has a timestamp smaller than the previous one or None,
     it gets assigned the timestamp that was written for the last message.
     It the first message does not have a timestamp, it is set to zero.
     """
@@ -125,27 +135,32 @@ class ASCWriter(Listener):
     FORMAT_DATE = "%a %b %m %I:%M:%S %p %Y"
     FORMAT_EVENT = "{timestamp: 9.4f} {message}\n"
 
-    def __init__(self, filename, channel=1):
-        # setup
+    def __init__(self, file, channel=1):
+        """
+        :param file: a path-like object or as file-like object to write to
+                     If this is a file-like object, is has to opened in text
+                     write mode, not binary write mode.
+        :param channel: a default channel to use when the message does not
+                        have a channel set
+        """
+        super(ASCWriter, self).__init__(file, mode='w')
         self.channel = channel
-        self.log_file = open(filename, 'w')
 
         # write start of file header
         now = datetime.now().strftime("%a %b %m %I:%M:%S %p %Y")
-        self.log_file.write("date %s\n" % now)
-        self.log_file.write("base hex  timestamps absolute\n")
-        self.log_file.write("internal events logged\n")
+        self.file.write("date %s\n" % now)
+        self.file.write("base hex  timestamps absolute\n")
+        self.file.write("internal events logged\n")
 
         # the last part is written with the timestamp of the first message
         self.header_written = False
         self.last_timestamp = None
         self.started = None
 
     def stop(self):
-        """Stops logging and closes the file."""
-        if not self.log_file.closed:
-            self.log_file.write("End TriggerBlock\n")
-            self.log_file.close()
+        if not self.file.closed:
+            self.file.write("End TriggerBlock\n")
+        super(ASCWriter, self).stop()
 
     def log_event(self, message, timestamp=None):
         """Add a message to the log file.
@@ -163,10 +178,9 @@ def log_event(self, message, timestamp=None):
             self.last_timestamp = (timestamp or 0.0)
             self.started = self.last_timestamp
             formatted_date = time.strftime(self.FORMAT_DATE, time.localtime(self.last_timestamp))
-            self.log_file.write("base hex  timestamps absolute\n")
-            self.log_file.write("Begin Triggerblock %s\n" % formatted_date)
+            self.file.write("Begin Triggerblock %s\n" % formatted_date)
             self.header_written = True
-            self.log_event("Start of measurement") # recursive call
+            self.log_event("Start of measurement") # caution: this is a recursive call!
 
         # figure out the correct timestamp
         if timestamp is None or timestamp < self.last_timestamp:
@@ -177,11 +191,7 @@ def log_event(self, message, timestamp=None):
             timestamp -= self.started
 
         line = self.FORMAT_EVENT.format(timestamp=timestamp, message=message)
-
-        if self.log_file.closed:
-            logger.warn("ASCWriter: ignoring write call to closed file")
-        else:
-            self.log_file.write(line)
+        self.file.write(line)
 
     def on_message_received(self, msg):
 

diff --git a/can/io/blf.py b/can/io/blf.py
@@ -15,6 +15,8 @@
 objects types.
 """
 
+from __future__ import absolute_import
+
 import struct
 import zlib
 import datetime
@@ -24,6 +26,7 @@
 from can.message import Message
 from can.listener import Listener
 from can.util import len2dlc, dlc2len, channel2int
+from .generic import BaseIOHandler
 
 
 class BLFParseError(Exception):
@@ -112,19 +115,23 @@ def systemtime_to_timestamp(systemtime):
         return 0
 
 
-class BLFReader(object):
+class BLFReader(BaseIOHandler):
     """
     Iterator of CAN messages from a Binary Logging File.
 
     Only CAN messages and error frames are supported. Other object types are
     silently ignored.
     """
 
-    def __init__(self, filename):
-        self.fp = open(filename, "rb")
-        data = self.fp.read(FILE_HEADER_STRUCT.size)
+    def __init__(self, file):
+        """
+        :param file: a path-like object or as file-like object to read from
+                     If this is a file-like object, is has to opened in binary
+                     read mode, not text read mode.
+        """
+        super(BLFReader, self).__init__(file, mode='rb')
+        data = self.file.read(FILE_HEADER_STRUCT.size)
         header = FILE_HEADER_STRUCT.unpack(data)
-        #print(header)
         if header[0] != b"LOGG":
             raise BLFParseError("Unexpected file format")
         self.file_size = header[10]
@@ -133,25 +140,24 @@ def __init__(self, filename):
         self.start_timestamp = systemtime_to_timestamp(header[14:22])
         self.stop_timestamp = systemtime_to_timestamp(header[22:30])
         # Read rest of header
-        self.fp.read(header[1] - FILE_HEADER_STRUCT.size)
+        self.file.read(header[1] - FILE_HEADER_STRUCT.size)
 
     def __iter__(self):
         tail = b""
         while True:
-            data = self.fp.read(OBJ_HEADER_BASE_STRUCT.size)
+            data = self.file.read(OBJ_HEADER_BASE_STRUCT.size)
             if not data:
                 # EOF
                 break
 
             header = OBJ_HEADER_BASE_STRUCT.unpack(data)
-            #print(header)
             if header[0] != b"LOBJ":
                 raise BLFParseError()
             obj_type = header[4]
             obj_data_size = header[3] - OBJ_HEADER_BASE_STRUCT.size
-            obj_data = self.fp.read(obj_data_size)
+            obj_data = self.file.read(obj_data_size)
             # Read padding bytes
-            self.fp.read(obj_data_size % 4)
+            self.file.read(obj_data_size % 4)
 
             if obj_type == LOG_CONTAINER:
                 method, uncompressed_size = LOG_CONTAINER_STRUCT.unpack_from(
@@ -245,13 +251,13 @@ def __iter__(self):
 
                     pos = next_pos
 
-                # Save remaing data that could not be processed
+                # save the remaining data that could not be processed
                 tail = data[pos:]
 
-        self.fp.close()
+        self.stop()
 
 
-class BLFWriter(Listener):
+class BLFWriter(BaseIOHandler, Listener):
     """
     Logs CAN data to a Binary Logging File compatible with Vector's tools.
     """
@@ -262,11 +268,16 @@ class BLFWriter(Listener):
     #: ZLIB compression level
     COMPRESSION_LEVEL = 9
 
-    def __init__(self, filename, channel=1):
-        self.fp = open(filename, "wb")
+    def __init__(self, file, channel=1):
+        """
+        :param file: a path-like object or as file-like object to write to
+                     If this is a file-like object, is has to opened in binary
+                     write mode, not text write mode.
+        """
+        super(BLFWriter, self).__init__(file, mode='wb')
         self.channel = channel
         # Header will be written after log is done
-        self.fp.write(b"\x00" * FILE_HEADER_SIZE)
+        self.file.write(b"\x00" * FILE_HEADER_SIZE)
         self.cache = []
         self.cache_size = 0
         self.count_of_objects = 0
@@ -360,7 +371,7 @@ def _add_object(self, obj_type, data, timestamp=None):
 
     def _flush(self):
         """Compresses and writes data in the cache to file."""
-        if self.fp.closed:
+        if self.file.closed:
             return
         cache = b"".join(self.cache)
         if not cache:
@@ -379,21 +390,19 @@ def _flush(self):
             b"LOBJ", OBJ_HEADER_BASE_STRUCT.size, 1, obj_size, LOG_CONTAINER)
         container_header = LOG_CONTAINER_STRUCT.pack(
             ZLIB_DEFLATE, len(uncompressed_data))
-        self.fp.write(base_header)
-        self.fp.write(container_header)
-        self.fp.write(compressed_data)
+        self.file.write(base_header)
+        self.file.write(container_header)
+        self.file.write(compressed_data)
         # Write padding bytes
-        self.fp.write(b"\x00" * (obj_size % 4))
+        self.file.write(b"\x00" * (obj_size % 4))
         self.uncompressed_size += OBJ_HEADER_V1_STRUCT.size + LOG_CONTAINER_STRUCT.size
         self.uncompressed_size += len(uncompressed_data)
 
     def stop(self):
         """Stops logging and closes the file."""
-        if self.fp.closed:
-            return
         self._flush()
-        filesize = self.fp.tell()
-        self.fp.close()
+        filesize = self.file.tell()
+        super(BLFWriter, self).stop()
 
         # Write header in the beginning of the file
         header = [b"LOGG", FILE_HEADER_SIZE,
@@ -403,5 +412,5 @@ def stop(self):
                        self.count_of_objects, 0])
         header.extend(timestamp_to_systemtime(self.start_timestamp))
         header.extend(timestamp_to_systemtime(self.stop_timestamp))
-        with open(self.fp.name, "r+b") as f:
+        with open(self.file.name, "r+b") as f:
             f.write(FILE_HEADER_STRUCT.pack(*header))