Ejemplo n.º 1
0
def test_unwriteable_contents():
    my_app_setup_py = dedent("""
      from setuptools import setup

      setup(
        name='my_app',
        version='0.0.0',
        zip_safe=True,
        packages=['my_app'],
        include_package_data=True,
        package_data={'my_app': ['unwriteable.so']},
      )
    """)

    UNWRITEABLE_PERMS = 0o400
    with temporary_content(
        {
            'setup.py': my_app_setup_py,
            'my_app/__init__.py': '',
            'my_app/unwriteable.so': ''
        },
            perms=UNWRITEABLE_PERMS) as my_app_project_dir:
        with pushd(my_app_project_dir):
            subprocess.check_call([sys.executable, 'setup.py', 'bdist_wheel'])

        uses_my_app_setup_py = dedent("""
      from setuptools import setup

      setup(
        name='uses_my_app',
        version='0.0.0',
        zip_safe=True,
        install_requires=['my_app'],
      )
    """)
        with temporary_content({'setup.py': uses_my_app_setup_py
                                }) as uses_my_app_project_dir:
            with pushd(uses_my_app_project_dir):
                subprocess.check_call([
                    sys.executable, 'setup.py', 'bdist_pex',
                    '--pex-args=--disable-cache --no-pypi -f {}'.format(
                        os.path.join(my_app_project_dir, 'dist'))
                ])

                with open_zip('dist/uses_my_app-0.0.0.pex') as zf:
                    unwriteable_sos = [
                        path for path in zf.namelist()
                        if path.endswith('my_app/unwriteable.so')
                    ]
                    assert 1 == len(unwriteable_sos)
                    unwriteable_so = unwriteable_sos.pop()
                    zf.extract(unwriteable_so)
                    assert UNWRITEABLE_PERMS == stat.S_IMODE(
                        os.stat(unwriteable_so).st_mode)
Ejemplo n.º 2
0
def test_unwriteable_contents():
    my_app_setup_py = dedent("""
      from setuptools import setup

      setup(
        name='my_app',
        version='0.0.0',
        zip_safe=True,
        packages=['my_app'],
        include_package_data=True,
        package_data={'my_app': ['unwriteable.so']},
      )
    """)

    UNWRITEABLE_PERMS = 0o400
    with temporary_content(
        {
            'setup.py': my_app_setup_py,
            'my_app/__init__.py': '',
            'my_app/unwriteable.so': ''
        },
            perms=UNWRITEABLE_PERMS) as my_app_project_dir:
        my_app_whl = WheelInstaller(my_app_project_dir).bdist()

        uses_my_app_setup_py = bdist_pex_setup_py(name='uses_my_app',
                                                  version='0.0.0',
                                                  zip_safe=True,
                                                  install_requires=['my_app'])
        with temporary_content({'setup.py': uses_my_app_setup_py
                                }) as uses_my_app_project_dir:
            pex_args = '--pex-args=--disable-cache --no-pypi -f {}'.format(
                os.path.dirname(my_app_whl))
            uses_my_app_pex = bdist_pex_installer(uses_my_app_project_dir,
                                                  bdist_args=[pex_args
                                                              ]).bdist()

            with open_zip(uses_my_app_pex) as zf:
                unwriteable_sos = [
                    path for path in zf.namelist()
                    if path.endswith('my_app/unwriteable.so')
                ]
                assert 1 == len(unwriteable_sos)
                unwriteable_so = unwriteable_sos.pop()
                zf.extract(unwriteable_so, path=uses_my_app_project_dir)
                extract_dest = os.path.join(uses_my_app_project_dir,
                                            unwriteable_so)
                assert UNWRITEABLE_PERMS == stat.S_IMODE(
                    os.stat(extract_dest).st_mode)
Ejemplo n.º 3
0
def test_entry_point_exit_code():
  setup_py = dedent("""
    from setuptools import setup

    setup(
      name='my_app',
      version='0.0.0',
      zip_safe=True,
      packages=[''],
      entry_points={'console_scripts': ['my_app = my_app:do_something']},
    )
  """)

  error_msg = 'setuptools expects this to exit non-zero'

  my_app = dedent("""
    def do_something():
      return '%s'
  """ % error_msg)

  with temporary_content({'setup.py': setup_py, 'my_app.py': my_app}) as project_dir:
    installer = EggInstaller(project_dir)
    dist = DistributionHelper.distribution_from_path(installer.bdist())
    so, rc = run_simple_pex_test('', env={'PEX_SCRIPT': 'my_app'}, dists=[dist])
    assert so.decode('utf-8').strip() == error_msg
    assert rc == 1
Ejemplo n.º 4
0
def assert_entry_points(entry_points):
  setup_py = dedent("""
      from setuptools import setup

      setup(
        name='my_app',
        version='0.0.0',
        zip_safe=True,
        packages=[''],
        entry_points=%(entry_points)r,
      )
    """ % dict(entry_points=entry_points))

  my_app = dedent("""
      def do_something():
        print("hello world!")
    """)

  with temporary_content({'setup.py': setup_py, 'my_app.py': my_app}) as project_dir:
    with pushd(project_dir):
      subprocess.check_call([sys.executable, 'setup.py', 'bdist_pex'])
      process = subprocess.Popen([os.path.join(project_dir, 'dist', 'my_app-0.0.0.pex')],
                                 stdout=subprocess.PIPE)
      stdout, _ = process.communicate()
      assert 0 == process.returncode
      assert stdout == b'hello world!\n'
Ejemplo n.º 5
0
def assert_entry_points(entry_points):
    setup_py = dedent("""
      from setuptools import setup

      setup(
        name='my_app',
        version='0.0.0',
        zip_safe=True,
        packages=[''],
        entry_points=%(entry_points)r,
      )
    """ % dict(entry_points=entry_points))

    my_app = dedent("""
      def do_something():
        print("hello world!")
    """)

    with temporary_content({
            'setup.py': setup_py,
            'my_app.py': my_app
    }) as project_dir:
        with pushd(project_dir):
            subprocess.check_call([sys.executable, 'setup.py', 'bdist_pex'])
            process = subprocess.Popen(
                [os.path.join(project_dir, 'dist', 'my_app-0.0.0.pex')],
                stdout=subprocess.PIPE)
            stdout, _ = process.communicate()
            assert '{pex_root}' not in os.listdir(project_dir)
            assert 0 == process.returncode
            assert stdout == b'hello world!\n'
Ejemplo n.º 6
0
def test_entry_point_exit_code():
    setup_py = dedent("""
    from setuptools import setup

    setup(
      name='my_app',
      version='0.0.0',
      zip_safe=True,
      packages=[''],
      entry_points={'console_scripts': ['my_app = my_app:do_something']},
    )
  """)

    error_msg = 'setuptools expects this to exit non-zero'

    my_app = dedent("""
    def do_something():
      return '%s'
  """ % error_msg)

    with temporary_content({
            'setup.py': setup_py,
            'my_app.py': my_app
    }) as project_dir:
        installer = EggInstaller(project_dir)
        dist = DistributionHelper.distribution_from_path(installer.bdist())
        so, rc = run_simple_pex_test('',
                                     env=make_env(PEX_SCRIPT='my_app'),
                                     dists=[dist])
        assert so.decode('utf-8').strip() == error_msg
        assert rc == 1
Ejemplo n.º 7
0
def pex_with_entrypoints(entry_point):
  setup_py = dedent("""
    from setuptools import setup

    setup(
      name='my_app',
      version='0.0.0',
      zip_safe=True,
      packages=[''],
      install_requires=['setuptools==36.2.7'],
      entry_points={'console_scripts': ['my_app_function = my_app:do_something',
                                        'my_app_module = my_app']},
    )
  """)

  my_app = dedent("""
    from setuptools.sandbox import run_setup

    def do_something():
      return run_setup

    if __name__ == '__main__':
      do_something()
  """)

  with temporary_content({'setup.py': setup_py, 'my_app.py': my_app}) as project_dir:
    with temporary_dir() as out:
      pex = os.path.join(out, 'pex.pex')
      pex_command = ['--validate-entry-point', '-c', entry_point, project_dir, '-o', pex]
      results = run_pex_command(pex_command)
      results.assert_success()
      yield pex
Ejemplo n.º 8
0
def test_hash_consistency():
  for reverse in (False, True):
    with temporary_content(CONTENT) as td:
      dir_hash = CacheHelper.dir_hash(td)
      with named_temporary_file() as tf:
        write_zipfile(td, tf.name, reverse=reverse)
        with contextlib.closing(zipfile.ZipFile(tf.name, 'r')) as zf:
          zip_hash = CacheHelper.zip_hash(zf)
          assert zip_hash == dir_hash
          assert zip_hash != sha1().hexdigest()  # make sure it's not an empty hash
Ejemplo n.º 9
0
def test_hash_consistency():
  for reverse in (False, True):
    with temporary_content(CONTENT) as td:
      dir_hash = CacheHelper.dir_hash(td)
      with named_temporary_file() as tf:
        write_zipfile(td, tf.name, reverse=reverse)
        with open_zip(tf.name, 'r') as zf:
          zip_hash = CacheHelper.zip_hash(zf)
          assert zip_hash == dir_hash
          assert zip_hash != sha1().hexdigest()  # make sure it's not an empty hash
Ejemplo n.º 10
0
def test_pex_executable():
    # type: () -> None
    # Tests that pex keeps executable permissions
    with temporary_dir() as temp_dir:
        pex_dir = os.path.join(temp_dir, "pex_dir")
        safe_mkdir(pex_dir)

        with open(os.path.join(pex_dir, "exe.py"), "w") as fp:
            fp.write(
                textwrap.dedent(
                    """
                    import subprocess
                    import os
                    import sys
                    import my_package
                    path = os.path.join(os.path.dirname(my_package.__file__), 'bin/start.sh')
                    sys.stdout.write(subprocess.check_output([path]).decode('utf-8'))      
                    """
                )
            )

        project_content = {
            "setup.py": textwrap.dedent(
                """
                from setuptools import setup

                setup(
                    name='my_project',
                    version='0.0.0.0',
                    zip_safe=True,
                    packages=['my_package'],
                    package_data={'my_package': ['bin/*']},
                    install_requires=[],
                )
                """
            ),
            "my_package/__init__.py": 0,
            "my_package/bin/start.sh": (
                "#!/usr/bin/env bash\n" "echo 'hello world from start.sh!'"
            ),
            "my_package/my_module.py": 'def do_something():\n  print("hello world!")\n',
        }  # type: Dict[str, Union[str, int]]
        pex_builder = PEXBuilder(path=pex_dir)
        with temporary_content(project_content, perms=0o755) as project_dir:
            installer = WheelBuilder(project_dir)
            bdist = installer.bdist()
            pex_builder.add_dist_location(bdist)
            pex_builder.set_executable(os.path.join(pex_dir, "exe.py"))
            pex_builder.freeze()

            app_pex = os.path.join(os.path.join(temp_dir, "out_pex_dir"), "app.pex")
            pex_builder.build(app_pex)
            std_out, rc = run_simple_pex(app_pex, env={"PEX_ROOT": os.path.join(temp_dir, ".pex")})
            assert rc == 0
            assert std_out.decode("utf-8") == "hello world from start.sh!\n"
Ejemplo n.º 11
0
def test_pex_executable():
    # Tests that pex keeps executable permissions
    with temporary_dir() as temp_dir:
        pex_dir = os.path.join(temp_dir, 'pex_dir')
        safe_mkdir(pex_dir)

        with open(os.path.join(pex_dir, 'exe.py'), 'w') as fp:
            fp.write(
                textwrap.dedent('''
               import subprocess
               import os
               import sys
               import my_package
               path = os.path.join(os.path.dirname(my_package.__file__), 'bin/start.sh')
               sys.stdout.write(subprocess.check_output([path]).decode('utf-8'))      
               '''))

        project_content = {
            'setup.py':
            textwrap.dedent('''
          from setuptools import setup

          setup(
              name='my_project',
              version='0.0.0.0',
              zip_safe=True,
              packages=['my_package'],
              package_data={'my_package': ['bin/*']},
              install_requires=[],
          )
      '''),
            'my_package/__init__.py':
            0,
            'my_package/bin/start.sh': ("#!/usr/bin/env bash\n"
                                        "echo 'hello world from start.sh!'"),
            'my_package/my_module.py':
            'def do_something():\n  print("hello world!")\n',
        }
        pex_builder = PEXBuilder(path=pex_dir)
        with temporary_content(project_content, perms=0o755) as project_dir:
            installer = WheelInstaller(project_dir)
            bdist = DistributionHelper.distribution_from_path(
                installer.bdist())
            pex_builder.add_dist_location(bdist.location)
            pex_builder.set_executable(os.path.join(pex_dir, 'exe.py'))
            pex_builder.freeze()

            app_pex = os.path.join(os.path.join(temp_dir, 'out_pex_dir'),
                                   'app.pex')
            pex_builder.build(app_pex)
            std_out, rc = run_simple_pex(
                app_pex, env={'PEX_ROOT': os.path.join(temp_dir, '.pex')})
            assert rc == 0
            assert std_out.decode('utf-8') == 'hello world from start.sh!\n'
Ejemplo n.º 12
0
def assert_pex_args_shebang(shebang):
  setup_py = bdist_pex_setup_py(name='my_app',
                                version='0.0.0',
                                zip_safe=True,
                                packages=[''])

  with temporary_content({'setup.py': setup_py}) as project_dir:
    pex_args = '--pex-args=--python-shebang="{}"'.format(shebang)
    with bdist_pex(project_dir, bdist_args=[pex_args]) as my_app_pex:
      with open(my_app_pex, 'rb') as fp:
        assert fp.readline().decode().rstrip() == shebang
Ejemplo n.º 13
0
def assert_pex_args_shebang(shebang):
    setup_py = bdist_pex_setup_py(name='my_app',
                                  version='0.0.0',
                                  zip_safe=True,
                                  packages=[''])

    with temporary_content({'setup.py': setup_py}) as project_dir:
        pex_args = '--pex-args=--python-shebang="{}"'.format(shebang)
        with bdist_pex(project_dir, bdist_args=[pex_args]) as my_app_pex:
            with open(my_app_pex, 'rb') as fp:
                assert fp.readline().decode().rstrip() == shebang
Ejemplo n.º 14
0
def pythonpath_isolation_test():
    # type: () -> Iterator[PythonpathIsolationTest]
    with temporary_dir() as temp_dir:
        pythonpath = os.path.join(temp_dir, "one")
        with safe_open(os.path.join(pythonpath, "foo.py"), "w") as fp:
            fp.write("BAR = 42")
        with safe_open(os.path.join(pythonpath, "bar.py"), "w") as fp:
            fp.write("FOO = 137")

        dist_content = {
            "setup.py": textwrap.dedent(
                """
                from setuptools import setup

                setup(
                    name='foo',
                    version='0.0.0',
                    zip_safe=True,
                    packages=['foo'],
                    install_requires=[],
                )
                """
            ),
            "foo/__init__.py": "BAR = 137",
        }

        with temporary_content(dist_content) as project_dir:
            installer = WheelBuilder(project_dir)
            foo_bdist = installer.bdist()

            exe_contents = textwrap.dedent(
                """
                import sys

                try:
                    import bar
                except ImportError:
                    import collections
                    bar = collections.namedtuple('bar', ['FOO'])(None)

                import foo

                sys.stdout.write("foo.BAR={} bar.FOO={}".format(foo.BAR, bar.FOO))
                """
            )

            yield PythonpathIsolationTest(
                pythonpath=pythonpath, dists=[foo_bdist], exe=exe_contents
            )
Ejemplo n.º 15
0
def test_pex_exit_code_propagation():
    """Tests exit code propagation."""
    test_stub = dedent("""
    def test_fail():
      assert False
    """)

    with temporary_content({'tester.py': test_stub}) as output_dir:
        pex_path = os.path.join(output_dir, 'test.pex')
        tester_path = os.path.join(output_dir, 'tester.py')
        results = run_pex_command(
            ['pytest==3.9.1', '-e', 'pytest:main', '-o', pex_path])
        results.assert_success()

        assert subprocess.call([pex_path, os.path.realpath(tester_path)]) == 1
Ejemplo n.º 16
0
def test_unwriteable_contents():
  my_app_setup_py = dedent("""
      from setuptools import setup

      setup(
        name='my_app',
        version='0.0.0',
        zip_safe=True,
        packages=['my_app'],
        include_package_data=True,
        package_data={'my_app': ['unwriteable.so']},
      )
    """)

  UNWRITEABLE_PERMS = 0o400
  with temporary_content({'setup.py': my_app_setup_py,
                          'my_app/__init__.py': '',
                          'my_app/unwriteable.so': ''},
                         perms=UNWRITEABLE_PERMS) as my_app_project_dir:
    my_app_whl = WheelInstaller(my_app_project_dir).bdist()

    uses_my_app_setup_py = bdist_pex_setup_py(name='uses_my_app',
                                              version='0.0.0',
                                              zip_safe=True,
                                              install_requires=['my_app'])
    with temporary_content({'setup.py': uses_my_app_setup_py}) as uses_my_app_project_dir:
      pex_args = '--pex-args=--disable-cache --no-pypi -f {}'.format(os.path.dirname(my_app_whl))
      with bdist_pex(uses_my_app_project_dir, bdist_args=[pex_args]) as uses_my_app_pex:
        with open_zip(uses_my_app_pex) as zf:
          unwriteable_sos = [path for path in zf.namelist()
                             if path.endswith('my_app/unwriteable.so')]
          assert 1 == len(unwriteable_sos)
          unwriteable_so = unwriteable_sos.pop()
          zf.extract(unwriteable_so, path=uses_my_app_project_dir)
          extract_dest = os.path.join(uses_my_app_project_dir, unwriteable_so)
          assert UNWRITEABLE_PERMS == stat.S_IMODE(os.stat(extract_dest).st_mode)
Ejemplo n.º 17
0
def pythonpath_isolation_test():
    with temporary_dir() as temp_dir:
        pythonpath = os.path.join(temp_dir, 'one')
        with safe_open(os.path.join(pythonpath, 'foo.py'), 'w') as fp:
            fp.write('BAR = 42')
        with safe_open(os.path.join(pythonpath, 'bar.py'), 'w') as fp:
            fp.write('FOO = 137')

        dist_content = {
            'setup.py':
            textwrap.dedent("""
        from setuptools import setup

        setup(
          name='foo',
          version='0.0.0',
          zip_safe=True,
          packages=['foo'],
          install_requires=[],
        )
      """),
            'foo/__init__.py':
            'BAR = 137',
        }

        with temporary_content(dist_content) as project_dir:
            installer = WheelInstaller(project_dir)
            foo_bdist = DistributionHelper.distribution_from_path(
                installer.bdist())

            exe_contents = textwrap.dedent("""
        import sys
        
        try:
          import bar
        except ImportError:
          import collections
          bar = collections.namedtuple('bar', ['FOO'])(None)
  
        import foo
                  
        sys.stdout.write("foo.BAR={} bar.FOO={}".format(foo.BAR, bar.FOO))
      """)

            yield PythonpathIsolationTest(pythonpath=pythonpath,
                                          dists=[foo_bdist],
                                          exe=exe_contents)
Ejemplo n.º 18
0
def assert_entry_points(entry_points):
  setup_py = bdist_pex_setup_py(name='my_app',
                                version='0.0.0',
                                zip_safe=True,
                                packages=[''],
                                entry_points=entry_points)
  my_app = dedent("""
      def do_something():
        print("hello world!")
    """)

  with temporary_content({'setup.py': setup_py, 'my_app.py': my_app}) as project_dir:
    with bdist_pex(project_dir) as my_app_pex:
      process = subprocess.Popen([my_app_pex], stdout=subprocess.PIPE)
      stdout, _ = process.communicate()
      assert '{pex_root}' not in os.listdir(project_dir)
      assert 0 == process.returncode
      assert stdout == b'hello world!\n'
Ejemplo n.º 19
0
def test_pex_manylinux_runtime():
    """Tests resolver manylinux support and runtime resolution (and --platform=current)."""
    test_stub = dedent("""
    import msgpack
    print(msgpack.unpackb(msgpack.packb([1, 2, 3])))
    """)

    with temporary_content({'tester.py': test_stub}) as output_dir:
        pex_path = os.path.join(output_dir, 'test.pex')
        tester_path = os.path.join(output_dir, 'tester.py')
        results = run_pex_command([
            '--disable-cache', '--no-build', 'msgpack-python==0.4.7',
            '--platform=current'.format(platform), '-o', pex_path
        ])
        results.assert_success()

        out = subprocess.check_output([pex_path, tester_path])
        assert out.strip() == '[1, 2, 3]'
Ejemplo n.º 20
0
def test_unwriteable_contents():
    # type: () -> None
    my_app_setup_py = dedent("""
        from setuptools import setup
        
        setup(
            name='my_app',
            version='0.0.0',
            zip_safe=True,
            packages=['my_app'],
            include_package_data=True,
            package_data={'my_app': ['unwriteable.so']},
        )
        """)

    UNWRITEABLE_PERMS = 0o400
    with temporary_content(
        {
            "setup.py": my_app_setup_py,
            "my_app/__init__.py": "",
            "my_app/unwriteable.so": "so contents",
        },
            perms=UNWRITEABLE_PERMS,
    ) as my_app_project_dir:
        my_app_whl = WheelBuilder(my_app_project_dir).bdist()

        with make_project(name="uses_my_app",
                          install_reqs=["my_app"]) as uses_my_app_project_dir:
            pex_args = "--pex-args=--disable-cache --no-pypi -f {}".format(
                os.path.dirname(my_app_whl))
            with bdist_pex(uses_my_app_project_dir,
                           bdist_args=[pex_args]) as uses_my_app_pex:
                with open_zip(uses_my_app_pex) as zf:
                    unwriteable_sos = [
                        path for path in zf.namelist()
                        if path.endswith("my_app/unwriteable.so")
                    ]
                    assert 1 == len(unwriteable_sos)
                    unwriteable_so = unwriteable_sos.pop()
                    zf.extract(unwriteable_so, path=uses_my_app_project_dir)
                    extract_dest = os.path.join(uses_my_app_project_dir,
                                                unwriteable_so)
                    with open(extract_dest) as fp:
                        assert "so contents" == fp.read()
Ejemplo n.º 21
0
def assert_entry_points(entry_points):
    setup_py = bdist_pex_setup_py(name='my_app',
                                  version='0.0.0',
                                  zip_safe=True,
                                  packages=[''],
                                  entry_points=entry_points)
    my_app = dedent("""
      def do_something():
        print("hello world!")
    """)

    with temporary_content({
            'setup.py': setup_py,
            'my_app.py': my_app
    }) as project_dir:
        with bdist_pex(project_dir) as my_app_pex:
            process = subprocess.Popen([my_app_pex], stdout=subprocess.PIPE)
            stdout, _ = process.communicate()
            assert '{pex_root}' not in os.listdir(project_dir)
            assert 0 == process.returncode
            assert stdout == b'hello world!\n'
Ejemplo n.º 22
0
def assert_pex_args_shebang(shebang):
  setup_py = dedent("""
      from setuptools import setup

      setup(
        name='my_app',
        version='0.0.0',
        zip_safe=True,
        packages=[''],
      )
    """)

  with temporary_content({'setup.py': setup_py}) as project_dir:
    with pushd(project_dir):
      assert subprocess.check_call(
        [sys.executable, 'setup.py', 'bdist_pex',
         '--pex-args=--python-shebang="%(shebang)s"' %
         dict(shebang=shebang)]) == 0

      with open(os.path.join(project_dir, 'dist',
                             'my_app-0.0.0.pex'), 'rb') as fp:
        assert fp.readline().decode().rstrip() == shebang
Ejemplo n.º 23
0
def assert_pex_args_shebang(shebang):
    setup_py = dedent("""
      from setuptools import setup

      setup(
        name='my_app',
        version='0.0.0',
        zip_safe=True,
        packages=[''],
      )
    """)

    with temporary_content({'setup.py': setup_py}) as project_dir:
        with pushd(project_dir):
            assert subprocess.check_call([
                sys.executable, 'setup.py', 'bdist_pex',
                '--pex-args=--python-shebang="%(shebang)s"' %
                dict(shebang=shebang)
            ]) == 0

            with open(os.path.join(project_dir, 'dist', 'my_app-0.0.0.pex'),
                      'rb') as fp:
                assert fp.readline().decode().rstrip() == shebang
Ejemplo n.º 24
0
 def add_wheel(builder, content):
     # type: (PEXBuilder, Dict[str, str]) -> None
     with temporary_content(content) as project:
         dist = WheelBuilder(project, interpreter=builder.interpreter).bdist()
         builder.add_dist_location(dist)
Ejemplo n.º 25
0
 def add_wheel(builder, content):
   with temporary_content(content) as project:
     dist = WheelInstaller(project, interpreter=builder.interpreter).bdist()
     builder.add_dist_location(dist)
Ejemplo n.º 26
0
 def add_sources(builder, content):
   with temporary_content(content) as project:
     for path in content.keys():
       builder.add_source(os.path.join(project, path), path)
Ejemplo n.º 27
0
 def add_sources(builder, content):
     # type: (PEXBuilder, Dict[str, str]) -> None
     with temporary_content(content) as project:
         for path in content.keys():
             builder.add_source(os.path.join(project, path), path)