The Tor Browser / file comparison
comparison: python/virtualenv/virtualenv.py
python/virtualenv/virtualenv.py
- changeset 0
- 6474c204b198
equal
deleted
inserted
replaced
| -1:000000000000 | 0:f5bd6eba782a |
|---|---|
| 1 #!/usr/bin/env python | |
| 2 """Create a "virtual" Python installation | |
| 3 """ | |
| 4 | |
| 5 __version__ = "1.11.4" | |
| 6 virtualenv_version = __version__ # legacy | |
| 7 | |
| 8 import base64 | |
| 9 import sys | |
| 10 import os | |
| 11 import codecs | |
| 12 import optparse | |
| 13 import re | |
| 14 import shutil | |
| 15 import logging | |
| 16 import tempfile | |
| 17 import zlib | |
| 18 import errno | |
| 19 import glob | |
| 20 import distutils.sysconfig | |
| 21 from distutils.util import strtobool | |
| 22 import struct | |
| 23 import subprocess | |
| 24 import tarfile | |
| 25 | |
| 26 if sys.version_info < (2, 6): | |
| 27 print('ERROR: %s' % sys.exc_info()[1]) | |
| 28 print('ERROR: this script requires Python 2.6 or greater.') | |
| 29 sys.exit(101) | |
| 30 | |
| 31 try: | |
| 32 set | |
| 33 except NameError: | |
| 34 from sets import Set as set | |
| 35 try: | |
| 36 basestring | |
| 37 except NameError: | |
| 38 basestring = str | |
| 39 | |
| 40 try: | |
| 41 import ConfigParser | |
| 42 except ImportError: | |
| 43 import configparser as ConfigParser | |
| 44 | |
| 45 join = os.path.join | |
| 46 py_version = 'python%s.%s' % (sys.version_info[0], sys.version_info[1]) | |
| 47 | |
| 48 is_jython = sys.platform.startswith('java') | |
| 49 is_pypy = hasattr(sys, 'pypy_version_info') | |
| 50 is_win = (sys.platform == 'win32') | |
| 51 is_cygwin = (sys.platform == 'cygwin') | |
| 52 is_darwin = (sys.platform == 'darwin') | |
| 53 abiflags = getattr(sys, 'abiflags', '') | |
| 54 | |
| 55 user_dir = os.path.expanduser('~') | |
| 56 if is_win: | |
| 57 default_storage_dir = os.path.join(user_dir, 'virtualenv') | |
| 58 else: | |
| 59 default_storage_dir = os.path.join(user_dir, '.virtualenv') | |
| 60 default_config_file = os.path.join(default_storage_dir, 'virtualenv.ini') | |
| 61 | |
| 62 if is_pypy: | |
| 63 expected_exe = 'pypy' | |
| 64 elif is_jython: | |
| 65 expected_exe = 'jython' | |
| 66 else: | |
| 67 expected_exe = 'python' | |
| 68 | |
| 69 # Return a mapping of version -> Python executable | |
| 70 # Only provided for Windows, where the information in the registry is used | |
| 71 if not is_win: | |
| 72 def get_installed_pythons(): | |
| 73 return {} | |
| 74 else: | |
| 75 try: | |
| 76 import winreg | |
| 77 except ImportError: | |
| 78 import _winreg as winreg | |
| 79 | |
| 80 def get_installed_pythons(): | |
| 81 python_core = winreg.CreateKey(winreg.HKEY_LOCAL_MACHINE, | |
| 82 "Software\\Python\\PythonCore") | |
| 83 i = 0 | |
| 84 versions = [] | |
| 85 while True: | |
| 86 try: | |
| 87 versions.append(winreg.EnumKey(python_core, i)) | |
| 88 i = i + 1 | |
| 89 except WindowsError: | |
| 90 break | |
| 91 exes = dict() | |
| 92 for ver in versions: | |
| 93 path = winreg.QueryValue(python_core, "%s\\InstallPath" % ver) | |
| 94 exes[ver] = join(path, "python.exe") | |
| 95 | |
| 96 winreg.CloseKey(python_core) | |
| 97 | |
| 98 # Add the major versions | |
| 99 # Sort the keys, then repeatedly update the major version entry | |
| 100 # Last executable (i.e., highest version) wins with this approach | |
| 101 for ver in sorted(exes): | |
| 102 exes[ver[0]] = exes[ver] | |
| 103 | |
| 104 return exes | |
| 105 | |
| 106 REQUIRED_MODULES = ['os', 'posix', 'posixpath', 'nt', 'ntpath', 'genericpath', | |
| 107 'fnmatch', 'locale', 'encodings', 'codecs', | |
| 108 'stat', 'UserDict', 'readline', 'copy_reg', 'types', | |
| 109 're', 'sre', 'sre_parse', 'sre_constants', 'sre_compile', | |
| 110 'zlib'] | |
| 111 | |
| 112 REQUIRED_FILES = ['lib-dynload', 'config'] | |
| 113 | |
| 114 majver, minver = sys.version_info[:2] | |
| 115 if majver == 2: | |
| 116 if minver >= 6: | |
| 117 REQUIRED_MODULES.extend(['warnings', 'linecache', '_abcoll', 'abc']) | |
| 118 if minver >= 7: | |
| 119 REQUIRED_MODULES.extend(['_weakrefset']) | |
| 120 if minver <= 3: | |
| 121 REQUIRED_MODULES.extend(['sets', '__future__']) | |
| 122 elif majver == 3: | |
| 123 # Some extra modules are needed for Python 3, but different ones | |
| 124 # for different versions. | |
| 125 REQUIRED_MODULES.extend(['_abcoll', 'warnings', 'linecache', 'abc', 'io', | |
| 126 '_weakrefset', 'copyreg', 'tempfile', 'random', | |
| 127 '__future__', 'collections', 'keyword', 'tarfile', | |
| 128 'shutil', 'struct', 'copy', 'tokenize', 'token', | |
| 129 'functools', 'heapq', 'bisect', 'weakref', | |
| 130 'reprlib']) | |
| 131 if minver >= 2: | |
| 132 REQUIRED_FILES[-1] = 'config-%s' % majver | |
| 133 if minver >= 3: | |
| 134 import sysconfig | |
| 135 platdir = sysconfig.get_config_var('PLATDIR') | |
| 136 REQUIRED_FILES.append(platdir) | |
| 137 # The whole list of 3.3 modules is reproduced below - the current | |
| 138 # uncommented ones are required for 3.3 as of now, but more may be | |
| 139 # added as 3.3 development continues. | |
| 140 REQUIRED_MODULES.extend([ | |
| 141 #"aifc", | |
| 142 #"antigravity", | |
| 143 #"argparse", | |
| 144 #"ast", | |
| 145 #"asynchat", | |
| 146 #"asyncore", | |
| 147 "base64", | |
| 148 #"bdb", | |
| 149 #"binhex", | |
| 150 #"bisect", | |
| 151 #"calendar", | |
| 152 #"cgi", | |
| 153 #"cgitb", | |
| 154 #"chunk", | |
| 155 #"cmd", | |
| 156 #"codeop", | |
| 157 #"code", | |
| 158 #"colorsys", | |
| 159 #"_compat_pickle", | |
| 160 #"compileall", | |
| 161 #"concurrent", | |
| 162 #"configparser", | |
| 163 #"contextlib", | |
| 164 #"cProfile", | |
| 165 #"crypt", | |
| 166 #"csv", | |
| 167 #"ctypes", | |
| 168 #"curses", | |
| 169 #"datetime", | |
| 170 #"dbm", | |
| 171 #"decimal", | |
| 172 #"difflib", | |
| 173 #"dis", | |
| 174 #"doctest", | |
| 175 #"dummy_threading", | |
| 176 "_dummy_thread", | |
| 177 #"email", | |
| 178 #"filecmp", | |
| 179 #"fileinput", | |
| 180 #"formatter", | |
| 181 #"fractions", | |
| 182 #"ftplib", | |
| 183 #"functools", | |
| 184 #"getopt", | |
| 185 #"getpass", | |
| 186 #"gettext", | |
| 187 #"glob", | |
| 188 #"gzip", | |
| 189 "hashlib", | |
| 190 #"heapq", | |
| 191 "hmac", | |
| 192 #"html", | |
| 193 #"http", | |
| 194 #"idlelib", | |
| 195 #"imaplib", | |
| 196 #"imghdr", | |
| 197 "imp", | |
| 198 "importlib", | |
| 199 #"inspect", | |
| 200 #"json", | |
| 201 #"lib2to3", | |
| 202 #"logging", | |
| 203 #"macpath", | |
| 204 #"macurl2path", | |
| 205 #"mailbox", | |
| 206 #"mailcap", | |
| 207 #"_markupbase", | |
| 208 #"mimetypes", | |
| 209 #"modulefinder", | |
| 210 #"multiprocessing", | |
| 211 #"netrc", | |
| 212 #"nntplib", | |
| 213 #"nturl2path", | |
| 214 #"numbers", | |
| 215 #"opcode", | |
| 216 #"optparse", | |
| 217 #"os2emxpath", | |
| 218 #"pdb", | |
| 219 #"pickle", | |
| 220 #"pickletools", | |
| 221 #"pipes", | |
| 222 #"pkgutil", | |
| 223 #"platform", | |
| 224 #"plat-linux2", | |
| 225 #"plistlib", | |
| 226 #"poplib", | |
| 227 #"pprint", | |
| 228 #"profile", | |
| 229 #"pstats", | |
| 230 #"pty", | |
| 231 #"pyclbr", | |
| 232 #"py_compile", | |
| 233 #"pydoc_data", | |
| 234 #"pydoc", | |
| 235 #"_pyio", | |
| 236 #"queue", | |
| 237 #"quopri", | |
| 238 #"reprlib", | |
| 239 "rlcompleter", | |
| 240 #"runpy", | |
| 241 #"sched", | |
| 242 #"shelve", | |
| 243 #"shlex", | |
| 244 #"smtpd", | |
| 245 #"smtplib", | |
| 246 #"sndhdr", | |
| 247 #"socket", | |
| 248 #"socketserver", | |
| 249 #"sqlite3", | |
| 250 #"ssl", | |
| 251 #"stringprep", | |
| 252 #"string", | |
| 253 #"_strptime", | |
| 254 #"subprocess", | |
| 255 #"sunau", | |
| 256 #"symbol", | |
| 257 #"symtable", | |
| 258 #"sysconfig", | |
| 259 #"tabnanny", | |
| 260 #"telnetlib", | |
| 261 #"test", | |
| 262 #"textwrap", | |
| 263 #"this", | |
| 264 #"_threading_local", | |
| 265 #"threading", | |
| 266 #"timeit", | |
| 267 #"tkinter", | |
| 268 #"tokenize", | |
| 269 #"token", | |
| 270 #"traceback", | |
| 271 #"trace", | |
| 272 #"tty", | |
| 273 #"turtledemo", | |
| 274 #"turtle", | |
| 275 #"unittest", | |
| 276 #"urllib", | |
| 277 #"uuid", | |
| 278 #"uu", | |
| 279 #"wave", | |
| 280 #"weakref", | |
| 281 #"webbrowser", | |
| 282 #"wsgiref", | |
| 283 #"xdrlib", | |
| 284 #"xml", | |
| 285 #"xmlrpc", | |
| 286 #"zipfile", | |
| 287 ]) | |
| 288 if minver >= 4: | |
| 289 REQUIRED_MODULES.extend([ | |
| 290 'operator', | |
| 291 '_collections_abc', | |
| 292 '_bootlocale', | |
| 293 ]) | |
| 294 | |
| 295 if is_pypy: | |
| 296 # these are needed to correctly display the exceptions that may happen | |
| 297 # during the bootstrap | |
| 298 REQUIRED_MODULES.extend(['traceback', 'linecache']) | |
| 299 | |
| 300 class Logger(object): | |
| 301 | |
| 302 """ | |
| 303 Logging object for use in command-line script. Allows ranges of | |
| 304 levels, to avoid some redundancy of displayed information. | |
| 305 """ | |
| 306 | |
| 307 DEBUG = logging.DEBUG | |
| 308 INFO = logging.INFO | |
| 309 NOTIFY = (logging.INFO+logging.WARN)/2 | |
| 310 WARN = WARNING = logging.WARN | |
| 311 ERROR = logging.ERROR | |
| 312 FATAL = logging.FATAL | |
| 313 | |
| 314 LEVELS = [DEBUG, INFO, NOTIFY, WARN, ERROR, FATAL] | |
| 315 | |
| 316 def __init__(self, consumers): | |
| 317 self.consumers = consumers | |
| 318 self.indent = 0 | |
| 319 self.in_progress = None | |
| 320 self.in_progress_hanging = False | |
| 321 | |
| 322 def debug(self, msg, *args, **kw): | |
| 323 self.log(self.DEBUG, msg, *args, **kw) | |
| 324 def info(self, msg, *args, **kw): | |
| 325 self.log(self.INFO, msg, *args, **kw) | |
| 326 def notify(self, msg, *args, **kw): | |
| 327 self.log(self.NOTIFY, msg, *args, **kw) | |
| 328 def warn(self, msg, *args, **kw): | |
| 329 self.log(self.WARN, msg, *args, **kw) | |
| 330 def error(self, msg, *args, **kw): | |
| 331 self.log(self.ERROR, msg, *args, **kw) | |
| 332 def fatal(self, msg, *args, **kw): | |
| 333 self.log(self.FATAL, msg, *args, **kw) | |
| 334 def log(self, level, msg, *args, **kw): | |
| 335 if args: | |
| 336 if kw: | |
| 337 raise TypeError( | |
| 338 "You may give positional or keyword arguments, not both") | |
| 339 args = args or kw | |
| 340 rendered = None | |
| 341 for consumer_level, consumer in self.consumers: | |
| 342 if self.level_matches(level, consumer_level): | |
| 343 if (self.in_progress_hanging | |
| 344 and consumer in (sys.stdout, sys.stderr)): | |
| 345 self.in_progress_hanging = False | |
| 346 sys.stdout.write('\n') | |
| 347 sys.stdout.flush() | |
| 348 if rendered is None: | |
| 349 if args: | |
| 350 rendered = msg % args | |
| 351 else: | |
| 352 rendered = msg | |
| 353 rendered = ' '*self.indent + rendered | |
| 354 if hasattr(consumer, 'write'): | |
| 355 consumer.write(rendered+'\n') | |
| 356 else: | |
| 357 consumer(rendered) | |
| 358 | |
| 359 def start_progress(self, msg): | |
| 360 assert not self.in_progress, ( | |
| 361 "Tried to start_progress(%r) while in_progress %r" | |
| 362 % (msg, self.in_progress)) | |
| 363 if self.level_matches(self.NOTIFY, self._stdout_level()): | |
| 364 sys.stdout.write(msg) | |
| 365 sys.stdout.flush() | |
| 366 self.in_progress_hanging = True | |
| 367 else: | |
| 368 self.in_progress_hanging = False | |
| 369 self.in_progress = msg | |
| 370 | |
| 371 def end_progress(self, msg='done.'): | |
| 372 assert self.in_progress, ( | |
| 373 "Tried to end_progress without start_progress") | |
| 374 if self.stdout_level_matches(self.NOTIFY): | |
| 375 if not self.in_progress_hanging: | |
| 376 # Some message has been printed out since start_progress | |
| 377 sys.stdout.write('...' + self.in_progress + msg + '\n') | |
| 378 sys.stdout.flush() | |
| 379 else: | |
| 380 sys.stdout.write(msg + '\n') | |
| 381 sys.stdout.flush() | |
| 382 self.in_progress = None | |
| 383 self.in_progress_hanging = False | |
| 384 | |
| 385 def show_progress(self): | |
| 386 """If we are in a progress scope, and no log messages have been | |
| 387 shown, write out another '.'""" | |
| 388 if self.in_progress_hanging: | |
| 389 sys.stdout.write('.') | |
| 390 sys.stdout.flush() | |
| 391 | |
| 392 def stdout_level_matches(self, level): | |
| 393 """Returns true if a message at this level will go to stdout""" | |
| 394 return self.level_matches(level, self._stdout_level()) | |
| 395 | |
| 396 def _stdout_level(self): | |
| 397 """Returns the level that stdout runs at""" | |
| 398 for level, consumer in self.consumers: | |
| 399 if consumer is sys.stdout: | |
| 400 return level | |
| 401 return self.FATAL | |
| 402 | |
| 403 def level_matches(self, level, consumer_level): | |
| 404 """ | |
| 405 >>> l = Logger([]) | |
| 406 >>> l.level_matches(3, 4) | |
| 407 False | |
| 408 >>> l.level_matches(3, 2) | |
| 409 True | |
| 410 >>> l.level_matches(slice(None, 3), 3) | |
| 411 False | |
| 412 >>> l.level_matches(slice(None, 3), 2) | |
| 413 True | |
| 414 >>> l.level_matches(slice(1, 3), 1) | |
| 415 True | |
| 416 >>> l.level_matches(slice(2, 3), 1) | |
| 417 False | |
| 418 """ | |
| 419 if isinstance(level, slice): | |
| 420 start, stop = level.start, level.stop | |
| 421 if start is not None and start > consumer_level: | |
| 422 return False | |
| 423 if stop is not None and stop <= consumer_level: | |
| 424 return False | |
| 425 return True | |
| 426 else: | |
| 427 return level >= consumer_level | |
| 428 | |
| 429 #@classmethod | |
| 430 def level_for_integer(cls, level): | |
| 431 levels = cls.LEVELS | |
| 432 if level < 0: | |
| 433 return levels[0] | |
| 434 if level >= len(levels): | |
| 435 return levels[-1] | |
| 436 return levels[level] | |
| 437 | |
| 438 level_for_integer = classmethod(level_for_integer) | |
| 439 | |
| 440 # create a silent logger just to prevent this from being undefined | |
| 441 # will be overridden with requested verbosity main() is called. | |
| 442 logger = Logger([(Logger.LEVELS[-1], sys.stdout)]) | |
| 443 | |
| 444 def mkdir(path): | |
| 445 if not os.path.exists(path): | |
| 446 logger.info('Creating %s', path) | |
| 447 os.makedirs(path) | |
| 448 else: | |
| 449 logger.info('Directory %s already exists', path) | |
| 450 | |
| 451 def copyfileordir(src, dest, symlink=True): | |
| 452 if os.path.isdir(src): | |
| 453 shutil.copytree(src, dest, symlink) | |
| 454 else: | |
| 455 shutil.copy2(src, dest) | |
| 456 | |
| 457 def copyfile(src, dest, symlink=True): | |
| 458 if not os.path.exists(src): | |
| 459 # Some bad symlink in the src | |
| 460 logger.warn('Cannot find file %s (bad symlink)', src) | |
| 461 return | |
| 462 if os.path.exists(dest): | |
| 463 logger.debug('File %s already exists', dest) | |
| 464 return | |
| 465 if not os.path.exists(os.path.dirname(dest)): | |
| 466 logger.info('Creating parent directories for %s', os.path.dirname(dest)) | |
| 467 os.makedirs(os.path.dirname(dest)) | |
| 468 if not os.path.islink(src): | |
| 469 srcpath = os.path.abspath(src) | |
| 470 else: | |
| 471 srcpath = os.readlink(src) | |
| 472 if symlink and hasattr(os, 'symlink') and not is_win: | |
| 473 logger.info('Symlinking %s', dest) | |
| 474 try: | |
| 475 os.symlink(srcpath, dest) | |
| 476 except (OSError, NotImplementedError): | |
| 477 logger.info('Symlinking failed, copying to %s', dest) | |
| 478 copyfileordir(src, dest, symlink) | |
| 479 else: | |
| 480 logger.info('Copying to %s', dest) | |
| 481 copyfileordir(src, dest, symlink) | |
| 482 | |
| 483 def writefile(dest, content, overwrite=True): | |
| 484 if not os.path.exists(dest): | |
| 485 logger.info('Writing %s', dest) | |
| 486 f = open(dest, 'wb') | |
| 487 f.write(content.encode('utf-8')) | |
| 488 f.close() | |
| 489 return | |
| 490 else: | |
| 491 f = open(dest, 'rb') | |
| 492 c = f.read() | |
| 493 f.close() | |
| 494 if c != content.encode("utf-8"): | |
| 495 if not overwrite: | |
| 496 logger.notify('File %s exists with different content; not overwriting', dest) | |
| 497 return | |
| 498 logger.notify('Overwriting %s with new content', dest) | |
| 499 f = open(dest, 'wb') | |
| 500 f.write(content.encode('utf-8')) | |
| 501 f.close() | |
| 502 else: | |
| 503 logger.info('Content %s already in place', dest) | |
| 504 | |
| 505 def rmtree(dir): | |
| 506 if os.path.exists(dir): | |
| 507 logger.notify('Deleting tree %s', dir) | |
| 508 shutil.rmtree(dir) | |
| 509 else: | |
| 510 logger.info('Do not need to delete %s; already gone', dir) | |
| 511 | |
| 512 def make_exe(fn): | |
| 513 if hasattr(os, 'chmod'): | |
| 514 oldmode = os.stat(fn).st_mode & 0xFFF # 0o7777 | |
| 515 newmode = (oldmode | 0x16D) & 0xFFF # 0o555, 0o7777 | |
| 516 os.chmod(fn, newmode) | |
| 517 logger.info('Changed mode of %s to %s', fn, oct(newmode)) | |
| 518 | |
| 519 def _find_file(filename, dirs): | |
| 520 for dir in reversed(dirs): | |
| 521 files = glob.glob(os.path.join(dir, filename)) | |
| 522 if files and os.path.isfile(files[0]): | |
| 523 return True, files[0] | |
| 524 return False, filename | |
| 525 | |
| 526 def file_search_dirs(): | |
| 527 here = os.path.dirname(os.path.abspath(__file__)) | |
| 528 dirs = ['.', here, | |
| 529 join(here, 'virtualenv_support')] | |
| 530 if os.path.splitext(os.path.dirname(__file__))[0] != 'virtualenv': | |
| 531 # Probably some boot script; just in case virtualenv is installed... | |
| 532 try: | |
| 533 import virtualenv | |
| 534 except ImportError: | |
| 535 pass | |
| 536 else: | |
| 537 dirs.append(os.path.join(os.path.dirname(virtualenv.__file__), 'virtualenv_support')) | |
| 538 return [d for d in dirs if os.path.isdir(d)] | |
| 539 | |
| 540 | |
| 541 class UpdatingDefaultsHelpFormatter(optparse.IndentedHelpFormatter): | |
| 542 """ | |
| 543 Custom help formatter for use in ConfigOptionParser that updates | |
| 544 the defaults before expanding them, allowing them to show up correctly | |
| 545 in the help listing | |
| 546 """ | |
| 547 def expand_default(self, option): | |
| 548 if self.parser is not None: | |
| 549 self.parser.update_defaults(self.parser.defaults) | |
| 550 return optparse.IndentedHelpFormatter.expand_default(self, option) | |
| 551 | |
| 552 | |
| 553 class ConfigOptionParser(optparse.OptionParser): | |
| 554 """ | |
| 555 Custom option parser which updates its defaults by checking the | |
| 556 configuration files and environmental variables | |
| 557 """ | |
| 558 def __init__(self, *args, **kwargs): | |
| 559 self.config = ConfigParser.RawConfigParser() | |
| 560 self.files = self.get_config_files() | |
| 561 self.config.read(self.files) | |
| 562 optparse.OptionParser.__init__(self, *args, **kwargs) | |
| 563 | |
| 564 def get_config_files(self): | |
| 565 config_file = os.environ.get('VIRTUALENV_CONFIG_FILE', False) | |
| 566 if config_file and os.path.exists(config_file): | |
| 567 return [config_file] | |
| 568 return [default_config_file] | |
| 569 | |
| 570 def update_defaults(self, defaults): | |
| 571 """ | |
| 572 Updates the given defaults with values from the config files and | |
| 573 the environ. Does a little special handling for certain types of | |
| 574 options (lists). | |
| 575 """ | |
| 576 # Then go and look for the other sources of configuration: | |
| 577 config = {} | |
| 578 # 1. config files | |
| 579 config.update(dict(self.get_config_section('virtualenv'))) | |
| 580 # 2. environmental variables | |
| 581 config.update(dict(self.get_environ_vars())) | |
| 582 # Then set the options with those values | |
| 583 for key, val in config.items(): | |
| 584 key = key.replace('_', '-') | |
| 585 if not key.startswith('--'): | |
| 586 key = '--%s' % key # only prefer long opts | |
| 587 option = self.get_option(key) | |
| 588 if option is not None: | |
| 589 # ignore empty values | |
| 590 if not val: | |
| 591 continue | |
| 592 # handle multiline configs | |
| 593 if option.action == 'append': | |
| 594 val = val.split() | |
| 595 else: | |
| 596 option.nargs = 1 | |
| 597 if option.action == 'store_false': | |
| 598 val = not strtobool(val) | |
| 599 elif option.action in ('store_true', 'count'): | |
| 600 val = strtobool(val) | |
| 601 try: | |
| 602 val = option.convert_value(key, val) | |
| 603 except optparse.OptionValueError: | |
| 604 e = sys.exc_info()[1] | |
| 605 print("An error occured during configuration: %s" % e) | |
| 606 sys.exit(3) | |
| 607 defaults[option.dest] = val | |
| 608 return defaults | |
| 609 | |
| 610 def get_config_section(self, name): | |
| 611 """ | |
| 612 Get a section of a configuration | |
| 613 """ | |
| 614 if self.config.has_section(name): | |
| 615 return self.config.items(name) | |
| 616 return [] | |
| 617 | |
| 618 def get_environ_vars(self, prefix='VIRTUALENV_'): | |
| 619 """ | |
| 620 Returns a generator with all environmental vars with prefix VIRTUALENV | |
| 621 """ | |
| 622 for key, val in os.environ.items(): | |
| 623 if key.startswith(prefix): | |
| 624 yield (key.replace(prefix, '').lower(), val) | |
| 625 | |
| 626 def get_default_values(self): | |
| 627 """ | |
| 628 Overridding to make updating the defaults after instantiation of | |
| 629 the option parser possible, update_defaults() does the dirty work. | |
| 630 """ | |
| 631 if not self.process_default_values: | |
| 632 # Old, pre-Optik 1.5 behaviour. | |
| 633 return optparse.Values(self.defaults) | |
| 634 | |
| 635 defaults = self.update_defaults(self.defaults.copy()) # ours | |
| 636 for option in self._get_all_options(): | |
| 637 default = defaults.get(option.dest) | |
| 638 if isinstance(default, basestring): | |
| 639 opt_str = option.get_opt_string() | |
| 640 defaults[option.dest] = option.check_value(opt_str, default) | |
| 641 return optparse.Values(defaults) | |
| 642 | |
| 643 | |
| 644 def main(): | |
| 645 parser = ConfigOptionParser( | |
| 646 version=virtualenv_version, | |
| 647 usage="%prog [OPTIONS] DEST_DIR", | |
| 648 formatter=UpdatingDefaultsHelpFormatter()) | |
| 649 | |
| 650 parser.add_option( | |
| 651 '-v', '--verbose', | |
| 652 action='count', | |
| 653 dest='verbose', | |
| 654 default=0, | |
| 655 help="Increase verbosity.") | |
| 656 | |
| 657 parser.add_option( | |
| 658 '-q', '--quiet', | |
| 659 action='count', | |
| 660 dest='quiet', | |
| 661 default=0, | |
| 662 help='Decrease verbosity.') | |
| 663 | |
| 664 parser.add_option( | |
| 665 '-p', '--python', | |
| 666 dest='python', | |
| 667 metavar='PYTHON_EXE', | |
| 668 help='The Python interpreter to use, e.g., --python=python2.5 will use the python2.5 ' | |
| 669 'interpreter to create the new environment. The default is the interpreter that ' | |
| 670 'virtualenv was installed with (%s)' % sys.executable) | |
| 671 | |
| 672 parser.add_option( | |
| 673 '--clear', | |
| 674 dest='clear', | |
| 675 action='store_true', | |
| 676 help="Clear out the non-root install and start from scratch.") | |
| 677 | |
| 678 parser.set_defaults(system_site_packages=False) | |
| 679 parser.add_option( | |
| 680 '--no-site-packages', | |
| 681 dest='system_site_packages', | |
| 682 action='store_false', | |
| 683 help="DEPRECATED. Retained only for backward compatibility. " | |
| 684 "Not having access to global site-packages is now the default behavior.") | |
| 685 | |
| 686 parser.add_option( | |
| 687 '--system-site-packages', | |
| 688 dest='system_site_packages', | |
| 689 action='store_true', | |
| 690 help="Give the virtual environment access to the global site-packages.") | |
| 691 | |
| 692 parser.add_option( | |
| 693 '--always-copy', | |
| 694 dest='symlink', | |
| 695 action='store_false', | |
| 696 default=True, | |
| 697 help="Always copy files rather than symlinking.") | |
| 698 | |
| 699 parser.add_option( | |
| 700 '--unzip-setuptools', | |
| 701 dest='unzip_setuptools', | |
| 702 action='store_true', | |
| 703 help="Unzip Setuptools when installing it.") | |
| 704 | |
| 705 parser.add_option( | |
| 706 '--relocatable', | |
| 707 dest='relocatable', | |
| 708 action='store_true', | |
| 709 help='Make an EXISTING virtualenv environment relocatable. ' | |
| 710 'This fixes up scripts and makes all .pth files relative.') | |
| 711 | |
| 712 parser.add_option( | |
| 713 '--no-setuptools', | |
| 714 dest='no_setuptools', | |
| 715 action='store_true', | |
| 716 help='Do not install setuptools (or pip) in the new virtualenv.') | |
| 717 | |
| 718 parser.add_option( | |
| 719 '--no-pip', | |
| 720 dest='no_pip', | |
| 721 action='store_true', | |
| 722 help='Do not install pip in the new virtualenv.') | |
| 723 | |
| 724 default_search_dirs = file_search_dirs() | |
| 725 parser.add_option( | |
| 726 '--extra-search-dir', | |
| 727 dest="search_dirs", | |
| 728 action="append", | |
| 729 metavar='DIR', | |
| 730 default=default_search_dirs, | |
| 731 help="Directory to look for setuptools/pip distributions in. " | |
| 732 "This option can be used multiple times.") | |
| 733 | |
| 734 parser.add_option( | |
| 735 '--never-download', | |
| 736 dest="never_download", | |
| 737 action="store_true", | |
| 738 default=True, | |
| 739 help="DEPRECATED. Retained only for backward compatibility. This option has no effect. " | |
| 740 "Virtualenv never downloads pip or setuptools.") | |
| 741 | |
| 742 parser.add_option( | |
| 743 '--prompt', | |
| 744 dest='prompt', | |
| 745 help='Provides an alternative prompt prefix for this environment.') | |
| 746 | |
| 747 parser.add_option( | |
| 748 '--setuptools', | |
| 749 dest='setuptools', | |
| 750 action='store_true', | |
| 751 help="DEPRECATED. Retained only for backward compatibility. This option has no effect.") | |
| 752 | |
| 753 parser.add_option( | |
| 754 '--distribute', | |
| 755 dest='distribute', | |
| 756 action='store_true', | |
| 757 help="DEPRECATED. Retained only for backward compatibility. This option has no effect.") | |
| 758 | |
| 759 if 'extend_parser' in globals(): | |
| 760 extend_parser(parser) | |
| 761 | |
| 762 options, args = parser.parse_args() | |
| 763 | |
| 764 global logger | |
| 765 | |
| 766 if 'adjust_options' in globals(): | |
| 767 adjust_options(options, args) | |
| 768 | |
| 769 verbosity = options.verbose - options.quiet | |
| 770 logger = Logger([(Logger.level_for_integer(2 - verbosity), sys.stdout)]) | |
| 771 | |
| 772 if options.python and not os.environ.get('VIRTUALENV_INTERPRETER_RUNNING'): | |
| 773 env = os.environ.copy() | |
| 774 interpreter = resolve_interpreter(options.python) | |
| 775 if interpreter == sys.executable: | |
| 776 logger.warn('Already using interpreter %s' % interpreter) | |
| 777 else: | |
| 778 logger.notify('Running virtualenv with interpreter %s' % interpreter) | |
| 779 env['VIRTUALENV_INTERPRETER_RUNNING'] = 'true' | |
| 780 file = __file__ | |
| 781 if file.endswith('.pyc'): | |
| 782 file = file[:-1] | |
| 783 popen = subprocess.Popen([interpreter, file] + sys.argv[1:], env=env) | |
| 784 raise SystemExit(popen.wait()) | |
| 785 | |
| 786 if not args: | |
| 787 print('You must provide a DEST_DIR') | |
| 788 parser.print_help() | |
| 789 sys.exit(2) | |
| 790 if len(args) > 1: | |
| 791 print('There must be only one argument: DEST_DIR (you gave %s)' % ( | |
| 792 ' '.join(args))) | |
| 793 parser.print_help() | |
| 794 sys.exit(2) | |
| 795 | |
| 796 home_dir = args[0] | |
| 797 | |
| 798 if os.environ.get('WORKING_ENV'): | |
| 799 logger.fatal('ERROR: you cannot run virtualenv while in a workingenv') | |
| 800 logger.fatal('Please deactivate your workingenv, then re-run this script') | |
| 801 sys.exit(3) | |
| 802 | |
| 803 if 'PYTHONHOME' in os.environ: | |
| 804 logger.warn('PYTHONHOME is set. You *must* activate the virtualenv before using it') | |
| 805 del os.environ['PYTHONHOME'] | |
| 806 | |
| 807 if options.relocatable: | |
| 808 make_environment_relocatable(home_dir) | |
| 809 return | |
| 810 | |
| 811 if not options.never_download: | |
| 812 logger.warn('The --never-download option is for backward compatibility only.') | |
| 813 logger.warn('Setting it to false is no longer supported, and will be ignored.') | |
| 814 | |
| 815 create_environment(home_dir, | |
| 816 site_packages=options.system_site_packages, | |
| 817 clear=options.clear, | |
| 818 unzip_setuptools=options.unzip_setuptools, | |
| 819 prompt=options.prompt, | |
| 820 search_dirs=options.search_dirs, | |
| 821 never_download=True, | |
| 822 no_setuptools=options.no_setuptools, | |
| 823 no_pip=options.no_pip, | |
| 824 symlink=options.symlink) | |
| 825 if 'after_install' in globals(): | |
| 826 after_install(options, home_dir) | |
| 827 | |
| 828 def call_subprocess(cmd, show_stdout=True, | |
| 829 filter_stdout=None, cwd=None, | |
| 830 raise_on_returncode=True, extra_env=None, | |
| 831 remove_from_env=None): | |
| 832 cmd_parts = [] | |
| 833 for part in cmd: | |
| 834 if len(part) > 45: | |
| 835 part = part[:20]+"..."+part[-20:] | |
| 836 if ' ' in part or '\n' in part or '"' in part or "'" in part: | |
| 837 part = '"%s"' % part.replace('"', '\\"') | |
| 838 if hasattr(part, 'decode'): | |
| 839 try: | |
| 840 part = part.decode(sys.getdefaultencoding()) | |
| 841 except UnicodeDecodeError: | |
| 842 part = part.decode(sys.getfilesystemencoding()) | |
| 843 cmd_parts.append(part) | |
| 844 cmd_desc = ' '.join(cmd_parts) | |
| 845 if show_stdout: | |
| 846 stdout = None | |
| 847 else: | |
| 848 stdout = subprocess.PIPE | |
| 849 logger.debug("Running command %s" % cmd_desc) | |
| 850 if extra_env or remove_from_env: | |
| 851 env = os.environ.copy() | |
| 852 if extra_env: | |
| 853 env.update(extra_env) | |
| 854 if remove_from_env: | |
| 855 for varname in remove_from_env: | |
| 856 env.pop(varname, None) | |
| 857 else: | |
| 858 env = None | |
| 859 try: | |
| 860 proc = subprocess.Popen( | |
| 861 cmd, stderr=subprocess.STDOUT, stdin=None, stdout=stdout, | |
| 862 cwd=cwd, env=env) | |
| 863 except Exception: | |
| 864 e = sys.exc_info()[1] | |
| 865 logger.fatal( | |
| 866 "Error %s while executing command %s" % (e, cmd_desc)) | |
| 867 raise | |
| 868 all_output = [] | |
| 869 if stdout is not None: | |
| 870 stdout = proc.stdout | |
| 871 encoding = sys.getdefaultencoding() | |
| 872 fs_encoding = sys.getfilesystemencoding() | |
| 873 while 1: | |
| 874 line = stdout.readline() | |
| 875 try: | |
| 876 line = line.decode(encoding) | |
| 877 except UnicodeDecodeError: | |
| 878 line = line.decode(fs_encoding) | |
| 879 if not line: | |
| 880 break | |
| 881 line = line.rstrip() | |
| 882 all_output.append(line) | |
| 883 if filter_stdout: | |
| 884 level = filter_stdout(line) | |
| 885 if isinstance(level, tuple): | |
| 886 level, line = level | |
| 887 logger.log(level, line) | |
| 888 if not logger.stdout_level_matches(level): | |
| 889 logger.show_progress() | |
| 890 else: | |
| 891 logger.info(line) | |
| 892 else: | |
| 893 proc.communicate() | |
| 894 proc.wait() | |
| 895 if proc.returncode: | |
| 896 if raise_on_returncode: | |
| 897 if all_output: | |
| 898 logger.notify('Complete output from command %s:' % cmd_desc) | |
| 899 logger.notify('\n'.join(all_output) + '\n----------------------------------------') | |
| 900 raise OSError( | |
| 901 "Command %s failed with error code %s" | |
| 902 % (cmd_desc, proc.returncode)) | |
| 903 else: | |
| 904 logger.warn( | |
| 905 "Command %s had error code %s" | |
| 906 % (cmd_desc, proc.returncode)) | |
| 907 | |
| 908 def filter_install_output(line): | |
| 909 if line.strip().startswith('running'): | |
| 910 return Logger.INFO | |
| 911 return Logger.DEBUG | |
| 912 | |
| 913 def find_wheels(projects, search_dirs): | |
| 914 """Find wheels from which we can import PROJECTS. | |
| 915 | |
| 916 Scan through SEARCH_DIRS for a wheel for each PROJECT in turn. Return | |
| 917 a list of the first wheel found for each PROJECT | |
| 918 """ | |
| 919 | |
| 920 wheels = [] | |
| 921 | |
| 922 # Look through SEARCH_DIRS for the first suitable wheel. Don't bother | |
| 923 # about version checking here, as this is simply to get something we can | |
| 924 # then use to install the correct version. | |
| 925 for project in projects: | |
| 926 for dirname in search_dirs: | |
| 927 # This relies on only having "universal" wheels available. | |
| 928 # The pattern could be tightened to require -py2.py3-none-any.whl. | |
| 929 files = glob.glob(os.path.join(dirname, project + '-*.whl')) | |
| 930 if files: | |
| 931 wheels.append(os.path.abspath(files[0])) | |
| 932 break | |
| 933 else: | |
| 934 # We're out of luck, so quit with a suitable error | |
| 935 logger.fatal('Cannot find a wheel for %s' % (project,)) | |
| 936 | |
| 937 return wheels | |
| 938 | |
| 939 def install_wheel(project_names, py_executable, search_dirs=None): | |
| 940 if search_dirs is None: | |
| 941 search_dirs = file_search_dirs() | |
| 942 | |
| 943 wheels = find_wheels(['setuptools', 'pip'], search_dirs) | |
| 944 pythonpath = os.pathsep.join(wheels) | |
| 945 findlinks = ' '.join(search_dirs) | |
| 946 | |
| 947 cmd = [ | |
| 948 py_executable, '-c', | |
| 949 'import sys, pip; sys.exit(pip.main(["install", "--ignore-installed"] + sys.argv[1:]))', | |
| 950 ] + project_names | |
| 951 logger.start_progress('Installing %s...' % (', '.join(project_names))) | |
| 952 logger.indent += 2 | |
| 953 try: | |
| 954 call_subprocess(cmd, show_stdout=False, | |
| 955 extra_env = { | |
| 956 'PYTHONPATH': pythonpath, | |
| 957 'PIP_FIND_LINKS': findlinks, | |
| 958 'PIP_USE_WHEEL': '1', | |
| 959 'PIP_PRE': '1', | |
| 960 'PIP_NO_INDEX': '1' | |
| 961 } | |
| 962 ) | |
| 963 finally: | |
| 964 logger.indent -= 2 | |
| 965 logger.end_progress() | |
| 966 | |
| 967 def create_environment(home_dir, site_packages=False, clear=False, | |
| 968 unzip_setuptools=False, | |
| 969 prompt=None, search_dirs=None, never_download=False, | |
| 970 no_setuptools=False, no_pip=False, symlink=True): | |
| 971 """ | |
| 972 Creates a new environment in ``home_dir``. | |
| 973 | |
| 974 If ``site_packages`` is true, then the global ``site-packages/`` | |
| 975 directory will be on the path. | |
| 976 | |
| 977 If ``clear`` is true (default False) then the environment will | |
| 978 first be cleared. | |
| 979 """ | |
| 980 home_dir, lib_dir, inc_dir, bin_dir = path_locations(home_dir) | |
| 981 | |
| 982 py_executable = os.path.abspath(install_python( | |
| 983 home_dir, lib_dir, inc_dir, bin_dir, | |
| 984 site_packages=site_packages, clear=clear, symlink=symlink)) | |
| 985 | |
| 986 install_distutils(home_dir) | |
| 987 | |
| 988 if not no_setuptools: | |
| 989 to_install = ['setuptools'] | |
| 990 if not no_pip: | |
| 991 to_install.append('pip') | |
| 992 install_wheel(to_install, py_executable, search_dirs) | |
| 993 | |
| 994 install_activate(home_dir, bin_dir, prompt) | |
| 995 | |
| 996 def is_executable_file(fpath): | |
| 997 return os.path.isfile(fpath) and os.access(fpath, os.X_OK) | |
| 998 | |
| 999 def path_locations(home_dir): | |
| 1000 """Return the path locations for the environment (where libraries are, | |
| 1001 where scripts go, etc)""" | |
| 1002 # XXX: We'd use distutils.sysconfig.get_python_inc/lib but its | |
| 1003 # prefix arg is broken: http://bugs.python.org/issue3386 | |
| 1004 if is_win: | |
| 1005 # Windows has lots of problems with executables with spaces in | |
| 1006 # the name; this function will remove them (using the ~1 | |
| 1007 # format): | |
| 1008 mkdir(home_dir) | |
| 1009 if ' ' in home_dir: | |
| 1010 import ctypes | |
| 1011 GetShortPathName = ctypes.windll.kernel32.GetShortPathNameW | |
| 1012 size = max(len(home_dir)+1, 256) | |
| 1013 buf = ctypes.create_unicode_buffer(size) | |
| 1014 try: | |
| 1015 u = unicode | |
| 1016 except NameError: | |
| 1017 u = str | |
| 1018 ret = GetShortPathName(u(home_dir), buf, size) | |
| 1019 if not ret: | |
| 1020 print('Error: the path "%s" has a space in it' % home_dir) | |
| 1021 print('We could not determine the short pathname for it.') | |
| 1022 print('Exiting.') | |
| 1023 sys.exit(3) | |
| 1024 home_dir = str(buf.value) | |
| 1025 lib_dir = join(home_dir, 'Lib') | |
| 1026 inc_dir = join(home_dir, 'Include') | |
| 1027 bin_dir = join(home_dir, 'Scripts') | |
| 1028 if is_jython: | |
| 1029 lib_dir = join(home_dir, 'Lib') | |
| 1030 inc_dir = join(home_dir, 'Include') | |
| 1031 bin_dir = join(home_dir, 'bin') | |
| 1032 elif is_pypy: | |
| 1033 lib_dir = home_dir | |
| 1034 inc_dir = join(home_dir, 'include') | |
| 1035 bin_dir = join(home_dir, 'bin') | |
| 1036 elif not is_win: | |
| 1037 lib_dir = join(home_dir, 'lib', py_version) | |
| 1038 multiarch_exec = '/usr/bin/multiarch-platform' | |
| 1039 if is_executable_file(multiarch_exec): | |
| 1040 # In Mageia (2) and Mandriva distros the include dir must be like: | |
| 1041 # virtualenv/include/multiarch-x86_64-linux/python2.7 | |
| 1042 # instead of being virtualenv/include/python2.7 | |
| 1043 p = subprocess.Popen(multiarch_exec, stdout=subprocess.PIPE, stderr=subprocess.PIPE) | |
| 1044 stdout, stderr = p.communicate() | |
| 1045 # stdout.strip is needed to remove newline character | |
| 1046 inc_dir = join(home_dir, 'include', stdout.strip(), py_version + abiflags) | |
| 1047 else: | |
| 1048 inc_dir = join(home_dir, 'include', py_version + abiflags) | |
| 1049 bin_dir = join(home_dir, 'bin') | |
| 1050 return home_dir, lib_dir, inc_dir, bin_dir | |
| 1051 | |
| 1052 | |
| 1053 def change_prefix(filename, dst_prefix): | |
| 1054 prefixes = [sys.prefix] | |
| 1055 | |
| 1056 if is_darwin: | |
| 1057 prefixes.extend(( | |
| 1058 os.path.join("/Library/Python", sys.version[:3], "site-packages"), | |
| 1059 os.path.join(sys.prefix, "Extras", "lib", "python"), | |
| 1060 os.path.join("~", "Library", "Python", sys.version[:3], "site-packages"), | |
| 1061 # Python 2.6 no-frameworks | |
| 1062 os.path.join("~", ".local", "lib","python", sys.version[:3], "site-packages"), | |
| 1063 # System Python 2.7 on OSX Mountain Lion | |
| 1064 os.path.join("~", "Library", "Python", sys.version[:3], "lib", "python", "site-packages"))) | |
| 1065 | |
| 1066 if hasattr(sys, 'real_prefix'): | |
| 1067 prefixes.append(sys.real_prefix) | |
| 1068 if hasattr(sys, 'base_prefix'): | |
| 1069 prefixes.append(sys.base_prefix) | |
| 1070 prefixes = list(map(os.path.expanduser, prefixes)) | |
| 1071 prefixes = list(map(os.path.abspath, prefixes)) | |
| 1072 # Check longer prefixes first so we don't split in the middle of a filename | |
| 1073 prefixes = sorted(prefixes, key=len, reverse=True) | |
| 1074 filename = os.path.abspath(filename) | |
| 1075 for src_prefix in prefixes: | |
| 1076 if filename.startswith(src_prefix): | |
| 1077 _, relpath = filename.split(src_prefix, 1) | |
| 1078 if src_prefix != os.sep: # sys.prefix == "/" | |
| 1079 assert relpath[0] == os.sep | |
| 1080 relpath = relpath[1:] | |
| 1081 return join(dst_prefix, relpath) | |
| 1082 assert False, "Filename %s does not start with any of these prefixes: %s" % \ | |
| 1083 (filename, prefixes) | |
| 1084 | |
| 1085 def copy_required_modules(dst_prefix, symlink): | |
| 1086 import imp | |
| 1087 # If we are running under -p, we need to remove the current | |
| 1088 # directory from sys.path temporarily here, so that we | |
| 1089 # definitely get the modules from the site directory of | |
| 1090 # the interpreter we are running under, not the one | |
| 1091 # virtualenv.py is installed under (which might lead to py2/py3 | |
| 1092 # incompatibility issues) | |
| 1093 _prev_sys_path = sys.path | |
| 1094 if os.environ.get('VIRTUALENV_INTERPRETER_RUNNING'): | |
| 1095 sys.path = sys.path[1:] | |
| 1096 try: | |
| 1097 for modname in REQUIRED_MODULES: | |
| 1098 if modname in sys.builtin_module_names: | |
| 1099 logger.info("Ignoring built-in bootstrap module: %s" % modname) | |
| 1100 continue | |
| 1101 try: | |
| 1102 f, filename, _ = imp.find_module(modname) | |
| 1103 except ImportError: | |
| 1104 logger.info("Cannot import bootstrap module: %s" % modname) | |
| 1105 else: | |
| 1106 if f is not None: | |
| 1107 f.close() | |
| 1108 # special-case custom readline.so on OS X, but not for pypy: | |
| 1109 if modname == 'readline' and sys.platform == 'darwin' and not ( | |
| 1110 is_pypy or filename.endswith(join('lib-dynload', 'readline.so'))): | |
| 1111 dst_filename = join(dst_prefix, 'lib', 'python%s' % sys.version[:3], 'readline.so') | |
| 1112 elif modname == 'readline' and sys.platform == 'win32': | |
| 1113 # special-case for Windows, where readline is not a | |
| 1114 # standard module, though it may have been installed in | |
| 1115 # site-packages by a third-party package | |
| 1116 pass | |
| 1117 else: | |
| 1118 dst_filename = change_prefix(filename, dst_prefix) | |
| 1119 copyfile(filename, dst_filename, symlink) | |
| 1120 if filename.endswith('.pyc'): | |
| 1121 pyfile = filename[:-1] | |
| 1122 if os.path.exists(pyfile): | |
| 1123 copyfile(pyfile, dst_filename[:-1], symlink) | |
| 1124 finally: | |
| 1125 sys.path = _prev_sys_path | |
| 1126 | |
| 1127 | |
| 1128 def subst_path(prefix_path, prefix, home_dir): | |
| 1129 prefix_path = os.path.normpath(prefix_path) | |
| 1130 prefix = os.path.normpath(prefix) | |
| 1131 home_dir = os.path.normpath(home_dir) | |
| 1132 if not prefix_path.startswith(prefix): | |
| 1133 logger.warn('Path not in prefix %r %r', prefix_path, prefix) | |
| 1134 return | |
| 1135 return prefix_path.replace(prefix, home_dir, 1) | |
| 1136 | |
| 1137 | |
| 1138 def install_python(home_dir, lib_dir, inc_dir, bin_dir, site_packages, clear, symlink=True): | |
| 1139 """Install just the base environment, no distutils patches etc""" | |
| 1140 if sys.executable.startswith(bin_dir): | |
| 1141 print('Please use the *system* python to run this script') | |
| 1142 return | |
| 1143 | |
| 1144 if clear: | |
| 1145 rmtree(lib_dir) | |
| 1146 ## FIXME: why not delete it? | |
| 1147 ## Maybe it should delete everything with #!/path/to/venv/python in it | |
| 1148 logger.notify('Not deleting %s', bin_dir) | |
| 1149 | |
| 1150 if hasattr(sys, 'real_prefix'): | |
| 1151 logger.notify('Using real prefix %r' % sys.real_prefix) | |
| 1152 prefix = sys.real_prefix | |
| 1153 elif hasattr(sys, 'base_prefix'): | |
| 1154 logger.notify('Using base prefix %r' % sys.base_prefix) | |
| 1155 prefix = sys.base_prefix | |
| 1156 else: | |
| 1157 prefix = sys.prefix | |
| 1158 mkdir(lib_dir) | |
| 1159 fix_lib64(lib_dir, symlink) | |
| 1160 stdlib_dirs = [os.path.dirname(os.__file__)] | |
| 1161 if is_win: | |
| 1162 stdlib_dirs.append(join(os.path.dirname(stdlib_dirs[0]), 'DLLs')) | |
| 1163 elif is_darwin: | |
| 1164 stdlib_dirs.append(join(stdlib_dirs[0], 'site-packages')) | |
| 1165 if hasattr(os, 'symlink'): | |
| 1166 logger.info('Symlinking Python bootstrap modules') | |
| 1167 else: | |
| 1168 logger.info('Copying Python bootstrap modules') | |
| 1169 logger.indent += 2 | |
| 1170 try: | |
| 1171 # copy required files... | |
| 1172 for stdlib_dir in stdlib_dirs: | |
| 1173 if not os.path.isdir(stdlib_dir): | |
| 1174 continue | |
| 1175 for fn in os.listdir(stdlib_dir): | |
| 1176 bn = os.path.splitext(fn)[0] | |
| 1177 if fn != 'site-packages' and bn in REQUIRED_FILES: | |
| 1178 copyfile(join(stdlib_dir, fn), join(lib_dir, fn), symlink) | |
| 1179 # ...and modules | |
| 1180 copy_required_modules(home_dir, symlink) | |
| 1181 finally: | |
| 1182 logger.indent -= 2 | |
| 1183 mkdir(join(lib_dir, 'site-packages')) | |
| 1184 import site | |
| 1185 site_filename = site.__file__ | |
| 1186 if site_filename.endswith('.pyc'): | |
| 1187 site_filename = site_filename[:-1] | |
| 1188 elif site_filename.endswith('$py.class'): | |
| 1189 site_filename = site_filename.replace('$py.class', '.py') | |
| 1190 site_filename_dst = change_prefix(site_filename, home_dir) | |
| 1191 site_dir = os.path.dirname(site_filename_dst) | |
| 1192 writefile(site_filename_dst, SITE_PY) | |
| 1193 writefile(join(site_dir, 'orig-prefix.txt'), prefix) | |
| 1194 site_packages_filename = join(site_dir, 'no-global-site-packages.txt') | |
| 1195 if not site_packages: | |
| 1196 writefile(site_packages_filename, '') | |
| 1197 | |
| 1198 if is_pypy or is_win: | |
| 1199 stdinc_dir = join(prefix, 'include') | |
| 1200 else: | |
| 1201 stdinc_dir = join(prefix, 'include', py_version + abiflags) | |
| 1202 if os.path.exists(stdinc_dir): | |
| 1203 copyfile(stdinc_dir, inc_dir, symlink) | |
| 1204 else: | |
| 1205 logger.debug('No include dir %s' % stdinc_dir) | |
| 1206 | |
| 1207 platinc_dir = distutils.sysconfig.get_python_inc(plat_specific=1) | |
| 1208 if platinc_dir != stdinc_dir: | |
| 1209 platinc_dest = distutils.sysconfig.get_python_inc( | |
| 1210 plat_specific=1, prefix=home_dir) | |
| 1211 if platinc_dir == platinc_dest: | |
| 1212 # Do platinc_dest manually due to a CPython bug; | |
| 1213 # not http://bugs.python.org/issue3386 but a close cousin | |
| 1214 platinc_dest = subst_path(platinc_dir, prefix, home_dir) | |
| 1215 if platinc_dest: | |
| 1216 # PyPy's stdinc_dir and prefix are relative to the original binary | |
| 1217 # (traversing virtualenvs), whereas the platinc_dir is relative to | |
| 1218 # the inner virtualenv and ignores the prefix argument. | |
| 1219 # This seems more evolved than designed. | |
| 1220 copyfile(platinc_dir, platinc_dest, symlink) | |
| 1221 | |
| 1222 # pypy never uses exec_prefix, just ignore it | |
| 1223 if sys.exec_prefix != prefix and not is_pypy: | |
| 1224 if is_win: | |
| 1225 exec_dir = join(sys.exec_prefix, 'lib') | |
| 1226 elif is_jython: | |
| 1227 exec_dir = join(sys.exec_prefix, 'Lib') | |
| 1228 else: | |
| 1229 exec_dir = join(sys.exec_prefix, 'lib', py_version) | |
| 1230 for fn in os.listdir(exec_dir): | |
| 1231 copyfile(join(exec_dir, fn), join(lib_dir, fn), symlink) | |
| 1232 | |
| 1233 if is_jython: | |
| 1234 # Jython has either jython-dev.jar and javalib/ dir, or just | |
| 1235 # jython.jar | |
| 1236 for name in 'jython-dev.jar', 'javalib', 'jython.jar': | |
| 1237 src = join(prefix, name) | |
| 1238 if os.path.exists(src): | |
| 1239 copyfile(src, join(home_dir, name), symlink) | |
| 1240 # XXX: registry should always exist after Jython 2.5rc1 | |
| 1241 src = join(prefix, 'registry') | |
| 1242 if os.path.exists(src): | |
| 1243 copyfile(src, join(home_dir, 'registry'), symlink=False) | |
| 1244 copyfile(join(prefix, 'cachedir'), join(home_dir, 'cachedir'), | |
| 1245 symlink=False) | |
| 1246 | |
| 1247 mkdir(bin_dir) | |
| 1248 py_executable = join(bin_dir, os.path.basename(sys.executable)) | |
| 1249 if 'Python.framework' in prefix: | |
| 1250 # OS X framework builds cause validation to break | |
| 1251 # https://github.com/pypa/virtualenv/issues/322 | |
| 1252 if os.environ.get('__PYVENV_LAUNCHER__'): | |
| 1253 del os.environ["__PYVENV_LAUNCHER__"] | |
| 1254 if re.search(r'/Python(?:-32|-64)*$', py_executable): | |
| 1255 # The name of the python executable is not quite what | |
| 1256 # we want, rename it. | |
| 1257 py_executable = os.path.join( | |
| 1258 os.path.dirname(py_executable), 'python') | |
| 1259 | |
| 1260 logger.notify('New %s executable in %s', expected_exe, py_executable) | |
| 1261 pcbuild_dir = os.path.dirname(sys.executable) | |
| 1262 pyd_pth = os.path.join(lib_dir, 'site-packages', 'virtualenv_builddir_pyd.pth') | |
| 1263 if is_win and os.path.exists(os.path.join(pcbuild_dir, 'build.bat')): | |
| 1264 logger.notify('Detected python running from build directory %s', pcbuild_dir) | |
| 1265 logger.notify('Writing .pth file linking to build directory for *.pyd files') | |
| 1266 writefile(pyd_pth, pcbuild_dir) | |
| 1267 else: | |
| 1268 pcbuild_dir = None | |
| 1269 if os.path.exists(pyd_pth): | |
| 1270 logger.info('Deleting %s (not Windows env or not build directory python)' % pyd_pth) | |
| 1271 os.unlink(pyd_pth) | |
| 1272 | |
| 1273 if sys.executable != py_executable: | |
| 1274 ## FIXME: could I just hard link? | |
| 1275 executable = sys.executable | |
| 1276 shutil.copyfile(executable, py_executable) | |
| 1277 make_exe(py_executable) | |
| 1278 if is_win or is_cygwin: | |
| 1279 pythonw = os.path.join(os.path.dirname(sys.executable), 'pythonw.exe') | |
| 1280 if os.path.exists(pythonw): | |
| 1281 logger.info('Also created pythonw.exe') | |
| 1282 shutil.copyfile(pythonw, os.path.join(os.path.dirname(py_executable), 'pythonw.exe')) | |
| 1283 python_d = os.path.join(os.path.dirname(sys.executable), 'python_d.exe') | |
| 1284 python_d_dest = os.path.join(os.path.dirname(py_executable), 'python_d.exe') | |
| 1285 if os.path.exists(python_d): | |
| 1286 logger.info('Also created python_d.exe') | |
| 1287 shutil.copyfile(python_d, python_d_dest) | |
| 1288 elif os.path.exists(python_d_dest): | |
| 1289 logger.info('Removed python_d.exe as it is no longer at the source') | |
| 1290 os.unlink(python_d_dest) | |
| 1291 # we need to copy the DLL to enforce that windows will load the correct one. | |
| 1292 # may not exist if we are cygwin. | |
| 1293 py_executable_dll = 'python%s%s.dll' % ( | |
| 1294 sys.version_info[0], sys.version_info[1]) | |
| 1295 py_executable_dll_d = 'python%s%s_d.dll' % ( | |
| 1296 sys.version_info[0], sys.version_info[1]) | |
| 1297 pythondll = os.path.join(os.path.dirname(sys.executable), py_executable_dll) | |
| 1298 pythondll_d = os.path.join(os.path.dirname(sys.executable), py_executable_dll_d) | |
| 1299 pythondll_d_dest = os.path.join(os.path.dirname(py_executable), py_executable_dll_d) | |
| 1300 if os.path.exists(pythondll): | |
| 1301 logger.info('Also created %s' % py_executable_dll) | |
| 1302 shutil.copyfile(pythondll, os.path.join(os.path.dirname(py_executable), py_executable_dll)) | |
| 1303 if os.path.exists(pythondll_d): | |
| 1304 logger.info('Also created %s' % py_executable_dll_d) | |
| 1305 shutil.copyfile(pythondll_d, pythondll_d_dest) | |
| 1306 elif os.path.exists(pythondll_d_dest): | |
| 1307 logger.info('Removed %s as the source does not exist' % pythondll_d_dest) | |
| 1308 os.unlink(pythondll_d_dest) | |
| 1309 if is_pypy: | |
| 1310 # make a symlink python --> pypy-c | |
| 1311 python_executable = os.path.join(os.path.dirname(py_executable), 'python') | |
| 1312 if sys.platform in ('win32', 'cygwin'): | |
| 1313 python_executable += '.exe' | |
| 1314 logger.info('Also created executable %s' % python_executable) | |
| 1315 copyfile(py_executable, python_executable, symlink) | |
| 1316 | |
| 1317 if is_win: | |
| 1318 for name in 'libexpat.dll', 'libpypy.dll', 'libpypy-c.dll', 'libeay32.dll', 'ssleay32.dll', 'sqlite.dll': | |
| 1319 src = join(prefix, name) | |
| 1320 if os.path.exists(src): | |
| 1321 copyfile(src, join(bin_dir, name), symlink) | |
| 1322 | |
| 1323 if os.path.splitext(os.path.basename(py_executable))[0] != expected_exe: | |
| 1324 secondary_exe = os.path.join(os.path.dirname(py_executable), | |
| 1325 expected_exe) | |
| 1326 py_executable_ext = os.path.splitext(py_executable)[1] | |
| 1327 if py_executable_ext.lower() == '.exe': | |
| 1328 # python2.4 gives an extension of '.4' :P | |
| 1329 secondary_exe += py_executable_ext | |
| 1330 if os.path.exists(secondary_exe): | |
| 1331 logger.warn('Not overwriting existing %s script %s (you must use %s)' | |
| 1332 % (expected_exe, secondary_exe, py_executable)) | |
| 1333 else: | |
| 1334 logger.notify('Also creating executable in %s' % secondary_exe) | |
| 1335 shutil.copyfile(sys.executable, secondary_exe) | |
| 1336 make_exe(secondary_exe) | |
| 1337 | |
| 1338 if '.framework' in prefix: | |
| 1339 if 'Python.framework' in prefix: | |
| 1340 logger.debug('MacOSX Python framework detected') | |
| 1341 # Make sure we use the the embedded interpreter inside | |
| 1342 # the framework, even if sys.executable points to | |
| 1343 # the stub executable in ${sys.prefix}/bin | |
| 1344 # See http://groups.google.com/group/python-virtualenv/ | |
| 1345 # browse_thread/thread/17cab2f85da75951 | |
| 1346 original_python = os.path.join( | |
| 1347 prefix, 'Resources/Python.app/Contents/MacOS/Python') | |
| 1348 if 'EPD' in prefix: | |
| 1349 logger.debug('EPD framework detected') | |
| 1350 original_python = os.path.join(prefix, 'bin/python') | |
| 1351 shutil.copy(original_python, py_executable) | |
| 1352 | |
| 1353 # Copy the framework's dylib into the virtual | |
| 1354 # environment | |
| 1355 virtual_lib = os.path.join(home_dir, '.Python') | |
| 1356 | |
| 1357 if os.path.exists(virtual_lib): | |
| 1358 os.unlink(virtual_lib) | |
| 1359 copyfile( | |
| 1360 os.path.join(prefix, 'Python'), | |
| 1361 virtual_lib, | |
| 1362 symlink) | |
| 1363 | |
| 1364 # And then change the install_name of the copied python executable | |
| 1365 try: | |
| 1366 mach_o_change(py_executable, | |
| 1367 os.path.join(prefix, 'Python'), | |
| 1368 '@executable_path/../.Python') | |
| 1369 except: | |
| 1370 e = sys.exc_info()[1] | |
| 1371 logger.warn("Could not call mach_o_change: %s. " | |
| 1372 "Trying to call install_name_tool instead." % e) | |
| 1373 try: | |
| 1374 call_subprocess( | |
| 1375 ["install_name_tool", "-change", | |
| 1376 os.path.join(prefix, 'Python'), | |
| 1377 '@executable_path/../.Python', | |
| 1378 py_executable]) | |
| 1379 except: | |
| 1380 logger.fatal("Could not call install_name_tool -- you must " | |
| 1381 "have Apple's development tools installed") | |
| 1382 raise | |
| 1383 | |
| 1384 if not is_win: | |
| 1385 # Ensure that 'python', 'pythonX' and 'pythonX.Y' all exist | |
| 1386 py_exe_version_major = 'python%s' % sys.version_info[0] | |
| 1387 py_exe_version_major_minor = 'python%s.%s' % ( | |
| 1388 sys.version_info[0], sys.version_info[1]) | |
| 1389 py_exe_no_version = 'python' | |
| 1390 required_symlinks = [ py_exe_no_version, py_exe_version_major, | |
| 1391 py_exe_version_major_minor ] | |
| 1392 | |
| 1393 py_executable_base = os.path.basename(py_executable) | |
| 1394 | |
| 1395 if py_executable_base in required_symlinks: | |
| 1396 # Don't try to symlink to yourself. | |
| 1397 required_symlinks.remove(py_executable_base) | |
| 1398 | |
| 1399 for pth in required_symlinks: | |
| 1400 full_pth = join(bin_dir, pth) | |
| 1401 if os.path.exists(full_pth): | |
| 1402 os.unlink(full_pth) | |
| 1403 if symlink: | |
| 1404 os.symlink(py_executable_base, full_pth) | |
| 1405 else: | |
| 1406 copyfile(py_executable, full_pth, symlink) | |
| 1407 | |
| 1408 if is_win and ' ' in py_executable: | |
| 1409 # There's a bug with subprocess on Windows when using a first | |
| 1410 # argument that has a space in it. Instead we have to quote | |
| 1411 # the value: | |
| 1412 py_executable = '"%s"' % py_executable | |
| 1413 # NOTE: keep this check as one line, cmd.exe doesn't cope with line breaks | |
| 1414 cmd = [py_executable, '-c', 'import sys;out=sys.stdout;' | |
| 1415 'getattr(out, "buffer", out).write(sys.prefix.encode("utf-8"))'] | |
| 1416 logger.info('Testing executable with %s %s "%s"' % tuple(cmd)) | |
| 1417 try: | |
| 1418 proc = subprocess.Popen(cmd, | |
| 1419 stdout=subprocess.PIPE) | |
| 1420 proc_stdout, proc_stderr = proc.communicate() | |
| 1421 except OSError: | |
| 1422 e = sys.exc_info()[1] | |
| 1423 if e.errno == errno.EACCES: | |
| 1424 logger.fatal('ERROR: The executable %s could not be run: %s' % (py_executable, e)) | |
| 1425 sys.exit(100) | |
| 1426 else: | |
| 1427 raise e | |
| 1428 | |
| 1429 proc_stdout = proc_stdout.strip().decode("utf-8") | |
| 1430 proc_stdout = os.path.normcase(os.path.abspath(proc_stdout)) | |
| 1431 norm_home_dir = os.path.normcase(os.path.abspath(home_dir)) | |
| 1432 if hasattr(norm_home_dir, 'decode'): | |
| 1433 norm_home_dir = norm_home_dir.decode(sys.getfilesystemencoding()) | |
| 1434 if proc_stdout != norm_home_dir: | |
| 1435 logger.fatal( | |
| 1436 'ERROR: The executable %s is not functioning' % py_executable) | |
| 1437 logger.fatal( | |
| 1438 'ERROR: It thinks sys.prefix is %r (should be %r)' | |
| 1439 % (proc_stdout, norm_home_dir)) | |
| 1440 logger.fatal( | |
| 1441 'ERROR: virtualenv is not compatible with this system or executable') | |
| 1442 if is_win: | |
| 1443 logger.fatal( | |
| 1444 'Note: some Windows users have reported this error when they ' | |
| 1445 'installed Python for "Only this user" or have multiple ' | |
| 1446 'versions of Python installed. Copying the appropriate ' | |
| 1447 'PythonXX.dll to the virtualenv Scripts/ directory may fix ' | |
| 1448 'this problem.') | |
| 1449 sys.exit(100) | |
| 1450 else: | |
| 1451 logger.info('Got sys.prefix result: %r' % proc_stdout) | |
| 1452 | |
| 1453 pydistutils = os.path.expanduser('~/.pydistutils.cfg') | |
| 1454 if os.path.exists(pydistutils): | |
| 1455 logger.notify('Please make sure you remove any previous custom paths from ' | |
| 1456 'your %s file.' % pydistutils) | |
| 1457 ## FIXME: really this should be calculated earlier | |
| 1458 | |
| 1459 fix_local_scheme(home_dir, symlink) | |
| 1460 | |
| 1461 if site_packages: | |
| 1462 if os.path.exists(site_packages_filename): | |
| 1463 logger.info('Deleting %s' % site_packages_filename) | |
| 1464 os.unlink(site_packages_filename) | |
| 1465 | |
| 1466 return py_executable | |
| 1467 | |
| 1468 | |
| 1469 def install_activate(home_dir, bin_dir, prompt=None): | |
| 1470 home_dir = os.path.abspath(home_dir) | |
| 1471 if is_win or is_jython and os._name == 'nt': | |
| 1472 files = { | |
| 1473 'activate.bat': ACTIVATE_BAT, | |
| 1474 'deactivate.bat': DEACTIVATE_BAT, | |
| 1475 'activate.ps1': ACTIVATE_PS, | |
| 1476 } | |
| 1477 | |
| 1478 # MSYS needs paths of the form /c/path/to/file | |
| 1479 drive, tail = os.path.splitdrive(home_dir.replace(os.sep, '/')) | |
| 1480 home_dir_msys = (drive and "/%s%s" or "%s%s") % (drive[:1], tail) | |
| 1481 | |
| 1482 # Run-time conditional enables (basic) Cygwin compatibility | |
| 1483 home_dir_sh = ("""$(if [ "$OSTYPE" "==" "cygwin" ]; then cygpath -u '%s'; else echo '%s'; fi;)""" % | |
| 1484 (home_dir, home_dir_msys)) | |
| 1485 files['activate'] = ACTIVATE_SH.replace('__VIRTUAL_ENV__', home_dir_sh) | |
| 1486 | |
| 1487 else: | |
| 1488 files = {'activate': ACTIVATE_SH} | |
| 1489 | |
| 1490 # suppling activate.fish in addition to, not instead of, the | |
| 1491 # bash script support. | |
| 1492 files['activate.fish'] = ACTIVATE_FISH | |
| 1493 | |
| 1494 # same for csh/tcsh support... | |
| 1495 files['activate.csh'] = ACTIVATE_CSH | |
| 1496 | |
| 1497 files['activate_this.py'] = ACTIVATE_THIS | |
| 1498 if hasattr(home_dir, 'decode'): | |
| 1499 home_dir = home_dir.decode(sys.getfilesystemencoding()) | |
| 1500 vname = os.path.basename(home_dir) | |
| 1501 for name, content in files.items(): | |
| 1502 content = content.replace('__VIRTUAL_PROMPT__', prompt or '') | |
| 1503 content = content.replace('__VIRTUAL_WINPROMPT__', prompt or '(%s)' % vname) | |
| 1504 content = content.replace('__VIRTUAL_ENV__', home_dir) | |
| 1505 content = content.replace('__VIRTUAL_NAME__', vname) | |
| 1506 content = content.replace('__BIN_NAME__', os.path.basename(bin_dir)) | |
| 1507 writefile(os.path.join(bin_dir, name), content) | |
| 1508 | |
| 1509 def install_distutils(home_dir): | |
| 1510 distutils_path = change_prefix(distutils.__path__[0], home_dir) | |
| 1511 mkdir(distutils_path) | |
| 1512 ## FIXME: maybe this prefix setting should only be put in place if | |
| 1513 ## there's a local distutils.cfg with a prefix setting? | |
| 1514 home_dir = os.path.abspath(home_dir) | |
| 1515 ## FIXME: this is breaking things, removing for now: | |
| 1516 #distutils_cfg = DISTUTILS_CFG + "\n[install]\nprefix=%s\n" % home_dir | |
| 1517 writefile(os.path.join(distutils_path, '__init__.py'), DISTUTILS_INIT) | |
| 1518 writefile(os.path.join(distutils_path, 'distutils.cfg'), DISTUTILS_CFG, overwrite=False) | |
| 1519 | |
| 1520 def fix_local_scheme(home_dir, symlink=True): | |
| 1521 """ | |
| 1522 Platforms that use the "posix_local" install scheme (like Ubuntu with | |
| 1523 Python 2.7) need to be given an additional "local" location, sigh. | |
| 1524 """ | |
| 1525 try: | |
| 1526 import sysconfig | |
| 1527 except ImportError: | |
| 1528 pass | |
| 1529 else: | |
| 1530 if sysconfig._get_default_scheme() == 'posix_local': | |
| 1531 local_path = os.path.join(home_dir, 'local') | |
| 1532 if not os.path.exists(local_path): | |
| 1533 os.mkdir(local_path) | |
| 1534 for subdir_name in os.listdir(home_dir): | |
| 1535 if subdir_name == 'local': | |
| 1536 continue | |
| 1537 copyfile(os.path.abspath(os.path.join(home_dir, subdir_name)), \ | |
| 1538 os.path.join(local_path, subdir_name), symlink) | |
| 1539 | |
| 1540 def fix_lib64(lib_dir, symlink=True): | |
| 1541 """ | |
| 1542 Some platforms (particularly Gentoo on x64) put things in lib64/pythonX.Y | |
| 1543 instead of lib/pythonX.Y. If this is such a platform we'll just create a | |
| 1544 symlink so lib64 points to lib | |
| 1545 """ | |
| 1546 if [p for p in distutils.sysconfig.get_config_vars().values() | |
| 1547 if isinstance(p, basestring) and 'lib64' in p]: | |
| 1548 # PyPy's library path scheme is not affected by this. | |
| 1549 # Return early or we will die on the following assert. | |
| 1550 if is_pypy: | |
| 1551 logger.debug('PyPy detected, skipping lib64 symlinking') | |
| 1552 return | |
| 1553 | |
| 1554 logger.debug('This system uses lib64; symlinking lib64 to lib') | |
| 1555 | |
| 1556 assert os.path.basename(lib_dir) == 'python%s' % sys.version[:3], ( | |
| 1557 "Unexpected python lib dir: %r" % lib_dir) | |
| 1558 lib_parent = os.path.dirname(lib_dir) | |
| 1559 top_level = os.path.dirname(lib_parent) | |
| 1560 lib_dir = os.path.join(top_level, 'lib') | |
| 1561 lib64_link = os.path.join(top_level, 'lib64') | |
| 1562 assert os.path.basename(lib_parent) == 'lib', ( | |
| 1563 "Unexpected parent dir: %r" % lib_parent) | |
| 1564 if os.path.lexists(lib64_link): | |
| 1565 return | |
| 1566 cp_or_ln = (os.symlink if symlink else copyfile) | |
| 1567 cp_or_ln('lib', lib64_link) | |
| 1568 | |
| 1569 def resolve_interpreter(exe): | |
| 1570 """ | |
| 1571 If the executable given isn't an absolute path, search $PATH for the interpreter | |
| 1572 """ | |
| 1573 # If the "executable" is a version number, get the installed executable for | |
| 1574 # that version | |
| 1575 python_versions = get_installed_pythons() | |
| 1576 if exe in python_versions: | |
| 1577 exe = python_versions[exe] | |
| 1578 | |
| 1579 if os.path.abspath(exe) != exe: | |
| 1580 paths = os.environ.get('PATH', '').split(os.pathsep) | |
| 1581 for path in paths: | |
| 1582 if os.path.exists(os.path.join(path, exe)): | |
| 1583 exe = os.path.join(path, exe) | |
| 1584 break | |
| 1585 if not os.path.exists(exe): | |
| 1586 logger.fatal('The executable %s (from --python=%s) does not exist' % (exe, exe)) | |
| 1587 raise SystemExit(3) | |
| 1588 if not is_executable(exe): | |
| 1589 logger.fatal('The executable %s (from --python=%s) is not executable' % (exe, exe)) | |
| 1590 raise SystemExit(3) | |
| 1591 return exe | |
| 1592 | |
| 1593 def is_executable(exe): | |
| 1594 """Checks a file is executable""" | |
| 1595 return os.access(exe, os.X_OK) | |
| 1596 | |
| 1597 ############################################################ | |
| 1598 ## Relocating the environment: | |
| 1599 | |
| 1600 def make_environment_relocatable(home_dir): | |
| 1601 """ | |
| 1602 Makes the already-existing environment use relative paths, and takes out | |
| 1603 the #!-based environment selection in scripts. | |
| 1604 """ | |
| 1605 home_dir, lib_dir, inc_dir, bin_dir = path_locations(home_dir) | |
| 1606 activate_this = os.path.join(bin_dir, 'activate_this.py') | |
| 1607 if not os.path.exists(activate_this): | |
| 1608 logger.fatal( | |
| 1609 'The environment doesn\'t have a file %s -- please re-run virtualenv ' | |
| 1610 'on this environment to update it' % activate_this) | |
| 1611 fixup_scripts(home_dir, bin_dir) | |
| 1612 fixup_pth_and_egg_link(home_dir) | |
| 1613 ## FIXME: need to fix up distutils.cfg | |
| 1614 | |
| 1615 OK_ABS_SCRIPTS = ['python', 'python%s' % sys.version[:3], | |
| 1616 'activate', 'activate.bat', 'activate_this.py', | |
| 1617 'activate.fish', 'activate.csh'] | |
| 1618 | |
| 1619 def fixup_scripts(home_dir, bin_dir): | |
| 1620 if is_win: | |
| 1621 new_shebang_args = ( | |
| 1622 '%s /c' % os.path.normcase(os.environ.get('COMSPEC', 'cmd.exe')), | |
| 1623 '', '.exe') | |
| 1624 else: | |
| 1625 new_shebang_args = ('/usr/bin/env', sys.version[:3], '') | |
| 1626 | |
| 1627 # This is what we expect at the top of scripts: | |
| 1628 shebang = '#!%s' % os.path.normcase(os.path.join( | |
| 1629 os.path.abspath(bin_dir), 'python%s' % new_shebang_args[2])) | |
| 1630 # This is what we'll put: | |
| 1631 new_shebang = '#!%s python%s%s' % new_shebang_args | |
| 1632 | |
| 1633 for filename in os.listdir(bin_dir): | |
| 1634 filename = os.path.join(bin_dir, filename) | |
| 1635 if not os.path.isfile(filename): | |
| 1636 # ignore subdirs, e.g. .svn ones. | |
| 1637 continue | |
| 1638 f = open(filename, 'rb') | |
| 1639 try: | |
| 1640 try: | |
| 1641 lines = f.read().decode('utf-8').splitlines() | |
| 1642 except UnicodeDecodeError: | |
| 1643 # This is probably a binary program instead | |
| 1644 # of a script, so just ignore it. | |
| 1645 continue | |
| 1646 finally: | |
| 1647 f.close() | |
| 1648 if not lines: | |
| 1649 logger.warn('Script %s is an empty file' % filename) | |
| 1650 continue | |
| 1651 | |
| 1652 old_shebang = lines[0].strip() | |
| 1653 old_shebang = old_shebang[0:2] + os.path.normcase(old_shebang[2:]) | |
| 1654 | |
| 1655 if not old_shebang.startswith(shebang): | |
| 1656 if os.path.basename(filename) in OK_ABS_SCRIPTS: | |
| 1657 logger.debug('Cannot make script %s relative' % filename) | |
| 1658 elif lines[0].strip() == new_shebang: | |
| 1659 logger.info('Script %s has already been made relative' % filename) | |
| 1660 else: | |
| 1661 logger.warn('Script %s cannot be made relative (it\'s not a normal script that starts with %s)' | |
| 1662 % (filename, shebang)) | |
| 1663 continue | |
| 1664 logger.notify('Making script %s relative' % filename) | |
| 1665 script = relative_script([new_shebang] + lines[1:]) | |
| 1666 f = open(filename, 'wb') | |
| 1667 f.write('\n'.join(script).encode('utf-8')) | |
| 1668 f.close() | |
| 1669 | |
| 1670 def relative_script(lines): | |
| 1671 "Return a script that'll work in a relocatable environment." | |
| 1672 activate = "import os; activate_this=os.path.join(os.path.dirname(os.path.realpath(__file__)), 'activate_this.py'); exec(compile(open(activate_this).read(), activate_this, 'exec'), dict(__file__=activate_this)); del os, activate_this" | |
| 1673 # Find the last future statement in the script. If we insert the activation | |
| 1674 # line before a future statement, Python will raise a SyntaxError. | |
| 1675 activate_at = None | |
| 1676 for idx, line in reversed(list(enumerate(lines))): | |
| 1677 if line.split()[:3] == ['from', '__future__', 'import']: | |
| 1678 activate_at = idx + 1 | |
| 1679 break | |
| 1680 if activate_at is None: | |
| 1681 # Activate after the shebang. | |
| 1682 activate_at = 1 | |
| 1683 return lines[:activate_at] + ['', activate, ''] + lines[activate_at:] | |
| 1684 | |
| 1685 def fixup_pth_and_egg_link(home_dir, sys_path=None): | |
| 1686 """Makes .pth and .egg-link files use relative paths""" | |
| 1687 home_dir = os.path.normcase(os.path.abspath(home_dir)) | |
| 1688 if sys_path is None: | |
| 1689 sys_path = sys.path | |
| 1690 for path in sys_path: | |
| 1691 if not path: | |
| 1692 path = '.' | |
| 1693 if not os.path.isdir(path): | |
| 1694 continue | |
| 1695 path = os.path.normcase(os.path.abspath(path)) | |
| 1696 if not path.startswith(home_dir): | |
| 1697 logger.debug('Skipping system (non-environment) directory %s' % path) | |
| 1698 continue | |
| 1699 for filename in os.listdir(path): | |
| 1700 filename = os.path.join(path, filename) | |
| 1701 if filename.endswith('.pth'): | |
| 1702 if not os.access(filename, os.W_OK): | |
| 1703 logger.warn('Cannot write .pth file %s, skipping' % filename) | |
| 1704 else: | |
| 1705 fixup_pth_file(filename) | |
| 1706 if filename.endswith('.egg-link'): | |
| 1707 if not os.access(filename, os.W_OK): | |
| 1708 logger.warn('Cannot write .egg-link file %s, skipping' % filename) | |
| 1709 else: | |
| 1710 fixup_egg_link(filename) | |
| 1711 | |
| 1712 def fixup_pth_file(filename): | |
| 1713 lines = [] | |
| 1714 prev_lines = [] | |
| 1715 f = open(filename) | |
| 1716 prev_lines = f.readlines() | |
| 1717 f.close() | |
| 1718 for line in prev_lines: | |
| 1719 line = line.strip() | |
| 1720 if (not line or line.startswith('#') or line.startswith('import ') | |
| 1721 or os.path.abspath(line) != line): | |
| 1722 lines.append(line) | |
| 1723 else: | |
| 1724 new_value = make_relative_path(filename, line) | |
| 1725 if line != new_value: | |
| 1726 logger.debug('Rewriting path %s as %s (in %s)' % (line, new_value, filename)) | |
| 1727 lines.append(new_value) | |
| 1728 if lines == prev_lines: | |
| 1729 logger.info('No changes to .pth file %s' % filename) | |
| 1730 return | |
| 1731 logger.notify('Making paths in .pth file %s relative' % filename) | |
| 1732 f = open(filename, 'w') | |
| 1733 f.write('\n'.join(lines) + '\n') | |
| 1734 f.close() | |
| 1735 | |
| 1736 def fixup_egg_link(filename): | |
| 1737 f = open(filename) | |
| 1738 link = f.readline().strip() | |
| 1739 f.close() | |
| 1740 if os.path.abspath(link) != link: | |
| 1741 logger.debug('Link in %s already relative' % filename) | |
| 1742 return | |
| 1743 new_link = make_relative_path(filename, link) | |
| 1744 logger.notify('Rewriting link %s in %s as %s' % (link, filename, new_link)) | |
| 1745 f = open(filename, 'w') | |
| 1746 f.write(new_link) | |
| 1747 f.close() | |
| 1748 | |
| 1749 def make_relative_path(source, dest, dest_is_directory=True): | |
| 1750 """ | |
| 1751 Make a filename relative, where the filename is dest, and it is | |
| 1752 being referred to from the filename source. | |
| 1753 | |
| 1754 >>> make_relative_path('/usr/share/something/a-file.pth', | |
| 1755 ... '/usr/share/another-place/src/Directory') | |
| 1756 '../another-place/src/Directory' | |
| 1757 >>> make_relative_path('/usr/share/something/a-file.pth', | |
| 1758 ... '/home/user/src/Directory') | |
| 1759 '../../../home/user/src/Directory' | |
| 1760 >>> make_relative_path('/usr/share/a-file.pth', '/usr/share/') | |
| 1761 './' | |
| 1762 """ | |
| 1763 source = os.path.dirname(source) | |
| 1764 if not dest_is_directory: | |
| 1765 dest_filename = os.path.basename(dest) | |
| 1766 dest = os.path.dirname(dest) | |
| 1767 dest = os.path.normpath(os.path.abspath(dest)) | |
| 1768 source = os.path.normpath(os.path.abspath(source)) | |
| 1769 dest_parts = dest.strip(os.path.sep).split(os.path.sep) | |
| 1770 source_parts = source.strip(os.path.sep).split(os.path.sep) | |
| 1771 while dest_parts and source_parts and dest_parts[0] == source_parts[0]: | |
| 1772 dest_parts.pop(0) | |
| 1773 source_parts.pop(0) | |
| 1774 full_parts = ['..']*len(source_parts) + dest_parts | |
| 1775 if not dest_is_directory: | |
| 1776 full_parts.append(dest_filename) | |
| 1777 if not full_parts: | |
| 1778 # Special case for the current directory (otherwise it'd be '') | |
| 1779 return './' | |
| 1780 return os.path.sep.join(full_parts) | |
| 1781 | |
| 1782 | |
| 1783 | |
| 1784 ############################################################ | |
| 1785 ## Bootstrap script creation: | |
| 1786 | |
| 1787 def create_bootstrap_script(extra_text, python_version=''): | |
| 1788 """ | |
| 1789 Creates a bootstrap script, which is like this script but with | |
| 1790 extend_parser, adjust_options, and after_install hooks. | |
| 1791 | |
| 1792 This returns a string that (written to disk of course) can be used | |
| 1793 as a bootstrap script with your own customizations. The script | |
| 1794 will be the standard virtualenv.py script, with your extra text | |
| 1795 added (your extra text should be Python code). | |
| 1796 | |
| 1797 If you include these functions, they will be called: | |
| 1798 | |
| 1799 ``extend_parser(optparse_parser)``: | |
| 1800 You can add or remove options from the parser here. | |
| 1801 | |
| 1802 ``adjust_options(options, args)``: | |
| 1803 You can change options here, or change the args (if you accept | |
| 1804 different kinds of arguments, be sure you modify ``args`` so it is | |
| 1805 only ``[DEST_DIR]``). | |
| 1806 | |
| 1807 ``after_install(options, home_dir)``: | |
| 1808 | |
| 1809 After everything is installed, this function is called. This | |
| 1810 is probably the function you are most likely to use. An | |
| 1811 example would be:: | |
| 1812 | |
| 1813 def after_install(options, home_dir): | |
| 1814 subprocess.call([join(home_dir, 'bin', 'easy_install'), | |
| 1815 'MyPackage']) | |
| 1816 subprocess.call([join(home_dir, 'bin', 'my-package-script'), | |
| 1817 'setup', home_dir]) | |
| 1818 | |
| 1819 This example immediately installs a package, and runs a setup | |
| 1820 script from that package. | |
| 1821 | |
| 1822 If you provide something like ``python_version='2.5'`` then the | |
| 1823 script will start with ``#!/usr/bin/env python2.5`` instead of | |
| 1824 ``#!/usr/bin/env python``. You can use this when the script must | |
| 1825 be run with a particular Python version. | |
| 1826 """ | |
| 1827 filename = __file__ | |
| 1828 if filename.endswith('.pyc'): | |
| 1829 filename = filename[:-1] | |
| 1830 f = codecs.open(filename, 'r', encoding='utf-8') | |
| 1831 content = f.read() | |
| 1832 f.close() | |
| 1833 py_exe = 'python%s' % python_version | |
| 1834 content = (('#!/usr/bin/env %s\n' % py_exe) | |
| 1835 + '## WARNING: This file is generated\n' | |
| 1836 + content) | |
| 1837 return content.replace('##EXT' 'END##', extra_text) | |
| 1838 | |
| 1839 ##EXTEND## | |
| 1840 | |
| 1841 def convert(s): | |
| 1842 b = base64.b64decode(s.encode('ascii')) | |
| 1843 return zlib.decompress(b).decode('utf-8') | |
| 1844 | |
| 1845 ##file site.py | |
| 1846 SITE_PY = convert(""" | |
| 1847 eJzFPf1z2zaWv/OvwMqToZTIdOJ0e3tOnRsncVrvuYm3SWdz63q0lARZrCmSJUjL2pu7v/3eBwAC | |
| 1848 JCXbm+6cphNLJPDw8PC+8PAeOhgMTopCZnOxyud1KoWScTlbiiKulkos8lJUy6Sc7xdxWW3g6ewm | |
| 1849 vpZKVLlQGxVhqygInn7lJ3gqPi8TZVCAb3Fd5au4SmZxmm5EsiryspJzMa/LJLsWSZZUSZwm/4AW | |
| 1850 eRaJp1+PQXCWCZh5mshS3MpSAVwl8oW42FTLPBPDusA5v4j+GL8cjYWalUlRQYNS4wwUWcZVkEk5 | |
| 1851 BzShZa2AlEkl91UhZ8kimdmG67xO56JI45kUf/87T42ahmGg8pVcL2UpRQbIAEwJsArEA74mpZjl | |
| 1852 cxkJ8UbOYhyAnzfEChjaGNdMIRmzXKR5dg1zyuRMKhWXGzGc1hUBIpTFPAecEsCgStI0WOfljRrB | |
| 1853 ktJ6rOGRiJk9/Mkwe8A8cfwu5wCOH7Pg5yy5GzNs4B4EVy2ZbUq5SO5EjGDhp7yTs4l+NkwWYp4s | |
| 1854 FkCDrBphk4ARUCJNpgcFLcd3eoVeHxBWlitjGEMiytyYX1KPKDirRJwqYNu6QBopwvydnCZxBtTI | |
| 1855 bmE4gAgkDfrGmSeqsuPQ7EQOAEpcxwqkZKXEcBUnGTDrj/GM0P5rks3ztRoRBWC1lPi1VpU7/2EP | |
| 1856 AaC1Q4BxgItlVrPO0uRGppsRIPAZsC+lqtMKBWKelHJW5WUiFQEA1DZC3gHSYxGXUpOQOdPI7Zjo | |
| 1857 TzRJMlxYFDAUeHyJJFkk13VJEiYWCXAucMX7jz+Jd6dvzk4+aB4zwFhmr1eAM0ChhXZwggHEQa3K | |
| 1858 gzQHgY6Cc/wj4vkchewaxwe8mgYH9650MIS5F1G7j7PgQHa9uHoYmGMFyoTGCqjff0OXsVoCff7n | |
| 1859 nvUOgpNtVKGJ87f1MgeZzOKVFMuY+Qs5I/hOw3kdFdXyFXCDQjgVkErh4iCCCcIDkrg0G+aZFAWw | |
| 1860 WJpkchQAhabU1l9FYIUPebZPa93iBIBQBhm8dJ6NaMRMwkS7sF6hvjCNNzQz3SSw67zKS1IcwP/Z | |
| 1861 jHRRGmc3hKMihuJvU3mdZBkihLwQhHshDaxuEuDEeSTOqRXpBdNIhKy9uCWKRA28hEwHPCnv4lWR | |
| 1862 yjGLL+rW3WqEBpOVMGudMsdBy4rUK61aM9Ve3juMvrS4jtCslqUE4PXUE7pFno/FFHQ2YVPEKxav | |
| 1863 ap0T5wQ98kSdkCeoJfTF70DRE6XqlbQvkVdAsxBDBYs8TfM1kOwoCITYw0bGKPvMCW/hHfwLcPHf | |
| 1864 VFazZRA4I1nAGhQivw0UAgGTIDPN1RoJj9s0K7eVTJKxpsjLuSxpqIcR+4ARf2BjnGvwIa+0UePp | |
| 1865 4irnq6RClTTVJjNhi5eFFevHVzxvmAZYbkU0M00bOq1wemmxjKfSuCRTuUBJ0Iv0yi47jBn0jEm2 | |
| 1866 uBIrtjLwDsgiE7Yg/YoFlc6ikuQEAAwWvjhLijqlRgoZTMQw0Kog+KsYTXqunSVgbzbLASokNt8z | |
| 1867 sD+A2z9AjNbLBOgzAwigYVBLwfJNk6pEB6HRR4Fv9E1/Hh849WyhbRMPuYiTVFv5OAvO6OFpWZL4 | |
| 1868 zmSBvcaaGApmmFXo2l1nQEcU88FgEATGHdoo8zVXQVVujoAVhBlnMpnWCRq+yQRNvf6hAh5FOAN7 | |
| 1869 3Ww7Cw80hOn0AajkdFmU+Qpf27l9AmUCY2GPYE9ckJaR7CB7nPgKyeeq9MI0RdvtsLNAPRRc/HT6 | |
| 1870 /uzL6SdxLC4blTZu67MrGPM0i4GtySIAU7WGbXQZtETFl6DuE+/BvBNTgD2j3iS+Mq5q4F1A/XNZ | |
| 1871 02uYxsx7GZx+OHlzfjr5+dPpT5NPZ59PAUGwMzLYoymjeazBYVQRCAdw5VxF2r4GnR704M3JJ/sg | |
| 1872 mCRq8u03wG7wZHgtK2DicggzHotwFd8pYNBwTE1HiGOnAVjwcDQSr8Xh06cvDwlasSk2AAzMrtMU | |
| 1873 H060RZ8k2SIPR9T4V3bpj1lJaf/t8uibK3F8LMJf49s4DMCHapoyS/xI4vR5U0joWsGfYa5GQTCX | |
| 1874 CxC9G4kCOnxKfvGIO8CSQMtc2+lf8yQz75kr3SFIfwypB+AwmczSWClsPJmEQATq0POBDhE71yh1 | |
| 1875 Q+hYbNyuI40KfkoJC5thlzH+04NiPKV+iAaj6HYxjUBcV7NYSW5F04d+kwnqrMlkqAcEYSaJAYeL | |
| 1876 1VAoTBPUWWUCfi1xHuqwqcpT/InwUQuQAOLWCrUkLpLeOkW3cVpLNXQmBUQcDltkREWbKOJHcFGG | |
| 1877 YImbpRuN2tQ0PAPNgHxpDlq0bFEOP3vg74C6Mps43Ojx3otphpj+mXcahAO4nCGqe6VaUFg7iovT | |
| 1878 C/Hy+eE+ujOw55xb6njN0UInWS3twwWslpEHRph7GXlx6bJAPYtPj3bDXEV2ZbqssNBLXMpVfivn | |
| 1879 gC0ysLPK4id6AztzmMcshlUEvU7+AKtQ4zfGuA/l2YO0oO8A1FsRFLP+Zun3OBggMwWKiDfWRGq9 | |
| 1880 62dTWJT5bYLOxnSjX4KtBGWJFtM4NoGzcB6ToUkEDQFecIaUWssQ1GFZs8NKeCNItBfzRrFGBO4c | |
| 1881 NfUVfb3J8nU24Z3wMSrd4ciyLgqWZl5s0CzBnngPVgiQzGFj1xCNoYDLL1C29gF5mD5MFyhLewsA | |
| 1882 BIZe0XbNgWW2ejRF3jXisAhj9EqQ8JYS/YVbMwRttQwxHEj0NrIPjJZASDA5q+CsatBMhrJmmsHA | |
| 1883 Dkl8rjuPeAvqA2hRMQKzOdTQuJGh3+URKGdx7iolpx9a5C9fvjDbqCXFVxCxKU4aXYgFGcuo2IBh | |
| 1884 TUAnGI+MozXEBmtwbgFMrTRriv1PIi/YG4P1vNCyDX4A7O6qqjg6OFiv15GOLuTl9YFaHPzxT99+ | |
| 1885 +6fnrBPnc+IfmI4jLTrUFh3QO/Roo++MBXptVq7Fj0nmcyPBGkryysgVRfy+r5N5Lo72R1Z/Ihc3 | |
| 1886 Zhr/Na4MKJCJGZSpDLQdNBg9UftPopdqIJ6QdbZthyP2S7RJtVbMt7rQo8rBEwC/ZZbXaKobTlDi | |
| 1887 GVg32KHP5bS+Du3gno00P2CqKKdDywP7L64QA58zDF8ZUzxBLUFsgRbfIf1PzDYxeUdaQyB50UR1 | |
| 1888 ds+bfi1miDt/uLxbX9MRGjPDRCF3oET4TR4sgLZxV3Lwo11btHuOa2s+niEwlj4wzKsdyyEKDuGC | |
| 1889 azF2pc7havR4QZrWrJpBwbiqERQ0OIlTprYGRzYyRJDo3ZjNPi+sbgF0akUOTXzArAK0cMfpWLs2 | |
| 1890 KzieEPLAsXhBTyS4yEedd895aes0pYBOi0c9qjBgb6HRTufAl0MDYCwG5c8Dbmm2KR9bi8Jr0AMs | |
| 1891 5xgQMtiiw0z4xvUBB3uDHnbqWP1tvZnGfSBwkYYci3oQdEL5mEcoFUhTMfR7bmNxS9zuYDstDjGV | |
| 1892 WSYSabVFuNrKo1eodhqmRZKh7nUWKZqlOXjFVisSIzXvfWeB9kH4uM+YaQnUZGjI4TQ6Jm/PE8BQ | |
| 1893 t8Pw2XWNgQY3DoMYrRJF1g3JtIR/wK2g+AYFo4CWBM2CeaiU+RP7HWTOzld/2cIeltDIEG7TbW5I | |
| 1894 x2JoOOb9nkAy6mgMSEEGJOwKI7mOrA5S4DBngTzhhtdyq3QTjEiBnDkWhNQM4E4vvQ0OPonwBIQk | |
| 1895 FCHfVUoW4pkYwPK1RfVhuvt35VIThBg6DchV0NGLYzey4UQ1jltRDp+h/fgGnZUUOXDwFFweN9Dv | |
| 1896 srlhWht0AWfdV9wWKdDIFIcZjFxUrwxh3GDyH46dFg2xzCCGobyBvCMdM9IosMutQcOCGzDemrfH | |
| 1897 0o/diAX2HYa5OpSrO9j/hWWiZrkKKWbSjl24H80VXdpYbM+T6QD+eAswGF15kGSq4xcYZfknBgk9 | |
| 1898 6GEfdG+yGBaZx+U6yUJSYJp+x/7SdPCwpPSM3MEn2k4dwEQx4nnwvgQBoaPPAxAn1ASwK5eh0m5/ | |
| 1899 F+zOKQ4sXO4+8Nzmy6OXV13ijrdFeOynf6lO76oyVrhaKS8aCwWuVteAo9KFycXZRh9e6sNt3CaU | |
| 1900 uYJdpPj46YtAQnBcdx1vHjf1huERm3vn5H0M6qDX7iVXa3bELoAIakVklIPw8Rz5cGQfO7kdE3sE | |
| 1901 kEcxzI5FMZA0n/wzcHYtFIyxP99kGEdrqwz8wOtvv5n0REZdJL/9ZnDPKC1i9In9sOUJ2pE5qWDX | |
| 1902 bEsZp+RqOH0oqJg1rGPbFCPW57T90zx21eNzarRs7Lu/BX4MFAypS/ARno8bsnWnih/fndoKT9up | |
| 1903 HcA6u1Xz2aNFgL19Pv0VdshKB9Vu4ySlcwWY/P4+Klezued4Rb/28CDtVDAOCfr2X+ryOXBDyNGE | |
| 1904 UXc62hk7MQHnnl2w+RSx6qKyp3MImiMwLy/APf7sQtUWzDDucz5eOOxRTd6M+5yJr1Gr+PldNJAF | |
| 1905 5tFg0Ef2rez4/zHL5/+aST5wKubk+ne0ho8E9HvNhI0HQ9PGw4fVv+yu3TXAHmCetridO9zC7tB8 | |
| 1906 Vrkwzh2rJCWeou56KtaUrkCxVTwpAihz9vt64OAy6kPvt3VZ8tE1qcBClvt4HDsWmKllPL9eE7Mn | |
| 1907 Dj7ICjGxzWYUq3byevI+NRLq6LOdSdjsG/rlbJmbmJXMbpMS+oLCHYY/fPzxNOw3IRjHhU4PtyIP | |
| 1908 9xsQ7iOYNtTECR/Thyn0mC7/vFS1ty4+QU1GgIkIa7L12gc/EGziCP1rcE9EyDuw5WN23KHPlnJ2 | |
| 1909 M5GUOoBsil2doPhbfI2Y2IwCP/9LxQtKYoOZzNIaacWON2YfLupsRucjlQT/SqcKY+oQJQRw+G+R | |
| 1910 xtdiSJ3nGHrS3EjRqdu41N5nUeaYnCrqZH5wncyF/K2OU9zWy8UCcMHDK/0q4uEpAiXecU4DJy0q | |
| 1911 OavLpNoACWKV67M/Sn9wGk43PNGhhyQf8zABMSHiSHzCaeN7JtzckMsEB/wTD5wk7ruxg5OsENFz | |
| 1912 eJ/lExx1Qjm+Y0aqey5Pj4P2CDkAGABQmP9gpCN3/htJr9wDRlpzl6ioJT1SupGGnJwxhDIcYaSD | |
| 1913 f9NPnxFd3tqC5fV2LK93Y3ndxvK6F8trH8vr3Vi6IoELa4NWRhL6AlftY43efBs35sTDnMazJbfD | |
| 1914 3E/M8QSIojAbbCNTnALtRbb4fI+AkNp2DpzpYZM/k3BSaZlzCFyDRO7HQyy9mTfJ605nysbRnXkq | |
| 1915 xp3dlkPk9z2IIkoVm1J3lrd5XMWRJxfXaT4FsbXojhsAY9FOJ+JYaXY7mXJ0t2WpBhf/9fmHjx+w | |
| 1916 OYIamPQG6oaLiIYFpzJ8GpfXqitNzeavAHakln4iDnXTAPceGFnjUfb4n3eU4YGMI9aUoZCLAjwA | |
| 1917 yuqyzdzcpzBsPddJUvo5MzkfNh2LQVYNmkltIdLJxcW7k88nAwr5Df534AqMoa0vHS4+poVt0PXf | |
| 1918 3OaW4tgHhFrHthrj587Jo3XDEffbWAO248O3Hhw+xGD3hgn8Wf5LKQVLAoSKdPD3MYR68B7oq7YJ | |
| 1919 HfoYRuwk/7kna+ys2HeO7DkuiiP6fccO7QH8w07cY0yAANqFGpqdQbOZail9a153UNQB+kBf76u3 | |
| 1920 YO2tV3sn41PUTqLHAXQoa5ttd/+8cxo2ekpWb06/P/twfvbm4uTzD44LiK7cx08Hh+L0xy+C8kPQ | |
| 1921 gLFPFGNqRIWZSGBY3EInMc/hvxojP/O64iAx9Hp3fq5PalZY6oK5z2hzInjOaUwWGgfNOAptH+r8 | |
| 1922 I8Qo1Rskp6aI0nWo5gj3SyuuZ1G5zo+mUqUpOqu13nrpWjFTU0bn2hFIHzR2ScEgOMUMXlEWe2V2 | |
| 1923 hSWfAOo6qx6ktI22iSEpBQU76QLO+Zc5XfECpdQZnjSdtaK/DF1cw6tIFWkCO7lXoZUl3Q3TYxrG | |
| 1924 0Q/tATfj1acBne4wsm7Is96KBVqtVyHPTfcfNYz2Ww0YNgz2DuadSUoPoQxsTG4TITbik5xQ3sFX | |
| 1925 u/R6DRQsGB70VbiIhukSmH0Mm2uxTGADATy5BOuL+wSA0FoJ/0DgyIkOyByzM8K3q/n+X0JNEL/1 | |
| 1926 L7/0NK/KdP9vooBdkOBUorCHmG7jd7DxiWQkTj++H4WMHKXmir/UWB4ADgkFQB1pp/wlPkGfDJVM | |
| 1927 Fzq/xNcH+EL7CfS61b2URam797vGIUrAEzUkr+GJMvQLMd3Lwh7jVEYt0Fj5YDHDCkI3DcF89sSn | |
| 1928 pUxTne9+9u78FHxHLMZACeJzt1MYjuMleISuk++4wrEFCg/Y4XWJbFyiC0tJFvPIa9YbtEaRo95e | |
| 1929 XoZdJwoMd3t1osBlnCgX7SFOm2GZcoIIWRnWwiwrs3arDVLYbUMUR5lhlphclJTA6vME8DI9jXlL | |
| 1930 BHslLPUwEXg+RU6yymQspskM9CioXFCoYxASJC7WMxLn5RnHwPNSmTIoeFhsyuR6WeHpBnSOqAQD | |
| 1931 m/948uX87AOVJRy+bLzuHuYc005gzEkkx5giiNEO+OKm/SFXTSZ9PKtfIQzUPvCn/YqzU455gE4/ | |
| 1932 Dizin/YrrkM7dnaCPANQUHXRFg/cADjd+uSmkQXG1e6D8eOmADaY+WAoFollLzrRw51flxNty5Yp | |
| 1933 obiPefmIA5xFYVPSdGc3Ja390XNcFHjONR/2N4K3fbJlPlPoetN5sy35zf10pBBLYgGjbmt/DJMd | |
| 1934 1mmqp+Mw2zZuoW2ttrG/ZE6s1Gk3y1CUgYhDt/PIZbJ+JaybMwd6adQdYOI7ja6RxF5VPvglG2gP | |
| 1935 w8PEEruzTzEdqYyFjABGMqSu/anBh0KLAAqEsn+HjuSOR08PvTk61uD+OWrdBbbxB1CEOheXajzy | |
| 1936 EjgRvvzGjiO/IrRQjx6J0PFUMpnlNk8MP+slepUv/Dn2ygAFMVHsyji7lkOGNTYwn/nE3hKCJW3r | |
| 1937 kfoyueozLOIMnNO7LRzelYv+gxODWosROu1u5KatjnzyYIPeUpCdBPPBl/EadH9RV0NeyS3n0L21 | |
| 1938 dNuh3g8Rsw+hqT59H4YYjvkt3LI+DeBeamhY6OH9tuUUltfGOLLWPraqmkL7QnuwsxK2ZpWiYxmn | |
| 1939 ONH4otYLaAzucWPyB/apThSyv3vqxJyYkAXKg7sgvbkNdINWOGHA5UpcOZpQOnxTTaPfzeWtTMFo | |
| 1940 gJEdYrXDr7baYRTZcEpvHthXY3exudj040ZvGsyOTDkGIkCFGL2Bnl0INTjgCv+idyJxdkPO8du/ | |
| 1941 no3F2w8/wb9v5EewoFjzOBZ/g9HF27yEbSUX7dJtCljAUfF+Ma8VFkYSNDqh4Isn0Fu78MiLpyG6 | |
| 1942 ssQvKbEKUmAybbni204ARZ4gFbI37oGpl4DfpqCr5YQaB7FvLQb6JdJge40L1oUc6JbRslqlaCac | |
| 1943 4EiziJeD87O3px8+nUbVHTK2+Tlwgid+HhZORx8Nl3gMNhb2yazGJ1eOv/yDTIsed1nvNU29DO41 | |
| 1944 RQjbkcLuL/kmjdjuKeISAwai2MzzWYQtgdO5RK9ag/88craV99p3z7girOFIH541Tjw+BmqIX9r6 | |
| 1945 ZwANqY+eE/UkhOIp1orx42jQb4HHgiLa8OfpzXruBsR10Q9NsI1pM+uh392qwCXTWcOznER4Hdtl | |
| 1946 MHWgaRKr1XTm1gd+zIS+CAWUGx1vyEVcp5WQGWylaG9PN1KAgndL+lhCmFXYilGdG0Vn0nW8UU7u | |
| 1947 UazEAEcdUFE9nsNQoBC23j/GN2wGsNZQ1FwCDdAJUdo25U5XVc+WLMG8EyLq9eQbrJPspZvGoynM | |
| 1948 g/LGeNb4rzBP9BYZo2tZ6fnzg+Ho8kWT4EDB6JlX0DsrwNi5bLIHGrN4+vTpQPzH/U4PoxKleX4D | |
| 1949 3hjA7nVWzun1FoOtJ2dXq+vQmzcR8ONsKS/hwRUFze3zOqOI5I6utCDS/jUwQlyb0DKjad8yxxyr | |
| 1950 K/l8mVvwOZU2GD9nCV13hBElicpW3xqF0SYjTcSSoBjCWM2SJOToBKzHJq+xFg+ji5pf5B1wfIJg | |
| 1951 xvgWD8Z4h71Ex5LyZi33WHSOxYAADyiljEejYmaqRgM8JxcbjebkLEuqpozkuXtmqq8AqOwtRpqv | |
| 1952 RLxGyTDzaBHDKev0WLVxrPOdLOptVPLZpRtnbM2SX9+HO7A2SFq+WBhM4aFZpFkuy5kxp7hiySyp | |
| 1953 HDCmHcLhznR5E1mfKOhBaQDqnazC3Eq0ffsHuy4uph/p+HjfjKSzhip7IRbHhOKslVcYRc34FH2y | |
| 1954 hLR8a76MYJQPFM3WnoA3lviDjqViDYF3b4dbzlhn+j4OTttoLukAOHQHlFWQlh09HeFcPGbhM9Nu | |
| 1955 uUUDP7QzJ9xuk7Kq43Sir32YoJ82sefpGk9bBrezwNN6K+Db5+D47uuMfXAcTHIN0hMzbk1FxrFY | |
| 1956 6MhE5FaW+UVYRY5e3iH7SuBTIGXmE1MPbWJHl5ZdbaGpTtV0VDyCemaKl7Y45KZqplNw4mI+pvQm | |
| 1957 U+6wxXn2M0fp6grxWgxfjsVha+czKzZ4kxMg+2Qe+q4YdYOpOMEAM8f2vRji9bEYvhiLP+6AHm0Z | |
| 1958 4OjQHaG9j21B2Ark5dWjyZgmUyJb2JfCfn9fncMImp5xHF21yd8l03dEpX9vUYkrBHWi8ot2onJr | |
| 1959 7K371s7HRzJcgeJYJHK+/0QhCTXSjW7ezuCEHxbQ79kcLV073lTUUOHcFDYj60YPOhrRuM12EFOU | |
| 1960 rtUX1++irmHDae8cMGkyrVRFe8scpjFq9FpEBQCTvqM0/IZ3u8B7TQrXP9t6xKqLACzYngiCrvTk | |
| 1961 A7OmYSOo9zqCj9IA9zCKCPEwtVEUrmQ9QkRCugeHmOhZ6xDb4fjfnXm4xGDbUWgHy2+/2YWnK5i9 | |
| 1962 RR09C7q70sITWVte0Sy3+fQH5jxG6ev6VQLjQGlEB5xVc1UluZlHmL3Md9DkNot5hZdB0sk0msRU | |
| 1963 um4Tb6X51i/0Yyh2QMlksBbgSdULPEi+pbstTxQlveEVNd8cvhibymAGpCfwMnr5TF8BSd3M5Qe+ | |
| 1964 jz3Wezd4qfsdRv/mAEsqv7d91dnN0LSOW3dB+YOFFD0bRRNLh8Yw3V8H0qxZLPDOxIaY7FvbC0De | |
| 1965 g7czBT/HXH6ag8MGG9KoD11XYzTSu021bRHg+03GNsl5UNdGkSLSu4Rtm/LcpTgfLQq6V78FwRAC | |
| 1966 cv4y5jfoCtbFkQ2xGZuCJ59DN5sTP9VNb90Z2xM0ttVNuGv63H/X3HWLwM7cJDN05u7Xl7o00H23 | |
| 1967 W9E+GnB4QxPiQSUSjcbvNyauHRjrHJr+CL3+IPndTjjTLWblPjAmYwfj/cSeGntj9lfxzP2OCWH7 | |
| 1968 fCGzW07c62y0pt2xGW2Of4inwMkv+NzeMEAZTXPNgbxfohv2JpwjO5HX12oS4+2OE9pkUz5XZ/dk | |
| 1969 tm3v6XI+GauN2W3hpUUAwnCTzrx1k+uBMUBX8i3TnA7l3E4jaGhKGnaykFUyZ5Ogt3YALuKIKfU3 | |
| 1970 gXhOIx6kEgPdqi6LEnbDA30XMefp9KU2N0BNAG8VqxuDuukx1lfTkmKl5DBTgsxx2laSDxCBjXjH | |
| 1971 NEwm9h3wyvPmmoVkbJlBZvVKlnHVXDHkZwQksOlqRqCic1xcJzzXSGWLS1zEEssbDlIYILPfn8HG | |
| 1972 0ttU77hXYWS13cPZiXrokO9jrmxwjJHh4uTOXi/oXms1p6utXe/QNmu4zl6pBMtg7sojHaljZfxW | |
| 1973 39/Fd8xyJB/9S4d/QN7dyks/C92qM/ZuLRrOM1chdC9swhsDyDj33cPY4YDujYutDbAd39cXllE6 | |
| 1974 HuaWxpaK2ifvVTjNaKMmgoQJo/dEkPyigEdGkDz4D4wg6VszwdBofLQe6C0TuCfUxOrBvYKyYQTo | |
| 1975 MwEi4QF26wJDYyqHbtJ9kavkbmAvlGZd6VTyGfOAHNm9m4xA8FWTys1Q9q6C2xVB8qWLHn9//vHN | |
| 1976 yTnRYnJx8vY/T76npCw8LmnZqgeH2LJ8n6m976V/u+E2nUjTN3iDbc8NsVzDpCF03ndyEHog9Ner | |
| 1977 9S1oW5G5r7d16NT9dDsB4run3YK6TWX3Qu74ZbrGxE2faeVpB/opJ9WaX05mgnlkTupYHJqTOPO+ | |
| 1978 OTzRMtqJLW9bOCe9tatOtL+qbwHdEvce2SRrWgE8M0H+skcmpmLGBubZQWn/bz4oMxyrDc0NOiCF | |
| 1979 M+nc5EiXODKoyv//iZSg7GLc27GjOLZ3c1M7Ph5S9tJ5PPudycgQxCv3G3Tn5wr7XKZbqBAErPD0 | |
| 1980 PYWMiNF/+kDVph88UeJynwqL91HZXNlfuGbauf1rgkkGlb3vS3GCEh+zQuNFnbqJA7ZPpwM5fXQa | |
| 1981 lS+cShbQfAdA50Y8FbA3+kusEKcbEcLGUbtkmBxLdNSX9TnIo910sDe0ei72t5WdumWXQrzY3nDe | |
| 1982 quzUPQ65h7qnh6pNcZ9jgTFLc1s9qXhNkPk4U9AFX57zgWfoetsPX28vXxzZwwXkd3ztKBLKJhs4 | |
| 1983 hv3Sycbceamk052YpRxTuh7u1ZyQsG5x5UBln2Db3qZTkrJl/2PyHBjSwHvfHzIzPbyr9wdtTC3r | |
| 1984 HcGUxPCJGtG0nCIejbt9MupOt1FbXSBckPQAIB0VCLAQTEc3OgmiG87yHj7Xu8FpTdfxuidMoSMV | |
| 1985 lCzmcwT3ML5fg1+7OxUSP6g7o2j6c4M2B+olB+Fm34FbjbxQyHaT0J56wwdbXACuye7v/+IB/btp | |
| 1986 jLb74S6/2rZ62VsHyL4sZr5iZlCLROZxBEYG9OaQtDWWSxhBx2toGjq6DNXMDfkCHT/KpsXLtmmD | |
| 1987 Qc7sRHsA1igE/wfVIOdx | |
| 1988 """) | |
| 1989 | |
| 1990 ##file activate.sh | |
| 1991 ACTIVATE_SH = convert(""" | |
| 1992 eJytVVFvokAQfudXTLEPtTlLeo9tvMSmJpq02hSvl7u2wRUG2QR2DSxSe7n/frOACEVNLlceRHa+ | |
| 1993 nfl25pvZDswCnoDPQ4QoTRQsENIEPci4CsBMZBq7CAsuLOYqvmYKTTj3YxnBgiXBudGBjUzBZUJI | |
| 1994 BXEqgCvweIyuCjeG4eF2F5x14bcB9KQiQQWrjSddI1/oQIx6SYYeoFjzWIoIhYI1izlbhJjkKO7D | |
| 1995 M/QEmKfO9O7WeRo/zr4P7pyHwWxkwitcgwpQ5Ej96OX+PmiFwLeVjFUOrNYKaq1Nud3nR2n8nI2m | |
| 1996 k9H0friPTGVsUdptaxGrTEfpNVFEskxpXtUkkCkl1UNF9cgLBkx48J4EXyALuBtAwNYIjF5kcmUU | |
| 1997 abMKmMq1ULoiRbgsDEkTSsKSGFCJ6Z8vY/2xYiSacmtyAfCDdCNTVZoVF8vSTQOoEwSnOrngBkws | |
| 1998 MYGMBMg8/bMBLSYKS7pYEXP0PqT+ZmBT0Xuy+Pplj5yn4aM9nk72JD8/Wi+Gr98sD9eWSMOwkapD | |
| 1999 BbUv91XSvmyVkICt2tmXR4tWmrcUCsjWOpw87YidEC8i0gdTSOFhouJUNxR+4NYBG0MftoCTD9F7 | |
| 2000 2rTtxG3oPwY1b2HncYwhrlmj6Wq924xtGDWqfdNxap+OYxplEurnMVo9RWks+rH8qKEtx7kZT5zJ | |
| 2001 4H7oOFclrN6uFe+d+nW2aIUsSgs/42EIPuOhXq+jEo3S6tX6w2ilNkDnIpHCWdEQhFgwj9pkk7FN | |
| 2002 l/y5eQvRSIQ5+TrL05lewxWpt/Lbhes5cJF3mLET1MGhcKCF+40tNWnUulxrpojwDo2sObdje3Bz | |
| 2003 N3QeHqf3D7OjEXMVV8LN3ZlvuzoWHqiUcNKHtwNd0IbvPGKYYM31nPKCgkUILw3KL+Y8l7aO1ArS | |
| 2004 Ad37nIU0fCj5NE5gQCuC5sOSu+UdI2NeXg/lFkQIlFpdWVaWZRfvqGiirC9o6liJ9FXGYrSY9mI1 | |
| 2005 D/Ncozgn13vJvsznr7DnkJWXsyMH7e42ljdJ+aqNDF1bFnKWFLdj31xtaJYK6EXFgqmV/ymD/ROG | |
| 2006 +n8O9H8f5vsGOWXsL1+1k3g= | |
| 2007 """) | |
| 2008 | |
| 2009 ##file activate.fish | |
| 2010 ACTIVATE_FISH = convert(""" | |
| 2011 eJydVW2P2jgQ/s6vmAZQoVpA9/WkqqJaTou0u6x2uZVOVWWZZEKsS+yc7UDpr+84bziQbauLxEvs | |
| 2012 eXnsZ56ZIWwTYSAWKUJWGAs7hMJgBEdhEwiMKnSIsBNywUMrDtziPBYmCeBDrFUG7v8HmCTW5n8u | |
| 2013 Fu7NJJim81Bl08EQTqqAkEupLOhCgrAQCY2hTU+DQVxIiqgkRNiEBphFEKy+kd1BaFvwFOUBuIxA | |
| 2014 oy20BKtAKp3xFMo0QNtCK5mhtMEA6BmSpUELKo38TThwLfguRVNaiRgs0llnEoIR29zfstf18/bv | |
| 2015 5T17Wm7vAiiN3ONCzfbfwC3DtWXXDqHfAGX0q6z/bO82j3ebh1VwnbrduwTQbvwcRtesAfMGor/W | |
| 2016 L3fs6Xnz8LRlm9fV8/P61sM0LDNwCZjl9gSpCokJRzpryGQ5t8kNGFUt51QjOZGu0Mj35FlYlXEr | |
| 2017 yC09EVOp4lEXfF84Lz1qbhBsgl59vDedXI3rTV03xipduSgt9kLytI3XmBp3aV6MPoMQGNUU62T6 | |
| 2018 uQdeefTy1Hfj10zVHg2pq8fXDoHBiOv94csfXwN49xECqWREy7pwukKfvxdMY2j23vXDPuuxxeE+ | |
| 2019 JOdCOhxCE3N44B1ZeSLuZh8Mmkr2wEPAmPfKWHA2uxIRjEopdbQYjDz3BWOf14/scfmwoki1eQvX | |
| 2020 ExBdF60Mqh+Y/QcX4uiH4Amwzx79KOVFtbL63sXJbtcvy8/3q5rupmO5CnE91wBviQAhjUUegYpL | |
| 2021 vVEbpLt2/W+PklRgq5Ku6mp+rpMhhCo/lXthQTxJ2ysO4Ka0ad97S7VT/n6YXus6fzk3fLnBZW5C | |
| 2022 KDC6gSO62QDqgFqLCCtPmjegjnLeAdArtSE8VYGbAJ/aLb+vnQutFhk768E9uRbSxhCMzdgEveYw | |
| 2023 IZ5ZqFKl6+kz7UR4U+buqQZXu9SIujrAfD7f0FXpozB4Q0gwp31H9mVTZGGC4b871/wm7lvyDLu1 | |
| 2024 FUyvTj/yvD66k3UPTs08x1AQQaGziOl0S1qRkPG9COtBTSTWM9NzQ4R64B+Px/l3tDzCgxv5C6Ni | |
| 2025 e+QaF9xFWrxx0V/G5uvYQOdiZzvYpQUVQSIsTr1TTghI33GnPbTA7/GCqcE3oE3GZurq4HeQXQD6 | |
| 2026 32XS1ITj/qLjN72ob0hc5C9bzw8MhfmL | |
| 2027 """) | |
| 2028 | |
| 2029 ##file activate.csh | |
| 2030 ACTIVATE_CSH = convert(""" | |
| 2031 eJx9VG1P2zAQ/u5fcYQKNgTNPtN1WxlIQ4KCUEGaxuQ6yYVYSuzKdhqVX7+zk3bpy5YPUXL3PPfc | |
| 2032 ne98DLNCWshliVDV1kGCUFvMoJGugMjq2qQIiVSxSJ1cCofD1BYRnOVGV0CfZ0N2DD91DalQSjsw | |
| 2033 tQLpIJMGU1euvPe7QeJlkKzgWixlhnAt4aoUVsLnLBiy5NtbJWQ5THX1ZciYKKWwkOFaE04dUm6D | |
| 2034 r/zh7pq/3D7Nnid3/HEy+wFHY/gEJydg0aFaQrBFgz1c5DG1IhTs+UZgsBC2GMFBlaeH+8dZXwcW | |
| 2035 VPvCjXdlAvCfQsE7al0+07XjZvrSCUevR5dnkVeKlFYZmUztG4BdzL2u9KyLVabTU0bdfg7a0hgs | |
| 2036 cSmUg6UwUiQl2iHrcbcVGNvPCiLOe7+cRwG13z9qRGgx2z6DHjfm/Op2yqeT+xvOLzs0PTKHDz2V | |
| 2037 tkckFHoQfQRXoGJAj9el0FyJCmEMhzgMS4sB7KPOE2ExoLcSieYwDvR+cP8cg11gKkVJc2wRcm1g | |
| 2038 QhYFlXiTaTfO2ki0fQoiFM4tLuO4aZrhOzqR4dIPcWx17hphMBY+Srwh7RTyN83XOWkcSPh1Pg/k | |
| 2039 TXX/jbJTbMtUmcxZ+/bbqOsy82suFQg/BhdSOTRhMNBHlUarCpU7JzBhmkKmRejKOQzayQe6MWoa | |
| 2040 n1wqWmuh6LZAaHxcdeqIlVLhIBJdO9/kbl0It2oEXQj+eGjJOuvOIR/YGRqvFhttUB2XTvLXYN2H | |
| 2041 37CBdbW2W7j2r2+VsCn0doVWcFG1/4y1VwBjfwAyoZhD | |
| 2042 """) | |
| 2043 | |
| 2044 ##file activate.bat | |
| 2045 ACTIVATE_BAT = convert(""" | |
| 2046 eJx9UdEKgjAUfW6wfxjiIH+hEDKUFHSKLCMI7kNOEkIf9P9pTJ3OLJ/03HPPPed4Es9XS9qqwqgT | |
| 2047 PbGKKOdXL4aAFS7A4gvAwgijuiKlqOpGlATS2NeMLE+TjJM9RkQ+SmqAXLrBo1LLIeLdiWlD6jZt | |
| 2048 r7VNubWkndkXaxg5GO3UaOOKS6drO3luDDiO5my3iA0YAKGzPRV1ack8cOdhysI0CYzIPzjSiH5X | |
| 2049 0QcvC8Lfaj0emsVKYF2rhL5L3fCkVjV76kShi59NHwDniAHzkgDgqBcwOgTMx+gDQQqXCw== | |
| 2050 """) | |
| 2051 | |
| 2052 ##file deactivate.bat | |
| 2053 DEACTIVATE_BAT = convert(""" | |
| 2054 eJxzSE3OyFfIT0vj4ipOLVEI8wwKCXX0iXf1C7Pl4spMU0hJTcvMS01RiPf3cYmHyQYE+fsGhCho | |
| 2055 cCkAAUibEkTEVhWLMlUlLk6QGixStlyaeCyJDPHw9/Pw93VFsQguim4ZXAJoIUw5DhX47XUM8UCx | |
| 2056 EchHtwsohN1bILUgw61c/Vy4AJYPYm4= | |
| 2057 """) | |
| 2058 | |
| 2059 ##file activate.ps1 | |
| 2060 ACTIVATE_PS = convert(""" | |
| 2061 eJylWdmS40Z2fVeE/oHT6rCloNUEAXDThB6wAyQAEjsB29GBjdgXYiWgmC/zgz/Jv+AEWNVd3S2N | |
| 2062 xuOKYEUxM+/Jmzfvcm7W//zXf/+wUMOoXtyi1F9kbd0sHH/hFc2iLtrK9b3FrSqyxaVQwr8uhqJd | |
| 2063 uHaeg9mqzRdR8/13Pyy8qPLdJh0+LMhi0QCoXxYfFh9WtttEnd34H8p6/f1300KauwrULws39e18 | |
| 2064 0ZaLNm9rgN/ZVf3h++/e124Vlc0vKsspHy+Yyi5+XbzPhijvCtduoiL/kA1ukWV27n0o7Sb8LIFj | |
| 2065 CvWR5GQgUJdp1Pw8TS9+rPy6SDv/+e3d+0+4qw8f3v20+PliV37efEYBAB9FTKC+RHn/Cfxn3rdv | |
| 2066 00Fube5O+iyCtHDs9BfPfz3q4sfFv9d91Ljhfy7ei0VO+nVTtdOkv/jpt0l2AX6iG1jXgKnnDuD4 | |
| 2067 ke2k/i8fzzz5UedkVcP4pwF+Wvz2FJl+3vt598urXf5Y6LNA5WcFOP7r0sW7b9a+W/xcu0Xpv5zk | |
| 2068 Kfq3P9Dz9di/fCxS72MXVU1rpx9L4Bxl85Wmn5a+zP76Zuh3pL9ROWr87PN+//GHIl+oOtvn9XSU | |
| 2069 qH+p0gQBFnx1uV+JLH5O5zv+PXW+WepXVVHZT0+oQezkIATcIm+ivPV/z5J/+cYj3ir4w0Lx09vC | |
| 2070 e5n/y5/Y5LPPfdrqb88ga/PabxZRVfmp39l588m/6u+/e+OpP+dF7n1WZpJ9//Z4v372fDDz9eHB | |
| 2071 7Juvs/BLMHzrxL9+9twXpJfhd1/DrpQ5Euu/vlss3wp9HXC/54C/Ld69m6zwdx3tC0d8daSv0V8B | |
| 2072 n4b9YYF53sJelJV/ix6LZspw/sJtqyl5LJ5r/23htA1Imfm/gt9R7dqVB1LjhydAX4Gb+zksQF59 | |
| 2073 9+P7H//U+376afFuvh2/T6P85Xr/5c8C6OXyFY4BGuN+EE0+GeR201b+wkkLN5mmBY5TfMw8ngqL | |
| 2074 CztXxCSXKMCYrRIElWkEJlEPYsSOeKBVZCAQTKBhApMwRFQzmCThE0YQu2CdEhgjbgmk9GluHpfR | |
| 2075 /hhwJCZhGI5jt5FsAkOrObVyE6g2y1snyhMGFlDY1x+BoHpCMulTj5JYWNAYJmnKpvLxXgmQ8az1 | |
| 2076 4fUGxxcitMbbhDFcsiAItg04E+OSBIHTUYD1HI4FHH4kMREPknuYRMyhh3AARWMkfhCketqD1CWJ | |
| 2077 mTCo/nhUScoQcInB1hpFhIKoIXLo5jLpwFCgsnLCx1QlEMlz/iFEGqzH3vWYcpRcThgWnEKm0QcS | |
| 2078 rA8ek2a2IYYeowUanOZOlrbWSJUC4c7y2EMI3uJPMnMF/SSXdk6E495VLhzkWHps0rOhKwqk+xBI | |
| 2079 DhJirhdUCTamMfXz2Hy303hM4DFJ8QL21BcPBULR+gcdYxoeiDqOFSqpi5B5PUISfGg46gFZBPo4 | |
| 2080 jdh8lueaWuVSMTURfbAUnLINr/QYuuYoMQV6l1aWxuZVTjlaLC14UzqZ+ziTGDzJzhiYoPLrt3uI | |
| 2081 tXkVR47kAo09lo5BD76CH51cTt1snVpMOttLhY93yxChCQPI4OBecS7++h4p4Bdn4H97bJongtPk | |
| 2082 s9gQnXku1vzsjjmX4/o4YUDkXkjHwDg5FXozU0fW4y5kyeYW0uJWlh536BKr0kMGjtzTkng6Ep62 | |
| 2083 uTWnQtiIqKnEsx7e1hLtzlXs7Upw9TwEnp0t9yzCGgUJIZConx9OHJArLkRYW0dW42G9OeR5Nzwk | |
| 2084 yk1mX7du5RGHT7dka7N3AznmSif7y6tuKe2N1Al/1TUPRqH6E2GLVc27h9IptMLkCKQYRqPQJgzV | |
| 2085 2m6WLsSipS3v3b1/WmXEYY1meLEVIU/arOGVkyie7ZsH05ZKpjFW4cpY0YkjySpSExNG2TS8nnJx | |
| 2086 nrQmWh2WY3cP1eISP9wbaVK35ZXc60yC3VN/j9n7UFoK6zvjSTE2+Pvz6Mx322rnftfP8Y0XKIdv | |
| 2087 Qd7AfK0nexBTMqRiErvCMa3Hegpfjdh58glW2oNMsKeAX8x6YJLZs9K8/ozjJkWL+JmECMvhQ54x | |
| 2088 9rsTHwcoGrDi6Y4I+H7yY4/rJVPAbYymUH7C2D3uiUS3KQ1nrCAUkE1dJMneDQIJMQQx5SONxoEO | |
| 2089 OEn1/Ig1eBBUeEDRuOT2WGGGE4bNypBLFh2PeIg3bEbg44PHiqNDbGIQm50LW6MJU62JHCGBrmc9 | |
| 2090 2F7WBJrrj1ssnTAK4sxwRgh5LLblhwNAclv3Gd+jC/etCfyfR8TMhcWQz8TBIbG8IIyAQ81w2n/C | |
| 2091 mHWAwRzxd3WoBY7BZnsqGOWrOCKwGkMMNfO0Kci/joZgEocLjNnzgcmdehPHJY0FudXgsr+v44TB | |
| 2092 I3jnMGnsK5veAhgi9iXGifkHMOC09Rh9cAw9sQ0asl6wKMk8mpzFYaaDSgG4F0wisQDDBRpjCINg | |
| 2093 FIxhlhQ31xdSkkk6odXZFpTYOQpOOgw9ugM2cDQ+2MYa7JsEirGBrOuxsQy5nPMRdYjsTJ/j1iNw | |
| 2094 FeSt1jY2+dd5yx1/pzZMOQXUIDcXeAzR7QlDRM8AMkUldXOmGmvYXPABjxqkYKO7VAY6JRU7kpXr | |
| 2095 +Epu2BU3qFFXClFi27784LrDZsJwbNlDw0JzhZ6M0SMXE4iBHehCpHVkrQhpTFn2dsvsZYkiPEEB | |
| 2096 GSEAwdiur9LS1U6P2U9JhGp4hnFpJo4FfkdJHcwV6Q5dV1Q9uNeeu7rV8PAjwdFg9RLtroifOr0k | |
| 2097 uOiRTo/obNPhQIf42Fr4mtThWoSjitEdAmFW66UCe8WFjPk1YVNpL9srFbond7jrLg8tqAasIMpy | |
| 2098 zkH0SY/6zVAwJrEc14zt14YRXdY+fcJ4qOd2XKB0/Kghw1ovd11t2o+zjt+txndo1ZDZ2T+uMVHT | |
| 2099 VSXhedBAHoJIID9xm6wPQI3cXY+HR7vxtrJuCKh6kbXaW5KkVeJsdsjqsYsOwYSh0w5sMbu7LF8J | |
| 2100 5T7U6LJdiTx+ca7RKlulGgS5Z1JSU2Llt32cHFipkaurtBrvNX5UtvNZjkufZ/r1/XyLl6yOpytL | |
| 2101 Km8Fn+y4wkhlqZP5db0rooqy7xdL4wxzFVTX+6HaxuQJK5E5B1neSSovZ9ALB8091dDbbjVxhWNY | |
| 2102 Ve5hn1VnI9OF0wpvaRm7SZuC1IRczwC7GnkhPt3muHV1YxUJfo+uh1sYnJy+vI0ZwuPV2uqWJYUH | |
| 2103 bmBsi1zmFSxHrqwA+WIzLrHkwW4r+bad7xbOzJCnKIa3S3YvrzEBK1Dc0emzJW+SqysQfdEDorQG | |
| 2104 9ZJlbQzEHQV8naPaF440YXzJk/7vHGK2xwuP+Gc5xITxyiP+WQ4x18oXHjFzCBy9kir1EFTAm0Zq | |
| 2105 LYwS8MpiGhtfxiBRDXpxDWxk9g9Q2fzPPAhS6VFDAc/aiNGatUkPtZIStZFQ1qD0IlJa/5ZPAi5J | |
| 2106 ySp1ETDomZMnvgiysZSBfMikrSDte/K5lqV6iwC5q7YN9I1dBZXUytDJNqU74MJsUyNNLAPopWK3 | |
| 2107 tzmLkCiDyl7WQnj9sm7Kd5kzgpoccdNeMw/6zPVB3pUwMgi4C7hj4AMFAf4G27oXH8NNT9zll/sK | |
| 2108 S6wVlQwazjxWKWy20ZzXb9ne8ngGalPBWSUSj9xkc1drsXkZ8oOyvYT3e0rnYsGwx85xZB9wKeKg | |
| 2109 cJKZnamYwiaMymZvzk6wtDUkxmdUg0mPad0YHtvzpjEfp2iMxvORhnx0kCVLf5Qa43WJsVoyfEyI | |
| 2110 pzmf8ruM6xBr7dnBgzyxpqXuUPYaKahOaz1LrxNkS/Q3Ae5AC+xl6NbxAqXXlzghZBZHmOrM6Y6Y | |
| 2111 ctAkltwlF7SKEsShjVh7QHuxMU0a08/eiu3x3M+07OijMcKFFltByXrpk8w+JNnZpnp3CfgjV1Ax | |
| 2112 gUYCnWwYow42I5wHCcTzLXK0hMZN2DrPM/zCSqe9jRSlJnr70BPE4+zrwbk/xVIDHy2FAQyHoomT | |
| 2113 Tt5jiM68nBQut35Y0qLclLiQrutxt/c0OlSqXAC8VrxW97lGoRWzhOnifE2zbF05W4xuyhg7JTUL | |
| 2114 aqJ7SWDywhjlal0b+NLTpERBgnPW0+Nw99X2Ws72gOL27iER9jgzj7Uu09JaZ3n+hmCjjvZpjNst | |
| 2115 vOWWTbuLrg+/1ltX8WpPauEDEvcunIgTxuMEHweWKCx2KQ9DU/UKdO/3za4Szm2iHYL+ss9AAttm | |
| 2116 gZHq2pkUXFbV+FiJCKrpBms18zH75vax5jSo7FNunrVWY3Chvd8KKnHdaTt/6ealwaA1x17yTlft | |
| 2117 8VBle3nAE+7R0MScC3MJofNCCkA9PGKBgGMYEwfB2QO5j8zUqa8F/EkWKCzGQJ5EZ05HTly1B01E | |
| 2118 z813G5BY++RZ2sxbQS8ZveGPJNabp5kXAeoign6Tlt5+L8i5ZquY9+S+KEUHkmYMRFBxRrHnbl2X | |
| 2119 rVemKnG+oB1yd9+zT+4c43jQ0wWmQRR6mTCkY1q3VG05Y120ZzKOMBe6Vy7I5Vz4ygPB3yY4G0FP | |
| 2120 8RxiMx985YJPXsgRU58EuHj75gygTzejP+W/zKGe78UQN3yOJ1aMQV9hFH+GAfLRsza84WlPLAI/ | |
| 2121 9G/5JdcHftEfH+Y3/fHUG7/o8bv98dzzy3e8S+XCvgqB+VUf7sH0yDHpONdbRE8tAg9NWOzcTJ7q | |
| 2122 TuAxe/AJ07c1Rs9okJvl1/0G60qvbdDzz5zO0FuPFQIHNp9y9Bd1CufYVx7dB26mAxwa8GMNrN/U | |
| 2123 oGbNZ3EQ7inLzHy5tRg9AXJrN8cB59cCUBeCiVO7zKM0jU0MamhnRThkg/NMmBOGb6StNeD9tDfA | |
| 2124 7czsAWopDdnGoXUHtA+s/k0vNPkBcxEI13jVd/axp85va3LpwGggXXWw12Gwr/JGAH0b8CPboiZd | |
| 2125 QO1l0mk/UHukud4C+w5uRoNzpCmoW6GbgbMyaQNkga2pQINB18lOXOCJzSWPFOhZcwzdgrsQnne7 | |
| 2126 nvjBi+7cP2BbtBeDOW5uOLGf3z94FasKIguOqJl+8ss/6Kumns4cuWbqq5592TN/RNIbn5Qo6qbi | |
| 2127 O4F0P9txxPAwagqPlftztO8cWBzdN/jz3b7GD6JHYP/Zp4ToAMaA74M+EGSft3hEGMuf8EwjnTk/ | |
| 2128 nz/P7SLipB/ogQ6xNX0fDqNncMCfHqGLCMM0ZzFa+6lPJYQ5p81vW4HkCvidYf6kb+P/oB965g8K | |
| 2129 C6uR0rdjX1DNKc5pOSTquI8uQ6KXxYaKBn+30/09tK4kMpJPgUIQkbENEPbuezNPPje2Um83SgyX | |
| 2130 GTCJb6MnGVIpgncdQg1qz2bvPfxYD9fewCXDomx9S+HQJuX6W3VAL+v5WZMudRQZk9ZdOk6GIUtC | |
| 2131 PqEb/uwSIrtR7/edzqgEdtpEwq7p2J5OQV+RLrmtTvFwFpf03M/VrRyTZ73qVod7v7Jh2Dwe5J25 | |
| 2132 JqFOU2qEu1sP+CRotklediycKfLjeIZzjJQsvKmiGSNQhxuJpKa+hoWUizaE1PuIRGzJqropwgVB | |
| 2133 oo1hr870MZLgnXF5ZIpr6mF0L8aSy2gVnTAuoB4WEd4d5NPVC9TMotYXERKlTcwQ2KiB/C48AEfH | |
| 2134 Qbyq4CN8xTFnTvf/ebOc3isnjD95s0QF0nx9s+y+zMmz782xL0SgEmRpA3x1w1Ff9/74xcxKEPdS | |
| 2135 IEFTz6GgU0+BK/UZ5Gwbl4gZwycxEw+Kqa5QmMkh4OzgzEVPnDAiAOGBFaBW4wkDmj1G4RyElKgj | |
| 2136 NlLCq8zsp085MNh/+R4t1Q8yxoSv8PUpTt7izZwf2BTHZZ3pIZpUIpuLkL1nNL6sYcHqcKm237wp | |
| 2137 T2+RCjgXweXd2Zp7ZM8W6dG5bZsqo0nrJBTx8EC0+CQQdzEGnabTnkzofu1pYkWl4E7XSniECdxy | |
| 2138 vLYavPMcL9LW5SToJFNnos+uqweOHriUZ1ntIYZUonc7ltEQ6oTRtwOHNwez2sVREskHN+bqG3ua | |
| 2139 eaEbJ8XpyO8CeD9QJc8nbLP2C2R3A437ISUNyt5Yd0TbDNcl11/DSsOzdbi/VhCC0KE6v1vqVNkq | |
| 2140 45ZnG6fiV2NwzInxCNth3BwL0+8814jE6+1W1EeWtpWbSZJOJNYXmWRXa7vLnAljE692eHjZ4y5u | |
| 2141 y1u63De0IzKca7As48Z3XshVF+3XiLNz0JIMh/JOpbiNLlMi672uO0wYzOCZjRxcxj3D+gVenGIE | |
| 2142 MvFUGGXuRps2RzMcgWIRolHXpGUP6sMsQt1hspUBnVKUn/WQj2u6j3SXd9Xz0QtEzoM7qTu5y7gR | |
| 2143 q9gNNsrlEMLdikBt9bFvBnfbUIh6voTw7eDsyTmPKUvF0bHqWLbHe3VRHyRZnNeSGKsB73q66Vsk | |
| 2144 taxWYmwz1tYVFG/vOQhlM0gUkyvIab3nv2caJ1udU1F3pDMty7stubTE4OJqm0i0ECfrJIkLtraC | |
| 2145 HwRWKzlqpfhEIqYH09eT9WrOhQyt8YEoyBlnXtAT37WHIQ03TIuEHbnRxZDdLun0iok9PUC79prU | |
| 2146 m5beZzfQUelEXnhzb/pIROKx3F7qCttYIFGh5dXNzFzID7u8vKykA8Uejf7XXz//S4nKvW//ofS/ | |
| 2147 QastYw== | |
| 2148 """) | |
| 2149 | |
| 2150 ##file distutils-init.py | |
| 2151 DISTUTILS_INIT = convert(""" | |
| 2152 eJytV1uL4zYUfvevOE0ottuMW9q3gVDa3aUMXXbLMlDKMBiNrSTqOJKRlMxkf33PkXyRbGe7Dw2E | |
| 2153 UXTu37lpxLFV2oIyifAncxmOL0xLIfcG+gv80x9VW6maw7o/CANSWWBwFtqeWMPlGY6qPjV8A0bB | |
| 2154 C4eKSTgZ5LRgFeyErMEeOBhbN+Ipgeizhjtnhkn7DdyjuNLPoCS0l/ayQTG0djwZC08cLXozeMss | |
| 2155 aG5EzQ0IScpnWtHSTXuxByV/QCmxE7y+eS0uxWeoheaVVfqSJHiU7Mhhi6gULbOHorshkrEnKxpT | |
| 2156 0n3A8Y8SMpuwZx6aoix3ouFlmW8gHRSkeSJ2g7hU+kiHLDaQw3bmRDaTGfTnty7gPm0FHbIBg9U9 | |
| 2157 oh1kZzAFLaue2R6htPCtAda2nGlDSUJ4PZBgCJBGVcwKTAMz/vJiLD+Oin5Z5QlvDPdulC6EsiyE | |
| 2158 NFzb7McNTKJzbJqzphx92VKRFY1idenzmq3K0emRcbWBD0ryqc4NZGmKOOOX9Pz5x+/l27tP797c | |
| 2159 f/z0d+4NruGNai8uAM0bfsYaw8itFk8ny41jsfpyO+BWlpqfhcG4yxLdi/0tQqoT4a8Vby382mt8 | |
| 2160 p7XSo7aWGdPBc+b6utaBmCQ7rQKQoWtAuthQCiold2KfJIPTT8xwg9blPumc+YDZC/wYGdAyHpJk | |
| 2161 vUbHbHWAp5No6pK/WhhLEWrFjUwtPEv1Agf8YmnsuXUQYkeZoHm8ogP16gt2uHoxcEMdf2C6pmbw | |
| 2162 hUMsWGhanboh4IzzmsIpWs134jVPqD/c74bZHdY69UKKSn/+KfVhxLgUlToemayLMYQOqfEC61bh | |
| 2163 cbhwaqoGUzIyZRFHPmau5juaWqwRn3mpWmoEA5nhzS5gog/5jbcFQqOZvmBasZtwYlG93k5GEiyw | |
| 2164 buHhMWLjDarEGpMGB2LFs5nIJkhp/nUmZneFaRth++lieJtHepIvKgx6PJqIlD9X2j6pG1i9x3pZ | |
| 2165 5bHuCPFiirGHeO7McvoXkz786GaKVzC9DSpnOxJdc4xm6NSVq7lNEnKdVlnpu9BNYoKX2Iq3wvgh | |
| 2166 gGEUM66kK6j4NiyoneuPLSwaCWDxczgaolEWpiMyDVDb7dNuLAbriL8ig8mmeju31oNvQdpnvEPC | |
| 2167 1vAXbWacGRVrGt/uXN/gU0CDDwgooKRrHfTBb1/s9lYZ8ZqOBU0yLvpuP6+K9hLFsvIjeNhBi0KL | |
| 2168 MlOuWRn3FRwx5oHXjl0YImUx0+gLzjGchrgzca026ETmYJzPD+IpuKzNi8AFn048Thd63OdD86M6 | |
| 2169 84zE8yQm0VqXdbbgvub2pKVnS76icBGdeTHHXTKspUmr4NYo/furFLKiMdQzFjHJNcdAnMhltBJK | |
| 2170 0/IKX3DVFqvPJ2dLE7bDBkH0l/PJ29074+F0CsGYOxsb7U3myTUncYfXqnLLfa6sJybX4g+hmcjO | |
| 2171 kMRBfA1JellfRRKJcyRpxdS4rIl6FdmQCWjo/o9Qz7yKffoP4JHjOvABcRn4CZIT2RH4jnxmfpVG | |
| 2172 qgLaAvQBNfuO6X0/Ux02nb4FKx3vgP+XnkX0QW9pLy/NsXgdN24dD3LxO2Nwil7Zlc1dqtP3d7/h | |
| 2173 kzp1/+7hGBuY4pk0XD/0Ao/oTe/XGrfyM773aB7iUhgkpy+dwAMalxMP0DrBcsVw/6p25+/hobP9 | |
| 2174 GBknrWExDhLJ1bwt1NcCNblaFbMKCyvmX0PeRaQ= | |
| 2175 """) | |
| 2176 | |
| 2177 ##file distutils.cfg | |
| 2178 DISTUTILS_CFG = convert(""" | |
| 2179 eJxNj00KwkAMhfc9xYNuxe4Ft57AjYiUtDO1wXSmNJnK3N5pdSEEAu8nH6lxHVlRhtDHMPATA4uH | |
| 2180 xJ4EFmGbvfJiicSHFRzUSISMY6hq3GLCRLnIvSTnEefN0FIjw5tF0Hkk9Q5dRunBsVoyFi24aaLg | |
| 2181 9FDOlL0FPGluf4QjcInLlxd6f6rqkgPu/5nHLg0cXCscXoozRrP51DRT3j9QNl99AP53T2Q= | |
| 2182 """) | |
| 2183 | |
| 2184 ##file activate_this.py | |
| 2185 ACTIVATE_THIS = convert(""" | |
| 2186 eJyNU01v2zAMvetXEB4K21jmDOstQA4dMGCHbeihlyEIDMWmG62yJEiKE//7kXKdpN2KzYBt8euR | |
| 2187 fKSyLPs8wiEo8wh4wqZTGou4V6Hm0wJa1cSiTkJdr8+GsoTRHuCotBayiWqQEYGtMCgfD1KjGYBe | |
| 2188 5a3p0cRKiAe2NtLADikftnDco0ko/SFEVgEZ8aRC5GLux7i3BpSJ6J1H+i7A2CjiHq9z7JRZuuQq | |
| 2189 siwTIvpxJYCeuWaBpwZdhB+yxy/eWz+ZvVSU8C4E9FFZkyxFsvCT/ZzL8gcz9aXVE14Yyp2M+2W0 | |
| 2190 y7n5mp0qN+avKXvbsyyzUqjeWR8hjGE+2iCE1W1tQ82hsCZN9UzlJr+/e/iab8WfqsmPI6pWeUPd | |
| 2191 FrMsd4H/55poeO9n54COhUs+sZNEzNtg/wanpjpuqHJaxs76HtZryI/K3H7KJ/KDIhqcbJ7kI4ar | |
| 2192 XL+sMgXnX0D+Te2Iy5xdP8yueSlQB/x/ED2BTAtyE3K4SYUN6AMNfbO63f4lBW3bUJPbTL+mjSxS | |
| 2193 PyRfJkZRgj+VbFv+EzHFi5pKwUEepa4JslMnwkowSRCXI+m5XvEOvtuBrxHdhLalG0JofYBok6qj | |
| 2194 YdN2dEngUlbC4PG60M1WEN0piu7Nq7on0mgyyUw3iV1etLo6r/81biWdQ9MWHFaePWZYaq+nmp+t | |
| 2195 s3az+sj7eA0jfgPfeoN1 | |
| 2196 """) | |
| 2197 | |
| 2198 MH_MAGIC = 0xfeedface | |
| 2199 MH_CIGAM = 0xcefaedfe | |
| 2200 MH_MAGIC_64 = 0xfeedfacf | |
| 2201 MH_CIGAM_64 = 0xcffaedfe | |
| 2202 FAT_MAGIC = 0xcafebabe | |
| 2203 BIG_ENDIAN = '>' | |
| 2204 LITTLE_ENDIAN = '<' | |
| 2205 LC_LOAD_DYLIB = 0xc | |
| 2206 maxint = majver == 3 and getattr(sys, 'maxsize') or getattr(sys, 'maxint') | |
| 2207 | |
| 2208 | |
| 2209 class fileview(object): | |
| 2210 """ | |
| 2211 A proxy for file-like objects that exposes a given view of a file. | |
| 2212 Modified from macholib. | |
| 2213 """ | |
| 2214 | |
| 2215 def __init__(self, fileobj, start=0, size=maxint): | |
| 2216 if isinstance(fileobj, fileview): | |
| 2217 self._fileobj = fileobj._fileobj | |
| 2218 else: | |
| 2219 self._fileobj = fileobj | |
| 2220 self._start = start | |
| 2221 self._end = start + size | |
| 2222 self._pos = 0 | |
| 2223 | |
| 2224 def __repr__(self): | |
| 2225 return '<fileview [%d, %d] %r>' % ( | |
| 2226 self._start, self._end, self._fileobj) | |
| 2227 | |
| 2228 def tell(self): | |
| 2229 return self._pos | |
| 2230 | |
| 2231 def _checkwindow(self, seekto, op): | |
| 2232 if not (self._start <= seekto <= self._end): | |
| 2233 raise IOError("%s to offset %d is outside window [%d, %d]" % ( | |
| 2234 op, seekto, self._start, self._end)) | |
| 2235 | |
| 2236 def seek(self, offset, whence=0): | |
| 2237 seekto = offset | |
| 2238 if whence == os.SEEK_SET: | |
| 2239 seekto += self._start | |
| 2240 elif whence == os.SEEK_CUR: | |
| 2241 seekto += self._start + self._pos | |
| 2242 elif whence == os.SEEK_END: | |
| 2243 seekto += self._end | |
| 2244 else: | |
| 2245 raise IOError("Invalid whence argument to seek: %r" % (whence,)) | |
| 2246 self._checkwindow(seekto, 'seek') | |
| 2247 self._fileobj.seek(seekto) | |
| 2248 self._pos = seekto - self._start | |
| 2249 | |
| 2250 def write(self, bytes): | |
| 2251 here = self._start + self._pos | |
| 2252 self._checkwindow(here, 'write') | |
| 2253 self._checkwindow(here + len(bytes), 'write') | |
| 2254 self._fileobj.seek(here, os.SEEK_SET) | |
| 2255 self._fileobj.write(bytes) | |
| 2256 self._pos += len(bytes) | |
| 2257 | |
| 2258 def read(self, size=maxint): | |
| 2259 assert size >= 0 | |
| 2260 here = self._start + self._pos | |
| 2261 self._checkwindow(here, 'read') | |
| 2262 size = min(size, self._end - here) | |
| 2263 self._fileobj.seek(here, os.SEEK_SET) | |
| 2264 bytes = self._fileobj.read(size) | |
| 2265 self._pos += len(bytes) | |
| 2266 return bytes | |
| 2267 | |
| 2268 | |
| 2269 def read_data(file, endian, num=1): | |
| 2270 """ | |
| 2271 Read a given number of 32-bits unsigned integers from the given file | |
| 2272 with the given endianness. | |
| 2273 """ | |
| 2274 res = struct.unpack(endian + 'L' * num, file.read(num * 4)) | |
| 2275 if len(res) == 1: | |
| 2276 return res[0] | |
| 2277 return res | |
| 2278 | |
| 2279 | |
| 2280 def mach_o_change(path, what, value): | |
| 2281 """ | |
| 2282 Replace a given name (what) in any LC_LOAD_DYLIB command found in | |
| 2283 the given binary with a new name (value), provided it's shorter. | |
| 2284 """ | |
| 2285 | |
| 2286 def do_macho(file, bits, endian): | |
| 2287 # Read Mach-O header (the magic number is assumed read by the caller) | |
| 2288 cputype, cpusubtype, filetype, ncmds, sizeofcmds, flags = read_data(file, endian, 6) | |
| 2289 # 64-bits header has one more field. | |
| 2290 if bits == 64: | |
| 2291 read_data(file, endian) | |
| 2292 # The header is followed by ncmds commands | |
| 2293 for n in range(ncmds): | |
| 2294 where = file.tell() | |
| 2295 # Read command header | |
| 2296 cmd, cmdsize = read_data(file, endian, 2) | |
| 2297 if cmd == LC_LOAD_DYLIB: | |
| 2298 # The first data field in LC_LOAD_DYLIB commands is the | |
| 2299 # offset of the name, starting from the beginning of the | |
| 2300 # command. | |
| 2301 name_offset = read_data(file, endian) | |
| 2302 file.seek(where + name_offset, os.SEEK_SET) | |
| 2303 # Read the NUL terminated string | |
| 2304 load = file.read(cmdsize - name_offset).decode() | |
| 2305 load = load[:load.index('\0')] | |
| 2306 # If the string is what is being replaced, overwrite it. | |
| 2307 if load == what: | |
| 2308 file.seek(where + name_offset, os.SEEK_SET) | |
| 2309 file.write(value.encode() + '\0'.encode()) | |
| 2310 # Seek to the next command | |
| 2311 file.seek(where + cmdsize, os.SEEK_SET) | |
| 2312 | |
| 2313 def do_file(file, offset=0, size=maxint): | |
| 2314 file = fileview(file, offset, size) | |
| 2315 # Read magic number | |
| 2316 magic = read_data(file, BIG_ENDIAN) | |
| 2317 if magic == FAT_MAGIC: | |
| 2318 # Fat binaries contain nfat_arch Mach-O binaries | |
| 2319 nfat_arch = read_data(file, BIG_ENDIAN) | |
| 2320 for n in range(nfat_arch): | |
| 2321 # Read arch header | |
| 2322 cputype, cpusubtype, offset, size, align = read_data(file, BIG_ENDIAN, 5) | |
| 2323 do_file(file, offset, size) | |
| 2324 elif magic == MH_MAGIC: | |
| 2325 do_macho(file, 32, BIG_ENDIAN) | |
| 2326 elif magic == MH_CIGAM: | |
| 2327 do_macho(file, 32, LITTLE_ENDIAN) | |
| 2328 elif magic == MH_MAGIC_64: | |
| 2329 do_macho(file, 64, BIG_ENDIAN) | |
| 2330 elif magic == MH_CIGAM_64: | |
| 2331 do_macho(file, 64, LITTLE_ENDIAN) | |
| 2332 | |
| 2333 assert(len(what) >= len(value)) | |
| 2334 do_file(open(path, 'r+b')) | |
| 2335 | |
| 2336 | |
| 2337 if __name__ == '__main__': | |
| 2338 main() | |
| 2339 | |
| 2340 ## TODO: | |
| 2341 ## Copy python.exe.manifest | |
| 2342 ## Monkeypatch distutils.sysconfig |
