FilesExpand file tree

main

/

setup.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

139 lines (112 loc) · 5.27 KB

main

/

setup.py

Copy path

Top

File metadata and controls

• Code
• Blame

139 lines (112 loc) · 5.27 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

import os

import re

import subprocess

import sys

from setuptools import Extension, setup

from setuptools.command.build_ext import build_ext

# Convert distutils Windows platform specifiers to CMake -A arguments

PLAT_TO_CMAKE = {

"win32": "Win32",

"win-amd64": "x64",

"win-arm32": "ARM",

"win-arm64": "ARM64",

}

# A CMakeExtension needs a sourcedir instead of a file list.

# The name must be the _single_ output extension from the CMake build.

# If you need multiple extensions, see scikit-build.

class CMakeExtension(Extension):

def __init__(self, name, sourcedir=""):

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

self.sourcedir = os.path.abspath(sourcedir)

class CMakeBuild(build_ext):

def build_extension(self, ext):

extdir = os.path.abspath(os.path.dirname(self.get_ext_fullpath(ext.name)))

# required for auto-detection & inclusion of auxiliary "native" libs

if not extdir.endswith(os.path.sep):

extdir += os.path.sep

debug = int(os.environ.get("DEBUG", 0)) if self.debug is None else self.debug

cfg = "Debug" if debug else "Release"

print("Building with cfg = ", cfg)

# CMake lets you override the generator - we need to check this.

# Can be set with Conda-Build, for example.

cmake_generator = os.environ.get("CMAKE_GENERATOR", "")

# Set Python_EXECUTABLE instead if you use PYBIND11_FINDPYTHON

# EXAMPLE_VERSION_INFO shows you how to pass a value into the C++ code

# from Python.

cmake_args = [

f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={extdir}",

f"-DPYTHON_EXECUTABLE={sys.executable}",

f"-DCMAKE_BUILD_TYPE={cfg}", # not used on MSVC, but no harm

f"-DCMAKE_VERBOSE_MAKEFILE=ON",

]

build_args = []

# Adding CMake arguments set as environment variable

# (needed e.g. to build for ARM OSx on conda-forge)

if "CMAKE_ARGS" in os.environ:

cmake_args += [item for item in os.environ["CMAKE_ARGS"].split(" ") if item]

# In this example, we pass in the version to C++. You might not need to.

cmake_args += [f"-DEXAMPLE_VERSION_INFO={self.distribution.get_version()}"]

if self.compiler.compiler_type != "msvc":

# Using Ninja-build since it a) is available as a wheel and b)

# multithreads automatically. MSVC would require all variables be

# exported for Ninja to pick it up, which is a little tricky to do.

# Users can override the generator with CMAKE_GENERATOR in CMake

# 3.15+.

if not cmake_generator:

try:

import ninja # noqa: F401

cmake_args += ["-GNinja"]

except ImportError:

pass

else:

# Single config generators are handled "normally"

single_config = any(x in cmake_generator for x in {"NMake", "Ninja"})

# CMake allows an arch-in-generator style for backward compatibility

contains_arch = any(x in cmake_generator for x in {"ARM", "Win64"})

# Specify the arch if using MSVC generator, but only if it doesn't

# contain a backward-compatibility arch spec already in the

# generator name.

if not single_config and not contains_arch:

cmake_args += ["-A", PLAT_TO_CMAKE[self.plat_name]]

# Multi-config generators have a different way to specify configs

if not single_config:

cmake_args += [

f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{cfg.upper()}={extdir}"

]

build_args += ["--config", cfg]

if sys.platform.startswith("darwin"):

# Cross-compile support for macOS - respect ARCHFLAGS if set

archs = re.findall(r"-arch (\S+)", os.environ.get("ARCHFLAGS", ""))

if archs:

cmake_args += ["-DCMAKE_OSX_ARCHITECTURES={}".format(";".join(archs))]

# Set CMAKE_BUILD_PARALLEL_LEVEL to control the parallel build level

# across all generators.

if "CMAKE_BUILD_PARALLEL_LEVEL" not in os.environ:

# self.parallel is a Python 3 only way to set parallel jobs by hand

# using -j in the build_ext call, not supported by pip or PyPA-build.

if hasattr(self, "parallel") and self.parallel:

# CMake 3.12+ only.

build_args += [f"-j{self.parallel}"]

if not os.path.exists(self.build_temp):

os.makedirs(self.build_temp)

subprocess.check_call(

["cmake", ext.sourcedir] + cmake_args, cwd=self.build_temp

)

subprocess.check_call(

["cmake", "--build", "."] + build_args, cwd=self.build_temp

)

# The information here can also be placed in setup.cfg - better separation of

# logic and declaration, and simpler if you include description/version in a file.

setup(

name="rtmp_streaming",

version="0.0.1",

author="andrea nobile",

author_email="",

description="rtmp streaming using double buffer",

long_description="",

ext_modules=[CMakeExtension("rtmp_streaming")],

cmdclass={"build_ext": CMakeBuild},

zip_safe=False,

extras_require={"test": ["pytest>=6.0"]},

python_requires=">=3.6",

)