continue refactor

cx1111 · cx1111 · commit c29b4313ad6c · 2018-04-26T12:39:35.000-04:00
diff --git a/wfdb/io/_header.py b/wfdb/io/_header.py
@@ -153,20 +153,23 @@ class BaseHeaderMixin(object):
 
     def get_write_subset(self, spec_type):
         """
-        Get the fields used to write the header,
-
-
-        Helper function for `get_write_fields`.
+        Get a set of fields used to write the header; either 'record'
+        or 'signal' specification fields. Helper function for
+        `get_write_fields`.
 
         Parameters
         ----------
         spec_type : str
             The set of specification fields desired. Either 'record' or
             'signal'.
 
-        - For record fields,  returns a list of all fields needed.
-        - For signal fields, it returns a dictionary of all fields needed,
-        with keys = field and value = list of 1 or 0 indicating channel for the field
+        Returns
+        -------
+        write_fields : list or dict
+            For record fields,  returns a list of all fields needed. For
+            signal fields, it returns a dictionary of all fields needed,
+            with keys = field and value = list of 1 or 0 indicating
+            channel for the field
 
         """
         if spec_type == 'record':
@@ -181,11 +184,11 @@ def get_write_subset(self, spec_type):
                     continue
                 # If the field is required by default or has been defined by the user
                 if fieldspecs[f].write_req or getattr(self, f) is not None:
-                    rf=f
+                    rf = f
                     # Add the field and its recursive dependencies
                     while rf is not None:
                         write_fields.append(rf)
-                        rf=fieldspecs[rf].dependency
+                        rf = fieldspecs[rf].dependency
             # Add comments if any
             if getattr(self, 'comments') is not None:
                 write_fields.append('comments')
@@ -262,6 +265,10 @@ def wrheader(self, write_dir=''):
         - Get the fields used to write the header for this instance.
         - Check each required field.
 
+        Parameters
+        ----------
+        write_dir : str, optional
+            The output directory in which the header is written.
         """
 
         # Get all the fields used to write the header
@@ -289,12 +296,22 @@ def wrheader(self, write_dir=''):
     def get_write_fields(self):
         """
         Get the list of fields used to write the header, separating
-        record and signal specification fields.
+        record and signal specification fields. Returns the default
+        required fields, the user defined fields,
+        and their dependencies.
 
         Does NOT include `d_signal` or `e_d_signal`.
 
-        Returns the default required fields, the user defined fields, and their dependencies.
-        rec_write_fields includes 'comment' if present.
+        Returns
+        -------
+        rec_write_fields : list
+            Record specification fields to be written. Includes
+            'comment' if present.
+        sig_write_fields : dict
+            Dictionary of signal specification fields to be written,
+            with values equal to the channels that need to be present
+            for each field.
+
         """
 
         # Record specification fields
@@ -304,8 +321,7 @@ def get_write_fields(self):
         if self.comments != None:
             rec_write_fields.append('comments')
 
-        # Determine whether there are signals. If so, get their required
-        # fields.
+        # Get required signal fields if signals are present.
         self.check_field('n_sig')
 
         if self.n_sig >  0:
diff --git a/wfdb/io/_signal.py b/wfdb/io/_signal.py
@@ -574,38 +574,40 @@ def calc_checksum(self, expanded=False):
             cs = [int(c) for c in cs]
         return cs
 
-    # Write each of the specified dat files
     def wr_dat_files(self, expanded=False, write_dir=''):
+        """
+        Write each of the specified dat files
 
+        """
         # Get the set of dat files to be written, and
         # the channels to be written to each file.
-        file_names, datchannels = orderedsetlist(self.file_name)
+        file_names, dat_channels = describe_list_indices(self.file_name)
 
         # Get the fmt and byte offset corresponding to each dat file
-        datfmts={}
-        datoffsets={}
+        dat_fmts = {}
+        dat_offsets = {}
         for fn in file_names:
-            datfmts[fn] = self.fmt[datchannels[fn][0]]
+            dat_fmts[fn] = self.fmt[dat_channels[fn][0]]
 
             # byte_offset may not be present
             if self.byte_offset is None:
-                datoffsets[fn] = 0
+                dat_offsets[fn] = 0
             else:
-                datoffsets[fn] = self.byte_offset[datchannels[fn][0]]
+                dat_offsets[fn] = self.byte_offset[dat_channels[fn][0]]
 
         # Write the dat files
         if expanded:
             for fn in file_names:
-                wr_dat_file(fn, datfmts[fn], None , datoffsets[fn], True,
-                            [self.e_d_signal[ch] for ch in datchannels[fn]],
+                wr_dat_file(fn, dat_fmts[fn], None , dat_offsets[fn], True,
+                            [self.e_d_signal[ch] for ch in dat_channels[fn]],
                             self.samps_per_frame, write_dir=write_dir)
         else:
             # Create a copy to prevent overwrite
             dsig = self.d_signal.copy()
             for fn in file_names:
-                wr_dat_file(fn, datfmts[fn],
-                            dsig[:, datchannels[fn][0]:datchannels[fn][-1]+1],
-                            datoffsets[fn], write_dir=write_dir)
+                wr_dat_file(fn, dat_fmts[fn],
+                            dsig[:, dat_channels[fn][0]:dat_channels[fn][-1]+1],
+                            dat_offsets[fn], write_dir=write_dir)
 
 
     def smooth_frames(self, sigtype='physical'):
@@ -689,7 +691,7 @@ def rd_segment(file_name, dirname, pb_dir, n_sig, fmt, sig_len, byte_offset,
 
     # Get the set of dat files, and the
     # channels that belong to each file.
-    file_name, datchannel = orderedsetlist(file_name)
+    file_name, datchannel = describe_list_indices(file_name)
 
     # Some files will not be read depending on input channels.
     # Get the the wanted fields only.
@@ -1487,25 +1489,36 @@ def wr_dat_file(file_name, fmt, d_signal, byte_offset, expanded=False,
     f.close()
 
 
-def orderedsetlist(fulllist):
+def describe_list_indices(full_list):
     """
-    Returns the unique elements in a list in the order that they appear.
-    Also returns the indices of the original list that correspond to each output element.
+    Parameters
+    ----------
+    full_list : list
+        The list of items to order and
+
+    Returns
+    -------
+    unique_elements : list
+        A list of the unique elements of the list, in the order in which
+        they first appear.
+    element_indices : dict
+        A dictionary of lists for each unique element, giving all the
+        indices in which they appear in the original list.
+
     """
-    uniquelist = []
-    original_inds = {}
+    unique_elements = []
+    element_indices = {}
 
-    for i in range(0, len(fulllist)):
-        item = fulllist[i]
+    for i in range(len(full_list)):
+        item = full_list[i]
         # new item
-        if item not in uniquelist:
-            uniquelist.append(item)
-            original_inds[item] = [i]
+        if item not in unique_elements:
+            unique_elements.append(item)
+            element_indices[item] = [i]
         # previously seen item
         else:
-            original_inds[item].append(i)
-    return uniquelist, original_inds
-
+            element_indices[item].append(i)
+    return unique_elements, element_indices
 
 
 def downround(x, base):
diff --git a/wfdb/io/record.py b/wfdb/io/record.py
@@ -5,8 +5,6 @@
 # The check_field_cohesion() function will be called in wrheader which checks all the header fields.
 # The check_sig_cohesion() function will be called in wrsamp in wrdat to check the d_signal against the header fields.
 
-
-from collections import OrderedDict
 import datetime
 import multiprocessing
 import numpy as np
@@ -46,7 +44,7 @@ def check_field(self, field, required_channels=None):
         ----------
         field : str
             The field name
-        channels : list, optional
+        required_channels : list, optional
             Used for signal specification fields. Species the channels
             to check. Other channels can be None.
 
@@ -57,8 +55,8 @@ def check_field(self, field, required_channels=None):
         if item is None:
             raise Exception('Missing field required: %s' % field)
 
-        if channels == 'all':
-            channels = range(len(item))
+        if required_channels == 'all':
+            required_channels = range(len(item))
 
         # We should have a list specifying these automatically.
 
@@ -138,10 +136,10 @@ def check_field(self, field, required_channels=None):
                     # Check for file_name characters
                     accepted_string = re.match('[-\w]+\.?[\w]+', item[ch])
                     if not accepted_string or accepted_string.string != item[ch]:
-                        raise ValueError('File names should only contain alphanumerics, hyphens, and an extension. eg. record_100.dat')
+                        raise ValueError('File names should only contain alphanumerics, hyphens, and an extension. eg. record-100.dat')
                     # Check that dat files are grouped together
-                    if orderedsetlist(self.file_name)[0] != orderednoconseclist(self.file_name):
-                        raise ValueError('file_name error: all entries for signals that share a given file must be consecutive')
+                    if not is_monotonic(self.file_name):
+                        raise ValueError('Signals in a record that share a given file must be consecutive.')
                 elif field == 'fmt':
                     if item[ch] not in _signal.dat_fmts:
                         raise ValueError('File formats must be valid WFDB dat formats:', _signal.dat_fmts)
@@ -156,7 +154,7 @@ def check_field(self, field, required_channels=None):
                         raise ValueError('byte_offset values must be non-negative integers')
                 elif field == 'adc_gain':
                     if item[ch] <= 0:
-                        raise ValueError('adc_gain values must be positive numbers')
+                        raise ValueError('adc_gain values must be positive')
                 elif field == 'baseline':
                     # Original WFDB library 10.5.24 only has 4 bytes for
                     # baseline.
@@ -286,7 +284,7 @@ def check_item_type(item, field_name, allowed_types, expect_list=False,
     """
     Check the item's type against a set of allowed types.
     Vary the print message regarding whether the item can be None.
-    Helper to `BaseRecord.check_field_type`.
+    Helper to `BaseRecord.check_field`.
 
     Parameters
     ----------
@@ -315,7 +313,7 @@ def check_item_type(item, field_name, allowed_types, expect_list=False,
 
         for ch in range(len(item)):
             # Check whether the field may be None
-            if ch_in required_channels:
+            if ch in required_channels:
                 allowed_types_ch = allowed_types + (type(None),)
             else:
                 allowed_types_ch = allowed_types
@@ -1200,8 +1198,9 @@ def rdsamp(record_name, sampfrom=0, sampto='end', channels='all', pb_dir=None):
                                       channel =[1,3])
 
     """
-
-    record = rdrecord(record_name, sampfrom, sampto, channels, True, pb_dir, True)
+    record = rdrecord(record_name=record_name, sampfrom=sampfrom,
+                      sampto=sampto, channels=channels, physical=True,
+                      pb_dir=pb_dir, m2s=True)
 
     signals = record.p_signal
     fields = {}
@@ -1347,33 +1346,24 @@ def wrsamp(record_name, fs, units, sig_name, p_signal=None, d_signal=None,
     record.wrsamp(write_dir=write_dir)
 
 
-# Returns the unique elements in a list in the order that they appear.
-# Also returns the indices of the original list that correspond to each output element.
-def orderedsetlist(fulllist):
-    uniquelist = []
-    original_inds = {}
+def is_monotonic(full_list):
+    """
+    Determine whether elements in a list are monotonic. ie. unique
+    elements are clustered together.
+
+    ie. [5,5,3,4] is, [5,3,5] is not.
+    """
+    prev_elements = set({full_list[0]})
+    prev_item = full_list[0]
 
-    for i in range(0, len(fulllist)):
-        item = fulllist[i]
-        # new item
-        if item not in uniquelist:
-            uniquelist.append(item)
-            original_inds[item] = [i]
-        # previously seen item
-        else:
-            original_inds[item].append(i)
-    return uniquelist, original_inds
-
-# Returns elements in a list without consecutive repeated values.
-def orderednoconseclist(fulllist):
-    noconseclist = [fulllist[0]]
-    if len(fulllist) == 1:
-        return noconseclist
-    for i in fulllist:
-        if i!= noconseclist[-1]:
-            noconseclist.append(i)
-    return noconseclist
+    for item in full_list:
+        if item != prev_item:
+            if item in prev_elements:
+                return False
+            prev_item = item
+            prev_elements.add(item)
 
+    return True
 
 def dl_database(db_dir, dl_dir, records='all', annotators='all',
                 keep_subdirs=True, overwrite = False):
