Merge pull request #35 from computational-metabolomics/new_tags_behaviour

Add new tags behaviour

Author: RJMW

dimspy/__main__.py

@@ -224,7 +224,7 @@ def main():
                            action='store_true', required=False,
                            help="Remove blank samples from peak matrix.")
 
-    parser_bf.add_argument('-a', '--class-labels',
+    parser_bf.add_argument('-a', '--labels',
                            type=str, required=False,
                            help="Tab delimited file with at least two columns named 'filename' and 'classLabel'.")
 
@@ -257,7 +257,7 @@ def main():
                            default=None, type=str, required=False,
                            help="Class label for QCs")
 
-    parser_sf.add_argument('-a', '--class-labels',
+    parser_sf.add_argument('-a', '--labels',
                            type=str, required=False,
                            help="Tab delimited file with at least two columns named 'filename' and 'classLabel'.")
 
@@ -470,7 +470,7 @@ def main():
                                    min_fold_change=args.min_fold_change,
                                    function=args.function,
                                    rm_samples=args.remove_blank_samples,
-                                   class_labels=args.class_labels)
+                                   labels=args.labels)
         hdf5_portal.save_peak_matrix_as_hdf5(pm_bf, args.output)
 
     elif args.step == "sample-filter":
@@ -479,7 +479,7 @@ def main():
                                     within=args.within,
                                     rsd=args.rsd_threshold,
                                     qc_label=args.qc_label,
-                                    class_labels=args.class_labels)
+                                    labels=args.labels)
         hdf5_portal.save_peak_matrix_as_hdf5(pm_sf, args.output)
 
     elif args.step == "mv-sample-filter":
@@ -545,9 +545,11 @@ def main():
         tools.hdf5_peaklists_to_txt(args.input, path_out=args.output, delimiter=map_delimiter(args.delimiter))
 
     elif args.step == "create-sample-list":
-        pls = hdf5_portal.load_peaklists_from_hdf5(args.input)
-        tools.create_sample_list(pls, args.output, delimiter=map_delimiter(args.delimiter))
-
+        try:
+            inp = hdf5_portal.load_peaklists_from_hdf5(args.input)
+        except:
+            inp = hdf5_portal.load_peak_matrix_from_hdf5(args.input)
+        tools.create_sample_list(inp, args.output, delimiter=map_delimiter(args.delimiter))
 
 if __name__ == "__main__":
     main()

dimspy/experiment.py

@@ -175,7 +175,7 @@ def check_metadata(fn_tsv):
     return fm_dict
 
 
-def update_metadata(peaklists, fl):
+def update_metadata_and_labels(peaklists, fl):
 
     if not isinstance(peaklists[0], PeakList):
         raise IOError("PeakList object required")
@@ -189,34 +189,16 @@ def update_metadata(peaklists, fl):
             pl.metadata[k] = fl[k][index]
             #pl.metadata["filelist"] = {k:fl[k][index] for k in fl.keys()}
 
-            if "classLabel" in fl.keys():
-                if pl.tags.has_tag_type("classLabel"):
-                    pl.tags.drop_tag_types("classLabel")
-                pl.tags.add_tags(classLabel=fl["classLabel"][index])
-
-            if "batch" in fl.keys():
-                if pl.tags.has_tag_type("batch"):
-                    pl.tags.drop_tag_types("batch")
-                pl.tags.add_tags(batch=fl["batch"][index])
+            for tag_name in ["replicate", "replicates", "batch", "injectionOrder", "classLabel"]:
+                if tag_name in fl.keys():
+                    if pl.tags.has_tag_type(tag_name):
+                        pl.tags.drop_tag_type(tag_name)
+                    pl.tags.add_tag(fl[tag_name][index], tag_name)
 
     return peaklists
 
 
-def copy_metadata(peak_list, peak_list_out, labels=None):
-    if not isinstance(peak_list, PeakList) or not isinstance(peak_list_out, PeakList):
-        raise IOError("PeakList object required")
-    for k, v in peak_list.metadata.items():
-        if labels is None:
-            peak_list_out.metadata[k] = v
-        elif k in labels:
-            peak_list_out.metadata[k] = v
-
-    peak_list_out.tags.add_tags(*peak_list.tags.tag_of(None),
-                                **{t: peak_list.tags.tag_of(t) for t in peak_list.tags.tag_types})
-    return peak_list
-
-
-def update_class_labels(pm, fn_tsv):
+def update_labels(pm, fn_tsv):
 
     assert os.path.isfile(fn_tsv.encode('string-escape')), "{} does not exist".format(fn_tsv)
 
@@ -228,17 +210,12 @@ def update_class_labels(pm, fn_tsv):
     assert "classLabel" in fm.dtype.names, "Column for class label (classLabel) not available"
     assert (fm[fm.dtype.names[0]] == pm.peaklist_ids).all(), "Sample ids do not match {}".format(np.setdiff1d(fm[fm.dtype.names[0]], pm.peaklist_ids))
 
-    for i in range(len(fm["classLabel"])):
-        if pm.peaklist_tags[i].has_tag_type("classLabel"):
-            pm.peaklist_tags[i].drop_tag_types("classLabel")
-            pm.peaklist_tags[i].add_tags(classLabel=fm["classLabel"][i])
-
-    if "batch" in fm.keys():
-        for i in range(len(fm["batch"])):
-            if pm.peaklist_tags[i].has_tag_type("batch"):
-                pm.peaklist_tags[i].drop_tag_types("batch")
-                pm.peaklist_tags[i].add_tags(batch=fm["batch"][i])
-
+    for tag_name in ["replicate", "replicates", "batch", "injectionOrder", "classLabel"]:
+        if tag_name in fm.dtype.names:
+            for i in range(len(fm[tag_name])):
+                if pm.peaklist_tags[i].has_tag_type(tag_name):
+                    pm.peaklist_tags[i].drop_tag_type(tag_name)
+                pm.peaklist_tags[i].add_tag(fm[tag_name][i], tag_name)
     return pm
 
 

dimspy/models/peak_matrix.py

@@ -16,6 +16,7 @@
 import numpy as np
 from collections import OrderedDict, Iterable
 from string import join
+from peaklist_tags import Tag
 from peaklist import PeakList
 
 
@@ -204,21 +205,21 @@ def peaklist_tag_types(self):
         Property of the source peaklist tag types.
 
         :getter: returns a tuple including the types of the typed tags of the source peaklists
-        :type: tuple
+        :type: set
 
         """
-        return tuple(set(reduce(lambda x, y: x + y, [t.tag_types for t in self.peaklist_tags], ())))
+        return reduce(lambda x,y: x.union(y), map(lambda x: x.tag_types, self.peaklist_tags))
 
     @property
     def peaklist_tag_values(self):
         """
         Property of the source peaklist tag values.
 
         :getter: returns a tuple including the values of the source peaklists tags, both typed and untyped
-        :type: tuple
+        :type: set
 
         """
-        return tuple(set(reduce(lambda x, y: x + y, [t.tag_values for t in self.peaklist_tags], ())))
+        return reduce(lambda x,y: x.union(y), map(lambda x: x.tag_values, self.peaklist_tags))
 
     @property
     def shape(self):
@@ -398,8 +399,8 @@ def rsd(self, *args, **kwargs):
         """
         Calculates relative standard deviation (RSD) array.
 
-        :param args: untyped tag label for RSD calculation, no value = calculate over all samples
-        :param kwargs: typed tag label for RSD calculation, , no value = calculate over all samples
+        :param args: tags or untyped tag values for RSD calculation, no value = calculate over all samples
+        :param kwargs: typed tags for RSD calculation, , no value = calculate over all samples
         :param flagged_only: whether to calculate on flagged peaks only. Default = True
         :type: numpy array
 
@@ -437,19 +438,19 @@ def tags_of(self, tag_type=None):
         :param tag_type: the type of the returning tags. Provide None to obtain untyped tags
         :rtype: tuple
 
-        """        
-        if not (tag_type is None or all(map(lambda x: x.has_tag_type(tag_type), self.peaklist_tags))):
-            raise ValueError('not all samples has tag type [%s]' % tag_type)
-        tlst = [t.tag_of(tag_type) for t in self.peaklist_tags]
+        """
+        if any(map(lambda x: not x.has_tag_type(tag_type), self.peaklist_tags)):
+            raise KeyError('not all samples has tag type [%s]' % tag_type)
+        tlst = filter(lambda x: x is not None, [t.tag_of(tag_type) for t in self.peaklist_tags])
         if tag_type is None: tlst = reduce(lambda x, y: x + y, tlst)
-        return tuple(set(tlst))
+        return reduce(lambda x, y: x + ((y,) if y not in x else ()), tlst, ())
 
     def mask_tags(self, *args, **kwargs):  # match to all
         """
         Masks samples with particular tags.
 
-        :param args: target tag values, both typed and untyped
-        :param kwargs: target typed tag types and values
+        :param args: tags or untyped tag values for masking
+        :param kwargs: typed tags for masking
         :param override: whether to override the current mask, default = False
         :rtype: PeakMatrix object (self)
 
@@ -462,17 +463,19 @@ def mask_tags(self, *args, **kwargs):  # match to all
 
         """            
         override = kwargs.pop('override') if kwargs.has_key('override') else False
+        if any(map(lambda x: isinstance(x, Tag), kwargs.values())):
+            logging.warning('setting additional type for Tag object in kwargs will be ignored')
         mask = map(lambda x: all(map(lambda t: x.has_tag(t), args)) and
-                             all(map(lambda t: x.has_tag(**dict([t])), kwargs.items())), self._tags)
+                             all(map(lambda t: x.has_tag(t[1], tag_type = t[0]), kwargs.items())), self._tags)
         self.mask = np.logical_or(False if override else self._mask, mask)
         return self
 
     def unmask_tags(self, *args, **kwargs):  # match to all
         """
         Unmasks samples with particular tags.
 
-        :param args: target tag values, both typed and untyped
-        :param kwargs: target typed tag types and values
+        :param args: tags or untyped tag values for unmasking
+        :param kwargs: typed tags for unmasking
         :param override: whether to override the current mask, default = False
         :rtype: PeakMatrix object (self)
 
@@ -486,8 +489,10 @@ def unmask_tags(self, *args, **kwargs):  # match to all
 
         """                
         override = kwargs.pop('override') if kwargs.has_key('override') else False
+        if any(map(lambda x: isinstance(x, Tag), kwargs.values())):
+            logging.warning('setting additional type for Tag object in kwargs will be ignored')
         mask = map(lambda x: not (all(map(lambda t: x.has_tag(t), args)) and
-                                  all(map(lambda t: x.has_tag(**dict([t])), kwargs.items()))), self._tags)
+                                  all(map(lambda t: x.has_tag(t[1], tag_type = t[0]), kwargs.items()))), self._tags)
         self.mask = np.logical_and(True if override else self._mask, mask)
         return self
 
@@ -757,21 +762,22 @@ def to_str(self, attr_name='intensity', delimiter='\t', samples_in_rows=True, co
              [map(str, ln) for ln in self.attr_matrix(attr_name, flagged_only = not comprehensive).T]
 
         if comprehensive:
-            ttypes = set(reduce(lambda x, y: x + y, map(lambda x: x.tag_types, self.peaklist_tags)))
+            ttypes = self.peaklist_tag_types
+            if None in ttypes: ttypes.remove(None)
             tnum = len(ttypes)
             hd = [hd[0]] + ['missing values'] + map(lambda x: 'tags_' + x, ttypes) + ['tags_untyped'] + hd[1:]
             dm = [dm[0]] + \
                  [map(str, self.missing_values)] + \
-                 [map(lambda x: str(x.tag_of(t)) if x.has_tag_type(t) else '', self.peaklist_tags) for t in ttypes] + \
-                 [map(lambda x: join(map(str, x.tag_of(None)), ';'), self.peaklist_tags)] + \
+                 [map(lambda x: (lambda v: str(v.value) if v else '')(x.tag_of(t)), self.peaklist_tags) for t in ttypes] + \
+                 [map(lambda x: join((lambda v: map(str,v) if v else ())(x.tag_of(None)), ';'), self.peaklist_tags)] + \
                  dm[1:]
 
             rsd_tags = tuple(rsd_tags) if isinstance(rsd_tags, Iterable) else (rsd_tags,)
 
             prelst = ['present']    + ([''] * (tnum + 2)) + map(str, self.property('present', flagged_only = False))
             ocrlst = ['occurrence'] + ([''] * (tnum + 2)) + map(str, self.property('occurrence', flagged_only = False))
             puplst = ['purity']     + ([''] * (tnum + 2)) + map(str, self.property('purity', flagged_only = False))
-            rsdmtx = [['rsd_' + rt] + ([''] * (tnum + 2)) + map(str, self.rsd(rt, flagged_only = False)) for rt in rsd_tags]
+            rsdmtx = [['rsd_' + str(rt.value if isinstance(rt, Tag) else rt)] + ([''] * (tnum + 2)) + map(str, self.rsd(rt, flagged_only = False)) for rt in rsd_tags]
             rsdlst = ['rsd_all']    + ([''] * (tnum + 2)) + map(str, self.rsd(flagged_only = False))
             flgmtx = [[fn] + ([''] * (tnum + 2)) + map(str, self.flag_values(fn).astype(int)) for fn in self.flag_names]
             flglst = ['flags']      + ([''] * (tnum + 2)) + map(str, self.flags.astype(int))
@@ -806,13 +812,13 @@ class mask_peakmatrix:
 
     def __init__(self, pm, *args, **kwargs):
         self._pm = pm
-        self._utags = args
-        self._ttags = kwargs
-        if not self._ttags.has_key('override'): self._ttags['override'] = True  # default for with statement
+        self._args = args
+        self._kwargs = kwargs
+        if not self._kwargs.has_key('override'): self._kwargs['override'] = True  # default for with statement
         self._oldmask = dict(zip(pm._pids, pm._mask))
 
     def __enter__(self):
-        self._pm.mask_tags(*self._utags, **self._ttags)
+        self._pm.mask_tags(*self._args, **self._kwargs)
         return self._pm
 
     def __exit__(self, exc_type, exc_val, exc_tb):
@@ -843,13 +849,13 @@ class unmask_peakmatrix:
 
     def __init__(self, pm, *args, **kwargs):
         self._pm = pm
-        self._utags = args
-        self._ttags = kwargs
-        if not self._ttags.has_key('override'): self._ttags['override'] = True  # default for with statement
+        self._args = args
+        self._kwargs = kwargs
+        if not self._kwargs.has_key('override'): self._kwargs['override'] = True  # default for with statement
         self._oldmask = dict(zip(pm._pids, pm._mask))
 
     def __enter__(self):
-        self._pm.unmask_tags(*self._utags, **self._ttags)
+        self._pm.unmask_tags(*self._args, **self._kwargs)
         return self._pm
 
     def __exit__(self, exc_type, exc_val, exc_tb):