Merge branch 'project'

Conflicts:
	doc/conf.py

Author: Stéphane Sénési

.gitignore

@@ -9,3 +9,4 @@ examples/.ipynb_checkpoints
 /doc/_build
 /README.html
 /doc/climaf.log
+climaf.log

bin/climaf

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+# Wrapper for launching Python while letting it import climaf.api
+# either interactively or on a series of files
+
+# No python launch flag is allowed
+
+# We assume this script is located in a subdir of climaf  installation dir
+cdir=$(cd ..; pwd) 
+
+export PYTHONPATH=$PYTHONPATH:$cdir 
+
+if [ "$*" ] ; then 
+    (echo 'from climaf.api import *'; cat $*) | python 
+else
+    python -i -c 'from climaf.api import *'
+fi
+

climaf/api.py

@@ -3,20 +3,46 @@
 
 It also imports a few functions from other modules, and declares a number of 'CliMAF standard operators'
 
-Main functions are ``dataloc``, ``ds``, ``cdataset``, ``cdef``, ``cscript``, ``cfile``, ``cMA`` :
+Main functions are :
+
+- for data definition and access :
+
+ - ``cproject``: declare a project and its non-standard attributes/facets
+
  - ``dataloc`` : set data locations for a series of experiments
+
  - ``cdef``    : define some default values for datasets attributes
- - ``ds``      : define a dataset object
- - ``cscript`` : define a new CliMAF operator (this also defines a new Pyhton fucntion)
- - ``cfile``   : get the file         value of a CliMAF object (compute it)
+
+ - ``ds``      : define a dataset object (actually a front-end for ``cdataset``)
+
+ - ``derive``  : define a variable as computed from other variables
+
+- for processing the data 
+
+ - ``cscript`` : define a new CliMAF operator (this also defines a new Python function)
+
  - ``cMA``     : get the Masked Array value of a CliMAF object (compute it)
 
+- for managing/viewing results :
+
+ - ``cfile``   : get the file value of a CliMAF object (compute it)
+
+ - ``cshow``   : display a result of type 'figure'
 
-Utility functions are  ``clog``, ``cdump``, ``craz``, ``csave``:
- - ``clog``    : tune verbosity
  - ``cdump``   : tell what's in cache
+
+ - ``cdrop``   : delete the cached file for an object
+
  - ``craz``    : reset cache
- - ``csave``   : save cache index to disk
+
+ - ``csync``   : save cache index to disk
+
+
+- utility functions :
+
+ - ``clog``    : tune verbosity
+
+ - ``clog_file``    : tune verbosity for log file
 
 """
 # Created : S.Senesi - 2014
@@ -25,22 +51,44 @@
 import os, os.path, shutil, logging
 
 import climaf, climaf.cache
-from climaf.classes   import cdefault as cdef,cdataset,ds #,cperiod
-from climaf.driver    import ceval,varOf #,cfile,cobj 
+from climaf.classes   import cdef,cdataset,ds,cproject,cprojects 
+from climaf.driver    import ceval,varOf 
 from climaf.dataloc   import dataloc 
 from climaf.operators import cscript, scripts as cscripts, derive
-from climaf.cache     import creset as craz, csync as csave , cdump, cdrop
+from climaf.cache     import craz, csync as csave , cdump, cdrop
 from clogging         import clogger, clog, clog_file
 import climaf.standard_operators
+import climaf.standard_projects
+
+#########################
+# CliMAF init phase
+#########################
+
+Climaf_version="0.5"
 
-clog(logging.ERROR)
-clog_file(logging.ERROR)
 #: Path for the CliMAF package. From here, can write e.g. ``cpath+"../scripts"``. The value shown in the doc is not meaningful for your own CliMAF install
 cpath=os.path.abspath(climaf.__path__[0]) 
-climaf.cache.setNewUniqueCache("~/tmp/climaf_cache")
+
+# Set default logging levels
+clog(os.getenv("CLIMAF_LOG_LEVEL","error"))
+clog_file(os.getenv("CLIMAF_LOGFILE_LEVEL","info"))
+
 climaf.standard_operators.load_standard_operators()
+climaf.standard_projects.init_standard_projects()
+from climaf.site_settings import onCiclad, atCNRM
+
+# Read user config file
+conf_file=os.path.expanduser("~/.climaf")
+if os.path.isfile(conf_file) : execfile(conf_file, {"Climaf_version":Climaf_version })
+
+# Decide for cache location
+climaf.cache.setNewUniqueCache(os.getenv("CLIMAF_CACHE","~/tmp/climaf_cache"))
+
 
+#########################
 # Commodity functions
+#########################
+
 def cfile(object,target=None,ln=None,deep=None) :
     """
     Provide the filename for a CliMAF object, or copy this file to target. Launch computation if needed. 
@@ -49,21 +97,28 @@ def cfile(object,target=None,ln=None,deep=None) :
       object (CliMAF object) : either a dataset or a 'compound' object (e.g. the result of a CliMAF operator)
       target (str, optional) : name of the destination file or link; CliMAF will anyway store the result
        in its cache; 
+
       ln (logical, optional) : if True, target is created as a symlink to the CLiMAF cache file
-      deep (logical, optional) : governs the use of cached values when computing the object
+
+      deep (logical, optional) : governs the use of cached values when computing the object:
       
         - if missing, or None : use cache as much as possible (speed up the computation)
+
         - False : make a shallow computation, i.e. do not use cached values for the 
           top level operation
+
         - True  : make a deep computation, i.e. do not use any cached value
 
     Returns: 
-      - if 'target' is provided : returns this filename if computation is successful ('target' contains the result), and None otherwise; 
+
+      - if 'target' is provided : returns this filename (or linkname) if computation is 
+        successful ('target' contains the result), and None otherwise; 
+
       - else : returns the filename in CliMAF cache, which contains the result (and None if failure)
 
 
     """
-    clogger.debug("cfile called on"+str(object))  
+    clogger.debug("cfile called on "+str(object))  
     result=climaf.driver.ceval(object,format='file',deep=deep)
     if target is None : return result
     else :
@@ -81,7 +136,7 @@ def cshow(obj) :
     For a figure object, this will lead to display it
     ( launch computation if needed. )
     """
-    clogger.debug("cshow called on"+str(obj)) #LV
+    clogger.debug("cshow called on "+str(obj)) 
     return climaf.driver.ceval(obj,format='MaskedArray')
 
 def  cMA(obj,deep=None) :
@@ -106,7 +161,7 @@ def cexport(*args,**kwargs) :
     """ Alias for climaf.driver.ceval. Create synonyms for arg 'format'
 
     """
-    clogger.debug("cexport called with arguments"+str(args))  #LV
+    clogger.debug("cexport called with arguments"+str(args))  
     if "format" in kwargs :
         if (kwargs['format']=="NetCDF" or kwargs['format']=="netcdf" or kwargs['format']=="nc") :
             kwargs['format']="file" 

climaf/cache.py

@@ -1,10 +1,14 @@
-""" CliMAF cache module : stores and retrieves CliMAF objects from their CRS expression.
+"""
+
+CliMAF cache module : stores and retrieves CliMAF objects from their CRS expression.
+
+
 
 """
 # Created : S.Senesi - 2014
 
 import sys, os, os.path, re, time
-from climaf.classes import compare_trees
+from climaf.classes import compare_trees, cobject, ctree, cdataset
 
 from clogging import clogger
 
@@ -24,7 +28,7 @@ def setNewUniqueCache(path) :
     crs2filename=dict()  # The index associating filenames to CRS expressions
     cacheIndexFileName = cachedirs[0]+"/index"  # The place to write the index
     currentCache=cachedirs[0]
-    creset(hideError=True)
+    craz(hideError=True)
 
 #def generateUniqueFileName(expression, operator=climaf.classes.firstGenericDataSet):
 def generateUniqueFileName(expression, operator=None, format="nc"):
@@ -68,7 +72,7 @@ def generateUniqueFileName(expression, operator=None, format="nc"):
             exit
         guess=full[0 : number - 1 ]
         existing=searchFile(prefix+stringToPath(guess, directoryNameLength )+"."+format)
-        readCRS=getCRS(existing)
+        if existing : readCRS=getCRS(existing)
     rep=currentCache+"/"+prefix+stringToPath(full[0 : number - 1 ], directoryNameLength )+"."+format
     rep=os.path.expanduser(rep)
     # Create the relevant directory, so that user scripts don't have to care
@@ -174,7 +178,7 @@ def hasMatchingObject(cobject,ds_func) :
     if len(crs2filename.keys()) == 0 : cload()
     def op_squeezes_time(operator):
         import operators
-        return operators.scripts[operator].flags.doSqueezeTime 
+        return not operators.scripts[operator].flags.commuteWithTimeConcatenation 
     #
     for crs in crs2filename :
         co=eval(crs, sys.modules['__main__'].__dict__)
@@ -221,10 +225,34 @@ def complement(crsb, crse, crs) :
         register(filet,crs)
         return filet
 
-def cdrop(crs, rm=True) :
-    """ Deletes a cached file for a given CliMAF Reference Syntax expression, if it exists
+def cdrop(obj, rm=True) :
+    """
+    Deletes the cached file for a CliMAF object, if it exists
 
-    Returns None if it does not exists, False if delete is unsuccessful, True if OK    """
+    Args :
+     obj (cobject or string) : object to delete, or its string representation (CRS)
+     rm (bool) : for advanced use only; should we actually delete (rm)  the file, or
+       just forget it in CliMAF cache index ?
+    
+    Returns : None if object does not exists, False if failing to delete, True if OK
+
+    Example ::
+
+    >>> dg=ds(project='example', experiment='AMIPV6ALB2G', variable='tas', period='1980-1981')
+    >>> dg
+    >>> cfile(dg)
+    '/home/senesi/tmp/climaf_cache/da/c.nc'
+    >>> os.system('ls -al '+f)
+    >>> cdrop(dg)    
+    """
+    if (type(obj) is ctree ) :
+        crs=cobject.crs
+        if (type(obj) is cdataset ) :
+            crs="select("+crs+")"
+    elif type(obj) is str : crs=obj
+    else :
+        clogger.error("%s is not a CliMAF object"%`obj`)
+        return
     if crs in crs2filename :
         clogger.info("discarding cached value for "+crs)
         try :
@@ -260,7 +288,7 @@ def cload() :
     except:
         clogger.debug("no index file yet")
 
-def creset(hideError=False) :
+def craz(hideError=False) :
     """
     Clear CliMAF cache : erase existing files content, reset in-memory index