setup.py

#!/usr/bin/env python
#
# Script to build and install Python-bindings.
# Version: 20211115

from __future__ import print_function

import copy
import glob
import gzip
import platform
import os
import shlex
import shutil
import subprocess
import sys
import tarfile

from distutils.ccompiler import new_compiler

from setuptools import Extension
from setuptools import setup
from setuptools.command.build_ext import build_ext
from setuptools.command.sdist import sdist

try:
  from distutils.command.bdist_msi import bdist_msi
except ImportError:
  bdist_msi = None

try:
  from setuptools.command.bdist_rpm import bdist_rpm
except ImportError:
  from distutils.command.bdist import bdist as bdist_rpm


if not bdist_msi:
  custom_bdist_msi = None
else:
  class custom_bdist_msi(bdist_msi):
    """Custom handler for the bdist_msi command."""

    def run(self):
      """Builds an MSI."""
      # Make a deepcopy of distribution so the following version changes
      # only apply to bdist_msi.
      self.distribution = copy.deepcopy(self.distribution)

      # bdist_msi does not support the library version so we add ".1"
      # as a work around.
      self.distribution.metadata.version = "{0:s}.1".format(
          self.distribution.metadata.version)

      bdist_msi.run(self)


class custom_bdist_rpm(bdist_rpm):
  """Custom handler for the bdist_rpm command."""

  def run(self):
    """Builds a RPM."""
    print("'setup.py bdist_rpm' command not supported use 'rpmbuild' instead.")
    sys.exit(1)


class custom_build_ext(build_ext):
  """Custom handler for the build_ext command."""

  def _RunCommand(self, command):
    """Runs the command."""
    arguments = shlex.split(command)
    process = subprocess.Popen(
        arguments, stderr=subprocess.PIPE, stdout=subprocess.PIPE,
        universal_newlines=True)
    if not process:
      raise RuntimeError("Running: {0:s} failed.".format(command))

    output, error = process.communicate()
    if process.returncode != 0:
      error = "\n".join(error.split("\n")[-5:])
      raise RuntimeError("Running: {0:s} failed with error:\n{1:s}.".format(
          command, error))

    return output

  def build_extensions(self):
    """Set up the build extensions."""
    # TODO: move build customization here?
    build_ext.build_extensions(self)

  def run(self):
    """Runs the build extension."""
    compiler = new_compiler(compiler=self.compiler)
    if compiler.compiler_type == "msvc":
      self.define = [
          ("UNICODE", ""),
      ]

    else:
      command = "sh configure --disable-shared-libs"
      output = self._RunCommand(command)

      print_line = False
      for line in output.split("\n"):
        line = line.rstrip()
        if line == "configure:":
          print_line = True

        if print_line:
          print(line)

      self.define = [
          ("HAVE_CONFIG_H", ""),
          ("LOCALEDIR", "\"/usr/share/locale\""),
      ]

    build_ext.run(self)


class custom_sdist(sdist):
  """Custom handler for the sdist command."""

  def run(self):
    """Builds a source distribution (sdist) package."""
    if self.formats != ["gztar"]:
      print("'setup.py sdist' unsupported format.")
      sys.exit(1)

    if glob.glob("*.tar.gz"):
      print("'setup.py sdist' remove existing *.tar.gz files from "
            "source directory.")
      sys.exit(1)

    command = "make dist"
    exit_code = subprocess.call(command, shell=True)
    if exit_code != 0:
      raise RuntimeError("Running: {0:s} failed.".format(command))

    if not os.path.exists("dist"):
      os.mkdir("dist")

    source_package_file = glob.glob("*.tar.gz")[0]
    source_package_prefix, _, source_package_suffix = (
        source_package_file.partition("-"))
    sdist_package_file = "{0:s}-python-{1:s}".format(
        source_package_prefix, source_package_suffix)
    sdist_package_file = os.path.join("dist", sdist_package_file)
    os.rename(source_package_file, sdist_package_file)

    # Create and add the PKG-INFO file to the source package.
    with gzip.open(sdist_package_file, 'rb') as input_file:
      with open(sdist_package_file[:-3], 'wb') as output_file:
        shutil.copyfileobj(input_file, output_file)
    os.remove(sdist_package_file)

    self.distribution.metadata.write_pkg_info(".")
    pkg_info_path = "{0:s}-{1:s}/PKG-INFO".format(
        source_package_prefix, source_package_suffix[:-7])
    with tarfile.open(sdist_package_file[:-3], "a:") as tar_file:
      tar_file.add("PKG-INFO", arcname=pkg_info_path)
    os.remove("PKG-INFO")

    with open(sdist_package_file[:-3], 'rb') as input_file:
      with gzip.open(sdist_package_file, 'wb') as output_file:
        shutil.copyfileobj(input_file, output_file)
    os.remove(sdist_package_file[:-3])

    # Inform distutils what files were created.
    dist_files = getattr(self.distribution, "dist_files", [])
    dist_files.append(("sdist", "", sdist_package_file))


class ProjectInformation(object):
  """Project information."""

  def __init__(self):
    """Initializes project information."""
    super(ProjectInformation, self).__init__()
    self.include_directories = []
    self.library_name = None
    self.library_names = []
    self.library_version = None

    self._ReadConfigureAc()
    self._ReadMakefileAm()

  @property
  def module_name(self):
    """The Python module name."""
    return "py{0:s}".format(self.library_name[3:])

  @property
  def package_name(self):
    """The package name."""
    return "{0:s}-python".format(self.library_name)

  @property
  def package_description(self):
    """The package description."""
    return "Python bindings module for {0:s}".format(self.library_name)

  @property
  def project_url(self):
    """The project URL."""
    return "https://github.com/libyal/{0:s}/".format(self.library_name)

  def _ReadConfigureAc(self):
    """Reads configure.ac to initialize the project information."""
    file_object = open("configure.ac", "rb")
    if not file_object:
      raise IOError("Unable to open: configure.ac")

    found_ac_init = False
    found_library_name = False
    for line in file_object.readlines():
      line = line.strip()
      if found_library_name:
        library_version = line[1:-2]
        if sys.version_info[0] >= 3:
          library_version = library_version.decode("ascii")
        self.library_version = library_version
        break

      elif found_ac_init:
        library_name = line[1:-2]
        if sys.version_info[0] >= 3:
          library_name = library_name.decode("ascii")
        self.library_name = library_name
        found_library_name = True

      elif line.startswith(b"AC_INIT"):
        found_ac_init = True

    file_object.close()

    if not self.library_name or not self.library_version:
      raise RuntimeError(
          "Unable to find library name and version in: configure.ac")

  def _ReadMakefileAm(self):
    """Reads Makefile.am to initialize the project information."""
    if not self.library_name:
      raise RuntimeError("Missing library name")

    file_object = open("Makefile.am", "rb")
    if not file_object:
      raise IOError("Unable to open: Makefile.am")

    found_subdirs = False
    for line in file_object.readlines():
      line = line.strip()
      if found_subdirs:
        library_name, _, _ = line.partition(b" ")
        if sys.version_info[0] >= 3:
          library_name = library_name.decode("ascii")

        self.include_directories.append(library_name)

        if library_name.startswith("lib"):
          self.library_names.append(library_name)

        if library_name == self.library_name:
          break

      elif line.startswith(b"SUBDIRS"):
        found_subdirs = True

    file_object.close()

    if not self.include_directories or not self.library_names:
      raise RuntimeError(
          "Unable to find include directories and library names in: "
          "Makefile.am")


project_information = ProjectInformation()

CMDCLASS = {
  "build_ext": custom_build_ext,
  "bdist_rpm": custom_bdist_rpm,
  "sdist": custom_sdist}

if custom_bdist_msi:
  CMDCLASS["bdist_msi"] = custom_bdist_msi

SOURCES = []

# TODO: replace by detection of MSC
DEFINE_MACROS = []
if platform.system() == "Windows":
  DEFINE_MACROS.append(("WINVER", "0x0501"))
  # TODO: determine how to handle third party DLLs.
  for library_name in project_information.library_names:
    if library_name != project_information.library_name:
      definition = "HAVE_LOCAL_{0:s}".format(library_name.upper())

    DEFINE_MACROS.append((definition, ""))

# Put everything inside the Python module to prevent issues with finding
# shared libaries since pip does not integrate well with the system package
# management.
for library_name in project_information.library_names:
  for source_file in glob.glob(os.path.join(library_name, "*.[ly]")):
    generated_source_file = "{0:s}.c".format(source_file[:-2])
    if not os.path.exists(generated_source_file):
      raise RuntimeError("Missing generated source file: {0:s}".format(
          generated_source_file))

  source_files = glob.glob(os.path.join(library_name, "*.c"))
  SOURCES.extend(source_files)

source_files = glob.glob(os.path.join(project_information.module_name, "*.c"))
SOURCES.extend(source_files)

# TODO: find a way to detect missing python.h
# e.g. on Ubuntu python-dev is not installed by python-pip

# TODO: what about description and platform in egg file

setup(
    name=project_information.package_name,
    url=project_information.project_url,
    version=project_information.library_version,
    description=project_information.package_description,
    long_description=project_information.package_description,
    author="Joachim Metz",
    author_email="joachim.metz@gmail.com",
    license="GNU Lesser General Public License v3 or later (LGPLv3+)",
    cmdclass=CMDCLASS,
    ext_modules=[
        Extension(
            project_information.module_name,
            define_macros=DEFINE_MACROS,
            include_dirs=project_information.include_directories,
            libraries=[],
            library_dirs=[],
            sources=SOURCES,
        ),
    ],
)