Ejemplo n.º 1
0
async def generate_chroot(request: SetupPyChrootRequest) -> SetupPyChroot:
  if request.py2:
    # TODO: Implement Python 2 support.  This will involve, among other things: merging ancestor
    # __init__.py files into the chroot, detecting packages based on the presence of __init__.py,
    # and inspecting all __init__.py files for the namespace package incantation.
    raise UnsupportedPythonVersion('Running setup.py commands not supported for Python 2.')

  owned_deps = await Get[OwnedDependencies](DependencyOwner(request.exported_target))
  targets = HydratedTargets(od.hydrated_target for od in owned_deps)
  sources = await Get[SetupPySources](SetupPySourcesRequest(targets))
  requirements = await Get[ExportedTargetRequirements](DependencyOwner(request.exported_target))

  # Nest the sources under the src/ prefix.
  src_digest = await Get[Digest](DirectoryWithPrefixToAdd(sources.digest, CHROOT_SOURCE_ROOT))

  # Generate the kwargs to the setup() call.
  setup_kwargs = request.exported_target.hydrated_target.adaptor.provides.setup_py_keywords.copy()
  setup_kwargs.update({
    'package_dir': {'': CHROOT_SOURCE_ROOT},
    'packages': sources.packages,
    'namespace_packages': sources.namespace_packages,
    'package_data': dict(sources.package_data),
    'install_requires': requirements.requirement_strs
  })
  ht = request.exported_target.hydrated_target
  key_to_binary_spec = getattr(ht.adaptor.provides, 'binaries', {})
  keys = list(key_to_binary_spec.keys())
  binaries = await MultiGet(Get[HydratedTarget](
    Address, Address.parse(key_to_binary_spec[key], relative_to=ht.address.spec_path))
    for key in keys)
  for key, binary in zip(keys, binaries):
    if (not isinstance(binary.adaptor, PythonBinaryAdaptor) or
        getattr(binary.adaptor, 'entry_point', None) is None):
      raise InvalidEntryPoint(
        f'The binary {key} exported by {ht.address.reference()} is not a valid entry point.')
    entry_points = setup_kwargs['entry_points'] = setup_kwargs.get('entry_points', {})
    console_scripts = entry_points['console_scripts'] = entry_points.get('console_scripts', [])
    console_scripts.append(f'{key}={binary.adaptor.entry_point}')

  # Generate the setup script.
  setup_py_content = SETUP_BOILERPLATE.format(
    target_address_spec=ht.address.reference(),
    setup_kwargs_str=distutils_repr(setup_kwargs)
  ).encode()
  extra_files_digest = await Get[Digest](
    InputFilesContent([
      FileContent('setup.py', setup_py_content),
      FileContent('MANIFEST.in', 'include *.py'.encode())  # Make sure setup.py is included.
    ]))

  chroot_digest = await Get[Digest](DirectoriesToMerge((src_digest, extra_files_digest)))
  return SetupPyChroot(chroot_digest, json.dumps(setup_kwargs, sort_keys=True))
Ejemplo n.º 2
0
    def write_setup(self, root_target, reduced_dependencies, chroot):
        """Write the setup.py of a target.

        Must be run after writing the contents to the chroot.
        """
        setup_keywords = root_target.provides.setup_py_keywords.copy()

        package_dir = {"": self.SOURCE_ROOT}
        packages, namespace_packages, resources = self.find_packages(
            root_target, chroot)

        if namespace_packages:
            setup_keywords["namespace_packages"] = list(
                sorted(namespace_packages))

        if packages:
            setup_keywords.update(
                package_dir=package_dir,
                packages=list(sorted(packages)),
                package_data=dict((str(package), list(map(str, rs)))
                                  for (package, rs) in resources.items()),
            )

        setup_keywords["install_requires"] = list(
            self.install_requires(reduced_dependencies))

        for binary_name, entry_point in self.iter_entry_points(root_target):
            if "entry_points" not in setup_keywords:
                setup_keywords["entry_points"] = {}
            if "console_scripts" not in setup_keywords["entry_points"]:
                setup_keywords["entry_points"]["console_scripts"] = []
            setup_keywords["entry_points"]["console_scripts"].append(
                "{} = {}".format(binary_name, entry_point))

        setup_py = self._setup_boilerplate().format(
            setup_dict=distutils_repr(setup_keywords),
            setup_target=root_target.address.reference())
        chroot.write(ensure_binary(setup_py), "setup.py")

        # Make sure that `setup.py` is included.
        chroot.write("include *.py", "MANIFEST.in", mode="w")
Ejemplo n.º 3
0
async def generate_chroot(request: SetupPyChrootRequest) -> SetupPyChroot:
    owned_deps = await Get[OwnedDependencies](DependencyOwner(
        request.exported_target))
    targets = HydratedTargets(od.hydrated_target for od in owned_deps)
    sources = await Get[SetupPySources](SetupPySourcesRequest(targets,
                                                              py2=request.py2))
    requirements = await Get[ExportedTargetRequirements](DependencyOwner(
        request.exported_target))

    # Nest the sources under the src/ prefix.
    src_digest = await Get[Digest](DirectoryWithPrefixToAdd(
        sources.digest, CHROOT_SOURCE_ROOT))

    # Generate the kwargs to the setup() call.
    setup_kwargs = request.exported_target.hydrated_target.adaptor.provides.setup_py_keywords.copy(
    )
    setup_kwargs.update({
        "package_dir": {
            "": CHROOT_SOURCE_ROOT
        },
        "packages": sources.packages,
        "namespace_packages": sources.namespace_packages,
        "package_data": dict(sources.package_data),
        "install_requires": requirements.requirement_strs,
    })
    adaptor = request.exported_target.hydrated_target.adaptor
    key_to_binary_spec = getattr(adaptor.provides, "binaries", {})
    keys = list(key_to_binary_spec.keys())
    binaries = await MultiGet(Get[HydratedTarget](
        Address,
        Address.parse(key_to_binary_spec[key],
                      relative_to=adaptor.address.spec_path)) for key in keys)
    for key, binary in zip(keys, binaries):
        if (not isinstance(binary.adaptor, PythonBinaryAdaptor)
                or getattr(binary.adaptor, "entry_point", None) is None):
            raise InvalidEntryPoint(
                f"The binary {key} exported by {adaptor.address.reference()} is not a valid entry point."
            )
        entry_points = setup_kwargs["entry_points"] = setup_kwargs.get(
            "entry_points", {})
        console_scripts = entry_points["console_scripts"] = entry_points.get(
            "console_scripts", [])
        console_scripts.append(f"{key}={binary.adaptor.entry_point}")

    # Generate the setup script.
    setup_py_content = SETUP_BOILERPLATE.format(
        target_address_spec=adaptor.address.reference(),
        setup_kwargs_str=distutils_repr(setup_kwargs),
    ).encode()
    extra_files_digest = await Get[Digest](
        InputFilesContent([
            FileContent("setup.py", setup_py_content),
            FileContent(
                "MANIFEST.in",
                "include *.py".encode()),  # Make sure setup.py is included.
        ]))

    chroot_digest = await Get[Digest](DirectoriesToMerge(
        (src_digest, extra_files_digest)))
    return SetupPyChroot(chroot_digest, json.dumps(setup_kwargs,
                                                   sort_keys=True))
Ejemplo n.º 4
0
def test_distutils_repr() -> None:
    assert expected == distutils_repr(testdata)