# Copyright 2018 The Bazel Authors. All rights reserved.

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

# http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

import argparse

import base64

import collections

import hashlib

import os

import os.path

import re

import sys

import zipfile

def commonpath(path1, path2):

ret = []

for a, b in zip(path1.split(os.path.sep), path2.split(os.path.sep)):

if a != b:

break

ret.append(a)

return os.path.sep.join(ret)

def escape_filename_segment(segment):

"""Escapes a filename segment per https://www.python.org/dev/peps/pep-0427/#escaping-and-unicode"""

return re.sub(r"[^\w\d.]+", "_", segment, re.UNICODE)

class WheelMaker(object):

def __init__(self, name, version, build_tag, python_tag, abi, platform,

outfile=None, strip_path_prefixes=None):

self._name = name

self._version = version

self._build_tag = build_tag

self._python_tag = python_tag

self._abi = abi

self._platform = platform

self._outfile = outfile

self._strip_path_prefixes = strip_path_prefixes if strip_path_prefixes is not None else []

self._distinfo_dir = (escape_filename_segment(self._name) + '-' +

escape_filename_segment(self._version) +

'.dist-info/')

self._zipfile = None

self._record = []

def __enter__(self):

self._zipfile = zipfile.ZipFile(self.filename(), mode="w",

compression=zipfile.ZIP_DEFLATED)

return self

def __exit__(self, type, value, traceback):

self._zipfile.close()

self._zipfile = None

def filename(self):

if self._outfile:

return self._outfile

components = [self._name, self._version]

if self._build_tag:

components.append(self._build_tag)

components += [self._python_tag, self._abi, self._platform]

return '-'.join(components) + '.whl'

def disttags(self):

return ['-'.join([self._python_tag, self._abi, self._platform])]

def distinfo_path(self, basename):

return self._distinfo_dir + basename

def _serialize_digest(self, hash):

# https://www.python.org/dev/peps/pep-0376/#record

# "base64.urlsafe_b64encode(digest) with trailing = removed"

digest = base64.urlsafe_b64encode(hash.digest())

digest = b'sha256=' + digest.rstrip(b'=')

return digest

def add_string(self, filename, contents):

"""Add given 'contents' as filename to the distribution."""

if sys.version_info[0] > 2 and isinstance(contents, str):

contents = contents.encode('utf-8', 'surrogateescape')

self._zipfile.writestr(filename, contents)

hash = hashlib.sha256()

hash.update(contents)

self._add_to_record(filename, self._serialize_digest(hash),

len(contents))

def add_file(self, package_filename, real_filename):

"""Add given file to the distribution."""

def arcname_from(name):

# Always use unix path separators.

normalized_arcname = name.replace(os.path.sep, '/')

for prefix in self._strip_path_prefixes:

if normalized_arcname.startswith(prefix):

return normalized_arcname[len(prefix):]

return normalized_arcname

if os.path.isdir(real_filename):

directory_contents = os.listdir(real_filename)

for file_ in directory_contents:

self.add_file("{}/{}".format(package_filename, file_),

"{}/{}".format(real_filename, file_))

return

arcname = arcname_from(package_filename)

self._zipfile.write(real_filename, arcname=arcname)

# Find the hash and length

hash = hashlib.sha256()

size = 0

with open(real_filename, 'rb') as f:

while True:

block = f.read(2 ** 20)

if not block:

break

hash.update(block)

size += len(block)

self._add_to_record(arcname, self._serialize_digest(hash), size)

def add_wheelfile(self):

"""Write WHEEL file to the distribution"""

# TODO(pstradomski): Support non-purelib wheels.

wheel_contents = """\

Wheel-Version: 1.0

Generator: bazel-wheelmaker 1.0

Root-Is-Purelib: {}

""".format("true" if self._platform == "any" else "false")

for tag in self.disttags():

wheel_contents += "Tag: %s\n" % tag

self.add_string(self.distinfo_path('WHEEL'), wheel_contents)

def add_metadata(self, extra_headers, description, classifiers, python_requires,

requires, extra_requires):

"""Write METADATA file to the distribution."""

# https://www.python.org/dev/peps/pep-0566/

# https://packaging.python.org/specifications/core-metadata/

metadata = []

metadata.append("Metadata-Version: 2.1")

metadata.append("Name: %s" % self._name)

metadata.append("Version: %s" % self._version)

metadata.extend(extra_headers)

for classifier in classifiers:

metadata.append("Classifier: %s" % classifier)

if python_requires:

metadata.append("Requires-Python: %s" % python_requires)

for requirement in requires:

metadata.append("Requires-Dist: %s" % requirement)

extra_requires = sorted(extra_requires.items())

for option, option_requires in extra_requires:

metadata.append("Provides-Extra: %s" % option)

for requirement in option_requires:

metadata.append(

"Requires-Dist: %s; extra == '%s'" % (requirement, option))

metadata = '\n'.join(metadata) + '\n\n'

# setuptools seems to insert UNKNOWN as description when none is

# provided.

metadata += description if description else "UNKNOWN"

metadata += "\n"

self.add_string(self.distinfo_path('METADATA'), metadata)

def add_recordfile(self):

"""Write RECORD file to the distribution."""

record_path = self.distinfo_path('RECORD')

entries = self._record + [(record_path, b'', b'')]

entries.sort()

contents = b''

for filename, digest, size in entries:

if sys.version_info[0] > 2 and isinstance(filename, str):

filename = filename.encode('utf-8', 'surrogateescape')

contents += b'%s,%s,%s\n' % (filename, digest, size)

self.add_string(record_path, contents)

def _add_to_record(self, filename, hash, size):

size = str(size).encode('ascii')

self._record.append((filename, hash, size))

def get_files_to_package(input_files):

"""Find files to be added to the distribution.

input_files: list of pairs (package_path, real_path)

"""

files = {}

for package_path, real_path in input_files:

files[package_path] = real_path

return files

def main():

parser = argparse.ArgumentParser(description='Builds a python wheel')

metadata_group = parser.add_argument_group(

"Wheel name, version and platform")

metadata_group.add_argument('--name', required=True,

type=str,

help="Name of the distribution")

metadata_group.add_argument('--version', required=True,

type=str,

help="Version of the distribution")

metadata_group.add_argument('--build_tag', type=str, default='',

help="Optional build tag for the distribution")

metadata_group.add_argument('--python_tag', type=str, default='py3',

help="Python version, e.g. 'py2' or 'py3'")

metadata_group.add_argument('--abi', type=str, default='none')

metadata_group.add_argument('--platform', type=str, default='any',

help="Target platform. ")

output_group = parser.add_argument_group("Output file location")

output_group.add_argument('--out', type=str, default=None,

help="Override name of ouptut file")

output_group.add_argument('--strip_path_prefix',

type=str,

action="append",

default=[],

help="Path prefix to be stripped from input package files' path. "

"Can be supplied multiple times. "

"Evaluated in order."

)

wheel_group = parser.add_argument_group("Wheel metadata")

wheel_group.add_argument(

'--header', action='append',

help="Additional headers to be embedded in the package metadata. "

"Can be supplied multiple times.")

wheel_group.add_argument('--classifier', action='append',

help="Classifiers to embed in package metadata. "

"Can be supplied multiple times")

wheel_group.add_argument('--python_requires',

help="Version of python that the wheel will work with")

wheel_group.add_argument('--description_file',

help="Path to the file with package description")

wheel_group.add_argument('--entry_points_file',

help="Path to a correctly-formatted entry_points.txt file")

contents_group = parser.add_argument_group("Wheel contents")

contents_group.add_argument(

'--input_file', action='append',

help="'package_path;real_path' pairs listing "

"files to be included in the wheel. "

"Can be supplied multiple times.")

contents_group.add_argument(

'--input_file_list', action='append',

help='A file that has all the input files defined as a list to avoid the long command'

)

requirements_group = parser.add_argument_group("Package requirements")

requirements_group.add_argument(

'--requires', type=str, action='append',

help="List of package requirements. Can be supplied multiple times.")

requirements_group.add_argument(

'--extra_requires', type=str, action='append',

help="List of optional requirements in a 'requirement;option name'. "

"Can be supplied multiple times.")

arguments = parser.parse_args(sys.argv[1:])

if arguments.input_file:

input_files = [i.split(';') for i in arguments.input_file]

else:

input_files = []

if arguments.input_file_list:

for input_file in arguments.input_file_list:

with open(input_file) as _file:

input_file_list = _file.read().splitlines()

for _input_file in input_file_list:

input_files.append(_input_file.split(';'))

all_files = get_files_to_package(input_files)

# Sort the files for reproducible order in the archive.

all_files = sorted(all_files.items())

strip_prefixes = [p for p in arguments.strip_path_prefix]

with WheelMaker(name=arguments.name,

version=arguments.version,

build_tag=arguments.build_tag,

python_tag=arguments.python_tag,

abi=arguments.abi,

platform=arguments.platform,

outfile=arguments.out,

strip_path_prefixes=strip_prefixes

) as maker:

for package_filename, real_filename in all_files:

maker.add_file(package_filename, real_filename)

maker.add_wheelfile()

description = None

if arguments.description_file:

if sys.version_info[0] == 2:

with open(arguments.description_file,

'rt') as description_file:

description = description_file.read()

else:

with open(arguments.description_file, 'rt',

encoding='utf-8') as description_file:

description = description_file.read()

extra_requires = collections.defaultdict(list)

if arguments.extra_requires:

for extra in arguments.extra_requires:

req, option = extra.rsplit(';', 1)

extra_requires[option].append(req)

classifiers = arguments.classifier or []

python_requires = arguments.python_requires or ""

requires = arguments.requires or []

extra_headers = arguments.header or []

maker.add_metadata(extra_headers=extra_headers,

description=description,

classifiers=classifiers,

python_requires=python_requires,

requires=requires,

extra_requires=extra_requires)

if arguments.entry_points_file:

maker.add_file(maker.distinfo_path(

"entry_points.txt"), arguments.entry_points_file)

maker.add_recordfile()

if __name__ == '__main__':

main()