Docstanya

Lib/MV2.py

@@ -109,11 +109,13 @@ def __call__(self, a, axis=0, **kwargs):
 
 def commonDomain(a, b, omit=None):
     """commonDomain(a,b) tests that the domains of variables/arrays a and b are equal,
-    and returns the common domain if equal, or None if not equal. The domains may
-    differ in that one domain may have leading axes not common
-    to the other; the result domain will contain those axes.
-    If <omit> is specified, as an integer i, skip comparison of the ith dimension
-    and return None for the ith (common) dimension.
+    and returns the common domain if equal, or None if not equal.
+
+       The domains may differ in that one domain may have leading axes not common
+       to the other; the result domain will contain those axes.
+
+       If <omit> is specified, as an integer i, skip comparison of the ith dimension
+       and return None for the ith (common) dimension.
     """
 
     if isinstance(b, AbstractVariable):
@@ -183,11 +185,11 @@ def commonGrid(a, b, axes):
     and consistent with the list of axes. If so, the common grid is returned, else None
     is returned. a and b can be numpy arrays, in which case the result is None.
 
-    The common grid is 'consistent' with axes if the grid axes (e.g., the axes of latitude and
-    longitude coordinate variables) are members of the list 'axes'.
+        The common grid is 'consistent' with axes if the grid axes (e.g., the axes of
+        latitude and longitude coordinate variables) are members of the list 'axes'.
 
-    If the grid(s) of a, b are rectilinear, the result is None, as the grids are implicitly
-    defined by the axes.
+        If the grid(s) of a, b are rectilinear, the result is None, as the grids
+        are implicitly defined by the axes.
     """
     if isinstance(b, AbstractVariable):
         gb = b.getGrid()
@@ -556,12 +558,15 @@ def sort(a, axis=-1):
 
 
 def choose(myindices, t):
-    """Returns an array shaped like indices containing elements chosen
-      from t.
-      If an element of t is the special element masked, any element
-      of the result that "chooses" that element is masked.
+    """
 
-      The result has only the default axes.
+    Returns
+    -------
+
+        an array shaped like indices containing elements chosen from t.
+        If an element of t is the special element masked, any element of
+        the result that "chooses" that element is masked. The result has
+        only the default axes.
     """
     maresult = numpy.ma.choose(myindices, list(map(_makeMaskedArg, t)))
     F = getattr(t, "fill_value", 1.e20)
@@ -580,8 +585,12 @@ def where(condition, x, y):
 
 
 def masked_where(condition, x, copy=1):
-    """Return x as an array masked where condition is true.
-       Also masked where x or condition masked.
+    """
+
+    Returns
+    -------
+
+         x as an array masked where condition is true. Also masked where x or condition masked.
     """
     tx = _makeMaskedArg(x)
     tcondition = _makeMaskedArg(condition)
@@ -766,6 +775,7 @@ def transpose(a, axes=None):
 
 
 class _minimum_operation:
+
     "Object to calculate minima"
 
     def __init__(self):
@@ -886,8 +896,13 @@ def outer(self, a, b):
 
 def asarray(data, typecode=None, dtype=None):
     """asarray(data, typecode=None, dtype=None) is equivalent to array(data, dtype=None, copy=0)
-       Returns data if dtype is None or data is a MaskedArray of the same dtype.
-       typecode arg is for backward compatibility.
+
+
+     Returns
+     -------
+
+          data if dtype is None or data is a MaskedArray of the same dtype.
+          typecode arg is for backward compatibility.
     """
     dtype = _convdtype(dtype, typecode)
     if isinstance(data, AbstractVariable) and (
@@ -939,7 +954,8 @@ def ones(myshape, typecode=float, savespace=0, axes=None,
 
 
 def outerproduct(a, b):
-    """outerproduct(a,b) = {a[i]*b[j]}, has shape (len(a),len(b))"""
+    """outerproduct(a,b) = {a[i]*b[j]}, has shape (len(a),len(b))
+    """
     ta = asVariable(a, writeable=1)
     tb = asVariable(b, writeable=1)
     maresult = numpy.ma.outerproduct(ta, tb)

Lib/avariable.py

@@ -36,17 +36,24 @@
 
 def getMinHorizontalMask(var):
     """
-    Get the minimum mask associated with 'x' and 'y' (i.e. with the
-    min number of ones) across all axes
+    Get the minimum mask associated with 'x' and 'y'
+    (i.e. with the min number of ones) across all axes
 
     Parameters
     ----------
-    var
-        CDMS variable with a mask
 
-    Return
-    ------
-        mask array or None if order 'x' and 'y' were not found
+    var :
+       CDMS variable with a mask
+
+    N/A :
+       None
+
+    Returns
+    -------
+
+    mask array or None :
+        if order 'x' and 'y' were not found
+
     """
     from distarray import MultiArrayIter
 
@@ -127,14 +134,21 @@ def getNumericCompatibility():
 
 
 class AbstractVariable(CdmsObj, Slab):
+    """Not to be called by users.
+
+    Parameters
+    ----------
+        variableNode
+            is the variable tree node, if any.
+        parent
+            is the containing dataset instance.
+    """
+
     def info(self, flag=None, device=None):
         Slab.info(self, flag, device)
 
     def __init__(self, parent=None, variableNode=None):
-        """Not to be called by users.
-           variableNode is the variable tree node, if any.
-           parent is the containing dataset instance.
-        """
+
         if variableNode is not None and variableNode.tag != 'variable':
             raise CDMSError('Node is not a variable node')
         CdmsObj.__init__(self, variableNode)
@@ -163,20 +177,20 @@ def __call__(self, *args, **kwargs):
         """
         Selection of a subregion using selectors.
 
-        Parameters
-        ----------
-        raw:
-            if set to 1, return numpy.ma only
-        squeeze:
-            if set to 1, eliminate any dimension of length 1
-        grid:
-            if given, result is regridded ont this grid.
-        order:
-            if given, result is permuted into this order
+        **Parameters:**
 
-        Returns
-        -------
-        Subregion selected
+            raw:
+                if set to 1, return numpy.ma only
+            squeeze:
+                if set to 1, eliminate any dimension of length 1
+            grid:
+                if given, result is regridded ont this grid.
+            order:
+                if given, result is permuted into this order
+
+        **Returns:**
+
+             Subregion selected
         """
         # separate options from selector specs
         d = kwargs.copy()
@@ -468,6 +482,10 @@ def getAxisListIndex(self, axes=None, omit=None, order=None):
            If axes is `None`, use all axes of this variable.
 
            Other specificiations are as for axisMatchIndex.
+
+        Returns
+        -------
+           a list of indices of axis objects;
         """
         return axisMatchIndex(self.getAxisList(), axes, omit, order)
 
@@ -521,7 +539,8 @@ def getMissing(self, asarray=0):
 
         if asarray == 0 and isinstance(mv, numpy.ndarray):
             mv = mv[0]
-        if isinstance(mv, string_types) and self.dtype.char not in ['?', 'c', 'O', 'S']:
+        if isinstance(mv, string_types) and self.dtype.char not in [
+                '?', 'c', 'O', 'S']:
             try:
                 mv = float(mv)
             except BaseException:
@@ -1426,7 +1445,8 @@ def _process_specs(self, specs, keys):
         nsupplied = len(specs)
         # numpy will broadcast if we have a new axis in specs
         # ---------------------------------------------------
-        if [x for x in specs if numpy.array_equal(x, numpy.newaxis)] == [numpy.newaxis]:
+        if [x for x in specs if numpy.array_equal(x, numpy.newaxis)] == [
+                numpy.newaxis]:
             nnewaxis = 1
         else:
             nnewaxis = 0
@@ -1713,8 +1733,13 @@ def __getitem__(self, key):
                 raise IndexError("Index too large: %d" % key)
             speclist = self._process_specs([key], {})
 
-        if [x for x in speclist if (type(x) is numpy.ndarray or type(x) is list)] != []:
-            index = [x for x in speclist if (type(x) is numpy.ndarray or type(x) is list)]
+        if [x for x in speclist if (isinstance(
+                x, numpy.ndarray) or isinstance(x, list))] != []:
+            index = [
+                x for x in speclist if (
+                    isinstance(
+                        x, numpy.ndarray) or isinstance(
+                        x, list))]
             return self.data.take(index)
         # Note: raw=0 ensures that a TransientVariable is returned
         return self.getSlice(numericSqueeze=1, raw=0, isitem=1, *speclist)
@@ -1823,14 +1848,15 @@ def astype(self, tc):
 
 def orderparse(order):
     """Parse an order string. Returns a list of axes specifiers.
-       Note
-       ----
-       Order elements can be:
-          * Letters t, x, y, z meaning time, longitude, latitude, level
-          * Numbers 0-9 representing position in axes
-          * The letter - meaning insert the next available axis here.
-          * The ellipsis ... meaning fill these positions with any remaining axes.
-          * (name) meaning an axis whose id is name
+
+       Note:
+
+           Order elements can be:
+              * Letters t, x, y, z meaning time, longitude, latitude, level
+              * Numbers 0-9 representing position in axes
+              * The letter - meaning insert the next available axis here.
+              * The ellipsis ... meaning fill these positions with any remaining axes.
+              * (name) meaning an axis whose id is name
     """
     if not isinstance(order, string_types):
         raise CDMSError('order arguments must be strings.')
@@ -1861,14 +1887,15 @@ def orderparse(order):
 def order2index(axes, order):
     """Find the index permutation of axes to match order.
        The argument order is a string.
-       Note
-       ----
-       Order elements can be:
-          * Letters t, x, y, z meaning time, longitude, latitude, level.
-          * Numbers 0-9 representing position in axes
-          * The letter - meaning insert the next available axis here.
-          * The ellipsis ... meaning fill these positions with any remaining axes.
-          * (name) meaning an axis whose id is name.
+
+       Note:
+
+           Order elements can be:
+              * Letters t, x, y, z meaning time, longitude, latitude, level.
+              * Numbers 0-9 representing position in axes
+              * The letter - meaning insert the next available axis here.
+              * The ellipsis ... meaning fill these positions with any remaining axes.
+              * (name) meaning an axis whose id is name.
     """
     if isinstance(order, string_types):
         result = orderparse(order)