Added context notion and used it in pickled_callable_wrapper.py

src/doc/API.rst

@@ -26,6 +26,10 @@ Functions
 .. autofunction:: callable_wrapper
 .. autofunction:: obfuscator
 .. autofunction:: store
+.. autofunction:: parsimony_directory
+.. autofunction:: context_name
+.. autofunction:: set_context
+
 
 
 

src/doc/index.rst

@@ -25,7 +25,7 @@ As a toy example, let's do some task that takes a few seconds twice in one sessi
 
    #nothing cached
    t0 = time.time()
-   x = parsimony.generators.PickledCallableWrapper('.parsimony/wrapped_results','x',pd.read_csv,filepath_or_buffer=path)
+   x = parsimony.generators.PickledCallableWrapper('x',pd.read_csv,filepath_or_buffer=path)
    t1 = time.time()
    print('Time taken {0:1.5f}s'.format(t1-t0))#nothing happened, default lazy init
 
@@ -36,7 +36,7 @@ As a toy example, let's do some task that takes a few seconds twice in one sessi
    print("y={0:}".format(y))
 
    t0 = time.time()
-   x = parsimony.generators.PickledCallableWrapper('.parsimony/wrapped_results','x',pd.read_csv,filepath_or_buffer=path)
+   x = parsimony.generators.PickledCallableWrapper('x',pd.read_csv,filepath_or_buffer=path)
    t1 = time.time()
    print('Time taken {0:1.5f}s'.format(t1-t0))#nothing happened, default lazy init
    t0 = time.time()
@@ -48,22 +48,23 @@ As a toy example, let's do some task that takes a few seconds twice in one sessi
 Prints
 ::
 
-   Time taken 0.00051s
-   Time taken 4.82472s
+   Time taken 0.00023s
+   Time taken 8.76389s
    y=12474872316
-   Time taken 0.05171s
-   Time taken 0.00056s
+   Time taken 0.05012s
+   Time taken 0.02810s
    y=12474872316
 
 
+
 However, this is not that useful of an example.  Let's run this script again immediately.
 ::
 
-   Time taken 0.00020s
-   Time taken 0.00087s
+   Time taken 0.00011s
+   Time taken 0.00061s
    y=12474872316
-   Time taken 0.00008s
-   Time taken 0.00063s
+   Time taken 0.00016s
+   Time taken 0.00060s
    y=12474872316
 
 Because intermediate results were cached, the large CSV file does not need to be read. In fact, the only computation to

src/parsimony/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '0.1.2'
+__version__ = '0.2.0'
 from .generate import generate
 from .exceptions import ParsimonyException
 

src/parsimony/configuration/__init__.py

@@ -1 +1 @@
-from .configuration import store, obfuscator, callable_wrapper
+from .configuration import store, obfuscator, callable_wrapper, context_name, set_context, parsimony_directory

src/parsimony/configuration/configuration.py

@@ -37,12 +37,40 @@ def obfuscator():
     return __obfuscator
 
 
+def parsimony_directory():
+    """Return the directory to store parsimony data in.
+
+    :return: .parsimony
+    """
+    directory_path = '.parsimony'
+    if not os.path.exists(directory_path):
+        os.makedirs(directory_path)
+
+    return directory_path
+
+__context_name = 'Default'
+
+
+def context_name():
+    """Get the context name
+
+    :return: Current context name
+    """
+    global __context_name
+    return __context_name
+
+
+def set_context(new_context_name):
+    """Set the context name. This should be something that can be a directory name.
+    """
+    global __context_name
+    __context_name = new_context_name
+
+
 def callable_wrapper(key, function, **parameters):
     """Gets the configured call wrapper. Currently, a default of PickledCallableWrapper is chosen.
 
     :return callable_wrapper: CallableWrapper Generator object
     """
-    if not os.path.exists('.parsimony/wrapped_results'):
-        os.makedirs('.parsimony/wrapped_results')
 
-    return parsimony.generators.PickledCallableWrapper('.parsimony/wrapped_results', key, function, **parameters)
+    return parsimony.generators.PickledCallableWrapper(key, function, **parameters)

src/parsimony/generators/pickled_callable_wrapper.py

@@ -1,4 +1,6 @@
 from parsimony.generators import Generator
+from parsimony.configuration import context_name, parsimony_directory
+
 import pickle
 import os
 import string
@@ -8,19 +10,20 @@ class PickledCallableWrapper(Generator):
     """ Generator for callables using pickle as the underlying storage mechanism
 
     """
-    def __init__(self, directory, key, function, **parameters):
-        """The PickledCallableWrapper is a simple way to cache arbitrary function results.
+    def __init__(self, key, function, **parameters):
+        """The PickledCallableWrapper is a simple way to cache arbitrary function results.  Results are stored in
+        the context subdirectory of the parsimony directory.
 
-        :param directory: directory to cache in
         :param key: generator key string
         :param function: callable handle
         :param parameters: key-value parameters for the callable function
         """
         self._function = function  # keep separate references to avoid copying later
         self._param_keys = list(parameters.keys())
-        if not os.path.exists(directory):
-            os.makedirs(directory)
-        self._store_location = self._generate_store_location(directory, key)
+        self._directory = os.path.join(parsimony_directory(), context_name())
+        if not os.path.exists(self._directory):
+            os.makedirs(self._directory)
+        self._store_location = self._generate_store_location(self._directory, key)
         super(PickledCallableWrapper, self).__init__(key, function=function, **parameters)
 
     def up_to_date(self):