home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / buildutil / buildfileutils.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  14.0 KB  |  512 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from __future__ import with_statement
  5. from contextlib import contextmanager
  6. import commands
  7. import fnmatch
  8. import hashlib
  9. import os.path as os
  10. import shlex
  11. import shutil
  12. import subprocess
  13. import sys
  14. pathjoin = os.path.join
  15. from constants import *
  16. if sys.platform == 'win32':
  17.     platformName = 'win'
  18.     build_dir = os.path.split(os.path.abspath(__file__))[0]
  19.     
  20.     class buildpaths:
  21.         platform_deps = pathjoin(build_dir, 'msw', 'dependencies')
  22.  
  23. elif sys.platform == 'darwin':
  24.     platformName = 'mac'
  25. elif 'linux' in sys.platform:
  26.     platformName = 'gtk'
  27. else:
  28.     raise AssertionError('Halp! Unknown platform!')
  29. if sys.platform == 'win32' == 'win':
  30.     platname = 'win32'
  31. else:
  32.     platname = platformName
  33. python_version = '26'
  34.  
  35. try:
  36.     import digsbypaths
  37. except ImportError:
  38.     path_to_digsby_paths = os.path.normpath(pathjoin(os.path.dirname(os.path.abspath(__file__)), '..', '..'))
  39.     sys.path.append(path_to_digsby_paths)
  40.     import digsbypaths
  41.  
  42. DEPS_DIR = digsbypaths.get_platlib_dir(DEBUG)
  43. if not os.path.isdir(DEPS_DIR):
  44.     os.makedirs(DEPS_DIR)
  45.  
  46. stars = '*' * 80
  47. if '--quiet' in sys.argv:
  48.     
  49.     def inform(*a, **k):
  50.         pass
  51.  
  52. else:
  53.     
  54.     def inform(*a, **k):
  55.         if 'banner' in k:
  56.             print '\n%s\n  %s\n\n%s\n' % (stars, k['banner'], stars)
  57.         else:
  58.             for arg in a:
  59.                 print arg,
  60.             
  61.             print 
  62.  
  63.  
  64. def fatal(msg, return_code = 1):
  65.     print >>sys.stderr, msg
  66.     sys.exit(return_code)
  67.  
  68.  
  69. class tardep(object):
  70.     
  71.     def __init__(self, url, tar, ext, size, dirname = None, md5 = None, indir = None):
  72.         self.url = url + tar + ext
  73.         self.tar = tar + ext
  74.         self.dirname = None if dirname is not None else tar
  75.         self.size = size
  76.         self.md5 = md5
  77.         self.indir = indir
  78.  
  79.     
  80.     def get(self):
  81.         if not os.path.isdir(self.dirname):
  82.             wget_cached(self.tar, self.size, self.url)
  83.             if self.md5 is not None and md5_file(self.tar, hex = True) != self.md5:
  84.                 raise AssertionError('md5 did not match: %r' % self.tar)
  85.             md5_file(self.tar, hex = True) != self.md5
  86.             if self.tar.endswith('.zip'):
  87.                 unzip(self.tar)
  88.             else:
  89.                 untar(self.tar, indir = self.indir)
  90.         else:
  91.             inform('exists: %s' % self.dirname)
  92.         return self.dirname
  93.  
  94.  
  95.  
  96. def timed(name = ''):
  97.     time = time
  98.     import time
  99.     before = time()
  100.     
  101.     try:
  102.         yield None
  103.     finally:
  104.         msg = 'took %s secs' % (time() - before)
  105.         if name:
  106.             msg = name + ' ' + msg
  107.         
  108.         inform(msg)
  109.  
  110.  
  111. timed = contextmanager(timed)
  112.  
  113. def cd(*path):
  114.     original_cwd = os.getcwd()
  115.     
  116.     try:
  117.         new_cwd = pathjoin(*path)
  118.         os.chdir(new_cwd)
  119.         yield None
  120.     finally:
  121.         os.chdir(original_cwd)
  122.  
  123.  
  124. cd = contextmanager(cd)
  125.  
  126. def which(cmd, default = None):
  127.     if platformName == 'win':
  128.         for adir in os.environ['PATH'].split(os.pathsep):
  129.             cmd_path = os.path.join(adir, cmd)
  130.             for ext in [
  131.                 ''] + os.environ['PATHEXT'].split(os.pathsep):
  132.                 if os.path.exists(cmd_path + ext):
  133.                     return cmd_path + ext
  134.             
  135.         
  136.     else:
  137.         return commands.getoutput('which ' + cmd)
  138.     return platformName == 'win'
  139.  
  140.  
  141. def run(cmd, checkret = True, expect_return_code = 0, capture_stdout = False, env = None, shell = False, executable = None, include_stderr = False):
  142.     inform(cmd)
  143.     
  144.     try:
  145.         if isinstance(cmd, basestring):
  146.             args = shlex.split(cmd.replace('\\', '\\\\'))
  147.         else:
  148.             args = cmd
  149.         if capture_stdout:
  150.             process = subprocess.Popen(args, stdout = subprocess.PIPE, stderr = subprocess.PIPE, env = env, shell = shell)
  151.         else:
  152.             process = subprocess.Popen(args, env = env, shell = shell)
  153.     except OSError:
  154.         print >>sys.stderr, 'Error using Popen: args were %r' % args
  155.         raise 
  156.  
  157.     (stdout, stderr) = process.communicate()
  158.     retcode = process.returncode
  159.     if checkret and retcode != expect_return_code:
  160.         print stderr
  161.         print 'Error running %s' % cmd
  162.         sys.exit(retcode)
  163.     
  164.     txt = None if stdout is not None else None
  165.     if txt is not None and include_stderr:
  166.         stdout += stderr
  167.     
  168.     if stdout is not None:
  169.         return stdout.strip()
  170.  
  171.  
  172. def downloaded(path, size):
  173.     if os.path.exists(path):
  174.         pass
  175.     return os.path.getsize(path) == size
  176.  
  177. if os.name == 'nt':
  178.     
  179.     def wget(url):
  180.         i = url.rfind('/')
  181.         file = url[i + 1:]
  182.         
  183.         def reporthook(*a):
  184.             print file, a
  185.  
  186.         print url, '->', file
  187.         import urllib
  188.         urllib.urlretrieve(url, file, reporthook)
  189.  
  190. else:
  191.     
  192.     def wget(url):
  193.         run([
  194.             'curl',
  195.             '-O',
  196.             url])
  197.  
  198.  
  199. def unzip(path, verbose = False):
  200.     import zipfile
  201.     makedirs = os.makedirs
  202.     dirname = os.path.dirname
  203.     f = zipfile.ZipFile(path, 'r')
  204.     for info in f.infolist():
  205.         filename = info.filename
  206.         
  207.         try:
  208.             makedirs(dirname(filename))
  209.         except Exception:
  210.             pass
  211.  
  212.         if not filename.endswith('/'):
  213.             open(filename, 'wb').write(f.read(filename))
  214.             continue
  215.     
  216.  
  217. import tarfile
  218. makedirs = os.makedirs
  219. dirname = os.path.dirname
  220.  
  221. def untar(path, verbose = False, indir = None):
  222.     if sys.platform.startswith('win'):
  223.         print 'untar %s' % path
  224.         fileobj = open(path, 'rb')
  225.         
  226.         try:
  227.             tf = tarfile.open(path, 'r:gz', fileobj = fileobj)
  228.         except:
  229.             fileobj = open(path, 'rb')
  230.             tf = tarfile.open(path, 'r', fileobj = fileobj)
  231.  
  232.         for oInfo in tf:
  233.             if verbose:
  234.                 print oInfo.name
  235.             
  236.             if oInfo.isfile():
  237.                 strFile = oInfo.name
  238.                 if indir is not None:
  239.                     strFile = os.path.join(indir, strFile)
  240.                 
  241.                 
  242.                 try:
  243.                     makedirs(dirname(strFile))
  244.                 except:
  245.                     pass
  246.  
  247.                 open(strFile, 'wb').write(tf.extractfile(oInfo).read())
  248.                 continue
  249.         
  250.     else:
  251.         flags = 'xf'
  252.         if path.endswith('.tar.gz') or path.endswith('.tgz'):
  253.             flags += 'z'
  254.         elif path.endswith('.tar.bz2'):
  255.             flags += 'j'
  256.         
  257.         if verbose:
  258.             flags += 'v'
  259.         
  260.         run([
  261.             'tar',
  262.             flags,
  263.             path])
  264.  
  265.  
  266. def wget_cached(filename, size, url):
  267.     if not downloaded(filename, size):
  268.         wget(url)
  269.     else:
  270.         inform('Already downloaded:', filename)
  271.  
  272.  
  273. def mkdirs(p):
  274.     if not os.path.exists(p):
  275.         inform('making directory %r' % p)
  276.         os.makedirs(p)
  277.     
  278.  
  279.  
  280. def locate(pattern, root = None):
  281.     if root is None:
  282.         root = os.getcwd()
  283.     
  284.     for path, dirs, files in os.walk(root):
  285.         for filename in (lambda .0: for filename in .0:
  286. if fnmatch.fnmatch(filename, pattern):
  287. os.path.abspath(pathjoin(path, filename))continue)(files):
  288.             yield filename
  289.             (None, None)
  290.         
  291.     
  292.  
  293.  
  294. def filerepl(filename, old, new):
  295.     
  296.     try:
  297.         fin = _[1]
  298.         inbytes = fin.read()
  299.     finally:
  300.         pass
  301.  
  302.     outbytes = inbytes.replace(old, new)
  303.  
  304. if os.name == 'nt':
  305.     
  306.     def dpy(cmd, platlib = False, addenv = None):
  307.         PYTHON_EXE = os.environ.get('PYTHON_EXE')
  308.         PYTHON_VER = os.environ.get('PYTHON_VER')
  309.         if PYTHON_EXE is None:
  310.             
  311.             try:
  312.                 PYTHON_EXE = PYTHON_EXE
  313.                 PYTHON_VER = PYTHON_VER
  314.                 import build_python
  315.             except ImportError:
  316.                 sys.path.append(os.path.abspath(pathjoin(__file__, '../../msw')))
  317.                 PYTHON_EXE = PYTHON_EXE
  318.                 PYTHON_VER = PYTHON_VER
  319.                 import build_python
  320.             except:
  321.                 None<EXCEPTION MATCH>ImportError
  322.             
  323.  
  324.         None<EXCEPTION MATCH>ImportError
  325.         env = python_env(platlib, addenv = addenv)
  326.         if PYTHON_VER == '25':
  327.             env.update(DISTUTILS_USE_SDK = '1', MSSdk = '1')
  328.         
  329.         run([
  330.             PYTHON_EXE] + cmd, env = env)
  331.  
  332.     import distutils.msvccompiler as distutils
  333.     
  334.     def list_repl(l, old, new):
  335.         if old in l:
  336.             l.remove(old)
  337.             l.append(new)
  338.         
  339.  
  340.     
  341.     def initialize(self, old_init = distutils.msvccompiler.MSVCCompiler.initialize):
  342.         res = old_init()
  343.         list_repl(self.compile_options, '/GX', '/EHsc')
  344.         list_repl(self.compile_options_debug, '/GX', '/EHsc')
  345.         return res
  346.  
  347.     distutils.msvccompiler.MSVCCompiler.initialize = initialize
  348. else:
  349.     
  350.     def dpy(cmd, platlib = False):
  351.         run([
  352.             'python'] + cmd, env = python_env(platlib))
  353.  
  354.  
  355. def python_env(platlib = False, addenv = None):
  356.     env = dict(os.environ)
  357.     if platlib:
  358.         env['PYTHONPATH'] = os.path.pathsep.join([
  359.             env.get('PYTHONPATH', ''),
  360.             DEPS_DIR])
  361.     
  362.     if addenv is not None:
  363.         env.update(addenv)
  364.     
  365.     return env
  366.  
  367.  
  368. def copytree_filter(src, dst, symlinks = False, filefilter = None, only_different = False):
  369.     Error = Error
  370.     copy2 = copy2
  371.     copystat = copystat
  372.     import shutil
  373.     if filefilter is None:
  374.         
  375.         filefilter = lambda filename: True
  376.     
  377.     names = os.listdir(src)
  378.     if not os.path.isdir(dst):
  379.         os.makedirs(dst)
  380.     
  381.     errors = []
  382.     for name in names:
  383.         srcname = pathjoin(src, name)
  384.         dstname = pathjoin(dst, name)
  385.         
  386.         try:
  387.             if symlinks and os.path.islink(srcname):
  388.                 linkto = os.readlink(srcname)
  389.                 os.symlink(linkto, dstname)
  390.             elif os.path.isdir(srcname):
  391.                 copytree_filter(srcname, dstname, symlinks, filefilter)
  392.             elif filefilter(srcname):
  393.                 copy_func(srcname, dstname)
  394.         continue
  395.         except (IOError, os.error):
  396.             why = None
  397.             errors.append((srcname, dstname, str(why)))
  398.             continue
  399.             except Error:
  400.                 err = None
  401.                 errors.extend(err.args[0])
  402.                 continue
  403.             
  404.         if platformName == 'win':
  405.             
  406.             try:
  407.                 copystat(src, dst)
  408.             except WindowsError:
  409.                 None<EXCEPTION MATCH>(IOError, os.error)
  410.                 None<EXCEPTION MATCH>(IOError, os.error)
  411.             except OSError:
  412.                 None<EXCEPTION MATCH>(IOError, os.error)
  413.                 why = None<EXCEPTION MATCH>(IOError, os.error)
  414.                 None<EXCEPTION MATCH>(IOError, os.error)
  415.                 errors.extend((src, dst, str(why)))
  416.             except:
  417.                 None<EXCEPTION MATCH>(IOError, os.error)<EXCEPTION MATCH>WindowsError
  418.             
  419.  
  420.  
  421.     None<EXCEPTION MATCH>(IOError, os.error)
  422.     
  423.     try:
  424.         copystat(src, dst)
  425.     except OSError:
  426.         None<EXCEPTION MATCH>(IOError, os.error)
  427.         why = None<EXCEPTION MATCH>(IOError, os.error)
  428.         errors.extend((src, dst, str(why)))
  429.     except:
  430.         None<EXCEPTION MATCH>(IOError, os.error)
  431.  
  432.     if errors:
  433.         raise Error, errors
  434.     errors
  435.  
  436.  
  437. def _hash_file(hashobj, fileobj, chunksize = 1024):
  438.     read = fileobj.read
  439.     update = hashobj.update
  440.     chunk = read(chunksize)
  441.     while chunk:
  442.         update(chunk)
  443.         chunk = read(chunksize)
  444.  
  445.  
  446. def md5_file(f, hex = False):
  447.     
  448.     try:
  449.         fobj = _[1]
  450.         md5obj = hashlib.md5()
  451.         _hash_file(md5obj, fobj)
  452.     finally:
  453.         pass
  454.  
  455.     if hex:
  456.         return md5obj.hexdigest()
  457.     return md5obj.digest()
  458.  
  459.  
  460. def files_different(src, dest):
  461.     isfile = isfile
  462.     pathsplit = split
  463.     getsize = getsize
  464.     isdir = isdir
  465.     import os.path
  466.     srcparent = pathsplit(src)[0]
  467.     destparent = pathsplit(dest)[0]
  468.     if not isdir(srcparent) or not isdir(destparent):
  469.         return True
  470.     if not isfile(src) or not isfile(dest):
  471.         return True
  472.     if getsize(src) != getsize(dest):
  473.         return True
  474.     if md5_file(src) != md5_file(dest):
  475.         return True
  476.     return False
  477.  
  478.  
  479. def copy_with_prompt(src, dest):
  480.     try_again = True
  481.     while try_again:
  482.         
  483.         try:
  484.             shutil.copy2(src, dest)
  485.         except IOError:
  486.             e = None
  487.             print e
  488.             inp = raw_input('Retry? [Y|n] ')
  489.             if inp and not inp.lower().startswith('y'):
  490.                 raise SystemExit(1)
  491.             not inp.lower().startswith('y')
  492.             try_again = True
  493.             continue
  494.  
  495.         try_again = False
  496.  
  497.  
  498. def copy_different(src, dest, prompt_on_deny = True, destname = None):
  499.     if not os.path.isfile(src):
  500.         raise AssertionError(src + ' not found, cwd is ' + os.getcwd())
  501.     os.path.isfile(src)
  502.     srcname = os.path.split(src)[1]
  503.     if os.path.isdir(dest):
  504.         dest = None(pathjoin, dest if destname is None else destname)
  505.     
  506.     if files_different(src, dest):
  507.         inform('* %s -> %s' % (srcname, dest))
  508.         copy_with_prompt(src, dest)
  509.     else:
  510.         inform('X %s -> %s (skipped)' % (srcname, dest))
  511.  
  512.