Datasets:

introvoyz042
/

haddock3

License:

Migrated from GitHub

5631464 verified about 1 month ago

10.5 kB

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
"""Setup dot py."""

import os
import platform
import subprocess
import sys
import tarfile
from urllib.error import HTTPError, URLError
import time
import urllib.request
from pathlib import Path
from typing import cast

from setuptools import Extension, setup
from setuptools.command.build_ext import build_ext
from setuptools.command.develop import develop
from setuptools.command.install import install


HADDOCK_RESTRAINTS_VERSION = "0.10.0"
BASE_GITHUB_URL = f"https://github.com/haddocking/haddock-restraints/releases/download/v{HADDOCK_RESTRAINTS_VERSION}"
HADDOCK_RESTRAINTS_BINARIES = {
    "x86_64-linux": f"{BASE_GITHUB_URL}/haddock-restraints-v{HADDOCK_RESTRAINTS_VERSION}-x86_64-unknown-linux-musl.tar.gz",
    "x86_64-darwin": f"{BASE_GITHUB_URL}/haddock-restraints-v{HADDOCK_RESTRAINTS_VERSION}-x86_64-apple-darwin.tar.gz",
    "arm64-darwin": f"{BASE_GITHUB_URL}/haddock-restraints-v{HADDOCK_RESTRAINTS_VERSION}-aarch64-apple-darwin.tar.gz",
    "aarch64-linux": f"{BASE_GITHUB_URL}/haddock-restraints-v{HADDOCK_RESTRAINTS_VERSION}-aarch64-unknown-linux-musl.tar.gz",
}


cpp_extensions = [
    Extension(
        "haddock.bin.contact_fcc",
        sources=["src/haddock/deps/contact_fcc.cpp"],
        extra_compile_args=["-O2"],
    ),
    Extension(
        "haddock.bin.fast_rmsdmatrix",
        sources=["src/haddock/deps/fast-rmsdmatrix.c"],
        extra_compile_args=["-Wall", "-O3", "-std=c99"],
        extra_link_args=["-lm"],
    ),
]


class CustomBuild(build_ext):
    """Custom build handles the C/C++ dependencies and downloading of binaries"""

    def run(self):
        """Run the custom build"""
        print("Building HADDOCK3 C/C++ binary dependencies...")
        self.build_executable(
            name="contact_fcc",
            cmd=["g++", "-O2", "-o", "contact_fcc", "src/haddock/deps/contact_fcc.cpp"],
        )
        self.build_executable(
            name="fast-rmsdmatrix",
            cmd=[
                "gcc",
                "-Wall",
                "-O3",
                "-std=c99",
                "-o",
                "fast-rmsdmatrix",
                "src/haddock/deps/fast-rmsdmatrix.c",
                "-lm",
            ],
        )
        print("Downloading the binaries...")
        self.download_binaries()

        # Run the standard build
        build_ext.run(self)

    def build_executable(self, name, cmd):
        """Helper function to execute the build command"""
        try:
            subprocess.check_call(cmd)
            # Ensure the source bin directory exists
            src_bin_dir = Path("src", "haddock", "bin")
            src_bin_dir.mkdir(exist_ok=True, parents=True)

            # Move the built executable to the source bin directory
            src_bin_exec = Path(src_bin_dir, name)
            if src_bin_exec.exists():
                src_bin_exec.unlink()

            self.move_file(name, src_bin_exec)

            # If build_lib exists, also copy to there
            if hasattr(self, "build_lib"):
                build_bin_dir = Path(self.build_lib, "haddock", "bin")
                build_bin_dir.mkdir(exist_ok=True, parents=True)
                self.copy_file(Path(src_bin_dir, name), Path(build_bin_dir, name))

            print(f"Successfully built and moved {name}")
        except subprocess.CalledProcessError as e:
            print(f"Error building {name}: {e}")
            raise

    def download_binaries(self):
        """Helper function to download binaries"""
        arch = self.get_arch()
        binary_configs = [
            (HADDOCK_RESTRAINTS_BINARIES, Path("haddock-restraints.tar.gz")),
        ]

        # Determine the target directory
        if hasattr(self, "build_lib") and self.build_lib and not self.inplace:
            target_bin_dir = Path(self.build_lib, "haddock", "bin")
        else:
            target_bin_dir = Path("src", "haddock", "bin")

        target_bin_dir.mkdir(exist_ok=True, parents=True)

        for binary_dict, filename in binary_configs:
            if arch not in binary_dict:
                print(f"Unknown architecture: {arch}")
                sys.exit(1)
            binary_url = binary_dict[arch]

            download_path = Path(target_bin_dir, filename.name)
            status, msg = self.download_file(binary_url, download_path)
            if not status:
                print(msg)
                sys.exit(1)

            if "".join(filename.suffixes) == ".tar.gz":
                try:
                    with tarfile.open(download_path, "r:gz") as tar:
                        tar.extractall(path=target_bin_dir)
                    # Remove the compressed file
                    download_path.unlink()
                    # The executable should be the filename without .tar.gz suffixes
                    executable = Path(
                        target_bin_dir, filename.with_suffix("").with_suffix("").name
                    )
                except tarfile.TarError as e:
                    print(f"Error extracting {download_path}: {e}")
                    sys.exit(1)
            else:
                executable = download_path

            print(f"Downloaded {filename} to {executable}")

            # Make it executable
            os.chmod(executable, 0o755)

    @staticmethod
    def download_file(url, dest, max_retries=10, delay=5) -> tuple[bool, str]:
        """Download a file from a URL"""
        for attempt in range(max_retries):
            try:
                urllib.request.urlretrieve(url, dest)
                return True, "Download successful"
            except (URLError, HTTPError) as e:  # pylint: disable=broad-except
                if attempt < max_retries - 1:
                    time.sleep(delay)
                    continue
                return (
                    False,
                    f"Download of {dest} failed after {max_retries} attempts: {e} URL: {url}",
                )
            except Exception as e:  # pylint: disable=broad-except
                return False, f"Download of {dest} failed: {e} URL: {url}"
        return (
            False,
            f"Download of {dest} failed after {max_retries} attempts URL: {url}",
        )

    @staticmethod
    def get_arch():
        """Helper function to figure out the architetchure"""
        system = platform.system().lower()
        machine = platform.machine().lower()

        return f"{machine}-{system}"


class DevelopCommand(develop):
    """Custom develop command for editable installations"""

    # NOTE: This is what is performed when using `pip install -e`

    def run(self):
        # First run the standard develop command
        develop.run(self)

        # Then run our custom build steps
        build_cmd = cast(CustomBuild, self.get_finalized_command("build_ext"))
        # specify we are building in place
        build_cmd.inplace = True

        # Build the executables
        print("Building executables for editable installation...")
        build_cmd.build_executable(
            name="contact_fcc",
            cmd=["g++", "-O2", "-o", "contact_fcc", "src/haddock/deps/contact_fcc.cpp"],
        )
        build_cmd.build_executable(
            name="fast-rmsdmatrix",
            cmd=[
                "gcc",
                "-Wall",
                "-O3",
                "-march=native",
                "-std=c99",
                "-o",
                "fast-rmsdmatrix",
                "src/haddock/deps/fast-rmsdmatrix.c",
                "-lm",
            ],
        )

        # Download binaries to source directory
        print("Downloading binaries for editable installation...")
        build_cmd.download_binaries()


class PostInstallCommand(install):
    """Post-installation for installation mode."""

    # NOTE: This is only executed for the installation, for editable see `DevelopCommand`

    def run(self):
        install.run(self)
        self.check_cns_binary()

    def check_cns_binary(self):
        """Execute the CNS binary to ensure it works"""
        arch = self.get_arch()
        cns_path = Path(f"{self.install_lib}/haddock/cns/bin/{arch}.bin")
        proc = subprocess.run(
            [cns_path],
            input="stop\n",
            text=True,
            stdout=subprocess.DEVNULL,
            stderr=subprocess.DEVNULL,
        )

        if proc.returncode != 0:
            self.cns_warning()
        if proc.returncode == 0:
            self.cns_valid()

    @staticmethod
    def cns_warning():
        """Warn the user that CNS could not be executed"""
        try:
            with open("/dev/tty", "w") as tty:
                tty.write("\n" + "=" * 79 + "\n")
                tty.write("=" * 79 + "\n")
                tty.write("=" * 79 + "\n")
                tty.write(
                    "\n⚠️ WARNING: The pre-compiled CNS binary could not be executed ⚠️\n\n"
                )
                tty.write("This may be due to missing dependencies on your system.\n")
                tty.write(
                    "Please refer to the installation instructions for troubleshooting steps:\n"
                )
                tty.write(
                    "`https://github.com/haddocking/haddock3/blob/main/docs/pages/CNS.md`\n\n"
                )
                tty.write("=" * 79 + "\n")
                tty.write("=" * 79 + "\n")
                tty.write("=" * 79 + "\n")
                tty.flush()
        except Exception as _:
            # Fallback for systems without /dev/tty
            sys.stderr.write(
                "\n⚠️ WARNING: The pre-compiled CNS binary could not be executed ⚠️\n\n"
            )

    @staticmethod
    def cns_valid():
        """Write a message to the user that CNS works"""
        try:
            with open("/dev/tty", "w") as tty:
                tty.write("\n" + "=" * 79 + "\n")
                tty.write("CNS execution passed ✅ \n")
                tty.write("=" * 79 + "\n")
        except Exception as _:
            # Fallback for systems without /dev/tty
            sys.stdout.write("CNS execution passed ✅ \n")

    @staticmethod
    def get_arch():
        """Helper function to figure out the architetchure"""
        system = platform.system().lower()
        machine = platform.machine().lower()

        return f"{machine}-{system}"


setup(
    cmdclass={
        "build_ext": CustomBuild,
        "install": PostInstallCommand,
        "develop": DevelopCommand,
    },
    ext_modules=cpp_extensions,
)

	#!/usr/bin/env python
	# -- encoding: utf-8 --
	"""Setup dot py."""

	import os
	import platform
	import subprocess
	import sys
	import tarfile
	from urllib.error import HTTPError, URLError
	import time
	import urllib.request
	from pathlib import Path
	from typing import cast

	from setuptools import Extension, setup
	from setuptools.command.build_ext import build_ext
	from setuptools.command.develop import develop
	from setuptools.command.install import install


	HADDOCK_RESTRAINTS_VERSION = "0.10.0"
	BASE_GITHUB_URL = f"https://github.com/haddocking/haddock-restraints/releases/download/v{HADDOCK_RESTRAINTS_VERSION}"
	HADDOCK_RESTRAINTS_BINARIES = {
	"x86_64-linux": f"{BASE_GITHUB_URL}/haddock-restraints-v{HADDOCK_RESTRAINTS_VERSION}-x86_64-unknown-linux-musl.tar.gz",
	"x86_64-darwin": f"{BASE_GITHUB_URL}/haddock-restraints-v{HADDOCK_RESTRAINTS_VERSION}-x86_64-apple-darwin.tar.gz",
	"arm64-darwin": f"{BASE_GITHUB_URL}/haddock-restraints-v{HADDOCK_RESTRAINTS_VERSION}-aarch64-apple-darwin.tar.gz",
	"aarch64-linux": f"{BASE_GITHUB_URL}/haddock-restraints-v{HADDOCK_RESTRAINTS_VERSION}-aarch64-unknown-linux-musl.tar.gz",
	}


	cpp_extensions = [
	Extension(
	"haddock.bin.contact_fcc",
	sources=["src/haddock/deps/contact_fcc.cpp"],
	extra_compile_args=["-O2"],
	),
	Extension(
	"haddock.bin.fast_rmsdmatrix",
	sources=["src/haddock/deps/fast-rmsdmatrix.c"],
	extra_compile_args=["-Wall", "-O3", "-std=c99"],
	extra_link_args=["-lm"],
	),
	]


	class CustomBuild(build_ext):
	"""Custom build handles the C/C++ dependencies and downloading of binaries"""

	def run(self):
	"""Run the custom build"""
	print("Building HADDOCK3 C/C++ binary dependencies...")
	self.build_executable(
	name="contact_fcc",
	cmd=["g++", "-O2", "-o", "contact_fcc", "src/haddock/deps/contact_fcc.cpp"],
	)
	self.build_executable(
	name="fast-rmsdmatrix",
	cmd=[
	"gcc",
	"-Wall",
	"-O3",
	"-std=c99",
	"-o",
	"fast-rmsdmatrix",
	"src/haddock/deps/fast-rmsdmatrix.c",
	"-lm",
	],
	)
	print("Downloading the binaries...")
	self.download_binaries()

	# Run the standard build
	build_ext.run(self)

	def build_executable(self, name, cmd):
	"""Helper function to execute the build command"""
	try:
	subprocess.check_call(cmd)
	# Ensure the source bin directory exists
	src_bin_dir = Path("src", "haddock", "bin")
	src_bin_dir.mkdir(exist_ok=True, parents=True)

	# Move the built executable to the source bin directory
	src_bin_exec = Path(src_bin_dir, name)
	if src_bin_exec.exists():
	src_bin_exec.unlink()

	self.move_file(name, src_bin_exec)

	# If build_lib exists, also copy to there
	if hasattr(self, "build_lib"):
	build_bin_dir = Path(self.build_lib, "haddock", "bin")
	build_bin_dir.mkdir(exist_ok=True, parents=True)
	self.copy_file(Path(src_bin_dir, name), Path(build_bin_dir, name))

	print(f"Successfully built and moved {name}")
	except subprocess.CalledProcessError as e:
	print(f"Error building {name}: {e}")
	raise

	def download_binaries(self):
	"""Helper function to download binaries"""
	arch = self.get_arch()
	binary_configs = [
	(HADDOCK_RESTRAINTS_BINARIES, Path("haddock-restraints.tar.gz")),
	]

	# Determine the target directory
	if hasattr(self, "build_lib") and self.build_lib and not self.inplace:
	target_bin_dir = Path(self.build_lib, "haddock", "bin")
	else:
	target_bin_dir = Path("src", "haddock", "bin")

	target_bin_dir.mkdir(exist_ok=True, parents=True)

	for binary_dict, filename in binary_configs:
	if arch not in binary_dict:
	print(f"Unknown architecture: {arch}")
	sys.exit(1)
	binary_url = binary_dict[arch]

	download_path = Path(target_bin_dir, filename.name)
	status, msg = self.download_file(binary_url, download_path)
	if not status:
	print(msg)
	sys.exit(1)

	if "".join(filename.suffixes) == ".tar.gz":
	try:
	with tarfile.open(download_path, "r:gz") as tar:
	tar.extractall(path=target_bin_dir)
	# Remove the compressed file
	download_path.unlink()
	# The executable should be the filename without .tar.gz suffixes
	executable = Path(
	target_bin_dir, filename.with_suffix("").with_suffix("").name
	)
	except tarfile.TarError as e:
	print(f"Error extracting {download_path}: {e}")
	sys.exit(1)
	else:
	executable = download_path

	print(f"Downloaded {filename} to {executable}")

	# Make it executable
	os.chmod(executable, 0o755)

	@staticmethod
	def download_file(url, dest, max_retries=10, delay=5) -> tuple[bool, str]:
	"""Download a file from a URL"""
	for attempt in range(max_retries):
	try:
	urllib.request.urlretrieve(url, dest)
	return True, "Download successful"
	except (URLError, HTTPError) as e: # pylint: disable=broad-except
	if attempt < max_retries - 1:
	time.sleep(delay)
	continue
	return (
	False,
	f"Download of {dest} failed after {max_retries} attempts: {e} URL: {url}",
	)
	except Exception as e: # pylint: disable=broad-except
	return False, f"Download of {dest} failed: {e} URL: {url}"
	return (
	False,
	f"Download of {dest} failed after {max_retries} attempts URL: {url}",
	)

	@staticmethod
	def get_arch():
	"""Helper function to figure out the architetchure"""
	system = platform.system().lower()
	machine = platform.machine().lower()

	return f"{machine}-{system}"


	class DevelopCommand(develop):
	"""Custom develop command for editable installations"""

	# NOTE: This is what is performed when using `pip install -e`

	def run(self):
	# First run the standard develop command
	develop.run(self)

	# Then run our custom build steps
	build_cmd = cast(CustomBuild, self.get_finalized_command("build_ext"))
	# specify we are building in place
	build_cmd.inplace = True

	# Build the executables
	print("Building executables for editable installation...")
	build_cmd.build_executable(
	name="contact_fcc",
	cmd=["g++", "-O2", "-o", "contact_fcc", "src/haddock/deps/contact_fcc.cpp"],
	)
	build_cmd.build_executable(
	name="fast-rmsdmatrix",
	cmd=[
	"gcc",
	"-Wall",
	"-O3",
	"-march=native",
	"-std=c99",
	"-o",
	"fast-rmsdmatrix",
	"src/haddock/deps/fast-rmsdmatrix.c",
	"-lm",
	],
	)

	# Download binaries to source directory
	print("Downloading binaries for editable installation...")
	build_cmd.download_binaries()


	class PostInstallCommand(install):
	"""Post-installation for installation mode."""

	# NOTE: This is only executed for the installation, for editable see `DevelopCommand`

	def run(self):
	install.run(self)
	self.check_cns_binary()

	def check_cns_binary(self):
	"""Execute the CNS binary to ensure it works"""
	arch = self.get_arch()
	cns_path = Path(f"{self.install_lib}/haddock/cns/bin/{arch}.bin")
	proc = subprocess.run(
	[cns_path],
	input="stop\n",
	text=True,
	stdout=subprocess.DEVNULL,
	stderr=subprocess.DEVNULL,
	)

	if proc.returncode != 0:
	self.cns_warning()
	if proc.returncode == 0:
	self.cns_valid()

	@staticmethod
	def cns_warning():
	"""Warn the user that CNS could not be executed"""
	try:
	with open("/dev/tty", "w") as tty:
	tty.write("\n" + "=" * 79 + "\n")
	tty.write("=" * 79 + "\n")
	tty.write("=" * 79 + "\n")
	tty.write(
	"\n⚠️ WARNING: The pre-compiled CNS binary could not be executed ⚠️\n\n"
	)
	tty.write("This may be due to missing dependencies on your system.\n")
	tty.write(
	"Please refer to the installation instructions for troubleshooting steps:\n"
	)
	tty.write(
	"`https://github.com/haddocking/haddock3/blob/main/docs/pages/CNS.md`\n\n"
	)
	tty.write("=" * 79 + "\n")
	tty.write("=" * 79 + "\n")
	tty.write("=" * 79 + "\n")
	tty.flush()
	except Exception as _:
	# Fallback for systems without /dev/tty
	sys.stderr.write(
	"\n⚠️ WARNING: The pre-compiled CNS binary could not be executed ⚠️\n\n"
	)

	@staticmethod
	def cns_valid():
	"""Write a message to the user that CNS works"""
	try:
	with open("/dev/tty", "w") as tty:
	tty.write("\n" + "=" * 79 + "\n")
	tty.write("CNS execution passed ✅ \n")
	tty.write("=" * 79 + "\n")
	except Exception as _:
	# Fallback for systems without /dev/tty
	sys.stdout.write("CNS execution passed ✅ \n")

	@staticmethod
	def get_arch():
	"""Helper function to figure out the architetchure"""
	system = platform.system().lower()
	machine = platform.machine().lower()

	return f"{machine}-{system}"


	setup(
	cmdclass={
	"build_ext": CustomBuild,
	"install": PostInstallCommand,
	"develop": DevelopCommand,
	},
	ext_modules=cpp_extensions,
	)