psg_view

bark/__init__.py

@@ -1,3 +1,4 @@
 from __future__ import absolute_import
 from bark.bark import *
 from bark.bark import __version__
+from bark import stream

bark/bark.py

@@ -13,9 +13,11 @@
 import arrow
 import yaml
 import numpy as np
+import pandas as pd
 import functools as ft
 
 BUFFER_SIZE = 10000
+DEFAULT_META = '.meta.yaml'
 
 spec_version = "0.2"
 __version__ = "0.2"
@@ -28,9 +30,6 @@
  bark: %s
 """ % (__version__)
 
-_Units = namedtuple('_Units', ['TIME_UNITS'])
-UNITS = _Units(TIME_UNITS=('s', 'samples'))
-
 _pairs = ((None, None), ('UNDEFINED', 0), ('ACOUSTIC', 1), ('EXTRAC_HP', 2),
           ('EXTRAC_LF', 3), ('EXTRAC_EEG', 4), ('INTRAC_CC', 5),
           ('INTRAC_VC', 6), ('EVENT', 1000), ('SPIKET', 1001),
@@ -44,7 +43,7 @@
 
 
 
-class LazyDict(dict):
+class _LazyDict(dict):
     """Allows lazy loading of data and memoizing the result.
 
     If value is a function, evaluates and replaces with the return
@@ -68,7 +67,7 @@ def __init__(self, path):
         # entries are lazily loaded by creating a dictionary
         # with the entry name and a function, that when called
         # loads the data. See the custom LazyDict data structure
-        self.entries = LazyDict({os.path.split(x)[-1]: ft.partial(read_entry, name=x) for x in subdirs})
+        self.entries = _LazyDict({os.path.split(x)[-1]: ft.partial(read_entry, name=x) for x in subdirs})
 
     def __getitem__(self, item):
         return self.entries[item]
@@ -78,6 +77,15 @@ def __len__(self):
 
     def __contains__(self, item):
         return self.entries.__contains__(item)
+
+    def close(self):
+        for e_name in self.entries:
+            entry = self.entries.get(e_name)
+            if not callable(entry):
+                entry.close()
+                p = entry.path
+                self.entries[e_name] = ft.partial(read_entry, name=p)
+                del entry
 
 
 class Entry():
@@ -100,6 +108,14 @@ def __contains__(self, item):
 
     def __lt__(self, other):
         return self.timestamp < other.timestamp
+
+    def close(self):
+        for ds_name in self.datasets:
+            dataset = self.datasets.get(ds_name)
+            if not callable(dataset):
+                p = dataset.path
+                self.datasets[ds_name] = ft.partial(read_dataset, fname=p)
+                del dataset
 
 
 class Data():
@@ -168,18 +184,20 @@ def event_columns(dataframe, columns=None):
             register with `dataframe`'s columns
 
     Returns:
-        dict, or None: Columns dictionary for `dataframe`
+        dict: Columns dictionary for `dataframe`
     """
     if columns is None:
-        return template_columns(dataframe.columns)
-    for fieldkey in columns:
-        if fieldkey not in dataframe.columns:
-            del columns[fieldkey]
-    for col in dataframe.columns:
-        if col not in columns:
-            columns[col] = {'units': None}
-        if 'units' not in columns[col]:
-            columns[col]['units'] = None
+        columns = template_columns(dataframe.columns)
+    else:
+        for fieldkey in columns:
+            if fieldkey not in dataframe.columns:
+                del columns[fieldkey]
+        for col in dataframe.columns:
+            if col not in columns:
+                columns[col] = {'units': None}
+            if 'units' not in columns[col]:
+                columns[col]['units'] = None
+    return columns
 
 
 def sampled_columns(data, columns=None):
@@ -193,7 +211,7 @@ def sampled_columns(data, columns=None):
             register with shape of `data`
 
     Returns:
-        dict, or None: Columns dictionary for `data`
+        dict: Columns dictionary for `data`
 
     Raises:
         ValueError: if the keys in `columns` don't match up with `data`
@@ -203,16 +221,18 @@ def sampled_columns(data, columns=None):
     else:
         n_channels = data.shape[1]
     if columns is None:
-        return template_columns(range(n_channels))
-    if len(columns) != n_channels:
-        raise ValueError(
-            'the columns attribute does not match the number of columns')
-    for i in range(n_channels):
-        if i not in columns:
+        columns = template_columns(range(n_channels))
+    else:
+        if len(columns) != n_channels:
             raise ValueError(
-                'the columns attribute is missing column {}'.format(i))
-        if 'units' not in columns[i]:
-            columns[i]['units'] = None
+                'the columns attribute does not match the number of columns')
+        for i in range(n_channels):
+            if i not in columns:
+                raise ValueError(
+                    'the columns attribute is missing column {}'.format(i))
+            if 'units' not in columns[i]:
+                columns[i]['units'] = None
+    return columns
 
 
 def write_sampled(datfile, data, sampling_rate, **params):
@@ -229,6 +249,7 @@ def write_sampled(datfile, data, sampling_rate, **params):
     Returns:
         SampledData: sampled dataset containing `data`
     """
+    path = os.path.abspath(datfile)
     if 'columns' not in params:
         params['columns'] = sampled_columns(data)
     params["dtype"] = data.dtype.str
@@ -237,7 +258,7 @@ def write_sampled(datfile, data, sampling_rate, **params):
     mdata[:] = data[:]
     write_metadata(datfile, sampling_rate=sampling_rate, **params)
     params['sampling_rate'] = sampling_rate
-    return SampledData(mdata, datfile, params)
+    return SampledData(mdata, path, params)
 
 
 def read_sampled(datfile, mode="r"):
@@ -274,7 +295,6 @@ def write_events(eventsfile, data, **params):
     Returns:
         EventData: event dataset containing `data`
     """
-    import pandas as pd
     if 'columns' not in params:
         params['columns'] = event_columns(data)
     if data.empty and not list(data.columns):
@@ -293,10 +313,10 @@ def read_events(eventsfile):
     Returns:
        EventData: event dataset containing `eventsfile`'s data
     """
-    import pandas as pd
-    data = pd.read_csv(eventsfile).fillna('')
+    path = os.path.abspath(eventsfile)
     params = read_metadata(eventsfile)
-    return EventData(data, eventsfile, params)
+    data = pd.read_csv(eventsfile).fillna('')
+    return EventData(data, path, params)
 
 
 def read_dataset(fname):
@@ -316,7 +336,7 @@ def read_dataset(fname):
     return dset
 
 
-def read_metadata(path, meta='.meta.yaml'):
+def read_metadata(path, meta=DEFAULT_META):
     """Loads metadata for a dataset.
 
     Args:
@@ -348,7 +368,7 @@ def read_metadata(path, meta='.meta.yaml'):
         raise FileNotFoundError(m.format(path, metafile))
 
 
-def write_metadata(path, meta='.meta.yaml', **params):
+def write_metadata(path, meta=DEFAULT_META, **params):
     """Writes metadata for a dataset.
 
     Args:
@@ -359,6 +379,7 @@ def write_metadata(path, meta='.meta.yaml', **params):
         **params: all other keyword arguments are treated as dataset attributes,
             and added to the meta file
     """
+    # the two following checks are for backwards-compatibility
     if 'n_channels' in params:
         del params['n_channels']
     if 'n_samples' in params:
@@ -422,7 +443,7 @@ def create_entry(name, timestamp, parents=False, **attributes):
     return read_entry(name)
 
 
-def read_entry(name, meta=".meta.yaml"):
+def read_entry(name, meta=DEFAULT_META):
     """Reads a Bark Entry from a directory.
 
     Args:
@@ -441,7 +462,7 @@ def read_entry(name, meta=".meta.yaml"):
     # datasets are lazily loaded by creating a dictionary
     # with the dataset name and a function, that when called
     # loads the data. See the custom LazyDict data structure
-    datasets = LazyDict({name: ft.partial(read_dataset, fname=full_name)
+    datasets = _LazyDict({name: ft.partial(read_dataset, fname=full_name)
                 for name, full_name in zip(dset_names, dset_full_names)})
     return Entry(datasets, path, attrs)
 

bark/io/arf2bark.py

@@ -8,9 +8,12 @@
 import numpy
 import collections as coll
 
+ENTRY_PREFIX = 'entry'
+
 def _parse_args(raw_args):
     desc = 'Unspool an HDF5 ARF file into a Bark tree.'
-    parser = argparse.ArgumentParser(description=desc)
+    epi = 'Fails if bark_root already exists.'
+    parser = argparse.ArgumentParser(description=desc, epilog=epi)
     parser.add_argument('-v',
                         '--verbose',
                         help='increase output verbosity',
@@ -19,8 +22,12 @@ def _parse_args(raw_args):
                         '--timezone',
                         help='timezone for data, tz database format (default is "America/Chicago")',
                         default=None)
+    parser.add_argument('-m',
+                        '--mangle-prefix',
+                        help='prefix for names which collide with bark function arguments (default: {})'.format(ENTRY_PREFIX),
+                        default=ENTRY_PREFIX)
     parser.add_argument('arf_file', help='ARF file to convert')
-    parser.add_argument('root_parent', help='directory in which to place the Bark Root')
+    parser.add_argument('bark_root', help='location of new bark root')
     return parser.parse_args(raw_args)
 
 def copy_attrs(attrs):
@@ -30,11 +37,8 @@ def copy_attrs(attrs):
     na.update({k: v.decode() for k,v in na.items() if isinstance(v, bytes)})
     return na
 
-def arf2bark(arf_file, root_parent, timezone, verbose):
+def arf2bark(arf_file, root_path, timezone, verbose, mangle_prefix=ENTRY_PREFIX):
     with arf.open_file(arf_file, 'r') as af:
-        # root
-        root_dirname = os.path.splitext(arf_file)[0]
-        root_path = os.path.join(os.path.abspath(root_parent), root_dirname)
         os.mkdir(root_path)
         root = bark.Root(root_path)
         if verbose:
@@ -45,6 +49,21 @@ def arf2bark(arf_file, root_parent, timezone, verbose):
             if isinstance(entry, h5py.Group): # entries
                 entry_path = os.path.join(root_path, ename)
                 entry_attrs = copy_attrs(entry.attrs)
+                for pos_arg in ('name', 'parents'):
+                    # along with 'timestamp' below, these are positional arguments to create_entry
+                    # for now, I prefer hard-coding them over messing with runtime introspection
+                    new_name = pos_arg
+                    while new_name in entry_attrs:
+                        new_name = '{}_{}'.format(mangle_prefix, new_name)
+                    try:
+                        entry_attrs[new_name] = entry_attrs.pop(pos_arg)
+                    except KeyError:
+                        pass
+                    else:
+                        if verbose:
+                            print('Renamed attribute {} of entry {} to {}'.format(pos_arg,
+                                                                                  ename,
+                                                                                  new_name))
                 timestamp = entry_attrs.pop('timestamp')
                 if timezone:
                     timestamp = bark.convert_timestamp(timestamp, timezone)
@@ -62,10 +81,13 @@ def arf2bark(arf_file, root_parent, timezone, verbose):
                     else:
                         transfer_dset(ds_name, dataset, entry_path, verbose)
             elif isinstance(entry, h5py.Dataset): # top-level datasets
-                if tle is None:
-                    path = os.path.join(root_path, 'top_level')
-                    tle = bark.create_entry(path, 0, parents=False).path
-                transfer_dset(ename, entry, tle, verbose)
+                if arf.is_time_series(entry) or arf.is_marked_pointproc(entry):
+                    if tle is None:
+                        path = os.path.join(root_path, 'top_level')
+                        tle = bark.create_entry(path, 0, parents=False).path
+                    transfer_dset(ename, entry, tle, verbose)
+                else:
+                    unknown_ds_warning(ename) # and skip, w/o creating TLE
         if found_trigin:
             print('Warning: found datasets named "trig_in". Jill-created ' +
                   '"trig_in" datasets segfault when read, so these datasets' +
@@ -84,6 +106,10 @@ def build_columns(units, column_names=None):
         d.update({k: None for k,v in d.items() if (k == 'units' and v == '')})
     return cols
 
+def unknown_ds_warning(ds_name):
+    print('Warning: unknown dataset type - neither time series nor point' +
+          ' process. Skipping dataset ' + ds_name)
+
 def transfer_dset(ds_name, ds, e_path, verbose=False):
     ds_attrs = copy_attrs(ds.attrs)
     units = ds_attrs.pop('units', None)
@@ -107,12 +133,11 @@ def transfer_dset(ds_name, ds, e_path, verbose=False):
         if verbose:
             print('Created event dataset: ' + ds_path)
     else:
-        print('Warning: unknown dataset type - neither time series nor point' +
-              ' process. Skipping dataset ' + ds_name)
+        unknown_ds_warning(ds_name)
 
 def _main():
     args = _parse_args(sys.argv[1:])
-    arf2bark(args.arf_file, args.root_parent, args.timezone, args.verbose)
+    arf2bark(args.arf_file, args.bark_root, args.timezone, args.verbose, args.mangle_prefix)
 
 if __name__ == '__main__':
     _main()

bark/io/datfromwav.py

@@ -0,0 +1,40 @@
+from scipy.io import wavfile
+import bark, os
+
+
+def dat_from_wav(wav, barkname, **attrs):
+    rate, data = wavfile.read(wav)
+    return bark.write_sampled(barkname, data, rate,**attrs)
+
+
+def _main():
+    ''' Function for getting commandline args.'''
+
+    import argparse
+
+    p = argparse.ArgumentParser(description='''
+    converts wav file to bark format
+        ''')
+    p.add_argument('wav', help='path to wav file')
+    p.add_argument('out', help="path to bark file")
+    p.add_argument("-a",
+        "--attributes",
+        action='append',
+        type=lambda kv: kv.split("="),
+        dest='keyvalues',
+        help="extra metadata in the form of KEY=VALUE")
+
+    args = p.parse_args()
+
+    if args.keyvalues:
+        dat_from_wav(args.wav,
+               args.out,
+               **dict(args.keyvalues))
+    else:
+        dat_from_wav(args.wav, args.out)
+
+
+
+
+if __name__ == '__main__':
+    _main()