This file is indexed.

/usr/lib/python2.7/dist-packages/scoop/encapsulation.py is in python-scoop 0.7.1.1-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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
#
#    This file is part of Scalable COncurrent Operations in Python (SCOOP).
#
#    SCOOP is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Lesser General Public License as
#    published by the Free Software Foundation, either version 3 of
#    the License, or (at your option) any later version.
#
#    SCOOP is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#    GNU Lesser General Public License for more details.
#
#    You should have received a copy of the GNU Lesser General Public
#    License along with SCOOP. If not, see <http://www.gnu.org/licenses/>.
#
import marshal
import tempfile
import types
import os
from inspect import ismodule
from functools import partial
try:
    import cPickle as pickle
except ImportError:
    import pickle

try:
    import copyreg
    from io import BytesIO as FileLikeIO
    from io import BufferedReader as FileType
except ImportError:
    # Support for Python 2.X
    import copy_reg as copyreg
    from StringIO import StringIO as FileLikeIO
    from types import FileType as FileType

import scoop


def functionFactory(in_code, name, defaults, globals_, imports):
    """Creates a function at runtime using binary compiled inCode"""
    def generatedFunction():
        pass
    generatedFunction.__code__ = marshal.loads(in_code)
    generatedFunction.__name__ = name
    generatedFunction.__defaults = defaults
    generatedFunction.__globals__.update(pickle.loads(globals_))
    for key, value in imports.items():
        imported_module = __import__(value)
        scoop.logger.debug("Dynamically loaded module {0}".format(value))
        generatedFunction.__globals__.update({key: imported_module})
    return generatedFunction


class FunctionEncapsulation(object):
    """Encapsulates a function in a serializable way.

    This is used by the sharing module (setConst).
    Used for lambda functions and function defined on-the-fly (interactive
    shell)"""
    def __init__(self, in_func, name):
        """Creates a serializable (picklable) object of a function"""
        self.code = marshal.dumps(in_func.__code__)
        self.name = name
        self.defaults = in_func.__defaults__
        # Pickle references to functions used in the function
        used_globals = {} # name: function
        used_modules = {} # used name: origin module name
        for key, value in in_func.__globals__.items():
            if key in in_func.__code__.co_names:
                if ismodule(value):
                    used_modules[key] = value.__name__
                else:
                    used_globals[key] = value
        self.globals = pickle.dumps(used_globals, pickle.HIGHEST_PROTOCOL)
        self.imports = used_modules

    def __call__(self, *args, **kwargs):
        """Called by local worker (which doesn't _communicate this class)"""
        return self.getFunction()(*args, **kwargs)

    def __name__(self):
        return self.name

    def getFunction(self):
        """Called by remote workers. Useful to populate main module globals()
        for interactive shells. Retrieves the serialized function."""
        return functionFactory(
            self.code,
            self.name,
            self.defaults,
            self.globals,
            self.imports,
        )


class ExternalEncapsulation(object):
    """Encapsulates an arbitrary file in a serializable way"""
    def __init__(self, in_filepath):
        """Creates a serializable (picklable) object of inFilePath"""
        self.filename = os.path.basename(in_filepath)
        with open(in_filepath, "rb") as fhdl:
            self.data = pickle.dumps(fhdl, pickle.HIGHEST_PROTOCOL)

    def writeFile(self, directory=None):
        """Writes back the file to a temporary path (optionaly specified)"""
        if directory:
            # If a directory was specified
            full_path = os.path.join(directory, self.filename)
            with open(full_path, 'wb') as f:
                f.write(pickle.loads(self.data).read())
            return full_path

        # if no directory was specified, create a temporary file
        this_file = tempfile.NamedTemporaryFile(delete=False)
        this_file.write(pickle.loads(self.data).read())
        this_file.close()

        return this_file.name


# The following block handles callables pickling and unpickling

# TODO: Make a factory to generate unpickling functions
def unpickleLambda(pickled_callable):
    # TODO: Set globals to user module
    return types.LambdaType(marshal.loads(pickled_callable), globals())

def unpickleMethodType(pickled_callable):
    # TODO: Set globals to user module
    return types.MethodType(marshal.loads(pickled_callable), globals())


def pickleCallable(callable_, unpickle_func):
    # TODO: Pickle also argdefs and closure
    return unpickle_func, (marshal.dumps(callable_.__code__), )

pickle_lambda = partial(pickleCallable, unpickle_func=unpickleLambda)
pickle_method = partial(pickleCallable, unpickle_func=unpickleMethodType)


def makeLambdaPicklable(lambda_function):
    """Take input lambda function l and makes it picklable."""
    if isinstance(lambda_function,
                  type(lambda: None)) and lambda_function.__name__ == '<lambda>':
        def __reduce_ex__(proto):
            # TODO: argdefs, closure
            return unpickleLambda, (marshal.dumps(lambda_function.__code__), )
        lambda_function.__reduce_ex__ = __reduce_ex__
    return lambda_function


# The following block handles file-like objects pickling and unpickling

def unpickleFileLike(position, data):
    file_ = FileLikeIO(data)
    file_.seek(position)
    return file_

def pickleFileLike(file_):
    position = file_.tell()
    file_.seek(0)
    data = file_.read()
    file_.seek(position)
    return unpickleFileLike, (position, data)

copyreg.pickle(FileType, pickleFileLike, unpickleFileLike)