user_options = [

("version=", None, "ots source version number to download"),

("sha256=", None, "expected SHA-256 hash of the source archive"),

("download-dir=", "d", "where to unpack the 'ots' dir (default: src/c)"),

("clean", None, "remove existing directory before downloading"),

]

boolean_options = ["clean"]

URL_TEMPLATE = (

"https://github.com/khaledhosny/ots/releases/download/"

"v{version}/ots-{version}.tar.xz"

)

def initialize_options(self):

self.version = None

self.download_dir = None

self.clean = False

self.sha256 = None

def finalize_options(self):

if self.version is None:

from distutils.errors import DistutilsSetupError

raise DistutilsSetupError("must specify --version to download")

if self.sha256 is None:

from distutils.errors import DistutilsSetupError

raise DistutilsSetupError("must specify --sha256 of downloaded file")

if self.download_dir is None:

self.download_dir = os.path.join("src", "c")

self.url = self.URL_TEMPLATE.format(**vars(self))

def run(self):

from urllib.request import urlopen

from io import BytesIO

import tarfile

import lzma

import hashlib

output_dir = os.path.join(self.download_dir, "ots")

if self.clean and os.path.isdir(output_dir):

remove_tree(output_dir, verbose=self.verbose, dry_run=self.dry_run)

if os.path.isdir(output_dir):

log.info("{} was already downloaded".format(output_dir))

else:

archive_name = self.url.rsplit("/", 1)[-1]

mkpath(self.download_dir, verbose=self.verbose, dry_run=self.dry_run)

log.info("downloading {}".format(self.url))

if not self.dry_run:

# response is not seekable so we first download *.tar.xz to an

# in-memory file, and then extract all files to the output_dir

# TODO: use hashlib to verify the SHA-256 hash

f = BytesIO()

with urlopen(self.url) as response:

f.write(response.read())

f.seek(0)

actual_sha256 = hashlib.sha256(f.getvalue()).hexdigest()

if actual_sha256 != self.sha256:

from distutils.errors import DistutilsSetupError

raise DistutilsSetupError(

"invalid SHA-256 checksum:\n"

"actual: {}\n"

"expected: {}".format(actual_sha256, self.sha256)

)

log.info("unarchiving {} to {}".format(archive_name, output_dir))

if not self.dry_run:

with lzma.open(f) as xz:

with tarfile.open(fileobj=xz) as tar:

filelist = tar.getmembers()

first = filelist[0]

if not (first.isdir() and first.name.startswith("ots")):

from distutils.errors import DistutilsSetupError

raise DistutilsSetupError(

"The downloaded archive is not recognized as "

"a valid ots source tarball"

)

# strip the root 'ots-X.X.X' directory before extracting

rootdir = first.name "/"

to_extract = []

for member in filelist[1:]:

if member.name.startswith(rootdir):

member.name = member.name[len(rootdir) :]

to_extract.append(member)

if os.name == "nt":

suffix = ".exe"

else:

suffix = ""

def __init__(self, name, script, options=None, output_dir=".", cwd=None, env=None):

Extension.__init__(self, name, sources=[])

self.target = self.name.split(".")[-1] self.suffix

self.script = script

self.options = options or []

self.output_dir = output_dir

self.cwd = cwd

def finalize_options(self):

from distutils.ccompiler import get_default_compiler

build_ext.finalize_options(self)

if self.compiler is None:

self.compiler = get_default_compiler(os.name)

self._compiler_env = dict(os.environ)

def get_ext_filename(self, ext_name):

for ext in self.extensions:

if isinstance(ext, Executable):

return os.path.join(*ext_name.split(".")) ext.suffix

return build_ext.get_ext_filename(self, ext_name)

def run(self):

self.run_command("download")

if self.compiler == "msvc":

self.call_vcvarsall_bat()

build_ext.run(self)

def call_vcvarsall_bat(self):

import struct

from distutils._msvccompiler import _get_vc_env

arch = "x64" if struct.calcsize("P") * 8 == 64 else "x86"

vc_env = _get_vc_env(arch)

self._compiler_env.update(vc_env)

def build_extension(self, ext):

if not isinstance(ext, Executable):

build_ext.build_extension(self, ext)

return

cmd = [sys.executable, ext.script] ext.options [ext.target]

if self.force:

cmd = ["--force"]

log.debug("running '{}'".format(" ".join(cmd)))

if not self.dry_run:

env = self._compiler_env.copy()

if ext.env:

env.update(ext.env)

p = subprocess.run(cmd, cwd=ext.cwd, env=env)

if p.returncode != 0:

from distutils.errors import DistutilsExecError

raise DistutilsExecError(

"running '{}' script failed".format(ext.script)

)

exe_fullpath = os.path.join(ext.output_dir, ext.target)

dest_path = self.get_ext_fullpath(ext.name)

mkpath(os.path.dirname(dest_path), verbose=self.verbose, dry_run=self.dry_run)

def run(self):

# make sure the ots source is downloaded before creating sdist manifest

self.run_command("download")

"ots.ots-sanitize",

script="build.py",

options=build_options,

output_dir=os.path.join("build", "meson"),