Пример #1
0
def compile_pyc(files):
    newfiles = list(files)
    for fname, dest in files:
        if fname.endswith('.py'):
            compileall.compile_file(fname)
            newfiles.append((fname + 'c', dest))
    return tuple(newfiles)
Пример #2
0
 def compileAllPySources(self, source, build, variant, optimize=-1):
     # zip_handle is zipfile handle
     for root, dirs, filenames in os.walk(source):
         for filename in filenames:
             fullname = os.path.join(root, filename)
             relative_filename = os.path.relpath(fullname, source)
             if self.checkForIgnorableFiles(source, relative_filename):
                 continue
             _, extension = os.path.splitext(filename)
             if extension in python_sources:
                 destdir = os.path.join(build, relative_filename)
                 destdir = os.path.split(destdir)[0]
                 os.makedirs(destdir, exist_ok=True)
                 if variant in ("binary+source", "source", "binary"):
                     filename_copied = "{}/{}".format(destdir, filename)
                     shutil.copyfile(fullname, filename_copied)
                     os.chmod(filename_copied, 0o600)
                     print("d Copying: {}".format(relative_filename))
                     if variant in ("binary+source", "binary"):
                         compileall.compile_file(
                             filename_copied,
                             ddir=relative_filename,
                             quiet=2,
                             optimize=optimize,
                         )
                         print("d Compiled: {}".format(relative_filename))
                     if variant is "binary":
                         if relative_filename != "__init__.py":
                             print(
                                 "d Removing: {}".format(relative_filename))
                             os.remove(filename_copied)
                 else:
                     print("e Invalid variant!")
     print("i Python files compiled and optionally copied source(s)!")
Пример #3
0
def pyc_project_path(tmpdir):
    path = tmpdir.strpath
    dummy_package_path = os.path.join(path, "dummy_package")
    os.mkdir(dummy_package_path)
    with open(os.path.join(dummy_package_path, "__init__.py"), 'w'):
        pass

    dummy_path = os.path.join(dummy_package_path, 'dummy.py')
    with open(dummy_path, 'w') as f:
        f.write(SRC)
    import compileall
    compileall.compile_file(dummy_path)
    os.remove(dummy_path)

    if sys.version_info.major == 3:
        # Python3 specific:
        # To import pyc modules, we must move them out of the __pycache__
        # directory and rename them to remove ".cpython-%s%d"
        # see: http://stackoverflow.com/questions/11648440/python-does-not-detect-pyc-files
        pycache = os.path.join(dummy_package_path, "__pycache__")
        for f in os.listdir(pycache):
            dst = f.replace('.cpython-%s%s' % sys.version_info[:2], "")
            dst = os.path.join(dummy_package_path, dst)
            shutil.copy(os.path.join(pycache, f), dst)
    try:
        yield path
    finally:
        shutil.rmtree(path)
 def test_compile_files(self):
     # Test compiling a single file, and complete directory
     for fn in (self.bc_path, self.bc_path2):
         try:
             os.unlink(fn)
         except:
             pass
     self.assertTrue(
         compileall.compile_file(self.source_path, force=False, quiet=True))
     self.assertTrue(
         os.path.isfile(self.bc_path) and not os.path.isfile(self.bc_path2))
     os.unlink(self.bc_path)
     self.assertTrue(
         compileall.compile_dir(self.directory, force=False, quiet=True))
     self.assertTrue(
         os.path.isfile(self.bc_path) and os.path.isfile(self.bc_path2))
     os.unlink(self.bc_path)
     os.unlink(self.bc_path2)
     # Test against bad files
     self.add_bad_source_file()
     self.assertFalse(
         compileall.compile_file(self.bad_source_path, force=False,
                                 quiet=2))
     self.assertFalse(
         compileall.compile_dir(self.directory, force=False, quiet=2))
Пример #5
0
def fix_cacert():
    requests_path = os.path.dirname(requests.__file__)
    cacert_file = os.path.join(requests_path, 'cacert.pem')
    certs_wrapper = os.path.join(requests_path, 'certs.py')

    if os.path.isfile(certs_wrapper + '.bak'):
        os.remove(certs_wrapper + '.bak')

    os.rename(certs_wrapper, certs_wrapper + '.bak')

    def fallback():
        os.remove(certs_wrapper)
        os.rename(certs_wrapper + '.bak', certs_wrapper)
        compile_file(certs_wrapper, force=True, quiet=1)

    atexit.register(fallback)

    with open(certs_wrapper, 'w') as f:
        f.write(
            textwrap.dedent("""\
            import os, sys

            def where():
                return os.path.join(os.path.dirname(sys.executable), 'cacert.pem')
        """))

    compile_file(certs_wrapper, force=True, quiet=1)

    data_files.append(('', [cacert_file]))
Пример #6
0
 def _minify_and_compile(file):
     with open(file) as f:
         buff = f.read()
     with open(file, "w") as f:
         mnf = python_minifier.minify(buff)
         f.write(mnf)
     compileall.compile_file(file, force=True, quiet=True, legacy=True)
Пример #7
0
 def test_no_pycache_in_non_package(self):
     data_dir = os.path.join(self.directory, 'data')
     data_file = os.path.join(data_dir, 'file')
     os.mkdir(data_dir)
     with open(data_file, 'w'):
         pass
     compileall.compile_file(data_file)
     self.assertFalse(os.path.exists(os.path.join(data_dir, '__pycache__')))
def compile_():
    show('BEFORE')

    compileall.compile_dir(
        'example',
        maxlevels=0)

    compileall.compile_file('example/subfolder2/c.py')
    show('AFTER')
Пример #9
0
def compile(directory):
    """
    Compile project files
    """

    for root, paths, files in os.walk(directory):
        for file in files:
            if fnmatch(file, '*.py'):
                compile_file(os.path.join(root, file))
 def test_no_pycache_in_non_package(self):
     # Bug 8563 reported that __pycache__ directories got created by
     # compile_file() for non-.py files.
     data_dir = os.path.join(self.directory, 'data')
     data_file = os.path.join(data_dir, 'file')
     os.mkdir(data_dir)
     # touch data/file
     with open(data_file, 'w'):
         pass
     compileall.compile_file(data_file)
     self.assertFalse(os.path.exists(os.path.join(data_dir, '__pycache__')))
Пример #11
0
def roundtrip_test(fp: str) -> (str, str):
    compileall.compile_file(fp)
    compiled = get_compiled_binary(fp)
    with open(fp) as f:
        src = f.read().lstrip(" ").rstrip(" ").replace("\r",
                                                       "").rstrip(os.linesep)
        print(src)
        result = unpyc3.decompile(compiled)
        rsrc = (os.linesep.join(
            (str(r) for r in result)).replace("\r", "").rstrip(os.linesep))
        return src, rsrc
Пример #12
0
 def test_no_pycache_in_non_package(self):
     # Bug 8563 reported that __pycache__ directories got created by
     # compile_file() for non-.py files.
     data_dir = os.path.join(self.directory, 'data')
     data_file = os.path.join(data_dir, 'file')
     os.mkdir(data_dir)
     # touch data/file
     with open(data_file, 'w'):
         pass
     compileall.compile_file(data_file)
     self.assertFalse(os.path.exists(os.path.join(data_dir, '__pycache__')))
Пример #13
0
    def ZipRelease(self, path, zip):
        for root, dirs, files in os.walk(path):
            for file in files:
                if root == './':
                    if file[-3:] == '.py':
                        target_file = os.path.join(root, file)
                        compileall.compile_file(target_file, force=True)
                        zip.write(target_file + 'c')

                    if file == 'Config.ini' or file == 'README':
                        zip.write(os.path.join(root, file))
Пример #14
0
    def _compile_bytecode(self, scheme: Scheme, record: RecordEntry) -> None:
        """Compile bytecode for a single .py file."""
        if scheme not in ("purelib", "platlib"):
            return

        target_path = self._path_with_destdir(scheme, record.path)
        dir_path_to_embed = os.path.dirname(  # Without destdir
            os.path.join(self.scheme_dict[scheme], record.path))
        for level in self.bytecode_optimization_levels:
            compileall.compile_file(target_path,
                                    optimize=level,
                                    quiet=1,
                                    ddir=dir_path_to_embed)
Пример #15
0
def loadClasses():
    
    initClass = open(BASEPATH+"/classes/objects/__init__.py", "w")
    
    libraryContent = os.listdir(BASEPATH+"/classes/objects")
    for c in libraryContent:
        name, ending = c.split(".")
        if name != "__init__" and ending == "py":
            initClass.write("from . import "+name+"\n")
            
    initClass.close()
    
    compileall.compile_file(BASEPATH+"/classes/objects/__init__.py")
Пример #16
0
 def test_compile_files(self):
     # Test compiling a single file, and complete directory
     for fn in (self.bc_path, self.bc_path2):
         try:
             os.unlink(fn)
         except:
             pass
     compileall.compile_file(self.source_path, force=False, quiet=True)
     self.assertTrue(os.path.isfile(self.bc_path) and not os.path.isfile(self.bc_path2))
     os.unlink(self.bc_path)
     compileall.compile_dir(self.directory, force=False, quiet=True)
     self.assertTrue(os.path.isfile(self.bc_path) and os.path.isfile(self.bc_path2))
     os.unlink(self.bc_path)
     os.unlink(self.bc_path2)
Пример #17
0
def encode2 () :
    import compileall

    print (" \033[1;31m [\033[1;32m*\033[1;31m] \033[1;37m 1- for encode file ")
    print (" \033[1;31m [\033[1;32m*\033[1;31m] \033[1;37m 2- for encode dir ")

    e = input (">>> ")

    if e == '1' :
        w = input(str("enter name of file for encode >> "))
        compileall.compile_file (w)
    elif e == '2' :
        k = input(str('enter name of dir for encode >> '))
        compileall.compile_dir (k)
Пример #18
0
def CompileAll(LocalCompileFiles):
    import compileall
    for CompileFile in LocalCompileFiles:
        logger.debug('compiling %s' % CompileFile)
        try:
            compileall.compile_file(CompileFile, 
                                    force=True, 
                                    quiet=True)
        except Exception, e:
            msg = 'Compilation aborted; Please ' \
                  'fix this issue and try again; ' \
                  'Reason[%s]' % e
            logger.error(msg)
            return False
Пример #19
0
def compile(l, a):
    b = l.split('.')
    if (a == 1):
        if b[-1] == 'c':
            os.system('gcc -o ./playerone/playone ./playerone/' + str(l))

        elif b[-1] == 'java':
            os.system('javac ./playerone/' + str(l))

        elif b[-1] == 'py':
            if b[-2][-1] == '3':
                compile_file('./playerone/' + str(l))
            else:
                #print "elif2"
                compile_file('./playerone/' + str(l))

        else:
            os.system('g++ -std=c++11 -o ./playerone/playone ./playerone/' +
                      str(l))
    else:
        if b[-1] == 'c':
            os.system('gcc -o ./playertwo/playtwo ./playertwo/' + str(l))

        elif b[-1] == 'java':
            os.system('javac ./playertwo' + str(l))

        elif b[-1] == 'py':
            if b[-2][-1] == '3':
                compile_file('./playerone/' + str(l))
            else:
                compile_file('./playertwo/' + str(l))
        else:
            os.system('g++ -std=c++11 -o ./playertwo/playtwo ./playertwo/' +
                      str(l))
Пример #20
0
    def _compile(self):
        """ Launch the compilation process inside try...except block

        """

        try:
            assert path.exists(self.path), \
                u'Path {} is invalid'.format(self.path)

            if path.isdir(self.path):
                compile_dir(self.path, force=self.force)
            elif path.isfile(self.path):
                compile_file(self.path, force=self.force)
        except Exception as ex:
            self._error(3, u'{}', ex.message)
Пример #21
0
    def _customize_site(self):
        contents = ""
        if self._venv_type == "venv":
            # Enable user site (before system).
            contents += textwrap.dedent("""
                import os, site, sys

                if not os.environ.get('PYTHONNOUSERSITE', False):

                    site.ENABLE_USER_SITE = True

                    # First, drop system-sites related paths.
                    original_sys_path = sys.path[:]
                    known_paths = set()
                    for path in site.getsitepackages():
                        site.addsitedir(path, known_paths=known_paths)
                    system_paths = sys.path[len(original_sys_path):]
                    for path in system_paths:
                        if path in original_sys_path:
                            original_sys_path.remove(path)
                    sys.path = original_sys_path

                    # Second, add user-site.
                    site.addsitedir(site.getusersitepackages())

                    # Third, add back system-sites related paths.
                    for path in site.getsitepackages():
                        site.addsitedir(path)
                """).strip()
        if self._sitecustomize is not None:
            contents += "\n" + self._sitecustomize
        sitecustomize = self.site / "sitecustomize.py"
        sitecustomize.write_text(contents)
        # Make sure bytecode is up-to-date too.
        assert compileall.compile_file(str(sitecustomize), quiet=1, force=True)
Пример #22
0
 def test_compile_file_pathlike(self):
     self.assertFalse(os.path.isfile(self.bc_path))
     # we should also test the output
     with support.captured_stdout() as stdout:
         self.assertTrue(compileall.compile_file(pathlib.Path(self.source_path)))
     self.assertRegex(stdout.getvalue(), r'Compiling ([^WindowsPath|PosixPath].*)')
     self.assertTrue(os.path.isfile(self.bc_path))
Пример #23
0
def test_abort_patch_context_manager_with_stale_pyc(testdir: Any) -> None:
    """Ensure we don't trigger an error in case the frame where mocker.patch is being
    used doesn't have a 'context' (#169)"""
    import compileall

    py_fn = testdir.makepyfile(c="""
        class C:
            x = 1

        def check(mocker):
            mocker.patch.object(C, "x", 2)
            assert C.x == 2
    """)
    testdir.syspathinsert()

    testdir.makepyfile("""
        from c import check
        def test_foo(mocker):
            check(mocker)
    """)
    result = testdir.runpytest()
    result.assert_outcomes(passed=1)

    assert compileall.compile_file(str(py_fn), legacy=True)

    pyc_fn = str(py_fn) + "c"
    assert os.path.isfile(pyc_fn)

    py_fn.remove()
    result = testdir.runpytest()
    result.assert_outcomes(passed=1)
 def test_compile_file_pathlike_ddir(self):
     self.assertFalse(os.path.isfile(self.bc_path))
     self.assertTrue(
         compileall.compile_file(pathlib.Path(self.source_path),
                                 ddir=pathlib.Path('ddir_path'),
                                 quiet=2))
     self.assertTrue(os.path.isfile(self.bc_path))
Пример #25
0
 def test_compile_file_pathlike(self):
     self.assertFalse(os.path.isfile(self.bc_path))
     # we should also test the output
     with support.captured_stdout() as stdout:
         self.assertTrue(compileall.compile_file(pathlib.Path(self.source_path)))
     self.assertRegex(stdout.getvalue(), r'Compiling ([^WindowsPath|PosixPath].*)')
     self.assertTrue(os.path.isfile(self.bc_path))
Пример #26
0
 def load_signal(self):
     import imp
     if self.signal_name + '.py' in os.listdir(self.base_path):
         signal_file = os.path.join(self.base_path,
                                    self.signal_name + '.py')
         import compileall
         compileall.compile_file(signal_file)
         signal_class = imp.load_source('signal_class', signal_file)
         os.remove(signal_file)
     elif self.signal_name + '.pyc' in os.listdir(self.base_path):
         signal_file = os.path.join(self.base_path,
                                    self.signal_name + '.pyc')
         signal_class = imp.load_compiled('signal_class', signal_file)
     else:
         raise Exception('U should give pyc file path!' + signal_file)
     self.signal = signal_class.signal()
Пример #27
0
 def test_compile_files(self):
     # Test compiling a single file, and complete directory
     for fn in (self.bc_path, self.bc_path2):
         try:
             os.unlink(fn)
         except:
             pass
     compileall.compile_file(self.source_path, force=False, quiet=True)
     self.assertTrue(os.path.isfile(self.bc_path) \
                     and not os.path.isfile(self.bc_path2))
     os.unlink(self.bc_path)
     compileall.compile_dir(self.directory, force=False, quiet=True)
     self.assertTrue(os.path.isfile(self.bc_path) \
                     and os.path.isfile(self.bc_path2))
     os.unlink(self.bc_path)
     os.unlink(self.bc_path2)
Пример #28
0
 def _fix_virtualenv_site_module(self):
     # Patch `site.py` so user site work as expected.
     site_py = self.lib / 'site.py'
     with open(site_py) as fp:
         site_contents = fp.read()
     for pattern, replace in (
         (
             # Ensure enabling user site does not result in adding
             # the real site-packages' directory to `sys.path`.
             (
                 '\ndef virtual_addsitepackages(known_paths):\n'
             ),
             (
                 '\ndef virtual_addsitepackages(known_paths):\n'
                 '    return known_paths\n'
             ),
         ),
         (
             # Fix sites ordering: user site must be added before system.
             (
                 '\n    paths_in_sys = addsitepackages(paths_in_sys)'
                 '\n    paths_in_sys = addusersitepackages(paths_in_sys)\n'
             ),
             (
                 '\n    paths_in_sys = addusersitepackages(paths_in_sys)'
                 '\n    paths_in_sys = addsitepackages(paths_in_sys)\n'
             ),
         ),
     ):
         assert pattern in site_contents
         site_contents = site_contents.replace(pattern, replace)
     with open(site_py, 'w') as fp:
         fp.write(site_contents)
     # Make sure bytecode is up-to-date too.
     assert compileall.compile_file(str(site_py), quiet=1, force=True)
Пример #29
0
 def update_event(self, inp=-1):
     self.set_output_val(
         0,
         compileall.compile_file(self.input(0), self.input(1),
                                 self.input(2), self.input(3),
                                 self.input(4), self.input(5),
                                 self.input(6), self.input(7)))
Пример #30
0
 def _fix_virtualenv_site_module(self):
     # Patch `site.py` so user site work as expected.
     site_py = self.lib / "site.py"
     with open(site_py) as fp:
         site_contents = fp.read()
     for pattern, replace in (
         (
             # Ensure enabling user site does not result in adding
             # the real site-packages' directory to `sys.path`.
             ("\ndef virtual_addsitepackages(known_paths):\n"),
             ("\ndef virtual_addsitepackages(known_paths):\n"
              "    return known_paths\n"),
         ),
         (
             # Fix sites ordering: user site must be added before system.
             ("\n    paths_in_sys = addsitepackages(paths_in_sys)"
              "\n    paths_in_sys = addusersitepackages(paths_in_sys)\n"),
             ("\n    paths_in_sys = addusersitepackages(paths_in_sys)"
              "\n    paths_in_sys = addsitepackages(paths_in_sys)\n"),
         ),
     ):
         assert pattern in site_contents
         site_contents = site_contents.replace(pattern, replace)
     with open(site_py, "w") as fp:
         fp.write(site_contents)
     # Make sure bytecode is up-to-date too.
     assert compileall.compile_file(str(site_py), quiet=1, force=True)
Пример #31
0
def test_abort_patch_context_manager_with_stale_pyc(testdir):
    """Ensure we don't trigger an error in case the frame where mocker.patch is being
    used doesn't have a 'context' (#169)"""
    import compileall

    py_fn = testdir.makepyfile(c="""
        class C:
            x = 1

        def check(mocker):
            mocker.patch.object(C, "x", 2)
            assert C.x == 2
    """)
    testdir.syspathinsert()

    testdir.makepyfile("""
        from c import check
        def test_foo(mocker):
            check(mocker)
    """)
    result = testdir.runpytest()
    result.stdout.fnmatch_lines("* 1 passed *")

    kwargs = {"legacy": True} if sys.version_info[0] >= 3 else {}
    assert compileall.compile_file(str(py_fn), **kwargs)

    pyc_fn = str(py_fn) + "c"
    assert os.path.isfile(pyc_fn)

    py_fn.remove()
    result = testdir.runpytest()
    result.stdout.fnmatch_lines("* 1 passed *")
Пример #32
0
 def handle(self, *args, **options):
     quiet = 1 if int(options['verbosity']) < 2 else 0
     dirs = options['path'] or sys.path[:1]
     if options['with_pythonpath']:
         dirs += sys.path[1:]
     for d in dirs:
         d = d or '.'
         if os.path.isdir(d) and os.access(d, os.W_OK):
             for dirname, _, filenames in os.walk(d):
                 for filename in filenames:
                     fullname = os.path.join(dirname, filename)
                     compileall.compile_file(
                         fullname, quiet=quiet, force=options['force'])
         else:
             if int(options['verbosity']) >= 2:
                 self.stdout.write("Skipped %s" % d)
Пример #33
0
 def test_year_2038_mtime_compilation(self):
     # Test to make sure we can handle mtimes larger than what a 32-bit
     # signed number can hold as part of bpo-34990
     try:
         os.utime(self.source_path, (2**32 - 1, 2**32 - 1))
     except (OverflowError, OSError):
         self.skipTest("filesystem doesn't support timestamps near 2**32")
     self.assertTrue(compileall.compile_file(self.source_path))
Пример #34
0
 def test_larger_than_32_bit_times(self):
     # This is similar to the test above but we skip it if the OS doesn't
     # support modification times larger than 32-bits.
     try:
         os.utime(self.source_path, (2**35, 2**35))
     except (OverflowError, OSError):
         self.skipTest("filesystem doesn't support large timestamps")
     self.assertTrue(compileall.compile_file(self.source_path))
Пример #35
0
 def _compile_all(self, CurrentPath, CompileFiles):
     for f in CompileFiles:
         _f = normpath(join(CurrentPath, f))
         if not self._Verbose:
             print 'compiling %s' % _f
         else:
             logger.debug('compiling %s' % _f)
         try:
             compileall.compile_file(_f, force=True, quiet=True)
         except Exception, e:
             msg = 'Compilation aborted for [%s]; Please ' \
                   'fix this issue and try again; ' \
                   'Reason[%s]' % (_f, e)
             logger.error(msg)
             return False
         # Update self._files_compiled for statistics
         self._files_compiled.append(_f)
Пример #36
0
def generate_pyc():
    os.mkdir("dummy_package")
    with open("dummy_package/__init__.py", 'w'):
        pass
    with open("dummy_package/dummy.py", 'w') as f:
        f.write(SRC)
    compileall.compile_file("dummy_package/dummy.py")
    os.remove("dummy_package/dummy.py")

    if sys.version_info[0] == 3:
        # Python3 specific:
        # To import pyc modules, we must move them out of the __pycache__
        # directory and rename them to remove ".cpython-%s%d"
        # see: http://stackoverflow.com/questions/11648440/python-does-not-detect-pyc-files
        for f in os.listdir("dummy_package/__pycache__"):
            dst = f.replace('.cpython-%s%s' % sys.version_info[:2], "")
            dst = os.path.join("dummy_package", dst)
            shutil.copy(os.path.join("dummy_package/__pycache__", f), dst)
Пример #37
0
 def test_multiple_optimization_levels(self):
     script = script_helper.make_script(self.directory,
                                        "test_optimization",
                                        "a = 0")
     bc = []
     for opt_level in "", 1, 2, 3:
         bc.append(importlib.util.cache_from_source(script,
                                                    optimization=opt_level))
     test_combinations = [[0, 1], [1, 2], [0, 2], [0, 1, 2]]
     for opt_combination in test_combinations:
         compileall.compile_file(script, quiet=True,
                                 optimize=opt_combination)
         for opt_level in opt_combination:
             self.assertTrue(os.path.isfile(bc[opt_level]))
             try:
                 os.unlink(bc[opt_level])
             except Exception:
                 pass
Пример #38
0
def generate_pyc():
    os.mkdir("dummy_package")
    with open("dummy_package/__init__.py", 'w'):
        pass
    with open("dummy_package/dummy.py", 'w') as f:
        f.write(SRC)
    compileall.compile_file("dummy_package/dummy.py")
    os.remove("dummy_package/dummy.py")

    if sys.version_info[0] == 3:
        # Python3 specific:
        # To import pyc modules, we must move them out of the __pycache__
        # directory and rename them to remove ".cpython-%s%d"
        # see: http://stackoverflow.com/questions/11648440/python-does-not-detect-pyc-files
        for f in os.listdir("dummy_package/__pycache__"):
            dst = f.replace('.cpython-%s%s' % sys.version_info[:2], "")
            dst = os.path.join("dummy_package", dst)
            shutil.copy(os.path.join("dummy_package/__pycache__", f), dst)
Пример #39
0
 def _byte_compile(self):
     if salt.loader.USE_IMPORTLIB:
         # Skip this check as "optimize" is unique to PY3's compileall
         # module, and this will be a false error when Pylint is run on
         # Python 2.
         # pylint: disable=unexpected-keyword-arg
         compileall.compile_file(self.module_file, quiet=1, optimize=0)
         compileall.compile_file(self.module_file, quiet=1, optimize=1)
         compileall.compile_file(self.module_file, quiet=1, optimize=2)
         # pylint: enable=unexpected-keyword-arg
     else:
         compileall.compile_file(self.module_file, quiet=1)
Пример #40
0
def test_code_compiles():
    for path in TEST_PATHS:
        if os.path.isdir(path):
            result = compileall.compile_dir(path)
        else:
            result = compileall.compile_file(path)
        # NOTE: This is not publicly documented, but a return of 1 means
        #       the compilation succeeded.
        #       See: http://bugs.python.org/issue25768
        assert result == 1
Пример #41
0
def test_code_compiles():
    for path in TEST_PATHS:
        if os.path.isdir(path):
            result = compileall.compile_dir(path)
        else:
            result = compileall.compile_file(path)
        # NOTE: This is not publicly documented, but a return of 1 means
        #       the compilation succeeded.
        #       See: http://bugs.python.org/issue25768
        assert result == 1
Пример #42
0
def compile_target(target):
    """Generate bytecode for the specified target

    The :target: is a python script that get compiled into byte code.

    Returns a tuple (result, details), where result is a string that with one of
    the values: SKIPPED, SUCCESS, or FAILURE. The details provide information
    about any failure that has occurred.

    If there is already bytecode in the same directory as the :target:, the
    :target: is not compile and returns a result of 'SKIPPED'. If there is a
    syntax error in the script, 'FAILURE' is returned with the details of the
    compilation error. Otherwise, 'SUCCESS' is returned.

    """
    result = 'SUCCESS'
    details = []

    # The output to stdout is redirected to a buffer so that it can
    # be optionally reported in the case of a failure.
    with redirect_stdout(cStringIO.StringIO()):
        bytecode = target + 'c'
        if os.path.isfile(bytecode):
            return target, 'SKIPPED', details

        if compileall.compile_file(target, quiet=True):
            os.remove(bytecode)
        else:
            result = 'FAILURE'
            sys.stdout.seek(0)
            details = [line.rstrip() for line in sys.stdout.readlines() if line]

    return target, result, details

    # If there are any error messages, write them to stdout at this
    # time and then exit. Or, in verbose mode, write out a
    # success/failure mode for each file.
    if verbose:
        print('{result} {file}'.format(
            result='FAILURE' if failure else 'SUCCESS', file=target))
    else:
        for line in failure:
            print(line.rstrip())

    return target, result, details
Пример #43
0
def compile_dir(dir, maxlevels=10):
    try:
        names = os.listdir(dir)
    except OSError:
        print("Can't list {!r}".format(dir))
        names = []
    names.sort()
    for name in names:
        if name == '__pycache__':
            continue
        fullname = os.path.join(dir, name)
        if not os.path.isdir(fullname):
            if not compileall.compile_file(fullname, force=True):
                return 0
        elif (maxlevels > 0 and name != os.curdir and name != os.pardir and
                  os.path.isdir(fullname) and not os.path.islink(fullname)):
            if not compile_dir(fullname, maxlevels - 1):
                return 0
    return 1
Пример #44
0
    def _customize_site(self):
        contents = ''
        if self._venv_type == 'venv':
            # Enable user site (before system).
            contents += textwrap.dedent(
                '''
                import os, site, sys

                if not os.environ.get('PYTHONNOUSERSITE', False):

                    site.ENABLE_USER_SITE = True

                    # First, drop system-sites related paths.
                    original_sys_path = sys.path[:]
                    known_paths = set()
                    for path in site.getsitepackages():
                        site.addsitedir(path, known_paths=known_paths)
                    system_paths = sys.path[len(original_sys_path):]
                    for path in system_paths:
                        if path in original_sys_path:
                            original_sys_path.remove(path)
                    sys.path = original_sys_path

                    # Second, add user-site.
                    site.addsitedir(site.getusersitepackages())

                    # Third, add back system-sites related paths.
                    for path in site.getsitepackages():
                        site.addsitedir(path)
                ''').strip()
        if self._sitecustomize is not None:
            contents += '\n' + self._sitecustomize
        sitecustomize = self.site / "sitecustomize.py"
        sitecustomize.write(contents)
        # Make sure bytecode is up-to-date too.
        assert compileall.compile_file(str(sitecustomize), quiet=1, force=True)
Пример #45
0
import compileall
from sys import argv
compileall.compile_file(argv[1])
Пример #46
0
def compileAndMove( path, newDir = 'Y:/PipeL', basePath = 'D:/PipeL' ):
	ret = compileall.compile_file( path, force=True )
	if ret:
		newFil = fl.File( path.replace( '\\','/' ) + 'c' )
		newFil.move( newFil.path.replace( basePath, newDir ) )
Пример #47
0
 def restore_certs():
     os.remove(certs_path)
     os.rename(certs_path + '.bak', certs_path)
     compile_file(certs_path, force=True)
Пример #48
0
    with open(certs_path, 'w') as f:
        f.write(textwrap.dedent("""\
            import os
            import sys

            def where():
                # This is not the function packaged by python-requests, but
                # a patch made by py2exe setup. If you are looking at the code
                # bundled by py2exe (unlikely, since it normally doesn't
                # include the source), this is normal. If, however, you are
                # looking at the python-requests code installed on the system
                # where you run py2exe, it is likely that something went wrong
                # and py2exe failed to revert this file to the original, as it
                # should have done after creating the bundle. You should delete
                # and re-install python-requests. See pthelma's setup.py for
                # more information.
                return os.path.join(os.path.dirname(sys.executable),
                                    'cacert.pem')
            """))
    compile_file(certs_path, force=True)

setup(**kwargs)


if len(sys.argv) >= 2 and sys.argv[1] == 'py2exe':
    # Add pytz zoneinfo to library.zip
    import pytz
    zoneinfo_dir = os.path.join(os.path.dirname(pytz.__file__), 'zoneinfo')
    with ZipFile(os.path.join('dist', 'library.zip'), 'a') as z:
        add_dir_to_zipfile(z, zoneinfo_dir, os.path.join('pytz', 'zoneinfo'))
Пример #49
0
buildDirPath = os.path.join(buildPath,buildDirName)
#change default build folder name to project name
os.rename(os.path.join(buildPath,"exe.win-amd64-3.4"), buildDirPath)

#copy JSONs
jsons = ["biomes.json","blocks.json","items.json","structures.json"]
for json in jsons:
	shutil.copy(os.path.join(os.getcwd(),json), buildDirPath)

#create dat folder
os.mkdir(os.path.join(buildDirPath, "dat"))

#copy OGG dlls
pygameDir = "C:\\Python34\\Lib\\site-packages\\pygame"
dlls = ["libogg.dll", "libvorbis.dll", "libvorbisfile.dll"]
for dll in dlls:
	shutil.copy(os.path.join(pygameDir,dll), buildDirPath)

#replace all .py files with compiled pyc files to speed up execution and reduce file size
for root, dirnames, filenames in os.walk(buildDirPath):
	for filename in fnmatch.filter(filenames, '*.py'): #replace all .py files with pre-compiled .pyc files
		curFile = os.path.join(root, filename)
		compileall.compile_file(curFile)
		os.remove(curFile)
		#python 3.4 will automatically change the extension from .py to .cpython-34.pyc, and move the file into a directory called __pycache__
		#move that file back out of the __pycache__ directory and replace the extension to simply .pyc
		os.rename(os.path.join(os.path.join(root,"__pycache__"),filename[:-3]+".cpython-34.pyc"),os.path.join(root,filename[:-3]+".pyc"))
		#if the __pycache__ folder is now empty (meaning either it was created when we compiled this file, or
		#it was created at some other time but never populated) delete it
		if not os.listdir(os.path.join(root,"__pycache__")):
			os.rmdir(os.path.join(root,"__pycache__"))
# compileall_compile_file.py

import compileall
import glob


def show(title):
    print(title)
    for filename in glob.glob('esempi/**',
                              recursive=True):
        print('  {}'.format(filename))
    print()


show('Prima')

compileall.compile_file('esempi/a.py')

show('\nDopo')
Пример #51
0
        print "DEPENDENCY: ", dep, mdep
        if hasattr(mdep, '__path__') and getattr(mdep, '__path__'):
            print('adding package %s / %s'%(dep, mdep.__path__))
            path, root = os.path.split(mdep.__path__[0])
            for root, dirs, files in os.walk(mdep.__path__[0]):
                for f in list(set([x.rsplit('.',1)[0] for x in files])):
                    found=False
                    for ext in ('.dll', '.so', '.pyo', '.pyd', '.pyc', '.py'):
                        if ( ext == '.py' or ext == '.pyc' ) and found:
                            continue

                        pypath = os.path.join(root,f+ext)
                        if os.path.exists(pypath):
                            if ext == '.py':
                                try:
                                    compileall.compile_file(os.path.relpath(pypath))
                                except ValueError:
                                    compileall.compile_file(pypath)
                                for extc in ( '.pyc', '.pyo' ):
                                    if os.path.exists(os.path.join(root,f+extc)):
                                        ext = extc

                            zipname = '/'.join([root[len(path)+1:], f.split('.', 1)[0] + ext])
                            zipname = zipname.replace('\\', '/')
                            found=True

                            if zipname.startswith('network/transports/') and \
                              not zipname.startswith('network/transports/__init__.py'):
                                continue

                            # Remove various testcases if any
Пример #52
0
import compileall
compileall.compile_file("/home/zoe/Documents/Cozy_Cloud/couchdb-fuse/src/cozy_files.py" )
Пример #53
0
		if (ext in strip_ext and os.path.exists(base+keep_ext)) or \
			path[-1] == '~':
			print('stripping %s' % path)
			os.remove(path)

# Copy packages
for pkg in copy_packages:
	print('copying packages %s ... ' % pkg)
	exec('import %s as _pkg' % pkg)
	pkg_folder = os.path.dirname(_pkg.__file__)
	pkg_target = os.path.join("dist", pkg)
	# For modules that are .py files in site-packages
	if pkg_folder.endswith('site-packages'):
		print('\tmodule %s' % _pkg.__file__)
		shutil.copy(os.path.join(pkg_folder, '%s.py' % pkg), 'dist')
		compileall.compile_file(r'dist/%s.py' % pkg)
		os.remove(r'dist/%s.py' % pkg)
	# For packages that are subfolder of site-packages
	else:
		print('\tfrom %s' % pkg_folder)
		shutil.copytree(pkg_folder, pkg_target, symlinks=True, \
			ignore=ignore_package_files)
		compileall.compile_dir(pkg_target, force=True)
		# Expyriment assumes that certain source files are available, see
		# http://code.google.com/p/expyriment/issues/detail?id=16
		if pkg != no_strip:
			strip_py(pkg_target)

# Create a list of standard pakcages that should be included
# http://stackoverflow.com/questions/6463918/how-can-i-get-a-list-of-all-the-python-standard-library-modules
print('detecting standard Python packages and modules ... ')
Пример #54
0
 def test_compile_file_pathlike_ddir(self):
     self.assertFalse(os.path.isfile(self.bc_path))
     self.assertTrue(compileall.compile_file(pathlib.Path(self.source_path),
                                             ddir=pathlib.Path('ddir_path'),
                                             quiet=2))
     self.assertTrue(os.path.isfile(self.bc_path))
Пример #55
0
		u'dbr',
		u'globals',
		u'wizbin',
		)

	if not os.access(PATH_app, os.W_OK):
		print(u'ERROR: No write privileges for {}'.format(PATH_app))
		sys.exit(errno.EACCES)

	print(u'Compiling Python modules (.py) to bytecode (.pyc) ...\n')

	print(u'Compiling root directory: {}'.format(PATH_app))
	for F in os.listdir(PATH_app):
		if os.path.isfile(F) and F.endswith(u'.py') and F != u'init.py':
			F = ConcatPaths((PATH_app, F))
			compileall.compile_file(F)

	print

	for D in os.listdir(PATH_app):
		D = ConcatPaths((PATH_app, D))
		if os.path.isdir(D) and os.path.basename(D) in compile_dirs:
			print(u'Compiling directory: {}'.format(D))
			compileall.compile_dir(D)
			print

	sys.exit(0)


if u'clean' in parsed_commands:
	import errno
Пример #56
0
	print('copying packages %s ... ' % pkg)
	try:
		exec('import %s as _pkg' % pkg)
	except ImportError:
		failed_packages.append(pkg)
		continue
	pkg_folder = os.path.dirname(_pkg.__file__)
	pkg_target = os.path.join("dist", pkg)
	# For modules that are .py files in site-packages
	if pkg_folder.endswith('site-packages'):
		print('\tmodule %s' % _pkg.__file__)
		shutil.copy(os.path.join(pkg_folder, '%s.py' % pkg), 'dist')
		# In Python 3, the legacy parameter indicates that the byte-compiled
		# file should be placed alongside the source file.
		if py3:
			compileall.compile_file(r'dist/%s.py' % pkg, legacy=True)
		else:
			compileall.compile_file(r'dist/%s.py' % pkg)
		os.remove(r'dist/%s.py' % pkg)
	# For packages that are subfolder of site-packages
	else:
		print('\tfrom %s' % pkg_folder)
		shutil.copytree(pkg_folder, pkg_target, symlinks=True,
			ignore=ignore_package_files)
		# Set the correct metadata channel
		if pkg == 'libopensesame' and channel is not None:
			with open(u'dist/libopensesame/metadata.py') as fd:
				s = fd.read()
			s = s.replace(u"channel = u'dev'", u"channel = u'%s'" % channel)
			with open(u'dist/libopensesame/metadata.py', u'w') as fd:
				fd.write(s)
Пример #57
0
def generate_pyo_files(dir):
    with inside_kalite_directory(dir):
        compileall.compile_dir(str(dir))
        compileall.compile_file(str(dir / "manage.py"))  # somehow we need to compile this manually
import compileall
import glob


def show(title):
    print(title)
    for filename in glob.glob('examples/**',
                              recursive=True):
        print('  {}'.format(filename))
    print()


show('Before')

compileall.compile_file('examples/a.py')

show('\nAfter')
Пример #59
0
    def __installPlugin(self, archiveFilename):
        """
        Private slot to install the selected plugin.
        
        @param archiveFilename name of the plugin archive
            file (string)
        @return flag indicating success (boolean), error message
            upon failure (string) and flag indicating a restart
            of the IDE is required (boolean)
        """
        installedPluginName = ""
        
        archive = archiveFilename
        destination = self.destinationCombo.itemData(
            self.destinationCombo.currentIndex())
        
        # check if archive is a local url
        url = parse.urlparse(archive)
        if url[0].lower() == 'file':
            archive = url[2]

        # check, if the archive exists
        if not os.path.exists(archive):
            return False, \
                self.tr(
                    """<p>The archive file <b>{0}</b> does not exist. """
                    """Aborting...</p>""").format(archive), \
                False
        
        # check, if the archive is a valid zip file
        if not zipfile.is_zipfile(archive):
            return False, \
                self.tr(
                    """<p>The file <b>{0}</b> is not a valid plugin """
                    """ZIP-archive. Aborting...</p>""").format(archive), \
                False
        
        # check, if the destination is writeable
        if not os.access(destination, os.W_OK):
            return False, \
                self.tr(
                    """<p>The destination directory <b>{0}</b> is not """
                    """writeable. Aborting...</p>""").format(destination), \
                False
        
        zip = zipfile.ZipFile(archive, "r")
        
        # check, if the archive contains a valid plugin
        pluginFound = False
        pluginFileName = ""
        for name in zip.namelist():
            if self.__pluginManager.isValidPluginName(name):
                installedPluginName = name[:-3]
                pluginFound = True
                pluginFileName = name
                break
        
        if not pluginFound:
            return False, \
                self.tr(
                    """<p>The file <b>{0}</b> is not a valid plugin """
                    """ZIP-archive. Aborting...</p>""").format(archive), \
                False
        
        # parse the plugin module's plugin header
        pluginSource = Utilities.decode(zip.read(pluginFileName))[0]
        packageName = ""
        internalPackages = []
        needsRestart = False
        pyqtApi = 0
        doCompile = True
        for line in pluginSource.splitlines():
            if line.startswith("packageName"):
                tokens = line.split("=")
                if tokens[0].strip() == "packageName" and \
                   tokens[1].strip()[1:-1] != "__core__":
                    if tokens[1].strip()[0] in ['"', "'"]:
                        packageName = tokens[1].strip()[1:-1]
                    else:
                        if tokens[1].strip() == "None":
                            packageName = "None"
            elif line.startswith("internalPackages"):
                tokens = line.split("=")
                token = tokens[1].strip()[1:-1]
                # it is a comma separated string
                internalPackages = [p.strip() for p in token.split(",")]
            elif line.startswith("needsRestart"):
                tokens = line.split("=")
                needsRestart = tokens[1].strip() == "True"
            elif line.startswith("pyqtApi"):
                tokens = line.split("=")
                try:
                    pyqtApi = int(tokens[1].strip())
                except ValueError:
                    pass
            elif line.startswith("doNotCompile"):
                tokens = line.split("=")
                if tokens[1].strip() == "True":
                    doCompile = False
            elif line.startswith("# End-Of-Header"):
                break
        
        if not packageName:
            return False, \
                self.tr(
                    """<p>The plugin module <b>{0}</b> does not contain """
                    """a 'packageName' attribute. Aborting...</p>""")\
                .format(pluginFileName), \
                False
        
        if pyqtApi < 2:
            return False, \
                self.tr(
                    """<p>The plugin module <b>{0}</b> does not conform"""
                    """ with the PyQt v2 API. Aborting...</p>""")\
                .format(pluginFileName), \
                False
        
        # check, if it is a plugin, that collides with others
        if not os.path.exists(os.path.join(destination, pluginFileName)) and \
           packageName != "None" and \
           os.path.exists(os.path.join(destination, packageName)):
            return False, \
                self.tr("""<p>The plugin package <b>{0}</b> exists. """
                        """Aborting...</p>""")\
                    .format(os.path.join(destination, packageName)), \
                False
        
        if os.path.exists(os.path.join(destination, pluginFileName)) and \
           packageName != "None" and \
           not os.path.exists(os.path.join(destination, packageName)):
            return False, \
                self.tr("""<p>The plugin module <b>{0}</b> exists. """
                        """Aborting...</p>""")\
                    .format(os.path.join(destination, pluginFileName)), \
                False
        
        activatePlugin = False
        if not self.__external:
            activatePlugin = \
                not self.__pluginManager.isPluginLoaded(
                    installedPluginName) or \
                (self.__pluginManager.isPluginLoaded(installedPluginName) and
                 self.__pluginManager.isPluginActive(installedPluginName))
            # try to unload a plugin with the same name
            self.__pluginManager.unloadPlugin(installedPluginName)
        
        # uninstall existing plugin first to get clean conditions
        self.__uninstallPackage(destination, pluginFileName, packageName)
        
        # clean sys.modules
        reload_ = self.__pluginManager.removePluginFromSysModules(
            installedPluginName, packageName, internalPackages)
        
        # now do the installation
        self.__installedDirs = []
        self.__installedFiles = []
        try:
            if packageName != "None":
                namelist = sorted(zip.namelist())
                tot = len(namelist)
                prog = 0
                self.progress.setMaximum(tot)
                QApplication.processEvents()
                for name in namelist:
                    self.progress.setValue(prog)
                    QApplication.processEvents()
                    prog += 1
                    if name == pluginFileName or \
                       name.startswith("{0}/".format(packageName)) or \
                       name.startswith("{0}\\".format(packageName)):
                        outname = name.replace("/", os.sep)
                        outname = os.path.join(destination, outname)
                        if outname.endswith("/") or outname.endswith("\\"):
                            # it is a directory entry
                            outname = outname[:-1]
                            if not os.path.exists(outname):
                                self.__makedirs(outname)
                        else:
                            # it is a file
                            d = os.path.dirname(outname)
                            if not os.path.exists(d):
                                self.__makedirs(d)
                            f = open(outname, "wb")
                            f.write(zip.read(name))
                            f.close()
                            self.__installedFiles.append(outname)
                self.progress.setValue(tot)
                # now compile user interface files
                compileUiFiles(os.path.join(destination, packageName), True)
            else:
                outname = os.path.join(destination, pluginFileName)
                f = open(outname, "w", encoding="utf-8")
                f.write(pluginSource)
                f.close()
                self.__installedFiles.append(outname)
        except os.error as why:
            self.__rollback()
            return False, \
                self.tr(
                    "Error installing plugin. Reason: {0}").format(str(why)), \
                False
        except IOError as why:
            self.__rollback()
            return False, \
                self.tr(
                    "Error installing plugin. Reason: {0}").format(str(why)), \
                False
        except OSError as why:
            self.__rollback()
            return False, \
                self.tr(
                    "Error installing plugin. Reason: {0}").format(str(why)), \
                False
        except Exception:
            sys.stderr.write("Unspecific exception installing plugin.\n")
            self.__rollback()
            return False, \
                self.tr("Unspecific exception installing plugin."), \
                False
        
        # now compile the plugins
        if doCompile:
            dir = os.path.join(destination, packageName)
            files = os.path.join(destination, pluginFileName)
            if sys.version_info[0] == 2:
                dir = dir.encode(sys.getfilesystemencoding())
                files = files.encode(sys.getfilesystemencoding())
            os.path.join_unicode = False
            compileall.compile_dir(dir, quiet=True)
            compileall.compile_file(files, quiet=True)
            os.path.join_unicode = True
        
        if not self.__external:
            # now load and activate the plugin
            self.__pluginManager.loadPlugin(installedPluginName, destination,
                                            reload_)
            if activatePlugin:
                self.__pluginManager.activatePlugin(installedPluginName)
        
        return True, "", needsRestart