Merge pull request #6 from UV-CDAT/metrics

done with cdp metrics.

Author: zshaheen

cdp/cdp_metric.py

@@ -5,13 +5,71 @@
 class CDPMetric(cdp.cdp_tool.CDPTool):
     __metaclass__ = abc.ABCMeta
 
-    def __init__(self, var, data1, data2):
-        self.var = var
-        self.data1 = data1
-        self.data2 = data2
+    def __init__(self, metric_path):
+        # metric_path: printed when this metric is used.
+        #  Let's users know when a metric is called in the code.
+        # _values: dictionary of the computed values. This allows for compound metrics.
+        self._metric_path = metric_path
+        # get the 'filename' from /path/to/filename.py
+        name_with_py = self._metric_path.split('/')[-1]
+        name = name_with_py.split('.')[0]
+        self._values = {name: self}
 
-    def __call__(self):
-        self.compute()
+    def __call__(self, *args, **kwargs):
+        self._show_metric_information()
+        if self._is_compound():
+            # Remove the 'CompoundMetric' key from the _values
+            self._values.pop('CompoundMetric')
+            # loop through and calculate all of the metrics
+            for key, value in self._values.items():
+                # replaces the function with the actual value
+                self._values[key] = value(*args, **kwargs)
+            return self._values
+        else:
+            return self.compute(*args, **kwargs)
+
+    def __add__(self, other):
+        class CompoundMetric(CDPMetric):
+            def compute(self):
+                pass
+        compound_metric = CompoundMetric('CompoundMetric')
+        self._add_values_dict_into_first(compound_metric, self)
+        self._add_values_dict_into_first(compound_metric, other)
+        return compound_metric
+
+    def __sub__(self, other):
+        class CompoundMetric(CDPMetric):
+            def compute(self):
+                pass
+        if not self._is_compound():
+            raise TypeError('First operand must be a CompoundMetric')
+        compound_metric = CompoundMetric('CompoundMetric')
+        self._add_values_dict_into_first(compound_metric, self)
+        self._subtract_values_dict_into_first(compound_metric, other)
+        return compound_metric
+
+    def _is_compound(self):
+        """ Determines if the current metric was a compound metric, one
+        created with the + operator. """
+        return len(self._values) > 1
+
+    def _add_values_dict_into_first(self, compound_metric, other_metric):
+        """ Merges the _values dict of two objects of type CDPMetric
+        into the first. """
+        for key, value in other_metric._values.items():
+            compound_metric._values[key] = value
+
+    def _subtract_values_dict_into_first(self, compound_metric, other_metric):
+        """ Removes the elements of the _values dict of the second
+        object from the first object's _values dict. """
+        for key in other_metric._values:
+            if compound_metric._values.pop(key, None) is None:
+                print "Could not subtract %s metric since it's not in the first operand." % key
+
+    def _show_metric_information(self):
+        """ Displays information about this metric so that a user
+        can easily identify what metrics are being used. """
+        print 'Using metric: ' + self._metric_path
 
     @abc.abstractmethod
     def compute(self):

cdp/test/test_cdp_metric.py

@@ -0,0 +1,65 @@
+import unittest
+import cdp.cdp_metric
+
+
+class TestCDPMetric(unittest.TestCase):
+
+    class Add(cdp.cdp_metric.CDPMetric):
+        def __init__(self):
+            metric_path = 'add'
+            super(TestCDPMetric.Add, self).__init__(metric_path)
+
+        def compute(self, a1, a2):
+            return a1 + a2
+
+    class Sub(cdp.cdp_metric.CDPMetric):
+        def __init__(self):
+            metric_path = 'sub'
+            super(TestCDPMetric.Sub, self).__init__(metric_path)
+
+        def compute(self, s1, s2):
+            return s1 - s2
+
+    def test_init_metric(self):
+        try:
+            sub = self.Sub()
+        except:
+            self.fail('Failed to initialize a variable of type Sub, a child type of CDPMetric.')
+
+    def test_compute(self):
+        try:
+            sub = self.Sub()
+            result = sub(2, 1)
+            self.assertEquals(result, 1)
+        except Exception as err:
+            self.fail('Failure during call compute(): %s' % err)
+
+    def test_add(self):
+        try:
+            sub = TestCDPMetric.Sub()
+            add = TestCDPMetric.Add()
+            new_metric = sub + add
+            result = new_metric(2, 1)
+            self.assertDictEqual(result, {'add':3, 'sub':1})
+        except Exception as err:
+            self.fail('Failure during metric addition: %s' % err)
+
+    def test_sub(self):
+        try:
+            sub = TestCDPMetric.Sub()
+            add = TestCDPMetric.Add()
+            compound_metric = sub + add
+            new_metric = compound_metric - sub
+            result = new_metric(2, 1)
+            self.assertDictEqual(result, {'add':3})
+        except Exception as err:
+            self.fail('Failure during metric subtraction: %s' % err)
+
+    def test_is_compound(self):
+        sub = TestCDPMetric.Sub()
+        add = TestCDPMetric.Add()
+        compound_metric = sub + add
+        self.assertTrue(compound_metric._is_compound())
+
+if __name__ == '__main__':
+    unittest.main()

conda/meta.yaml

@@ -4,10 +4,10 @@ about:
 
 package:
   name: cdp
-  version: '1.0.1'
+  version: '1.0.2'
 
 source:
-  git_rev: v1.0.1
+  git_rev: v1.0.2
   git_url: https://github.com/UV-CDAT/CDP.git
 
 requirements:

setup.py

@@ -2,10 +2,10 @@
 
 setup(
     name="cdp",
-    version="1.0.1",
+    version="1.0.2",
     author="Zeshawn Shaheen",
     author_email="[email protected]",
-    description="Framework for creating climate diagnostics.",
+    description="Framework for creating scientific diagnostics.",
     packages=find_packages(exclude=["*.test", "*.test.*", "test.*", "test"]),
     include_package_data=True
 )