#!/usr/bin/env python

import distutils

from distutils.command.build import build as _build

from setuptools.command.develop import develop as _develop

from setuptools.command.bdist_wheel import bdist_wheel as _bdist_wheel

from packaging.specifiers import SpecifierSet

from packaging.version import Version

from pyproject_parser import PyProject

from setuptools import Distribution

from setuptools import setup, Command

import os

import sys

# Disable SourceLink during the build until it can read repo-format v1, #1613

os.environ["EnableSourceControlManagerQueries"] = "false"

NET46_SUPPORT_OPTION = "--net46-support"

NET46_SUPPORT = NET46_SUPPORT_OPTION in sys.argv

if NET46_SUPPORT:

sys.argv.remove(NET46_SUPPORT_OPTION)

WINDOWS_PLATFORM_TAG = "win32.win_amd64"

class DotnetLib:

def __init__(self, name, path, **kwargs):

self.name = name

self.path = path

self.args = kwargs

class build_dotnet(Command):

"""Build command for dotnet-cli based builds"""

description = "Build DLLs with dotnet-cli"

user_options = [

("dotnet-config=", None, "dotnet build configuration"),

(

"inplace",

"i",

"ignore build-lib and put compiled extensions into the source "

+ "directory alongside your pure Python modules",

),

]

def initialize_options(self):

self.dotnet_config = None

self.build_lib = None

self.inplace = False

def finalize_options(self):

if self.dotnet_config is None:

self.dotnet_config = "release"

build = self.distribution.get_command_obj("build")

build.ensure_finalized()

if self.inplace:

self.build_lib = "."

else:

self.build_lib = build.build_lib

def run(self):

dotnet_modules = self.distribution.dotnet_libs

for lib in dotnet_modules:

output = os.path.join(

os.path.abspath(self.build_lib), lib.args.pop("output")

)

rename = lib.args.pop("rename", {})

opts = sum(

[

["--" + name.replace("_", "-"), value]

for name, value in lib.args.items()

],

[],

)

opts.extend(["--configuration", self.dotnet_config])

opts.extend(["--output", output])

self.announce("Running dotnet build...", level=distutils.log.INFO)

self.spawn(["dotnet", "build", lib.path] + opts)

for k, v in rename.items():

source = os.path.join(output, k)

dest = os.path.join(output, v)

if os.path.isfile(source):

try:

os.remove(dest)

except OSError:

pass

self.move_file(src=source, dst=dest, level=distutils.log.INFO)

else:

self.warn(

"Can't find file to rename: {}, current dir: {}".format(

source, os.getcwd()

)

)

# Add build_dotnet to the build tasks:

class build(_build):

sub_commands = _build.sub_commands + [("build_dotnet", None)]

class develop(_develop):

def install_for_development(self):

# Build extensions in-place

self.reinitialize_command("build_dotnet", inplace=1)

self.run_command("build_dotnet")

return super().install_for_development()

class bdist_wheel(_bdist_wheel):

def get_tag(self):

if NET46_SUPPORT:

platform_tag = WINDOWS_PLATFORM_TAG

else:

platform_tag = "any"

abi_tag = "none"

python_tag = self._get_python_tag()

return python_tag, abi_tag, platform_tag

def _get_python_tag(self) -> str:

pyproject = PyProject.load("pyproject.toml")

project = pyproject.project or {}

requires_python = project.get("requires-python")

if not requires_python:

raise RuntimeError("project.requires-python is required")

specifiers = SpecifierSet(str(requires_python))

return ".".join(

f"cp3{minor}"

for minor in range(0, 100)

if specifiers.contains(Version(f"3.{minor}"), prereleases=True)

)

# Monkey-patch Distribution s.t. it supports the dotnet_libs attribute

Distribution.dotnet_libs = None

cmdclass = {

"build": build,

"build_dotnet": build_dotnet,

"develop": develop,

"bdist_wheel": bdist_wheel,

}

if NET46_SUPPORT:

csproj = "src/compat/Python.Runtime.Compat.csproj"

else:

csproj = "src/runtime/Python.Runtime.csproj"

dotnet_libs = [DotnetLib("python-runtime", csproj, output="pythonnet/runtime")]

setup(

cmdclass=cmdclass,

dotnet_libs=dotnet_libs,

)