| # Copyright 2017 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| from . import build_platform |
| from . import source |
| from . import util |
| |
| from .builder import Builder, BuildPackageFromPyPiWheel, BuildPackageFromSource |
| |
| from .build_types import Spec |
| |
| |
| class ConditionalWheel(Builder): |
| """Builds a wheel selected based on different conditions. |
| |
| ConditionalWheel can help user select wheel based on platform without |
| match_tag |
| |
| Args: |
| name (str): The name of the conditional wheel. |
| version (str): The conditional wheel version. Note there is no |
| patch_version for ConditionalWheel, as the bundle wheel version |
| can be set to any value we like. |
| select_fn (Callable[[System, Wheel], Wheel]): A function select the wheel |
| to be built. |
| pyversions (iterable or None): The list of "python" wheel fields (see |
| "Wheel.pyversion_str"). If None, a default Python version will be |
| used. |
| default (bool): If true, the wheel will be built by default. |
| only_plat: (See Builder's "only_plat" argument.) |
| skip_plat: (See Builder's "skip_plat" argument.) |
| patch_version (str or None): If set, this string is appended to the CIPD |
| version tag, for example if set to 'chromium.1', the version tag |
| for version 1.2.3 of the wheel would be 'version:1.2.3.chromium.1'. |
| """ |
| |
| def __init__(self, |
| name, |
| version, |
| select_fn, |
| pyversions=None, |
| only_plat=None, |
| skip_plat=None, |
| default=True, |
| patch_version=None): |
| self._select_fn = select_fn |
| version_suffix = '.' + patch_version if patch_version else None |
| super(ConditionalWheel, self).__init__( |
| Spec( |
| name, |
| version, |
| universal=False, |
| pyversions=pyversions, |
| default=default, |
| version_suffix=version_suffix), |
| only_plat=only_plat, |
| skip_plat=skip_plat) |
| |
| def build_fn(self, system, wheel, output_dir): |
| b = self._select_fn(system, wheel) |
| w = b.wheel(system, wheel.plat) |
| return b.build_wheel(w, system, output_dir, rebuild=True) |
| |
| |
| class SourceOrPrebuilt(Builder): |
| |
| def __init__(self, |
| name, |
| version, |
| pyversions=None, |
| default=True, |
| patches=(), |
| patch_base=None, |
| patch_version=None, |
| build_deps=None, |
| tpp_libs_cb=None, |
| tpp_tools=None, |
| src_filter=None, |
| skip_auditwheel=False, |
| **kwargs): |
| """General-purpose wheel builder. |
| |
| If the wheel is "packaged" (see arg for description), it is expected that it |
| is resident in PyPi and will be downloaded; otherwise, it will be built from |
| source. |
| |
| Args: |
| name (str): The wheel name. |
| version (str): The wheel version. |
| pyversions (iterable or None): The list of "python" wheel fields (see |
| "Wheel.pyversion_str"). If None, a default Python version will be |
| used. |
| default (bool): If true, the wheel will be built by default. |
| patches (tuple): Short patch names to apply to the source tree. |
| patch_base (str or None): Optionally override the base names for patches. |
| patch_version (str or None): If set, this string is appended to the CIPD |
| version tag, for example if set to 'chromium.1', the version tag |
| for version 1.2.3 of the wheel would be 'version:1.2.3.chromium.1'. |
| build_deps (dockerbuild.builder.BuildDependencies|None): Dependencies |
| required to build the wheel. |
| tpp_libs_cb (Callable[[Wheel], List[builder.TppLib]]|None): Callback that |
| returns 3pp libraries to install in the build environment. |
| tpp_tools (List[builder.TppTool]|None): 3pp tools (for the build platform) |
| which are needed to build the wheel. |
| src_filter (Callable[[str], bool]): Filtering files from the source. This |
| is a workaround for python < 3.6 on Windows to prevent failure caused |
| by 260 path length limit. |
| skip_auditwheel (bool): If True, do not run 'auditwheel' tool to fix up |
| manylinux wheel library dependencies. This option may be necessary |
| if the generated wheel does not contain any compiled code, since |
| this causes a hard error from auditwheel. |
| packaged (iterable or None): The names of platforms that have this wheel |
| available via PyPi. If None, a default set of packaged wheels will be |
| generated based on standard PyPi expectations, encoded with each |
| Platform's "packaged" property. |
| env_cb (Callable[[Wheel], Dict[str, str]]|None): Envvars to set when |
| building the wheel from source. The Wheel object is received as an |
| argument. |
| kwargs: Keyword arguments forwarded to Builder. |
| """ |
| self._pypi_src = source.pypi_sdist( |
| name, version, patches=patches, patch_base=patch_base) |
| self._packaged = set( |
| kwargs.pop('packaged', (p.name for p in build_platform.PACKAGED))) |
| self._build_deps = build_deps |
| self._tpp_libs_cb = tpp_libs_cb |
| self._tpp_tools = tpp_tools |
| self._src_filter = src_filter |
| self._skip_auditwheel = skip_auditwheel |
| self._env_cb = kwargs.pop('env_cb', None) |
| version_suffix = '.' + patch_version if patch_version else None |
| spec = Spec( |
| name, |
| self._pypi_src.version, |
| universal=False, |
| pyversions=pyversions, |
| default=default, |
| version_suffix=version_suffix) |
| |
| for p in self._packaged: |
| assert p in build_platform.NAMES, ( |
| "Wheel %r has invalid platform %s in packaged" % (spec, p)) |
| |
| super(SourceOrPrebuilt, self).__init__(spec, **kwargs) |
| |
| def build_fn(self, system, wheel, output_dir): |
| if wheel.plat.name in self._packaged: |
| return BuildPackageFromPyPiWheel(system, wheel, output_dir) |
| wheel_env = self._env_cb(wheel) if self._env_cb else None |
| tpp_libs = self._tpp_libs_cb(wheel) if self._tpp_libs_cb else None |
| return BuildPackageFromSource(system, wheel, self._pypi_src, output_dir, |
| self._src_filter, self._build_deps, tpp_libs, |
| self._tpp_tools, wheel_env, |
| self._skip_auditwheel) |
| |
| |
| class MultiWheel(Builder): |
| |
| def __init__(self, |
| name, |
| version, |
| wheels, |
| pyversions=None, |
| only_plat=None, |
| skip_plat=None, |
| default=True, |
| patch_version=None): |
| """Builds a wheel consisting of multiple other wheels. |
| |
| Bundles can be useful when a user always wants a common set of packages. |
| |
| Args: |
| name (str): The name of the bundle wheel. |
| version (str): The bundle wheel version. Note there is no patch_version |
| for MultiWheels, as the bundle wheel version can be set to any value |
| we like. |
| wheels (iterable): A set of embedded wheel rules to add to the bundle. |
| pyversions (iterable or None): The list of "python" wheel fields (see |
| "Wheel.pyversion_str"). If None, a default Python version will be |
| used. |
| default (bool): If true, the wheel will be built by default. |
| only_plat: (See Builder's "only_plat" argument.) |
| skip_plat: (See Builder's "skip_plat" argument.) |
| patch_version (str or None): If set, this string is appended to the CIPD |
| version tag, for example if set to 'chromium.1', the version tag |
| for version 1.2.3 of the wheel would be 'version:1.2.3.chromium.1'. |
| """ |
| self._wheels = wheels |
| version_suffix = '.' + patch_version if patch_version else None |
| super(MultiWheel, self).__init__( |
| Spec( |
| name, |
| version, |
| universal=False, |
| pyversions=pyversions, |
| default=default, |
| version_suffix=version_suffix), |
| only_plat=only_plat, |
| skip_plat=skip_plat) |
| |
| def build_fn(self, system, wheel, output_dir): |
| sub_wheels = [] |
| for w in self._wheels: |
| subwheel_plat = ( |
| build_platform.ALL[build_platform.UNIVERSAL[0]] |
| if w.spec.universal else wheel.plat) |
| sub_wheel = w.wheel(system, subwheel_plat) |
| util.LOGGER.info('Building sub-wheel: %s', sub_wheel) |
| # Any time the MultiWheel is built, rebuild all the subwheels. |
| sub_wheels += w.build_wheel(sub_wheel, system, output_dir, rebuild=True) |
| return sub_wheels |
| |
| |
| class Prebuilt(Builder): |
| """Wheel builder for prepared wheels that must be downloaded from PyPi. |
| |
| Args: |
| name (str): The wheel name. |
| version (str): The wheel version. |
| only_plat: (See Builder's "only_plat" argument.) |
| pyversions (iterable or None): The list of "python" wheel fields (see |
| "Wheel.pyversion_str"). If None, a default Python version will be |
| used. |
| default (bool): If true, the wheel will be built by default. |
| kwargs: Keyword arguments forwarded to Builder. |
| """ |
| |
| def __init__(self, |
| name, |
| version, |
| only_plat, |
| pyversions=None, |
| default=True, |
| **kwargs): |
| kwargs['only_plat'] = only_plat |
| super(Prebuilt, self).__init__( |
| Spec( |
| name, |
| version, |
| universal=False, |
| pyversions=pyversions, |
| default=default, |
| version_suffix=None), **kwargs) |
| |
| def build_fn(self, system, wheel, output_dir): |
| return BuildPackageFromPyPiWheel(system, wheel, output_dir) |
| |
| |
| class Universal(Builder): |
| |
| def __init__(self, name, version, pyversions=None, default=True, **kwargs): |
| """Universal wheel version of SourceOrPrebuilt. |
| |
| Args: |
| name (str): The wheel name. |
| version (str): The wheel version. |
| pyversions (iterable or None): The list of "python" wheel fields (see |
| "Wheel.pyversion_str"). If None, a default Python version will be |
| used. |
| kwargs: Keyword arguments forwarded to Builder. |
| """ |
| super(Universal, self).__init__( |
| Spec( |
| name, |
| version, |
| universal=True, |
| pyversions=pyversions, |
| default=default, |
| version_suffix=None, |
| ), **kwargs) |
| |
| def build_fn(self, system, wheel, output_dir): |
| return BuildPackageFromPyPiWheel(system, wheel, output_dir) |
| |
| |
| class UniversalSource(Builder): |
| |
| def __init__(self, |
| name, |
| pypi_version, |
| pyversions=None, |
| pypi_name=None, |
| patches=(), |
| patch_base=None, |
| patch_version=None, |
| **kwargs): |
| """Universal wheel version of SourceOrPrebuilt that always builds from |
| source. |
| |
| Args: |
| name (str): The wheel name. |
| version (str): The wheel version. |
| pyversions (iterable or None): The list of "python" wheel fields (see |
| "Wheel.pyversion_str"). If None, a default Python version will be |
| used. |
| pypi_name (str or None): Name of the package in PyPi. This can be useful |
| when translating between the CIPD package name (uses underscores) and |
| the PyPi package name (may use hyphens). |
| patches (tuple): Short patch names to apply to the source tree. |
| patch_base (str or None): Optionally override the base name for patches. |
| patch_version (str or None): If set, this string is appended to the CIPD |
| version tag, for example if set to 'chromium.1', the version tag |
| for version 1.2.3 of the wheel would be 'version:1.2.3.chromium.1'. |
| May not be used in combination with 'patches', since 'patches' |
| already appends a hash of the patches to the version. |
| kwargs: Keyword arguments forwarded to Builder. |
| |
| Returns (Builder): A configured Builder for the specified wheel. |
| """ |
| self._pypi_src = source.pypi_sdist( |
| name=pypi_name or name, |
| version=pypi_version, |
| patches=patches, |
| patch_base=patch_base) |
| if patches: |
| if patch_version: |
| raise ValueError('patches and patch_version may not be used together.') |
| # For backward compatibility. |
| version_suffix = '-' + self._pypi_src.patches_hash |
| elif patch_version: |
| version_suffix = '.' + patch_version |
| else: |
| version_suffix = None |
| super(UniversalSource, self).__init__( |
| Spec( |
| name, |
| self._pypi_src.version, |
| universal=True, |
| pyversions=pyversions, |
| default=True, |
| version_suffix=version_suffix, |
| ), **kwargs) |
| |
| def build_fn(self, system, wheel, output_dir): |
| return BuildPackageFromSource(system, wheel, self._pypi_src, output_dir) |
| |
| def md_data_fn(self): |
| if not self._pypi_src.patches: |
| return [] |
| |
| return ['\n* custom patches: %s' % (', '.join(self._pypi_src.patches),)] |
| |
| |
| class GitUniversalSource(Builder): |
| |
| def __init__(self, |
| name, |
| version, |
| git_repo, |
| git_commit, |
| setup_path='', |
| **kwargs): |
| """Version of UniversalSource that always builds a Universal wheel |
| from a git repo source rather than pypi.org. |
| |
| Args: |
| name (str): The wheel name. |
| version (str): The wheel version. |
| git_repo (str): The git repository to fetch. |
| git_commit (str): The commit or tag to fetch. |
| setup_path (str): The repository-relative path to setup.py. |
| kwargs: Keyword arguments forwarded to Builder. |
| |
| Returns (Builder): A configured Builder for the specified wheel. |
| """ |
| self._git_repo = git_repo |
| self._git_commit = git_commit |
| self._setup_path = setup_path |
| super(GitUniversalSource, self).__init__( |
| Spec( |
| name, |
| version, |
| universal=True, |
| pyversions=['py3'], |
| default=True, |
| version_suffix=None, |
| ), **kwargs) |
| |
| def build_fn(self, system, wheel, output_dir): |
| return BuildPackageFromSource( |
| system, wheel, |
| source.git_source( |
| self.spec.name, self.spec.version, |
| source.GitSource(system, self._git_repo, self._git_commit, |
| self._setup_path, self.spec.name)), output_dir) |
