violation() - Code Metrics - hamcrest/PyHamcrest - Measure and Improve Code Quality continuously with Scrutinizer

violation() A
last analyzed 2016-03-05 23:52 UTC

↳ Parent: __no_sandbox()

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	1
dl	0
loc	2
rs	10

#!python
"""Bootstrap distribute installation

If you want to use setuptools in your package's setup.py, just include this
file in the same directory with it, and add this to the top of your setup.py::

    from distribute_setup import use_setuptools
    use_setuptools()

If you want to require a specific version of setuptools, set a download
mirror, or use an alternate download directory, you can do so by supplying
the appropriate options to ``use_setuptools()``.

This file can also be run as a script to install or upgrade setuptools.
"""
import os
import sys
import time
import fnmatch
import tempfile
import tarfile
from distutils import log

try:
    from site import USER_SITE
except ImportError:
    USER_SITE = None

try:
    import subprocess

    def _python_cmd(*args):
        args = (sys.executable,) + args
        return subprocess.call(args) == 0

except ImportError:
    # will be used for python 2.3
    def _python_cmd(*args):
        args = (sys.executable,) + args
        # quoting arguments if windows
        if sys.platform == 'win32':
            def quote(arg):
                if ' ' in arg:
                    return '"%s"' % arg
                return arg
            args = [quote(arg) for arg in args]
        return os.spawnl(os.P_WAIT, sys.executable, *args) == 0

DEFAULT_VERSION = "0.6.15"
DEFAULT_URL = "http://pypi.python.org/packages/source/d/distribute/"
SETUPTOOLS_FAKED_VERSION = "0.6c11"

SETUPTOOLS_PKG_INFO = """\
Metadata-Version: 1.0
Name: setuptools
Version: %s
Summary: xxxx
Home-page: xxx
Author: xxx
Author-email: xxx
License: xxx
Description: xxx
""" % SETUPTOOLS_FAKED_VERSION


def _install(tarball):
    # extracting the tarball
    tmpdir = tempfile.mkdtemp()
    log.warn('Extracting in %s', tmpdir)
    old_wd = os.getcwd()
    try:
        os.chdir(tmpdir)
        tar = tarfile.open(tarball)
        _extractall(tar)
        tar.close()

        # going in the directory
        subdir = os.path.join(tmpdir, os.listdir(tmpdir)[0])
        os.chdir(subdir)
        log.warn('Now working in %s', subdir)

        # installing
        log.warn('Installing Distribute')
        if not _python_cmd('setup.py', 'install'):
            log.warn('Something went wrong during the installation.')
            log.warn('See the error message above.')
    finally:
        os.chdir(old_wd)


def _build_egg(egg, tarball, to_dir):
    # extracting the tarball
    tmpdir = tempfile.mkdtemp()
    log.warn('Extracting in %s', tmpdir)
    old_wd = os.getcwd()
    try:
        os.chdir(tmpdir)
        tar = tarfile.open(tarball)
        _extractall(tar)
        tar.close()

        # going in the directory
        subdir = os.path.join(tmpdir, os.listdir(tmpdir)[0])
        os.chdir(subdir)
        log.warn('Now working in %s', subdir)

        # building an egg
        log.warn('Building a Distribute egg in %s', to_dir)
        _python_cmd('setup.py', '-q', 'bdist_egg', '--dist-dir', to_dir)

    finally:
        os.chdir(old_wd)
    # returning the result
    log.warn(egg)
    if not os.path.exists(egg):
        raise IOError('Could not build the egg.')


def _do_download(version, download_base, to_dir, download_delay):
    egg = os.path.join(to_dir, 'distribute-%s-py%d.%d.egg'
                       % (version, sys.version_info[0], sys.version_info[1]))
    if not os.path.exists(egg):
        tarball = download_setuptools(version, download_base,
                                      to_dir, download_delay)
        _build_egg(egg, tarball, to_dir)
    sys.path.insert(0, egg)
    import setuptools
    setuptools.bootstrap_install_from = egg


def use_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,
                   to_dir=os.curdir, download_delay=15, no_fake=True):
    # making sure we use the absolute path
    to_dir = os.path.abspath(to_dir)
    was_imported = 'pkg_resources' in sys.modules or \
        'setuptools' in sys.modules
    try:
        try:
            import pkg_resources
            if not hasattr(pkg_resources, '_distribute'):
                if not no_fake:
                    _fake_setuptools()
                raise ImportError
        except ImportError:
            return _do_download(version, download_base, to_dir, download_delay)
        try:
            pkg_resources.require("distribute>="+version)
            return
        except pkg_resources.VersionConflict:
            e = sys.exc_info()[1]
            if was_imported:
                sys.stderr.write(
                "The required version of distribute (>=%s) is not available,\n"
                "and can't be installed while this script is running. Please\n"
                "install a more recent version first, using\n"
                "'easy_install -U distribute'."
                "\n\n(Currently using %r)\n" % (version, e.args[0]))
                sys.exit(2)
            else:
                del pkg_resources, sys.modules['pkg_resources']    # reload ok
                return _do_download(version, download_base, to_dir,
                                    download_delay)
        except pkg_resources.DistributionNotFound:
            return _do_download(version, download_base, to_dir,
                                download_delay)
    finally:
        if not no_fake:
            _create_fake_setuptools_pkg_info(to_dir)

def download_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,
                        to_dir=os.curdir, delay=15):
    """Download distribute from a specified location and return its filename

    `version` should be a valid distribute version number that is available
    as an egg for download under the `download_base` URL (which should end
    with a '/'). `to_dir` is the directory where the egg will be downloaded.
    `delay` is the number of seconds to pause before an actual download
    attempt.
    """
    # making sure we use the absolute path
    to_dir = os.path.abspath(to_dir)
    try:
        from urllib.request import urlopen
    except ImportError:
        from urllib2 import urlopen
    tgz_name = "distribute-%s.tar.gz" % version
    url = download_base + tgz_name
    saveto = os.path.join(to_dir, tgz_name)
    src = dst = None
    if not os.path.exists(saveto):  # Avoid repeated downloads
        try:
            log.warn("Downloading %s", url)
            src = urlopen(url)
            # Read/write all in one block, so we don't create a corrupt file
            # if the download is interrupted.
            data = src.read()
            dst = open(saveto, "wb")
            dst.write(data)
        finally:
            if src:
                src.close()
            if dst:
                dst.close()
    return os.path.realpath(saveto)

def _no_sandbox(function):
    def __no_sandbox(*args, **kw):
        try:
            from setuptools.sandbox import DirectorySandbox
            if not hasattr(DirectorySandbox, '_old'):
                def violation(*args):
                    pass
                DirectorySandbox._old = DirectorySandbox._violation
                DirectorySandbox._violation = violation
                patched = True
            else:
                patched = False
        except ImportError:
            patched = False

        try:
            return function(*args, **kw)
        finally:
            if patched:
                DirectorySandbox._violation = DirectorySandbox._old
                del DirectorySandbox._old

    return __no_sandbox

def _patch_file(path, content):
    """Will backup the file then patch it"""
    existing_content = open(path).read()
    if existing_content == content:
        # already patched
        log.warn('Already patched.')
        return False
    log.warn('Patching...')
    _rename_path(path)
    f = open(path, 'w')
    try:
        f.write(content)
    finally:
        f.close()
    return True

_patch_file = _no_sandbox(_patch_file)

def _same_content(path, content):
    return open(path).read() == content

def _rename_path(path):
    new_name = path + '.OLD.%s' % time.time()
    log.warn('Renaming %s into %s', path, new_name)
    os.rename(path, new_name)
    return new_name

def _remove_flat_installation(placeholder):
    if not os.path.isdir(placeholder):
        log.warn('Unkown installation at %s', placeholder)
        return False
    found = False
    for file in os.listdir(placeholder):
        if fnmatch.fnmatch(file, 'setuptools*.egg-info'):
            found = True
            break
    if not found:
        log.warn('Could not locate setuptools*.egg-info')
        return

    log.warn('Removing elements out of the way...')
    pkg_info = os.path.join(placeholder, file)
    if os.path.isdir(pkg_info):
        patched = _patch_egg_dir(pkg_info)
    else:
        patched = _patch_file(pkg_info, SETUPTOOLS_PKG_INFO)

    if not patched:
        log.warn('%s already patched.', pkg_info)
        return False
    # now let's move the files out of the way
    for element in ('setuptools', 'pkg_resources.py', 'site.py'):
        element = os.path.join(placeholder, element)
        if os.path.exists(element):
            _rename_path(element)
        else:
            log.warn('Could not find the %s element of the '
                     'Setuptools distribution', element)
    return True

_remove_flat_installation = _no_sandbox(_remove_flat_installation)

def _after_install(dist):
    log.warn('After install bootstrap.')
    placeholder = dist.get_command_obj('install').install_purelib
    _create_fake_setuptools_pkg_info(placeholder)

def _create_fake_setuptools_pkg_info(placeholder):
    if not placeholder or not os.path.exists(placeholder):
        log.warn('Could not find the install location')
        return
    pyver = '%s.%s' % (sys.version_info[0], sys.version_info[1])
    setuptools_file = 'setuptools-%s-py%s.egg-info' % \
            (SETUPTOOLS_FAKED_VERSION, pyver)
    pkg_info = os.path.join(placeholder, setuptools_file)
    if os.path.exists(pkg_info):
        log.warn('%s already exists', pkg_info)
        return

    log.warn('Creating %s', pkg_info)
    f = open(pkg_info, 'w')
    try:
        f.write(SETUPTOOLS_PKG_INFO)
    finally:
        f.close()

    pth_file = os.path.join(placeholder, 'setuptools.pth')
    log.warn('Creating %s', pth_file)
    f = open(pth_file, 'w')
    try:
        f.write(os.path.join(os.curdir, setuptools_file))
    finally:
        f.close()

_create_fake_setuptools_pkg_info = _no_sandbox(_create_fake_setuptools_pkg_info)

def _patch_egg_dir(path):
    # let's check if it's already patched
    pkg_info = os.path.join(path, 'EGG-INFO', 'PKG-INFO')
    if os.path.exists(pkg_info):
        if _same_content(pkg_info, SETUPTOOLS_PKG_INFO):
            log.warn('%s already patched.', pkg_info)
            return False
    _rename_path(path)
    os.mkdir(path)
    os.mkdir(os.path.join(path, 'EGG-INFO'))
    pkg_info = os.path.join(path, 'EGG-INFO', 'PKG-INFO')
    f = open(pkg_info, 'w')
    try:
        f.write(SETUPTOOLS_PKG_INFO)
    finally:
        f.close()
    return True

_patch_egg_dir = _no_sandbox(_patch_egg_dir)

def _before_install():
    log.warn('Before install bootstrap.')
    _fake_setuptools()


def _under_prefix(location):
    if 'install' not in sys.argv:
        return True
    args = sys.argv[sys.argv.index('install')+1:]
    for index, arg in enumerate(args):
        for option in ('--root', '--prefix'):
            if arg.startswith('%s=' % option):
                top_dir = arg.split('root=')[-1]
                return location.startswith(top_dir)
            elif arg == option:
                if len(args) > index:
                    top_dir = args[index+1]
                    return location.startswith(top_dir)
        if arg == '--user' and USER_SITE is not None:
            return location.startswith(USER_SITE)
    return True


def _fake_setuptools():
    log.warn('Scanning installed packages')
    try:
        import pkg_resources
    except ImportError:
        # we're cool
        log.warn('Setuptools or Distribute does not seem to be installed.')
        return
    ws = pkg_resources.working_set
    try:
        setuptools_dist = ws.find(pkg_resources.Requirement.parse('setuptools',
                                  replacement=False))
    except TypeError:
        # old distribute API
        setuptools_dist = ws.find(pkg_resources.Requirement.parse('setuptools'))

    if setuptools_dist is None:
        log.warn('No setuptools distribution found')
        return
    # detecting if it was already faked
    setuptools_location = setuptools_dist.location
    log.warn('Setuptools installation detected at %s', setuptools_location)

    # if --root or --preix was provided, and if
    # setuptools is not located in them, we don't patch it
    if not _under_prefix(setuptools_location):
        log.warn('Not patching, --root or --prefix is installing Distribute'
                 ' in another location')
        return

    # let's see if its an egg
    if not setuptools_location.endswith('.egg'):
        log.warn('Non-egg installation')
        res = _remove_flat_installation(setuptools_location)
        if not res:
            return
    else:
        log.warn('Egg installation')
        pkg_info = os.path.join(setuptools_location, 'EGG-INFO', 'PKG-INFO')
        if (os.path.exists(pkg_info) and
            _same_content(pkg_info, SETUPTOOLS_PKG_INFO)):
            log.warn('Already patched.')
            return
        log.warn('Patching...')
        # let's create a fake egg replacing setuptools one
        res = _patch_egg_dir(setuptools_location)
        if not res:
            return
    log.warn('Patched done.')
    _relaunch()


def _relaunch():
    log.warn('Relaunching...')
    # we have to relaunch the process
    # pip marker to avoid a relaunch bug
    if sys.argv[:3] == ['-c', 'install', '--single-version-externally-managed']:
        sys.argv[0] = 'setup.py'
    args = [sys.executable] + sys.argv
    sys.exit(subprocess.call(args))


def _extractall(self, path=".", members=None):
    """Extract all members from the archive to the current working
       directory and set owner, modification time and permissions on
       directories afterwards. `path' specifies a different directory
       to extract to. `members' is optional and must be a subset of the
       list returned by getmembers().
    """
    import copy
    import operator
    from tarfile import ExtractError
    directories = []

    if members is None:
        members = self

    for tarinfo in members:
        if tarinfo.isdir():
            # Extract directories with a safe mode.
            directories.append(tarinfo)
            tarinfo = copy.copy(tarinfo)
            tarinfo.mode = 448 # decimal for oct 0700
        self.extract(tarinfo, path)

    # Reverse sort directories.
    if sys.version_info < (2, 4):
        def sorter(dir1, dir2):
            return cmp(dir1.name, dir2.name)
        directories.sort(sorter)
        directories.reverse()
    else:
        directories.sort(key=operator.attrgetter('name'), reverse=True)

    # Set correct owner, mtime and filemode on directories.
    for tarinfo in directories:
        dirpath = os.path.join(path, tarinfo.name)
        try:
            self.chown(tarinfo, dirpath)
            self.utime(tarinfo, dirpath)
            self.chmod(tarinfo, dirpath)
        except ExtractError:
            e = sys.exc_info()[1]
            if self.errorlevel > 1:
                raise
            else:
                self._dbg(1, "tarfile: %s" % e)


def main(argv, version=DEFAULT_VERSION):
    """Install or upgrade setuptools and EasyInstall"""
    tarball = download_setuptools()
    _install(tarball)


if __name__ == '__main__':
    main(sys.argv[1:])


1			#!python
2			"""Bootstrap distribute installation
3
4			If you want to use setuptools in your package's setup.py, just include this
5			file in the same directory with it, and add this to the top of your setup.py::
6
7			from distribute_setup import use_setuptools
8			use_setuptools()
9
10			If you want to require a specific version of setuptools, set a download
11			mirror, or use an alternate download directory, you can do so by supplying
12			the appropriate options to ``use_setuptools()``.
13
14			This file can also be run as a script to install or upgrade setuptools.
15			"""
16			import os
17			import sys
18			import time
19			import fnmatch
20			import tempfile
21			import tarfile
22			from distutils import log
23
24			try:
25			from site import USER_SITE
26			except ImportError:
27			USER_SITE = None
28
29			try:
30			import subprocess
31
32			def _python_cmd(*args):
33			args = (sys.executable,) + args
34			return subprocess.call(args) == 0
35
36			except ImportError:
37			# will be used for python 2.3
38			def _python_cmd(*args):
39			args = (sys.executable,) + args
40			# quoting arguments if windows
41			if sys.platform == 'win32':
42			def quote(arg):
43			if ' ' in arg:
44			return '"%s"' % arg
45			return arg
46			args = [quote(arg) for arg in args]
47			return os.spawnl(os.P_WAIT, sys.executable, *args) == 0
48
49			DEFAULT_VERSION = "0.6.15"
50			DEFAULT_URL = "http://pypi.python.org/packages/source/d/distribute/"
51			SETUPTOOLS_FAKED_VERSION = "0.6c11"
52
53			SETUPTOOLS_PKG_INFO = """\
54			Metadata-Version: 1.0
55			Name: setuptools
56			Version: %s
57			Summary: xxxx
58			Home-page: xxx
59			Author: xxx
60			Author-email: xxx
61			License: xxx
62			Description: xxx
63			""" % SETUPTOOLS_FAKED_VERSION
64
65
66			def _install(tarball):
67			# extracting the tarball
68			tmpdir = tempfile.mkdtemp()
69			log.warn('Extracting in %s', tmpdir)
70			old_wd = os.getcwd()
71			try:
72			os.chdir(tmpdir)
73			tar = tarfile.open(tarball)
74			_extractall(tar)
75			tar.close()
76
77			# going in the directory
78			subdir = os.path.join(tmpdir, os.listdir(tmpdir)[0])
79			os.chdir(subdir)
80			log.warn('Now working in %s', subdir)
81
82			# installing
83			log.warn('Installing Distribute')
84			if not _python_cmd('setup.py', 'install'):
85			log.warn('Something went wrong during the installation.')
86			log.warn('See the error message above.')
87			finally:
88			os.chdir(old_wd)
89
90
91			def _build_egg(egg, tarball, to_dir):
92			# extracting the tarball
93			tmpdir = tempfile.mkdtemp()
94			log.warn('Extracting in %s', tmpdir)
95			old_wd = os.getcwd()
96			try:
97			os.chdir(tmpdir)
98			tar = tarfile.open(tarball)
99			_extractall(tar)
100			tar.close()
101
102			# going in the directory
103			subdir = os.path.join(tmpdir, os.listdir(tmpdir)[0])
104			os.chdir(subdir)
105			log.warn('Now working in %s', subdir)
106
107			# building an egg
108			log.warn('Building a Distribute egg in %s', to_dir)
109			_python_cmd('setup.py', '-q', 'bdist_egg', '--dist-dir', to_dir)
110
111			finally:
112			os.chdir(old_wd)
113			# returning the result
114			log.warn(egg)
115			if not os.path.exists(egg):
116			raise IOError('Could not build the egg.')
117
118
119			def _do_download(version, download_base, to_dir, download_delay):
120			egg = os.path.join(to_dir, 'distribute-%s-py%d.%d.egg'
121			% (version, sys.version_info[0], sys.version_info[1]))
122			if not os.path.exists(egg):
123			tarball = download_setuptools(version, download_base,
124			to_dir, download_delay)
125			_build_egg(egg, tarball, to_dir)
126			sys.path.insert(0, egg)
127			import setuptools
128			setuptools.bootstrap_install_from = egg
129
130
131			def use_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,
132			to_dir=os.curdir, download_delay=15, no_fake=True):
133			# making sure we use the absolute path
134			to_dir = os.path.abspath(to_dir)
135			was_imported = 'pkg_resources' in sys.modules or \
136			'setuptools' in sys.modules
137			try:
138			try:
139			import pkg_resources
140			if not hasattr(pkg_resources, '_distribute'):
141			if not no_fake:
142			_fake_setuptools()
143			raise ImportError
144			except ImportError:
145			return _do_download(version, download_base, to_dir, download_delay)
146			try:
147			pkg_resources.require("distribute>="+version)
148			return
149			except pkg_resources.VersionConflict:
150			e = sys.exc_info()[1]
151			if was_imported:
152			sys.stderr.write(
153			"The required version of distribute (>=%s) is not available,\n"
154			"and can't be installed while this script is running. Please\n"
155			"install a more recent version first, using\n"
156			"'easy_install -U distribute'."
157			"\n\n(Currently using %r)\n" % (version, e.args[0]))
158			sys.exit(2)
159			else:
160			del pkg_resources, sys.modules['pkg_resources'] # reload ok
161			return _do_download(version, download_base, to_dir,
162			download_delay)
163			except pkg_resources.DistributionNotFound:
164			return _do_download(version, download_base, to_dir,
165			download_delay)
166			finally:
167			if not no_fake:
168			_create_fake_setuptools_pkg_info(to_dir)
169
170			def download_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,
171			to_dir=os.curdir, delay=15):
172			"""Download distribute from a specified location and return its filename
173
174			`version` should be a valid distribute version number that is available
175			as an egg for download under the `download_base` URL (which should end
176			with a '/'). `to_dir` is the directory where the egg will be downloaded.
177			`delay` is the number of seconds to pause before an actual download
178			attempt.
179			"""
180			# making sure we use the absolute path
181			to_dir = os.path.abspath(to_dir)
182			try:
183			from urllib.request import urlopen
184			except ImportError:
185			from urllib2 import urlopen
186			tgz_name = "distribute-%s.tar.gz" % version
187			url = download_base + tgz_name
188			saveto = os.path.join(to_dir, tgz_name)
189			src = dst = None
190			if not os.path.exists(saveto): # Avoid repeated downloads
191			try:
192			log.warn("Downloading %s", url)
193			src = urlopen(url)
194			# Read/write all in one block, so we don't create a corrupt file
195			# if the download is interrupted.
196			data = src.read()
197			dst = open(saveto, "wb")
198			dst.write(data)
199			finally:
200			if src:
201			src.close()
202			if dst:
203			dst.close()
204			return os.path.realpath(saveto)
205
206			def _no_sandbox(function):
207			def __no_sandbox(args, *kw):
208			try:
209			from setuptools.sandbox import DirectorySandbox
210			if not hasattr(DirectorySandbox, '_old'):
211			def violation(*args):
212			pass
213			DirectorySandbox._old = DirectorySandbox._violation
214			DirectorySandbox._violation = violation
215			patched = True
216			else:
217			patched = False
218			except ImportError:
219			patched = False
220
221			try:
222			return function(args, *kw)
223			finally:
224			if patched:
225			DirectorySandbox._violation = DirectorySandbox._old
226			del DirectorySandbox._old
227
228			return __no_sandbox
229
230			def _patch_file(path, content):
231			"""Will backup the file then patch it"""
232			existing_content = open(path).read()
233			if existing_content == content:
234			# already patched
235			log.warn('Already patched.')
236			return False
237			log.warn('Patching...')
238			_rename_path(path)
239			f = open(path, 'w')
240			try:
241			f.write(content)
242			finally:
243			f.close()
244			return True
245
246			_patch_file = _no_sandbox(_patch_file)
247
248			def _same_content(path, content):
249			return open(path).read() == content
250
251			def _rename_path(path):
252			new_name = path + '.OLD.%s' % time.time()
253			log.warn('Renaming %s into %s', path, new_name)
254			os.rename(path, new_name)
255			return new_name
256
257			def _remove_flat_installation(placeholder):
258			if not os.path.isdir(placeholder):
259			log.warn('Unkown installation at %s', placeholder)
260			return False
261			found = False
262			for file in os.listdir(placeholder):
263			if fnmatch.fnmatch(file, 'setuptools*.egg-info'):
264			found = True
265			break
266			if not found:
267			log.warn('Could not locate setuptools*.egg-info')
268			return
269
270			log.warn('Removing elements out of the way...')
271			pkg_info = os.path.join(placeholder, file)
272			if os.path.isdir(pkg_info):
273			patched = _patch_egg_dir(pkg_info)
274			else:
275			patched = _patch_file(pkg_info, SETUPTOOLS_PKG_INFO)
276
277			if not patched:
278			log.warn('%s already patched.', pkg_info)
279			return False
280			# now let's move the files out of the way
281			for element in ('setuptools', 'pkg_resources.py', 'site.py'):
282			element = os.path.join(placeholder, element)
283			if os.path.exists(element):
284			_rename_path(element)
285			else:
286			log.warn('Could not find the %s element of the '
287			'Setuptools distribution', element)
288			return True
289
290			_remove_flat_installation = _no_sandbox(_remove_flat_installation)
291
292			def _after_install(dist):
293			log.warn('After install bootstrap.')
294			placeholder = dist.get_command_obj('install').install_purelib
295			_create_fake_setuptools_pkg_info(placeholder)
296
297			def _create_fake_setuptools_pkg_info(placeholder):
298			if not placeholder or not os.path.exists(placeholder):
299			log.warn('Could not find the install location')
300			return
301			pyver = '%s.%s' % (sys.version_info[0], sys.version_info[1])
302			setuptools_file = 'setuptools-%s-py%s.egg-info' % \
303			(SETUPTOOLS_FAKED_VERSION, pyver)
304			pkg_info = os.path.join(placeholder, setuptools_file)
305			if os.path.exists(pkg_info):
306			log.warn('%s already exists', pkg_info)
307			return
308
309			log.warn('Creating %s', pkg_info)
310			f = open(pkg_info, 'w')
311			try:
312			f.write(SETUPTOOLS_PKG_INFO)
313			finally:
314			f.close()
315
316			pth_file = os.path.join(placeholder, 'setuptools.pth')
317			log.warn('Creating %s', pth_file)
318			f = open(pth_file, 'w')
319			try:
320			f.write(os.path.join(os.curdir, setuptools_file))
321			finally:
322			f.close()
323
324			_create_fake_setuptools_pkg_info = _no_sandbox(_create_fake_setuptools_pkg_info)
325
326			def _patch_egg_dir(path):
327			# let's check if it's already patched
328			pkg_info = os.path.join(path, 'EGG-INFO', 'PKG-INFO')
329			if os.path.exists(pkg_info):
330			if _same_content(pkg_info, SETUPTOOLS_PKG_INFO):
331			log.warn('%s already patched.', pkg_info)
332			return False
333			_rename_path(path)
334			os.mkdir(path)
335			os.mkdir(os.path.join(path, 'EGG-INFO'))
336			pkg_info = os.path.join(path, 'EGG-INFO', 'PKG-INFO')
337			f = open(pkg_info, 'w')
338			try:
339			f.write(SETUPTOOLS_PKG_INFO)
340			finally:
341			f.close()
342			return True
343
344			_patch_egg_dir = _no_sandbox(_patch_egg_dir)
345
346			def _before_install():
347			log.warn('Before install bootstrap.')
348			_fake_setuptools()
349
350
351			def _under_prefix(location):
352			if 'install' not in sys.argv:
353			return True
354			args = sys.argv[sys.argv.index('install')+1:]
355			for index, arg in enumerate(args):
356			for option in ('--root', '--prefix'):
357			if arg.startswith('%s=' % option):
358			top_dir = arg.split('root=')[-1]
359			return location.startswith(top_dir)
360			elif arg == option:
361			if len(args) > index:
362			top_dir = args[index+1]
363			return location.startswith(top_dir)
364			if arg == '--user' and USER_SITE is not None:
365			return location.startswith(USER_SITE)
366			return True
367
368
369			def _fake_setuptools():
370			log.warn('Scanning installed packages')
371			try:
372			import pkg_resources
373			except ImportError:
374			# we're cool
375			log.warn('Setuptools or Distribute does not seem to be installed.')
376			return
377			ws = pkg_resources.working_set
378			try:
379			setuptools_dist = ws.find(pkg_resources.Requirement.parse('setuptools',
380			replacement=False))
381			except TypeError:
382			# old distribute API
383			setuptools_dist = ws.find(pkg_resources.Requirement.parse('setuptools'))
384
385			if setuptools_dist is None:
386			log.warn('No setuptools distribution found')
387			return
388			# detecting if it was already faked
389			setuptools_location = setuptools_dist.location
390			log.warn('Setuptools installation detected at %s', setuptools_location)
391
392			# if --root or --preix was provided, and if
393			# setuptools is not located in them, we don't patch it
394			if not _under_prefix(setuptools_location):
395			log.warn('Not patching, --root or --prefix is installing Distribute'
396			' in another location')
397			return
398
399			# let's see if its an egg
400			if not setuptools_location.endswith('.egg'):
401			log.warn('Non-egg installation')
402			res = _remove_flat_installation(setuptools_location)
403			if not res:
404			return
405			else:
406			log.warn('Egg installation')
407			pkg_info = os.path.join(setuptools_location, 'EGG-INFO', 'PKG-INFO')
408			if (os.path.exists(pkg_info) and
409			_same_content(pkg_info, SETUPTOOLS_PKG_INFO)):
410			log.warn('Already patched.')
411			return
412			log.warn('Patching...')
413			# let's create a fake egg replacing setuptools one
414			res = _patch_egg_dir(setuptools_location)
415			if not res:
416			return
417			log.warn('Patched done.')
418			_relaunch()
419
420
421			def _relaunch():
422			log.warn('Relaunching...')
423			# we have to relaunch the process
424			# pip marker to avoid a relaunch bug
425			if sys.argv[:3] == ['-c', 'install', '--single-version-externally-managed']:
426			sys.argv[0] = 'setup.py'
427			args = [sys.executable] + sys.argv
428			sys.exit(subprocess.call(args))
429
430
431			def _extractall(self, path=".", members=None):
432			"""Extract all members from the archive to the current working
433			directory and set owner, modification time and permissions on
434			directories afterwards. `path' specifies a different directory
435			to extract to. `members' is optional and must be a subset of the
436			list returned by getmembers().
437			"""
438			import copy
439			import operator
440			from tarfile import ExtractError
441			directories = []
442
443			if members is None:
444			members = self
445
446			for tarinfo in members:
447			if tarinfo.isdir():
448			# Extract directories with a safe mode.
449			directories.append(tarinfo)
450			tarinfo = copy.copy(tarinfo)
451			tarinfo.mode = 448 # decimal for oct 0700
452			self.extract(tarinfo, path)
453
454			# Reverse sort directories.
455			if sys.version_info < (2, 4):
456			def sorter(dir1, dir2):
457			return cmp(dir1.name, dir2.name)
458			directories.sort(sorter)
459			directories.reverse()
460			else:
461			directories.sort(key=operator.attrgetter('name'), reverse=True)
462
463			# Set correct owner, mtime and filemode on directories.
464			for tarinfo in directories:
465			dirpath = os.path.join(path, tarinfo.name)
466			try:
467			self.chown(tarinfo, dirpath)
468			self.utime(tarinfo, dirpath)
469			self.chmod(tarinfo, dirpath)
470			except ExtractError:
471			e = sys.exc_info()[1]
472			if self.errorlevel > 1:
473			raise
474			else:
475			self._dbg(1, "tarfile: %s" % e)
476
477
478			def main(argv, version=DEFAULT_VERSION):
479			"""Install or upgrade setuptools and EasyInstall"""
480			tarball = download_setuptools()
481			_install(tarball)
482
483
484			if __name__ == '__main__':
485			main(sys.argv[1:])
486

hamcrest / PyHamcrest

violation() A last analyzed 2016-03-05 23:52 UTC

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like

violation() A
last analyzed 2016-03-05 23:52 UTC