This file is indexed.

/usr/lib/python2.7/dist-packages/joblib-0.10.4.dev0.egg-info is in python-joblib 0.10.3+git55-g660fe5d-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
Metadata-Version: 1.1
Name: joblib
Version: 0.10.4.dev0
Summary: 
Lightweight pipelining: using Python functions as pipeline jobs.

Home-page: http://pythonhosted.org/joblib/
Author: Gael Varoquaux
Author-email: gael.varoquaux@normalesup.org
License: BSD
Description:  Joblib is a set of tools to provide **lightweight pipelining in
        Python**. In particular, joblib offers:
        
          1. transparent disk-caching of the output values and lazy re-evaluation
             (memoize pattern)
        
          2. easy simple parallel computing
        
          3. logging and tracing of the execution
        
        Joblib is optimized to be **fast** and **robust** in particular on large
        data and has specific optimizations for `numpy` arrays. It is
        **BSD-licensed**.
        
        
            ============================== ============================================
            **User documentation**:        http://pythonhosted.org/joblib
        
            **Download packages**:         http://pypi.python.org/pypi/joblib#downloads
        
            **Source code**:               http://github.com/joblib/joblib
        
            **Report issues**:             http://github.com/joblib/joblib/issues
            ============================== ============================================
        
        
        Vision
        --------
        
        The vision is to provide tools to easily achieve better performance and
        reproducibility when working with long running jobs.
        
         *  **Avoid computing twice the same thing**: code is rerun over an
            over, for instance when prototyping computational-heavy jobs (as in
            scientific development), but hand-crafted solution to alleviate this
            issue is error-prone and often leads to unreproducible results
        
         *  **Persist to disk transparently**: persisting in an efficient way
            arbitrary objects containing large data is hard. Using
            joblib's caching mechanism avoids hand-written persistence and
            implicitly links the file on disk to the execution context of
            the original Python object. As a result, joblib's persistence is
            good for resuming an application status or computational job, eg
            after a crash.
        
        Joblib strives to address these problems while **leaving your code and
        your flow control as unmodified as possible** (no framework, no new
        paradigms).
        
        Main features
        ------------------
        
        1) **Transparent and fast disk-caching of output value:** a memoize or
           make-like functionality for Python functions that works well for
           arbitrary Python objects, including very large numpy arrays. Separate
           persistence and flow-execution logic from domain logic or algorithmic
           code by writing the operations as a set of steps with well-defined
           inputs and  outputs: Python functions. Joblib can save their
           computation to disk and rerun it only if necessary::
        
              >>> from joblib import Memory
              >>> mem = Memory(cachedir='/tmp/joblib')
              >>> import numpy as np
              >>> a = np.vander(np.arange(3)).astype(np.float)
              >>> square = mem.cache(np.square)
              >>> b = square(a)                                   # doctest: +ELLIPSIS
              ________________________________________________________________________________
              [Memory] Calling square...
              square(array([[ 0.,  0.,  1.],
                     [ 1.,  1.,  1.],
                     [ 4.,  2.,  1.]]))
              ___________________________________________________________square - 0...s, 0.0min
        
              >>> c = square(a)
              >>> # The above call did not trigger an evaluation
        
        2) **Embarrassingly parallel helper:** to make it easy to write readable
           parallel code and debug it quickly::
        
              >>> from joblib import Parallel, delayed
              >>> from math import sqrt
              >>> Parallel(n_jobs=1)(delayed(sqrt)(i**2) for i in range(10))
              [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]
        
        
        3) **Logging/tracing:** The different functionalities will
           progressively acquire better logging mechanism to help track what
           has been ran, and capture I/O easily. In addition, Joblib will
           provide a few I/O primitives, to easily define logging and
           display streams, and provide a way of compiling a report.
           We want to be able to quickly inspect what has been run.
        
        4) **Fast compressed Persistence**: a replacement for pickle to work
           efficiently on Python objects containing large data (
           *joblib.dump* & *joblib.load* ).
        
        ..
            >>> import shutil ; shutil.rmtree('/tmp/joblib/')
        
        
Platform: any
Classifier: Development Status :: 5 - Production/Stable
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Science/Research
Classifier: Intended Audience :: Education
Classifier: License :: OSI Approved :: BSD License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Topic :: Scientific/Engineering
Classifier: Topic :: Utilities
Classifier: Topic :: Software Development :: Libraries