config overhaul

theano/__init__.py

@@ -24,6 +24,11 @@ To learn more, check out:
 """
 
 __docformat__ = "restructuredtext en"
+
+import configparser, configdefaults
+
+config = configparser.TheanoConfigParser()
+
 import gof
 
 from gof import \
@@ -63,14 +68,7 @@ import gof
 import floatX
 floatX.set_floatX()
 
-import config
-
-#if THEANO_GPU not defined: don't automaticcaly importe cuda
-#if THEANO_GPU defined to something else then "": automatically import cuda
-#   he will init cuda automatically if THEANO_GPU is not -1 or GPU
-#if cuda.use() and THEANO_GPU not defined or defined to "": init to device 0.
-#if THEANO_GPU defined to "-1" or "CPU", automatically import cuda, but don't init it.
-if config.THEANO_GPU not in [None,""]:
+if config.device.startswith('gpu'):
     import theano.sandbox.cuda
 
 ## import scalar_opt

theano/compile/debugmode.py

@@ -11,7 +11,7 @@ from theano.gof import Env, graph, utils, link
 from theano.gof.link import WrapLinkerMany, raise_with_op
 #from theano.gof.cutils import run_cthunk
 from theano.gof.cc import OpWiseCLinker, CLinker
-import theano.config as config
+from ..configparser import config
 from theano.compile.function_module import (FunctionMaker,
         Function, 
         infer_reuse_pattern,
@@ -1375,27 +1375,27 @@ class DebugMode(Mode):
 
     """
 
-    stability_patience = config.THEANO_DEBUGMODE_PATIENCE
+    stability_patience = config.DebugMode.patience
     """
     When checking for the stability of optimization, recompile the graph this many times.
     """
 
-    check_c_code = config.THEANO_DEBUGMODE_CHECK_C
+    check_c_code = config.DebugMode.check_c
     """
     Should we evaluate (and check) the `c_code` implementations?
     """
 
-    check_py_code = config.THEANO_DEBUGMODE_CHECK_PY
+    check_py_code = config.DebugMode.check_py
     """
     Should we evaluate (and check) the `perform` implementations?
     """
 
-    check_isfinite = config.THEANO_DEBUGMODE_CHECK_FINITE
+    check_isfinite = config.DebugMode.check_finite
     """
     Should we check for (and complain about) NaN/Inf ndarray elements?
     """
 
-    require_matching_strides = config.THEANO_DEBUGMODE_CHECK_STRIDES
+    require_matching_strides = config.DebugMode.check_strides
     """
     Should we check for (and complain about) Ops whose python and C outputs are ndarrays with
     different strides? (This can catch bugs, but is generally overly strict.) 0 no check, 1 warn, 2 err.

theano/compile/mode.py

@@ -4,7 +4,7 @@ import os, logging
 
 import numpy
 from theano import gof
-import theano.config as config
+from ..configparser import config
 
 _logger = logging.getLogger('theano.compile.mode')
 
@@ -225,7 +225,7 @@ predefined_modes = {'FAST_COMPILE': FAST_COMPILE,
 # is not set, it will default to 'FAST_RUN'
 # keep default_mode.optimizer==default_optimizer and default_mode.linker==default_linker!
 ##
-default_mode = config.THEANO_DEFAULT_MODE
+default_mode = config.mode
 
 def get_mode(string):
     if string is None: string = default_mode

theano/compile/profilemode.py

@@ -6,7 +6,7 @@ from theano.compile.mode import Mode, register_mode, predefined_modes, predefine
 from theano.gof.cc import OpWiseCLinker
 from theano.gof.python25 import any
 from theano import gof
-import theano.config as config
+from ..configparser import config
 
 import_time = time.time()
 
@@ -83,8 +83,8 @@ class ProfileMode(Mode):
         self._optimizer = optimizer
 
     def print_summary(self, 
-                      n_apply_to_print=config.config.getint("ProfileMode.n_apply_to_print", None),
-                      n_ops_to_print=config.config.getint("ProfileMode.n_ops_to_print", None)):
+                      n_apply_to_print=config.ProfileMode.n_apply_to_print,
+                      n_ops_to_print=config.ProfileMode.n_ops_to_print):
         """ Print 3 summary that show where the time is spend. The first show an Apply-wise summary, the second show an Op-wise summary, the third show an type-Op-wise summary.
 
         The Apply-wise summary print the timing information for the worst offending Apply nodes. This corresponds to individual Op applications within your graph which take the longest to execute (so if you use dot twice, you will see two entries there). 

theano/floatX.py

 """Provide xscalar, xvector, xmatrix, etc. pseudo-types 
 """
-import theano.config as config
+from .configparser import config
 from theano.scalar import float64, float32
 from theano.tensor import (fscalar, fvector, fmatrix, frow, fcol, ftensor3, ftensor4, dscalar,
         dvector, dmatrix, drow, dcol, dtensor3, dtensor4)

theano/gof/cmodule.py

@@ -2,7 +2,7 @@
 """
 import os, tempfile, StringIO, sys, logging, subprocess, cPickle, atexit, time, shutil, stat
 import distutils.sysconfig
-import theano.config as config
+from theano.configparser import config
 import numpy.distutils #TODO: TensorType should handle this
 
 import compilelock # we will abuse the lockfile mechanism when reading and writing the registry
@@ -515,7 +515,7 @@ class ModuleCache(object):
 
 def _rmtree(parent):
     try:
-        if not config.THEANO_NOCLEANUP:
+        if not config.nocleanup:
             shutil.rmtree(parent)
     except Exception, e:
         try:

theano/gof/compiledir.py

@@ -4,7 +4,7 @@ import os
 import platform
 import re
 
-import theano.config as config
+from ..configparser import config
 
 def set_compiledir(path=None):
     """Set the directory into which theano will compile code objects
@@ -27,15 +27,15 @@ def set_compiledir(path=None):
 
     if path is None:
         # we need to set the default, which can come from one of two places
-        if config.THEANO_COMPILEDIR:
-            path = config.THEANO_COMPILEDIR
+        if config.compiledir:
+            path = config.compiledir
         else:
             platform_id = platform.platform() + '-' + platform.processor()
             platform_id = re.sub("[\(\)\s]+", "_", platform_id)
-            if config.THEANO_BASE_COMPILEDIR:
-                base = config.THEANO_BASE_COMPILEDIR
+            if config.base_compiledir:
+                base = config.base_compiledir
             else:
-                base = os.path.join(config.HOME,'.theano')
+                base = os.path.join(config.home,'.theano')
             path = os.path.join(base, 'compiledir_'+platform_id)
 
     if not os.access(path, os.R_OK | os.W_OK):

theano/scalar/basic.py

@@ -7,7 +7,7 @@ import numpy
 from theano import gof
 from theano.gof import Op, utils, Variable, Constant, Type, Apply, Env
 from theano.gof.python25 import partial, all, any
-import theano.config as config
+from ..configparser import config
 
 def upcast(dtype, *dtypes):
     z = numpy.zeros((), dtype = dtype)
@@ -77,18 +77,18 @@ class Scalar(Type):
 
     def c_headers(self):
         l=['<math.h>']
-        if config.config.getboolean('lib.amdlibm'):
+        if config.lib.amdlibm:
             l+=['<amdlibm.h>']
         return l
 
     def c_libraries(self):
         l=[]
-        if config.config.getboolean('lib.amdlibm'):
+        if config.lib.amdlibm:
             l+=['amdlibm']
         return l
 
     def c_compile_args(self):
-        if config.config.getboolean('lib.amdlibm'):
+        if config.lib.amdlibm:
             return ['-DREPLACE_WITH_AMDLIBM']
         else: return []
 

theano/tensor/basic.py

@@ -4,7 +4,7 @@ __docformat__ = "restructuredtext en"
 
 import __builtin__
 import sys # for sys.maxint
-import theano.config as config  # for THEANO_CMP_SLOPPY
+from ..configparser import config
 import traceback #for overriding Op.__call__
 if sys.version_info >= (2,5):
   import functools
@@ -260,7 +260,7 @@ def _wrap_tensor_into_member(x):
     return compile.module.Member(constant(x))
 compile.module.register_wrapper(_obj_is_wrappable_as_tensor, _wrap_tensor_into_member)
 
-if int(config.THEANO_CMP_SLOPPY)>1:
+if int(config.tensor.cmp_sloppy)>1:
     # This environment variable is a quick-and-dirty way to get low-precision comparisons.
     # For a more precise setting of these tolerances set them explicitly in your user code by
     # assigning, for example, "theano.tensor.basic.float32_atol = ..."
@@ -270,7 +270,7 @@ if int(config.THEANO_CMP_SLOPPY)>1:
     float32_rtol = 1e-3 
     float64_rtol = 1e-4
     float64_atol = 1e-3
-elif int(config.THEANO_CMP_SLOPPY):
+elif int(config.tensor.cmp_sloppy):
     float32_atol = 1e-4
     float32_rtol = 1e-3 
     float64_rtol = 1e-4

theano/tensor/blas.py

@@ -2,7 +2,7 @@
 
 import sys, traceback, logging
 import numpy
-import theano.config as config
+from ..configparser import config
 from theano.gof import (utils, Op, Apply, view_roots, PatternSub, DestroyHandler, 
         SeqOptimizer, local_optimizer, Optimizer, LocalOptimizer, OpKeyOptimizer, 
         InconsistencyError, toolbox)
@@ -33,7 +33,7 @@ def ldflags(libs=True, flags=False):
     Default: ['blas'], but environment variable THEANO_BLAS_LDFLAGS overrides this.
     """
     rval = []
-    for t in config.THEANO_BLAS_LDFLAGS.split():
+    for t in config.blas.ldflags.split():
         try:
             t0, t1, t2 = t[0:3]
             assert t0 == '-'

theano/tensor/opt.py

@@ -9,7 +9,7 @@ _logger = logging.getLogger('theano.tensor.opt')
 from theano import gof
 from theano.gof import opt, InconsistencyError, TopoOptimizer, graph
 from theano.gof.utils import MethodNotDefined
-import theano.config as config
+from ..configparser import config
 from elemwise import Elemwise, DimShuffle
 from theano import scalar
 import basic as T
@@ -1467,7 +1467,7 @@ class FusionOptimizer(Optimizer):
                         pass
 
 
-if config.config.getboolean('tensor_opt.local_elemwise_fusion'):
+if config.tensor.local_elemwise_fusion:
     _logger.debug("enabling optimization fusion elemwise in fast_run")
     compile.optdb.register('elemwise_fusion', FusionOptimizer(), 71.00, 'fast_run', 'fusion', 'local_elemwise_fusion')
 else:

theano/tests/unittest_tools.py

 import unittest
 import numpy
 import theano.tensor as T
-import theano.config as config
+from ..configparser import config, AddConfigVar, IntParam
 import os, sys
 
+AddConfigVar('unittests.rseed',
+        "Seed to use for randomized unit tests",
+        IntParam(666))
+
 def fetch_seed(pseed=None):
     """
     Returns the seed to use for running the unit tests.
@@ -17,7 +21,7 @@ def fetch_seed(pseed=None):
     >>> rng = numpy.random.RandomState(unittest_tools.fetch_seed())
     """
      
-    seed = pseed or config.THEANO_UNITTEST_SEED
+    seed = pseed or config.unittests.rseed
     if seed=='random':
       seed = None
     #backport