Release version 0.1.0

Update package URL to the new echemdata repo

.flake8

@@ -0,0 +1,2 @@
+# This file will be ignored - see http://flake8.pycqa.org/en/2.6.0/config.html#per-project
+# Edit the [flake8] section in tox.ini instead

.travis.yml

@@ -3,6 +3,7 @@ language: python
 cache:
   directories:
     - .tox
+    - .pytest_cache
     - tests/testdata
 python:
   - "2.7"

galvani/BioLogic.py

@@ -9,7 +9,8 @@ import csv
 from os import SEEK_SET
 import time
 from datetime import date, datetime, timedelta
-from collections import OrderedDict
+from collections import defaultdict, OrderedDict
+import functools
 
 import numpy as np
 
@@ -18,7 +19,7 @@ if sys.version_info.major <= 2:
     str3 = str
     from string import maketrans
 else:
-    str3 = lambda b: str(b, encoding='ascii')
+    str3 = functools.partial(str, encoding='ascii')
     maketrans = bytes.maketrans
 
 
@@ -71,19 +72,20 @@ def MPTfile(file_or_path):
         raise ValueError("Bad first line for EC-Lab file: '%s'" % magic)
 
     # TODO use rb'string' here once Python 2 is no longer supported
-    nb_headers_match = re.match(b'Nb header lines : (\\d+)\\s*$', next(mpt_file))
+    nb_headers_match = re.match(b'Nb header lines : (\\d+)\\s*$',
+                                next(mpt_file))
     nb_headers = int(nb_headers_match.group(1))
     if nb_headers < 3:
         raise ValueError("Too few header lines: %d" % nb_headers)
 
-    ## The 'magic number' line, the 'Nb headers' line and the column headers
+    # The 'magic number' line, the 'Nb headers' line and the column headers
-    ## make three lines. Every additional line is a comment line.
+    # make three lines. Every additional line is a comment line.
     comments = [next(mpt_file) for i in range(nb_headers - 3)]
 
     fieldnames = str3(next(mpt_file)).strip().split('\t')
     record_type = np.dtype(list(map(fieldname_to_dtype, fieldnames)))
 
-    ## Must be able to parse files where commas are used for decimal points
+    # Must be able to parse files where commas are used for decimal points
     converter_dict = dict(((i, comma_converter)
                            for i in range(len(fieldnames))))
     mpt_array = np.loadtxt(mpt_file, dtype=record_type,
@@ -113,8 +115,8 @@ def MPTfileCSV(file_or_path):
     if nb_headers < 3:
         raise ValueError("Too few header lines: %d" % nb_headers)
 
-    ## The 'magic number' line, the 'Nb headers' line and the column headers
+    # The 'magic number' line, the 'Nb headers' line and the column headers
-    ## make three lines. Every additional line is a comment line.
+    # make three lines. Every additional line is a comment line.
     comments = [next(mpt_file) for i in range(nb_headers - 3)]
 
     mpt_csv = csv.DictReader(mpt_file, dialect='excel-tab')
@@ -144,119 +146,105 @@ VMPmodule_hdr = np.dtype([('shortname', 'S10'),
                           ('version', '<u4'),
                           ('date', 'S8')])
 
+# Maps from colID to a tuple defining a numpy dtype
+VMPdata_colID_dtype_map = {
+    4: ('time/s', '<f8'),
+    5: ('control/V/mA', '<f4'),
+    6: ('Ewe/V', '<f4'),
+    7: ('dQ/mA.h', '<f8'),
+    8: ('I/mA', '<f4'),  # 8 is either I or <I> ??
+    9: ('Ece/V', '<f4'),
+    11: ('I/mA', '<f8'),
+    13: ('(Q-Qo)/mA.h', '<f8'),
+    19: ('control/V', '<f4'),
+    20: ('control/mA', '<f4'),
+    23: ('dQ/mA.h', '<f8'),  # Same as 7?
+    24: ('cycle number', '<f8'),
+    32: ('freq/Hz', '<f4'),
+    33: ('|Ewe|/V', '<f4'),
+    34: ('|I|/A', '<f4'),
+    35: ('Phase(Z)/deg', '<f4'),
+    36: ('|Z|/Ohm', '<f4'),
+    37: ('Re(Z)/Ohm', '<f4'),
+    38: ('-Im(Z)/Ohm', '<f4'),
+    39: ('I Range', '<u2'),
+    70: ('P/W', '<f4'),
+    76: ('<I>/mA', '<f4'),
+    77: ('<Ewe>/V', '<f4'),
+    123: ('Energy charge/W.h', '<f8'),
+    124: ('Energy discharge/W.h', '<f8'),
+    125: ('Capacitance charge/µF', '<f8'),
+    126: ('Capacitance discharge/µF', '<f8'),
+    131: ('Ns', '<u2'),
+    169: ('Cs/µF', '<f4'),
+    172: ('Cp/µF', '<f4'),
+    434: ('(Q-Qo)/C', '<f4'),
+    435: ('dQ/C', '<f4'),
+    467: ('Q charge/discharge/mA.h', '<f8'),
+    468: ('half cycle', '<u4'),
+    473: ('THD Ewe/%', '<f4'),
+    474: ('THD I/%', '<f4'),
+    476: ('NSD Ewe/%', '<f4'),
+    477: ('NSD I/%', '<f4'),
+    479: ('NSR Ewe/%', '<f4'),
+    480: ('NSR I/%', '<f4'),
+}
+
+# These column IDs define flags which are all stored packed in a single byte
+# The values in the map are (name, bitmask, dtype)
+VMPdata_colID_flag_map = {
+    1: ('mode', 0x03, np.uint8),
+    2: ('ox/red', 0x04, np.bool_),
+    3: ('error', 0x08, np.bool_),
+    21: ('control changes', 0x10, np.bool_),
+    31: ('Ns changes', 0x20, np.bool_),
+    65: ('counter inc.', 0x80, np.bool_),
+}
+
 
 def VMPdata_dtype_from_colIDs(colIDs):
-    dtype_dict = OrderedDict()
+    """Get a numpy record type from a list of column ID numbers.
+
+    The binary layout of the data in the MPR file is described by the sequence
+    of column ID numbers in the file header. This function converts that
+    sequence into a numpy dtype which can then be used to load data from the
+    file with np.frombuffer().
+
+    Some column IDs refer to small values which are packed into a single byte.
+    The second return value is a dict describing the bit masks with which to
+    extract these columns from the flags byte.
+
+    """
+    type_list = []
+    field_name_counts = defaultdict(int)
     flags_dict = OrderedDict()
-    flags2_dict = OrderedDict()
     for colID in colIDs:
-        if colID in (1, 2, 3, 21, 31, 65):
+        if colID in VMPdata_colID_flag_map:
-            dtype_dict['flags'] = 'u1'
+            # Some column IDs represent boolean flags or small integers
-            if colID == 1:
+            # These are all packed into a single 'flags' byte whose position
-                flags_dict['mode'] = (np.uint8(0x03), np.uint8)
+            # in the overall record is determined by the position of the first
-            elif colID == 2:
+            # column ID of flag type. If there are several flags present,
-                flags_dict['ox/red'] = (np.uint8(0x04), np.bool_)
+            # there is still only one 'flags' int
-            elif colID == 3:
+            if 'flags' not in field_name_counts:
-                flags_dict['error'] = (np.uint8(0x08), np.bool_)
+                type_list.append(('flags', 'u1'))
-            elif colID == 21:
+                field_name_counts['flags'] = 1
-                flags_dict['control changes'] = (np.uint8(0x10), np.bool_)
+            flag_name, flag_mask, flag_type = VMPdata_colID_flag_map[colID]
-            elif colID == 31:
+            # TODO what happens if a flag colID has already been seen
-                flags_dict['Ns changes'] = (np.uint8(0x20), np.bool_)
+            # i.e. if flag_name is already present in flags_dict?
-            elif colID == 65:
+            # Does it create a second 'flags' byte in the record?
-                flags_dict['counter inc.'] = (np.uint8(0x80), np.bool_)
+            flags_dict[flag_name] = (np.uint8(flag_mask), flag_type)
+        elif colID in VMPdata_colID_dtype_map:
+            field_name, field_type = VMPdata_colID_dtype_map[colID]
+            field_name_counts[field_name] += 1
+            count = field_name_counts[field_name]
+            if count > 1:
+                unique_field_name = '%s %d' % (field_name, count)
             else:
-                raise NotImplementedError("flag %d not implemented" % colID)
+                unique_field_name = field_name
-        elif colID == 4:
+            type_list.append((unique_field_name, field_type))
-            dtype_dict['time/s'] = '<f8'
-        elif colID == 5:
-            dtype_dict['control/V/mA'] = '<f4'
-        # 6 is Ewe, 77 is <Ewe>, I don't see the difference
-        elif colID in (6, 77):
-            dtype_dict['Ewe/V'] = '<f4'
-        # Can't see any difference between 7 and 23
-        elif colID in (7, 23):
-            dtype_dict['dQ/mA.h'] = '<f8'
-        # 76 is <I>, 8 is either I or <I> ??
-        elif colID in (8, 76):
-            dtype_dict['I/mA'] = '<f4'
-        elif colID == 9:
-            dtype_dict['Ece/V'] = '<f4'
-        elif colID == 11:
-            dtype_dict['I/mA'] = '<f8'
-        elif colID == 13:
-            dtype_dict['(Q-Qo)/mA.h'] = '<f8'
-        elif colID == 16:
-            dtype_dict['Analog IN 1/V'] = '<f4'
-        elif colID == 19:
-            dtype_dict['control/V'] = '<f4'
-        elif colID == 20:
-            dtype_dict['control/mA'] = '<f4'
-        elif colID == 24:
-            dtype_dict['cycle number'] = '<f8'
-        elif colID == 32:
-            dtype_dict['freq/Hz'] = '<f4'
-        elif colID == 33:
-            dtype_dict['|Ewe|/V'] = '<f4'
-        elif colID == 34:
-            dtype_dict['|I|/A'] = '<f4'
-        elif colID == 35:
-            dtype_dict['Phase(Z)/deg'] = '<f4'
-        elif colID == 36:
-            dtype_dict['|Z|/Ohm'] = '<f4'
-        elif colID == 37:
-            dtype_dict['Re(Z)/Ohm'] = '<f4'
-        elif colID == 38:
-            dtype_dict['-Im(Z)/Ohm'] = '<f4'
-        elif colID == 39:
-            dtype_dict['I Range'] = '<u2'
-        elif colID == 70:
-            dtype_dict['P/W'] = '<f4'
-        elif colID == 74:
-            dtype_dict['Energy/W.h'] = '<f8'
-        elif colID == 78:
-            dtype_dict['Cs-2/µf-2'] = '<f4'
-        elif colID == 123:
-            dtype_dict['Energy charge/W.h'] = '<f8'
-        elif colID == 124:
-            dtype_dict['Energy discharge/W.h'] = '<f8'
-        elif colID == 125:
-            dtype_dict['Capacitance charge/µF'] = '<f8'
-        elif colID == 126:
-            dtype_dict['Capacitance discharge/µF'] = '<f8'
-        elif colID == 131:
-            dtype_dict['Ns'] = '<u2'
-        elif colID == 169:
-            dtype_dict['Cs/µF'] = '<f4'
-        elif colID == 172:
-            dtype_dict['Cp/µF'] = '<f4'
-        elif colID == 173:
-            dtype_dict['Cp-2/µF-2'] = '<f4'
-        elif colID == 434:
-            dtype_dict['(Q-Qo)/C'] = '<f4'
-        elif colID == 435:
-            dtype_dict['dQ/C'] = '<f4'
-        elif colID == 467:
-            dtype_dict['Q charge/discharge/mA.h'] = '<f8'
-        elif colID == 468:
-            dtype_dict['half cycle'] = '<u4'
-        elif colID == 469:
-            dtype_dict['z cycle'] = '<u4'
-        elif colID == 473:
-            dtype_dict['THD Ewe/%'] = '<f4'
-        elif colID == 476:
-            dtype_dict['NSD Ewe/%'] = '<f4'
-        elif colID == 479:
-            dtype_dict['NSR Ewe/%'] = '<f4'
-        elif colID == 474:
-            dtype_dict['THD I/%'] = '<f4'
-        elif colID == 477:
-            dtype_dict['NSD I/%'] = '<f4'
-        elif colID == 480:
-            dtype_dict['NSR I/%'] = '<f4'
         else:
-            print(dtype_dict)
             raise NotImplementedError("column type %d not implemented" % colID)
-    return np.dtype(list(dtype_dict.items())), flags_dict, flags2_dict
+    return np.dtype(type_list), flags_dict
 
 
 def read_VMP_modules(fileobj, read_module_data=True):
@@ -270,7 +258,8 @@ def read_VMP_modules(fileobj, read_module_data=True):
         if len(module_magic) == 0:  # end of file
             break
         elif module_magic != b'MODULE':
-            raise ValueError("Found %r, expecting start of new VMP MODULE" % module_magic)
+            raise ValueError("Found %r, expecting start of new VMP MODULE"
+                             % module_magic)
 
         hdr_bytes = fileobj.read(VMPmodule_hdr.itemsize)
         if len(hdr_bytes) < VMPmodule_hdr.itemsize:
@@ -294,6 +283,9 @@ def read_VMP_modules(fileobj, read_module_data=True):
             fileobj.seek(hdr_dict['offset'] + hdr_dict['length'], SEEK_SET)
 
 
+MPR_MAGIC = b'BIO-LOGIC MODULAR FILE\x1a'.ljust(48) + b'\x00\x00\x00\x00'
+
+
 class MPRfile:
     """Bio-Logic .mpr file
 
@@ -311,20 +303,20 @@ class MPRfile:
     """
 
     def __init__(self, file_or_path):
+        self.loop_index = None
         if isinstance(file_or_path, str):
             mpr_file = open(file_or_path, 'rb')
         else:
             mpr_file = file_or_path
-
+        magic = mpr_file.read(len(MPR_MAGIC))
-        mpr_magic = b'BIO-LOGIC MODULAR FILE\x1a                         \x00\x00\x00\x00'
+        if magic != MPR_MAGIC:
-        magic = mpr_file.read(len(mpr_magic))
-        if magic != mpr_magic:
             raise ValueError('Invalid magic for .mpr file: %s' % magic)
 
         modules = list(read_VMP_modules(mpr_file))
         self.modules = modules
         settings_mod, = (m for m in modules if m['shortname'] == b'VMP Set   ')
         data_module, = (m for m in modules if m['shortname'] == b'VMP data  ')
+        maybe_loop_module = [m for m in modules if m['shortname'] == b'VMP loop  ']
         maybe_log_module = [m for m in modules if m['shortname'] == b'VMP LOG   ']
 
         n_data_points = np.frombuffer(data_module['data'][:4], dtype='<u4')
@@ -338,7 +330,7 @@ class MPRfile:
         elif data_module['version'] == 2:
             column_types = np.frombuffer(data_module['data'][5:], dtype='<u2',
                                          count=n_columns)
-            ## There is 405 bytes of data before the main array starts
+            # There is 405 bytes of data before the main array starts
             remaining_headers = data_module['data'][5 + 2 * n_columns:405]
             main_data = data_module['data'][405:]
         else:
@@ -350,12 +342,12 @@ class MPRfile:
         else:
             assert(not any(remaining_headers))
 
-        self.dtype, self.flags_dict, self.flags2_dict = VMPdata_dtype_from_colIDs(column_types)
+        self.dtype, self.flags_dict = VMPdata_dtype_from_colIDs(column_types)
         self.data = np.frombuffer(main_data, dtype=self.dtype)
         assert(self.data.shape[0] == n_data_points)
 
-        ## No idea what these 'column types' mean or even if they are actually
+        # No idea what these 'column types' mean or even if they are actually
-        ## column types at all
+        # column types at all
         self.version = int(data_module['version'])
         self.cols = column_types
         self.npts = n_data_points
@@ -366,6 +358,16 @@ class MPRfile:
             tm = time.strptime(str3(settings_mod['date']), '%m-%d-%y')
         self.startdate = date(tm.tm_year, tm.tm_mon, tm.tm_mday)
 
+        if maybe_loop_module:
+            loop_module, = maybe_loop_module
+            if loop_module['version'] == 0:
+                self.loop_index = np.fromstring(loop_module['data'][4:],
+                                                dtype='<u4')
+                self.loop_index = np.trim_zeros(self.loop_index, 'b')
+            else:
+                raise ValueError("Unrecognised version for data module: %d" %
+                                 data_module['version'])
+
         if maybe_log_module:
             log_module, = maybe_log_module
             try:
@@ -374,9 +376,9 @@ class MPRfile:
                 tm = time.strptime(str3(log_module['date']), '%m-%d-%y')
             self.enddate = date(tm.tm_year, tm.tm_mon, tm.tm_mday)
 
-            ## There is a timestamp at either 465 or 469 bytes
+            # There is a timestamp at either 465 or 469 bytes
-            ## I can't find any reason why it is one or the other in any
+            # I can't find any reason why it is one or the other in any
-            ## given file
+            # given file
             ole_timestamp1 = np.frombuffer(log_module['data'][465:],
                                            dtype='<f8', count=1)
             ole_timestamp2 = np.frombuffer(log_module['data'][469:],
@@ -402,17 +404,14 @@ class MPRfile:
             ole_timedelta = timedelta(days=ole_timestamp[0])
             self.timestamp = ole_base + ole_timedelta
             if self.startdate != self.timestamp.date():
-                raise ValueError("""Date mismatch:
+                raise ValueError("Date mismatch:\n"
-                Start date: %s
+                                 + "    Start date: %s\n" % self.startdate
-                End date: %s
+                                 + "    End date: %s\n" % self.enddate
-                Timestamp: %s""" % (self.startdate, self.enddate, self.timestamp))
+                                 + "    Timestamp: %s\n" % self.timestamp)
 
     def get_flag(self, flagname):
         if flagname in self.flags_dict:
             mask, dtype = self.flags_dict[flagname]
             return np.array(self.data['flags'] & mask, dtype=dtype)
-        elif flagname in self.flags2_dict:
-            mask, dtype = self.flags2_dict[flagname]
-            return np.array(self.data['flags2'] & mask, dtype=dtype)
         else:
             raise AttributeError("Flag '%s' not present" % flagname)

galvani/__init__.py

@@ -1 +1,3 @@
-from .BioLogic import MPTfile, MPRfile
+from .BioLogic import MPRfile, MPTfile
+
+__all__ = ['MPRfile', 'MPTfile']

galvani/res2sqlite.py

@@ -7,8 +7,8 @@ import csv
 import argparse
 
 
-## The following scripts are adapted from the result of running
+# The following scripts are adapted from the result of running
-## $ mdb-schema <result.res> oracle
+# $ mdb-schema <result.res> oracle
 
 mdb_tables = ["Version_Table", "Global_Table", "Resume_Table",
               "Channel_Normal_Table", "Channel_Statistic_Table",
@@ -126,7 +126,8 @@ CREATE TABLE Channel_Statistic_Table
   -- Version 1.14 ends here, version 5.23 continues
     Charge_Time             REAL DEFAULT NULL,
     Discharge_Time          REAL DEFAULT NULL,
-    FOREIGN KEY (Test_ID, Data_Point) REFERENCES Channel_Normal_Table (Test_ID, Data_Point)
+    FOREIGN KEY (Test_ID, Data_Point)
+        REFERENCES Channel_Normal_Table (Test_ID, Data_Point)
 ); """,
     "Auxiliary_Table": """
 CREATE TABLE Auxiliary_Table
@@ -137,7 +138,8 @@ CREATE TABLE Auxiliary_Table
     Data_Type               INTEGER,
     X                       REAL,
     "dX/dt"                 REAL,
-    FOREIGN KEY (Test_ID, Data_Point) REFERENCES Channel_Normal_Table (Test_ID, Data_Point)
+    FOREIGN KEY (Test_ID, Data_Point)
+        REFERENCES Channel_Normal_Table (Test_ID, Data_Point)
 ); """,
     "Event_Table": """
 CREATE TABLE Event_Table
@@ -220,9 +222,10 @@ CREATE TABLE Smart_Battery_Data_Table
     ChargingCurrent         REAL DEFAULT NULL,
     ChargingVoltage         REAL DEFAULT NULL,
     ManufacturerData        REAL DEFAULT NULL,
-    FOREIGN KEY (Test_ID, Data_Point) REFERENCES Channel_Normal_Table (Test_ID, Data_Point)
+    FOREIGN KEY (Test_ID, Data_Point)
+        REFERENCES Channel_Normal_Table (Test_ID, Data_Point)
 ); """,
-    ## The following tables are not present in version 1.14
+    # The following tables are not present in version 1.14
     'MCell_Aci_Data_Table': """
 CREATE TABLE MCell_Aci_Data_Table
  (
@@ -233,7 +236,8 @@ CREATE TABLE MCell_Aci_Data_Table
     Phase_Shift		REAL,
     Voltage			REAL,
     Current			REAL,
-    FOREIGN KEY (Test_ID, Data_Point) REFERENCES Channel_Normal_Table (Test_ID, Data_Point)
+    FOREIGN KEY (Test_ID, Data_Point)
+        REFERENCES Channel_Normal_Table (Test_ID, Data_Point)
 );""",
     'Aux_Global_Data_Table': """
 CREATE TABLE Aux_Global_Data_Table
@@ -288,7 +292,8 @@ CREATE TABLE Smart_Battery_Clock_Stretch_Table
     VCELL3			    INTEGER,
     VCELL2			    INTEGER,
     VCELL1			    INTEGER,
-    FOREIGN KEY (Test_ID, Data_Point) REFERENCES Channel_Normal_Table (Test_ID, Data_Point)
+    FOREIGN KEY (Test_ID, Data_Point)
+        REFERENCES Channel_Normal_Table (Test_ID, Data_Point)
 );"""}
 
 mdb_create_indices = {
@@ -306,11 +311,14 @@ CREATE TEMPORARY TABLE capacity_helper(
     Discharge_Capacity     REAL NOT NULL,
     Charge_Energy          REAL NOT NULL,
     Discharge_Energy       REAL NOT NULL,
-    FOREIGN KEY (Test_ID, Cycle_Index) REFERENCES Channel_Normal_Table (Test_ID, Cycle_Index)
+    FOREIGN KEY (Test_ID, Cycle_Index)
+        REFERENCES Channel_Normal_Table (Test_ID, Cycle_Index)
 );
 
 INSERT INTO capacity_helper
-    SELECT Test_ID, Cycle_Index, max(Charge_Capacity), max(Discharge_Capacity), max(Charge_Energy), max(Discharge_Energy) 
+    SELECT Test_ID, Cycle_Index,
+           max(Charge_Capacity), max(Discharge_Capacity),
+           max(Charge_Energy), max(Discharge_Energy)
         FROM Channel_Normal_Table
         GROUP BY Test_ID, Cycle_Index;
 
@@ -328,11 +336,14 @@ CREATE TABLE Capacity_Sum_Table(
     Discharge_Capacity_Sum REAL NOT NULL,
     Charge_Energy_Sum      REAL NOT NULL,
     Discharge_Energy_Sum   REAL NOT NULL,
-    FOREIGN KEY (Test_ID, Cycle_Index) REFERENCES Channel_Normal_Table (Test_ID, Cycle_Index)
+    FOREIGN KEY (Test_ID, Cycle_Index)
+        REFERENCES Channel_Normal_Table (Test_ID, Cycle_Index)
 );
 
 INSERT INTO Capacity_Sum_Table
-    SELECT a.Test_ID, a.Cycle_Index, total(b.Charge_Capacity), total(b.Discharge_Capacity), total(b.Charge_Energy), total(b.Discharge_Energy) 
+    SELECT a.Test_ID, a.Cycle_Index,
+           total(b.Charge_Capacity), total(b.Discharge_Capacity),
+           total(b.Charge_Energy), total(b.Discharge_Energy)
         FROM capacity_helper AS a LEFT JOIN capacity_helper AS b
             ON (a.Test_ID = b.Test_ID AND a.Cycle_Index > b.Cycle_Index)
         GROUP BY a.Test_ID, a.Cycle_Index;
@@ -342,30 +353,49 @@ DROP TABLE capacity_helper;
 CREATE VIEW IF NOT EXISTS Capacity_View
     AS SELECT Test_ID, Data_Point, Test_Time, Step_Time, DateTime,
               Step_Index, Cycle_Index, Current, Voltage, "dV/dt",
-              Discharge_Capacity + Discharge_Capacity_Sum - Charge_Capacity - Charge_Capacity_Sum AS Net_Capacity,
+              ( (Discharge_Capacity + Discharge_Capacity_Sum)
-              Discharge_Capacity + Discharge_Capacity_Sum + Charge_Capacity + Charge_Capacity_Sum AS Gross_Capacity,
+              - (Charge_Capacity + Charge_Capacity_Sum) ) AS Net_Capacity,
-              Discharge_Energy + Discharge_Energy_Sum - Charge_Energy - Charge_Energy_Sum AS Net_Energy,
+              ( (Discharge_Capacity + Discharge_Capacity_Sum)
-              Discharge_Energy + Discharge_Energy_Sum + Charge_Energy + Charge_Energy_Sum AS Gross_Energy
+              + (Charge_Capacity + Charge_Capacity_Sum) ) AS Gross_Capacity,
+              ( (Discharge_Energy + Discharge_Energy_Sum)
+              - (Charge_Energy + Charge_Energy_Sum) ) AS Net_Energy,
+              ( (Discharge_Energy + Discharge_Energy_Sum)
+              + (Charge_Energy + Charge_Energy_Sum) ) AS Gross_Energy
         FROM Channel_Normal_Table NATURAL JOIN Capacity_Sum_Table;
 """
 
 
 def mdb_get_data_text(s3db, filename, table):
     print("Reading %s..." % table)
+    insert_pattern = re.compile(
+        r'INSERT INTO "\w+" \([^)]+?\) VALUES \(("[^"]*"|[^")])+?\);\n',
+        re.IGNORECASE
+    )
+    # TODO after dropping Python 2 support - use Popen as contextmanager
     try:
         mdb_sql = sp.Popen(['mdb-export', '-I', 'postgres', filename, table],
                            bufsize=-1, stdin=None, stdout=sp.PIPE,
                            universal_newlines=True)
+    except OSError as e:
+        if e.errno == 2:
+            raise RuntimeError('Could not locate the `mdb-export` executable. '
+                               'Check that mdbtools is properly installed.')
+        else:
+            raise
+    try:
+        # Initialize values to avoid NameError in except clause
+        mdb_output = ''
+        insert_match = None
         mdb_output = mdb_sql.stdout.read()
         while len(mdb_output) > 0:
-            insert_match = re.match(r'INSERT INTO "\w+" \([^)]+?\) VALUES \(("[^"]*"|[^")])+?\);\n',
+            insert_match = insert_pattern.match(mdb_output)
-                                    mdb_output, re.IGNORECASE)
             s3db.execute(insert_match.group())
             mdb_output = mdb_output[insert_match.end():]
         s3db.commit()
-    except:
+    except BaseException:
         print("Error while importing %s" % table)
-        print("Remaining mdb-export output:", mdb_output)
+        if mdb_output:
+            print("Remaining mdb-export output:", mdb_output)
         if insert_match:
             print("insert_re match:", insert_match)
         raise
@@ -375,17 +405,28 @@ def mdb_get_data_text(s3db, filename, table):
 
 def mdb_get_data_numeric(s3db, filename, table):
     print("Reading %s..." % table)
+    # TODO after dropping Python 2 support - use Popen as contextmanager
     try:
         mdb_sql = sp.Popen(['mdb-export', filename, table],
                            bufsize=-1, stdin=None, stdout=sp.PIPE,
                            universal_newlines=True)
+    except OSError as e:
+        if e.errno == 2:
+            raise RuntimeError('Could not locate the `mdb-export` executable. '
+                               'Check that mdbtools is properly installed.')
+        else:
+            raise
+    try:
         mdb_csv = csv.reader(mdb_sql.stdout)
         mdb_headers = next(mdb_csv)
         quoted_headers = ['"%s"' % h for h in mdb_headers]
         joined_headers = ', '.join(quoted_headers)
         joined_placemarks = ', '.join(['?' for h in mdb_headers])
-        insert_stmt = 'INSERT INTO "{0}" ({1}) VALUES ({2});'.format(table,
+        insert_stmt = 'INSERT INTO "{0}" ({1}) VALUES ({2});'.format(
-                                        joined_headers, joined_placemarks)
+            table,
+            joined_headers,
+            joined_placemarks,
+        )
         s3db.executemany(insert_stmt, mdb_csv)
         s3db.commit()
     finally:
@@ -408,7 +449,6 @@ def convert_arbin_to_sqlite(input_file, output_file):
     """
     s3db = sqlite3.connect(output_file)
 
-    
     for table in reversed(mdb_tables + mdb_5_23_tables):
         s3db.execute('DROP TABLE IF EXISTS "%s";' % table)
 
@@ -419,7 +459,9 @@ def convert_arbin_to_sqlite(input_file, output_file):
             print("Creating indices for %s..." % table)
             s3db.executescript(mdb_create_indices[table])
 
-    if (s3db.execute("SELECT Version_Schema_Field FROM Version_Table;").fetchone()[0] == "Results File 5.23"):
+    csr = s3db.execute("SELECT Version_Schema_Field FROM Version_Table;")
+    version_text, = csr.fetchone()
+    if (version_text == "Results File 5.23"):
         for table in mdb_5_23_tables:
             s3db.executescript(mdb_create_scripts[table])
             mdb_get_data(input_file, table)
@@ -434,7 +476,9 @@ def convert_arbin_to_sqlite(input_file, output_file):
 
 
 def main(argv=None):
-    parser = argparse.ArgumentParser(description="Convert Arbin .res files to sqlite3 databases using mdb-export")
+    parser = argparse.ArgumentParser(
+        description="Convert Arbin .res files to sqlite3 databases using mdb-export",
+    )
     parser.add_argument('input_file', type=str)  # need file name to pass to sp.Popen
     parser.add_argument('output_file', type=str)  # need file name to pass to sqlite3.connect
 

setup.py

@@ -9,11 +9,11 @@ with open(os.path.join(os.path.dirname(__file__), 'README.md')) as f:
 
 setup(
     name='galvani',
-    version='0.0.2',
+    version='0.1.0',
     description='Open and process battery charger log data files',
     long_description=readme,
     long_description_content_type="text/markdown",
-    url='https://github.com/chatcannon/galvani',
+    url='https://github.com/echemdata/galvani',
     author='Chris Kerr',
     author_email='chris.kerr@mykolab.ch',
     license='GPLv3+',
@@ -25,9 +25,11 @@ setup(
         'Natural Language :: English',
     ],
     packages=['galvani'],
-    entry_points={'console_scripts': [
+    entry_points={
+        'console_scripts': [
             'res2sqlite = galvani.res2sqlite:main',
-    ]},
+        ],
+    },
     install_requires=['numpy'],
     tests_require=['pytest'],
 )

tests/conftest.py

@@ -0,0 +1,11 @@
+"""Helpers for pytest tests."""
+
+import os
+
+import pytest
+
+
+@pytest.fixture(scope='session')
+def testdata_dir():
+    """Path to the testdata directory."""
+    return os.path.join(os.path.dirname(__file__), 'testdata')

tests/test_Arbin.py

@@ -0,0 +1,56 @@
+"""Tests for loading Arbin .res files."""
+
+import os
+import sqlite3
+import subprocess
+
+import pytest
+
+from galvani import res2sqlite
+
+
+# TODO - change to subprocess.DEVNULL when python 2 support is removed
+have_mdbtools = (subprocess.call(['which', 'mdb-export'], stdout=None) == 0)
+
+
+def test_res2sqlite_help():
+    """Test running `res2sqlite --help`.
+
+    This should work even when mdbtools is not installed.
+    """
+    help_output = subprocess.check_output(['res2sqlite', '--help'])
+    assert b'Convert Arbin .res files to sqlite3 databases' in help_output
+
+
+@pytest.mark.skipif(have_mdbtools, reason='This tests the failure when mdbtools is not installed')
+def test_convert_Arbin_no_mdbtools(testdata_dir, tmpdir):
+    """Checks that the conversion fails with an appropriate error message."""
+    res_file = os.path.join(testdata_dir, 'arbin1.res')
+    sqlite_file = os.path.join(str(tmpdir), 'arbin1.s3db')
+    with pytest.raises(RuntimeError, match="Could not locate the `mdb-export` executable."):
+        res2sqlite.convert_arbin_to_sqlite(res_file, sqlite_file)
+
+
+@pytest.mark.skipif(not have_mdbtools, reason='Reading the Arbin file requires MDBTools')
+@pytest.mark.parametrize('basename', ['arbin1'])
+def test_convert_Arbin_to_sqlite_function(testdata_dir, tmpdir, basename):
+    """Convert an Arbin file to SQLite using the functional interface."""
+    res_file = os.path.join(testdata_dir, basename + '.res')
+    sqlite_file = os.path.join(str(tmpdir), basename + '.s3db')
+    res2sqlite.convert_arbin_to_sqlite(res_file, sqlite_file)
+    assert os.path.isfile(sqlite_file)
+    with sqlite3.connect(sqlite_file) as conn:
+        csr = conn.execute('SELECT * FROM Channel_Normal_Table;')
+        csr.fetchone()
+
+
+@pytest.mark.skipif(not have_mdbtools, reason='Reading the Arbin file requires MDBTools')
+def test_convert_cmdline(testdata_dir, tmpdir):
+    """Checks that the conversion fails with an appropriate error message."""
+    res_file = os.path.join(testdata_dir, 'arbin1.res')
+    sqlite_file = os.path.join(str(tmpdir), 'arbin1.s3db')
+    subprocess.check_call(['res2sqlite', res_file, sqlite_file])
+    assert os.path.isfile(sqlite_file)
+    with sqlite3.connect(sqlite_file) as conn:
+        csr = conn.execute('SELECT * FROM Channel_Normal_Table;')
+        csr.fetchone()

tests/test_BioLogic.py

@@ -8,13 +8,11 @@ import numpy as np
 from numpy.testing import assert_array_almost_equal, assert_array_equal
 import pytest
 
-from galvani import MPTfile, MPRfile
+from galvani import BioLogic, MPTfile, MPRfile
 from galvani.BioLogic import MPTfileCSV, str3  # not exported
 
-testdata_dir = os.path.join(os.path.dirname(__file__), 'testdata')
 
-
+def test_open_MPT(testdata_dir):
-def test_open_MPT():
     mpt1, comments = MPTfile(os.path.join(testdata_dir, 'bio_logic1.mpt'))
     assert comments == []
     assert mpt1.dtype.names == (
@@ -24,12 +22,12 @@ def test_open_MPT():
     )
 
 
-def test_open_MPT_fails_for_bad_file():
+def test_open_MPT_fails_for_bad_file(testdata_dir):
     with pytest.raises(ValueError, match='Bad first line'):
         MPTfile(os.path.join(testdata_dir, 'bio_logic1.mpr'))
 
 
-def test_open_MPT_csv():
+def test_open_MPT_csv(testdata_dir):
     mpt1, comments = MPTfileCSV(os.path.join(testdata_dir, 'bio_logic1.mpt'))
     assert comments == []
     assert mpt1.fieldnames == [
@@ -39,11 +37,42 @@ def test_open_MPT_csv():
     ]
 
 
-def test_open_MPT_csv_fails_for_bad_file():
+def test_open_MPT_csv_fails_for_bad_file(testdata_dir):
     with pytest.raises((ValueError, UnicodeDecodeError)):
         MPTfileCSV(os.path.join(testdata_dir, 'bio_logic1.mpr'))
 
 
+def test_colID_map_uniqueness():
+    """Check some uniqueness properties of the VMPdata_colID_xyz maps."""
+    field_colIDs = set(BioLogic.VMPdata_colID_dtype_map.keys())
+    flag_colIDs = set(BioLogic.VMPdata_colID_flag_map.keys())
+    field_names = [v[0] for v in BioLogic.VMPdata_colID_dtype_map.values()]
+    flag_names = [v[0] for v in BioLogic.VMPdata_colID_flag_map.values()]
+    assert not field_colIDs.intersection(flag_colIDs)
+    # 'I/mA' and 'dQ/mA.h' are duplicated
+    # assert len(set(field_names)) == len(field_names)
+    assert len(set(flag_names)) == len(flag_names)
+    assert not set(field_names).intersection(flag_names)
+
+
+@pytest.mark.parametrize('colIDs, expected', [
+    ([1, 2, 3], [('flags', 'u1')]),
+    ([4, 6], [('time/s', '<f8'), ('Ewe/V', '<f4')]),
+    ([1, 4, 21], [('flags', 'u1'), ('time/s', '<f8')]),
+    ([4, 6, 4], [('time/s', '<f8'), ('Ewe/V', '<f4'), ('time/s 2', '<f8')]),
+    ([4, 9999], NotImplementedError),
+])
+def test_colID_to_dtype(colIDs, expected):
+    """Test converting column ID to numpy dtype."""
+    if isinstance(expected, type) and issubclass(expected, Exception):
+        with pytest.raises(expected):
+            BioLogic.VMPdata_dtype_from_colIDs(colIDs)
+        return
+    expected_dtype = np.dtype(expected)
+    dtype, flags_dict = BioLogic.VMPdata_dtype_from_colIDs(colIDs)
+    assert dtype == expected_dtype
+
+
 @pytest.mark.parametrize('filename, startdate, enddate', [
     ('bio_logic1.mpr', '2011-10-29', '2011-10-31'),
     ('bio_logic2.mpr', '2012-09-27', '2012-09-27'),
@@ -55,7 +84,7 @@ def test_open_MPT_csv_fails_for_bad_file():
     # C019P-0ppb-A_C01.mpr stores the date in a different format
     ('C019P-0ppb-A_C01.mpr', '2019-03-14', '2019-03-14'),
 ])
-def test_MPR_dates(filename, startdate, enddate):
+def test_MPR_dates(testdata_dir, filename, startdate, enddate):
     """Check that the start and end dates in .mpr files are read correctly."""
     mpr = MPRfile(os.path.join(testdata_dir, filename))
     assert mpr.startdate.strftime('%Y-%m-%d') == startdate
@@ -65,7 +94,7 @@ def test_MPR_dates(filename, startdate, enddate):
         assert not hasattr(mpr, 'enddate')
 
 
-def test_open_MPR_fails_for_bad_file():
+def test_open_MPR_fails_for_bad_file(testdata_dir):
     with pytest.raises(ValueError, match='Invalid magic for .mpr file'):
         MPRfile(os.path.join(testdata_dir, 'arbin1.res'))
 
@@ -98,7 +127,7 @@ def assert_MPR_matches_MPT(mpr, mpt, comments):
     assert_array_equal(mpr.get_flag("control changes"), mpt["control changes"])
     if "Ns changes" in mpt.dtype.fields:
         assert_array_equal(mpr.get_flag("Ns changes"), mpt["Ns changes"])
-    ## Nothing uses the 0x40 bit of the flags    
+    # Nothing uses the 0x40 bit of the flags
     assert_array_equal(mpr.get_flag("counter inc."), mpt["counter inc."])
 
     assert_array_almost_equal(mpr.data["time/s"],
@@ -134,7 +163,7 @@ def assert_MPR_matches_MPT(mpr, mpt, comments):
     'CV_C01',
     '121_CA_455nm_6V_30min_C01',
 ])
-def test_MPR_matches_MPT(basename):
+def test_MPR_matches_MPT(testdata_dir, basename):
     """Check the MPR parser against the MPT parser.
 
     Load a binary .mpr file and a text .mpt file which should contain
@@ -147,7 +176,7 @@ def test_MPR_matches_MPT(basename):
     assert_MPR_matches_MPT(mpr, mpt, comments)
 
 
-def test_MPR5_matches_MPT5():
+def test_MPR5_matches_MPT5(testdata_dir):
     mpr = MPRfile(os.path.join(testdata_dir, 'bio_logic5.mpr'))
     mpt, comments = MPTfile((re.sub(b'\tXXX\t', b'\t0\t', line) for line in
                              open(os.path.join(testdata_dir, 'bio_logic5.mpt'),
@@ -155,7 +184,7 @@ def test_MPR5_matches_MPT5():
     assert_MPR_matches_MPT(mpr, mpt, comments)
 
 
-def test_MPR6_matches_MPT6():
+def test_MPR6_matches_MPT6(testdata_dir):
     mpr = MPRfile(os.path.join(testdata_dir, 'bio_logic6.mpr'))
     mpt, comments = MPTfile(os.path.join(testdata_dir, 'bio_logic6.mpt'))
     mpr.data = mpr.data[:958]  # .mpt file is incomplete

tox.ini

@@ -1,5 +1,13 @@
 [tox]
 envlist = py27,py35,py37
 [testenv]
-deps=pytest
+deps =
-commands=pytest
+  flake8
+  pytest
+commands =
+  flake8
+  pytest
+
+[flake8]
+exclude = build,dist,*.egg-info,.cache,.git,.tox,__pycache__
+max-line-length = 100