setup.py 21.5 KB
Newer Older
1
import distutils.command.clean
2
import distutils.spawn
3
import glob
4
import os
5
import shutil
6
7
import subprocess
import sys
8
9

import torch
10
11
12
from pkg_resources import DistributionNotFound, get_distribution, parse_version
from setuptools import find_packages, setup
from torch.utils.cpp_extension import BuildExtension, CppExtension, CUDA_HOME, CUDAExtension
soumith's avatar
soumith committed
13
14


Sasank Chilamkurthy's avatar
Sasank Chilamkurthy committed
15
def read(*names, **kwargs):
16
    with open(os.path.join(os.path.dirname(__file__), *names), encoding=kwargs.get("encoding", "utf8")) as fp:
Sasank Chilamkurthy's avatar
Sasank Chilamkurthy committed
17
18
        return fp.read()

Sasank Chilamkurthy's avatar
Sasank Chilamkurthy committed
19

20
21
22
23
24
25
26
def get_dist(pkgname):
    try:
        return get_distribution(pkgname)
    except DistributionNotFound:
        return None


27
28
cwd = os.path.dirname(os.path.abspath(__file__))

29
version_txt = os.path.join(cwd, "version.txt")
30
with open(version_txt) as f:
31
    version = f.readline().strip()
32
33
sha = "Unknown"
package_name = "torchvision"
Sasank Chilamkurthy's avatar
Sasank Chilamkurthy committed
34

35
try:
36
    sha = subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=cwd).decode("ascii").strip()
37
38
39
except Exception:
    pass

40
41
42
43
if os.getenv("BUILD_VERSION"):
    version = os.getenv("BUILD_VERSION")
elif sha != "Unknown":
    version += "+" + sha[:7]
44
45
46


def write_version_file():
47
48
    version_path = os.path.join(cwd, "torchvision", "version.py")
    with open(version_path, "w") as f:
49
50
        f.write(f"__version__ = '{version}'\n")
        f.write(f"git_version = {repr(sha)}\n")
51
52
53
        f.write("from torchvision.extension import _check_cuda_version\n")
        f.write("if _check_cuda_version() > 0:\n")
        f.write("    cuda = _check_cuda_version()\n")
54
55


56
57
58
pytorch_dep = "torch"
if os.getenv("PYTORCH_VERSION"):
    pytorch_dep += "==" + os.getenv("PYTORCH_VERSION")
soumith's avatar
soumith committed
59

60
requirements = [
61
    "numpy",
62
    "requests",
63
    pytorch_dep,
64
65
]

66
67
# Excluding 8.3.* because of https://github.com/pytorch/vision/issues/4934
pillow_ver = " >= 5.3.0, !=8.3.*"
68
pillow_req = "pillow-simd" if get_dist("pillow-simd") is not None else "pillow"
69
70
requirements.append(pillow_req + pillow_ver)

71

72
73
def find_library(name, vision_include):
    this_dir = os.path.dirname(os.path.abspath(__file__))
74
    build_prefix = os.environ.get("BUILD_PREFIX", None)
75
76
77
78
79
80
    is_conda_build = build_prefix is not None

    library_found = False
    conda_installed = False
    lib_folder = None
    include_folder = None
81
    library_header = f"{name}.h"
82

83
    # Lookup in TORCHVISION_INCLUDE or in the package file
84
    package_path = [os.path.join(this_dir, "torchvision")]
85
86
87
88
89
90
91
    for folder in vision_include + package_path:
        candidate_path = os.path.join(folder, library_header)
        library_found = os.path.exists(candidate_path)
        if library_found:
            break

    if not library_found:
92
        print(f"Running build on conda-build: {is_conda_build}")
93
94
        if is_conda_build:
            # Add conda headers/libraries
95
96
97
98
99
            if os.name == "nt":
                build_prefix = os.path.join(build_prefix, "Library")
            include_folder = os.path.join(build_prefix, "include")
            lib_folder = os.path.join(build_prefix, "lib")
            library_header_path = os.path.join(include_folder, library_header)
100
101
102
            library_found = os.path.isfile(library_header_path)
            conda_installed = library_found
        else:
103
            # Check if using Anaconda to produce wheels
104
            conda = shutil.which("conda")
105
            is_conda = conda is not None
106
            print(f"Running build on conda: {is_conda}")
107
108
109
            if is_conda:
                python_executable = sys.executable
                py_folder = os.path.dirname(python_executable)
110
111
                if os.name == "nt":
                    env_path = os.path.join(py_folder, "Library")
112
113
                else:
                    env_path = os.path.dirname(py_folder)
114
115
116
                lib_folder = os.path.join(env_path, "lib")
                include_folder = os.path.join(env_path, "include")
                library_header_path = os.path.join(include_folder, library_header)
117
118
119
120
                library_found = os.path.isfile(library_header_path)
                conda_installed = library_found

        if not library_found:
121
            if sys.platform == "linux":
122
123
                library_found = os.path.exists(f"/usr/include/{library_header}")
                library_found = library_found or os.path.exists(f"/usr/local/include/{library_header}")
124
125
126
127

    return library_found, conda_installed, include_folder, lib_folder


128
129
def get_extensions():
    this_dir = os.path.dirname(os.path.abspath(__file__))
130
    extensions_dir = os.path.join(this_dir, "torchvision", "csrc")
131

132
133
134
    main_file = glob.glob(os.path.join(extensions_dir, "*.cpp")) + glob.glob(
        os.path.join(extensions_dir, "ops", "*.cpp")
    )
135
    source_cpu = (
136
137
138
        glob.glob(os.path.join(extensions_dir, "ops", "autograd", "*.cpp"))
        + glob.glob(os.path.join(extensions_dir, "ops", "cpu", "*.cpp"))
        + glob.glob(os.path.join(extensions_dir, "ops", "quantized", "cpu", "*.cpp"))
139
    )
140

141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
    print("Compiling extensions with following flags:")
    force_cuda = os.getenv("FORCE_CUDA", "0") == "1"
    print(f"  FORCE_CUDA: {force_cuda}")
    debug_mode = os.getenv("DEBUG", "0") == "1"
    print(f"  DEBUG: {debug_mode}")
    use_png = os.getenv("TORCHVISION_USE_PNG", "1") == "1"
    print(f"  TORCHVISION_USE_PNG: {use_png}")
    use_jpeg = os.getenv("TORCHVISION_USE_JPEG", "1") == "1"
    print(f"  TORCHVISION_USE_JPEG: {use_jpeg}")
    use_nvjpeg = os.getenv("TORCHVISION_USE_NVJPEG", "1") == "1"
    print(f"  TORCHVISION_USE_NVJPEG: {use_nvjpeg}")
    use_ffmpeg = os.getenv("TORCHVISION_USE_FFMPEG", "1") == "1"
    print(f"  TORCHVISION_USE_FFMPEG: {use_ffmpeg}")
    use_video_codec = os.getenv("TORCHVISION_USE_VIDEO_CODEC", "1") == "1"
    print(f"  TORCHVISION_USE_VIDEO_CODEC: {use_video_codec}")

    nvcc_flags = os.getenv("NVCC_FLAGS", "")
    print(f"  NVCC_FLAGS: {nvcc_flags}")

160
    is_rocm_pytorch = False
161
162

    if torch.__version__ >= "1.5":
163
        from torch.utils.cpp_extension import ROCM_HOME
164

165
        is_rocm_pytorch = (torch.version.hip is not None) and (ROCM_HOME is not None)
166
167

    if is_rocm_pytorch:
168
        from torch.utils.hipify import hipify_python
169

170
171
172
        hipify_python.hipify(
            project_directory=this_dir,
            output_directory=this_dir,
173
            includes="torchvision/csrc/ops/cuda/*",
174
175
            show_detailed=True,
            is_pytorch_extension=True,
176
        )
177
        source_cuda = glob.glob(os.path.join(extensions_dir, "ops", "hip", "*.hip"))
178
        # Copy over additional files
179
180
        for file in glob.glob(r"torchvision/csrc/ops/cuda/*.h"):
            shutil.copy(file, "torchvision/csrc/ops/hip")
181
    else:
182
        source_cuda = glob.glob(os.path.join(extensions_dir, "ops", "cuda", "*.cu"))
183

184
    source_cuda += glob.glob(os.path.join(extensions_dir, "ops", "autocast", "*.cpp"))
185
186
187
188
189
190

    sources = main_file + source_cpu
    extension = CppExtension

    define_macros = []

191
    extra_compile_args = {"cxx": []}
192
    if (torch.cuda.is_available() and ((CUDA_HOME is not None) or is_rocm_pytorch)) or force_cuda:
193
194
        extension = CUDAExtension
        sources += source_cuda
195
        if not is_rocm_pytorch:
196
197
            define_macros += [("WITH_CUDA", None)]
            if nvcc_flags == "":
198
199
                nvcc_flags = []
            else:
200
                nvcc_flags = nvcc_flags.split(" ")
Soumith Chintala's avatar
Soumith Chintala committed
201
        else:
202
            define_macros += [("WITH_HIP", None)]
203
            nvcc_flags = []
204
        extra_compile_args["nvcc"] = nvcc_flags
205

206
207
    if sys.platform == "win32":
        define_macros += [("torchvision_EXPORTS", None)]
208
        define_macros += [("USE_PYTHON", None)]
209
        extra_compile_args["cxx"].append("/MP")
Francisco Massa's avatar
Francisco Massa committed
210

211
    if debug_mode:
212
        print("Compiling in debug mode")
213
214
        extra_compile_args["cxx"].append("-g")
        extra_compile_args["cxx"].append("-O0")
215
216
217
        if "nvcc" in extra_compile_args:
            # we have to remove "-OX" and "-g" flag if exists and append
            nvcc_flags = extra_compile_args["nvcc"]
218
            extra_compile_args["nvcc"] = [f for f in nvcc_flags if not ("-O" in f or "-g" in f)]
219
220
221
            extra_compile_args["nvcc"].append("-O0")
            extra_compile_args["nvcc"].append("-g")

222
223
    sources = [os.path.join(extensions_dir, s) for s in sources]

224
    include_dirs = [extensions_dir]
225
226
227

    ext_modules = [
        extension(
228
            "torchvision._C",
229
            sorted(sources),
230
231
            include_dirs=include_dirs,
            define_macros=define_macros,
Soumith Chintala's avatar
Soumith Chintala committed
232
            extra_compile_args=extra_compile_args,
233
        )
234
    ]
235

236
    # ------------------- Torchvision extra extensions ------------------------
237
238
239
240
    vision_include = os.environ.get("TORCHVISION_INCLUDE", None)
    vision_library = os.environ.get("TORCHVISION_LIBRARY", None)
    vision_include = vision_include.split(os.pathsep) if vision_include is not None else []
    vision_library = vision_library.split(os.pathsep) if vision_library is not None else []
241
242
243
244
245
246
247
248
249
    include_dirs += vision_include
    library_dirs = vision_library

    # Image reading extension
    image_macros = []
    image_include = [extensions_dir]
    image_library = []
    image_link_flags = []

250
251
252
    if sys.platform == "win32":
        image_macros += [("USE_PYTHON", None)]

253
    # Locating libPNG
254
255
    libpng = shutil.which("libpng-config")
    pngfix = shutil.which("pngfix")
256
    png_found = libpng is not None or pngfix is not None
257
258
259
260

    use_png = use_png and png_found
    if use_png:
        print("Found PNG library")
261
262
        if libpng is not None:
            # Linux / Mac
263
            min_version = "1.6.0"
264
265
            png_version = subprocess.run([libpng, "--version"], stdout=subprocess.PIPE)
            png_version = png_version.stdout.strip().decode("utf-8")
266
            png_version = parse_version(png_version)
267
            if png_version >= parse_version(min_version):
268
269
270
271
                print("Building torchvision with PNG image support")
                png_lib = subprocess.run([libpng, "--libdir"], stdout=subprocess.PIPE)
                png_lib = png_lib.stdout.strip().decode("utf-8")
                if "disabled" not in png_lib:
272
                    image_library += [png_lib]
273
274
275
                png_include = subprocess.run([libpng, "--I_opts"], stdout=subprocess.PIPE)
                png_include = png_include.stdout.strip().decode("utf-8")
                _, png_include = png_include.split("-I")
276
                image_include += [png_include]
277
                image_link_flags.append("png")
278
279
                print(f"  libpng version: {png_version}")
                print(f"  libpng include path: {png_include}")
280
            else:
281
282
283
                print("Could not add PNG image support to torchvision:")
                print(f"  libpng minimum version {min_version}, found {png_version}")
                use_png = False
284
285
        else:
            # Windows
286
287
            png_lib = os.path.join(os.path.dirname(os.path.dirname(pngfix)), "lib")
            png_include = os.path.join(os.path.dirname(os.path.dirname(pngfix)), "include", "libpng16")
288
289
            image_library += [png_lib]
            image_include += [png_include]
290
            image_link_flags.append("libpng")
291
292
293
    else:
        print("Building torchvision without PNG image support")
    image_macros += [("PNG_FOUND", str(int(use_png)))]
294

295
    # Locating libjpeg
296
    (jpeg_found, jpeg_conda, jpeg_include, jpeg_lib) = find_library("jpeglib", vision_include)
297

298
299
    use_jpeg = use_jpeg and jpeg_found
    if use_jpeg:
300
        print("Building torchvision with JPEG image support")
301
302
        print(f"  libpng include path: {jpeg_include}")
        print(f"  libpng lib path: {jpeg_lib}")
303
        image_link_flags.append("jpeg")
304
305
306
        if jpeg_conda:
            image_library += [jpeg_lib]
            image_include += [jpeg_include]
307
308
309
    else:
        print("Building torchvision without JPEG image support")
    image_macros += [("JPEG_FOUND", str(int(use_jpeg)))]
310

311
312
313
    # Locating nvjpeg
    # Should be included in CUDA_HOME for CUDA >= 10.1, which is the minimum version we have in the CI
    nvjpeg_found = (
314
315
316
        extension is CUDAExtension
        and CUDA_HOME is not None
        and os.path.exists(os.path.join(CUDA_HOME, "include", "nvjpeg.h"))
317
318
    )

319
320
    use_nvjpeg = use_nvjpeg and nvjpeg_found
    if use_nvjpeg:
321
322
        print("Building torchvision with NVJPEG image support")
        image_link_flags.append("nvjpeg")
323
324
325
    else:
        print("Building torchvision without NVJPEG image support")
    image_macros += [("NVJPEG_FOUND", str(int(use_nvjpeg)))]
326
327

    image_path = os.path.join(extensions_dir, "io", "image")
Philip Meier's avatar
Philip Meier committed
328
    image_src = glob.glob(os.path.join(image_path, "*.cpp")) + glob.glob(os.path.join(image_path, "cpu", "*.cpp"))
329

330
331
332
333
334
335
336
    if is_rocm_pytorch:
        image_src += glob.glob(os.path.join(image_path, "hip", "*.cpp"))
        # we need to exclude this in favor of the hipified source
        image_src.remove(os.path.join(image_path, "image.cpp"))
    else:
        image_src += glob.glob(os.path.join(image_path, "cuda", "*.cpp"))

337
    if use_png or use_jpeg:
338
339
340
341
342
343
344
345
346
347
348
349
        ext_modules.append(
            extension(
                "torchvision.image",
                image_src,
                include_dirs=image_include + include_dirs + [image_path],
                library_dirs=image_library + library_dirs,
                define_macros=image_macros,
                libraries=image_link_flags,
                extra_compile_args=extra_compile_args,
            )
        )

350
    # Locating ffmpeg
351
    ffmpeg_exe = shutil.which("ffmpeg")
352
    has_ffmpeg = ffmpeg_exe is not None
353
    ffmpeg_version = None
354
355
356
357
    # FIXME: Building torchvision with ffmpeg on MacOS or with Python 3.9
    # FIXME: causes crash. See the following GitHub issues for more details.
    # FIXME: https://github.com/pytorch/pytorch/issues/65000
    # FIXME: https://github.com/pytorch/vision/issues/3367
358
    if sys.platform != "linux" or (sys.version_info.major == 3 and sys.version_info.minor == 9):
359
        has_ffmpeg = False
360
361
    if has_ffmpeg:
        try:
362
            # This is to check if ffmpeg is installed properly.
363
            ffmpeg_version = subprocess.check_output(["ffmpeg", "-version"])
364
        except subprocess.CalledProcessError:
365
366
            print("Building torchvision without ffmpeg support")
            print("  Error fetching ffmpeg version, ignoring ffmpeg.")
367
368
            has_ffmpeg = False

369
    use_ffmpeg = use_ffmpeg and has_ffmpeg
370

371
    if use_ffmpeg:
372
        ffmpeg_libraries = {"libavcodec", "libavformat", "libavutil", "libswresample", "libswscale"}
373

374
375
        ffmpeg_bin = os.path.dirname(ffmpeg_exe)
        ffmpeg_root = os.path.dirname(ffmpeg_bin)
376
377
        ffmpeg_include_dir = os.path.join(ffmpeg_root, "include")
        ffmpeg_library_dir = os.path.join(ffmpeg_root, "lib")
378

379
        gcc = os.environ.get("CC", shutil.which("gcc"))
380
381
        platform_tag = subprocess.run([gcc, "-print-multiarch"], stdout=subprocess.PIPE)
        platform_tag = platform_tag.stdout.strip().decode("utf-8")
382
383
384

        if platform_tag:
            # Most probably a Debian-based distribution
385
386
            ffmpeg_include_dir = [ffmpeg_include_dir, os.path.join(ffmpeg_include_dir, platform_tag)]
            ffmpeg_library_dir = [ffmpeg_library_dir, os.path.join(ffmpeg_library_dir, platform_tag)]
387
388
389
390
391
392
393
        else:
            ffmpeg_include_dir = [ffmpeg_include_dir]
            ffmpeg_library_dir = [ffmpeg_library_dir]

        for library in ffmpeg_libraries:
            library_found = False
            for search_path in ffmpeg_include_dir + include_dirs:
394
                full_path = os.path.join(search_path, library, "*.h")
395
396
397
                library_found |= len(glob.glob(full_path)) > 0

            if not library_found:
398
399
400
401
402
                print("Building torchvision without ffmpeg support")
                print(f"  {library} header files were not found, disabling ffmpeg support")
                use_ffmpeg = False
    else:
        print("Building torchvision without ffmpeg support")
403

404
405
406
407
408
    if use_ffmpeg:
        print("Building torchvision with ffmpeg support")
        print(f"  ffmpeg version: {ffmpeg_version}")
        print(f"  ffmpeg include path: {ffmpeg_include_dir}")
        print(f"  ffmpeg library_dir: {ffmpeg_library_dir}")
409
410

        # TorchVision base decoder + video reader
411
        video_reader_src_dir = os.path.join(this_dir, "torchvision", "csrc", "io", "video_reader")
412
        video_reader_src = glob.glob(os.path.join(video_reader_src_dir, "*.cpp"))
413
414
        base_decoder_src_dir = os.path.join(this_dir, "torchvision", "csrc", "io", "decoder")
        base_decoder_src = glob.glob(os.path.join(base_decoder_src_dir, "*.cpp"))
415
        # Torchvision video API
416
        videoapi_src_dir = os.path.join(this_dir, "torchvision", "csrc", "io", "video")
417
        videoapi_src = glob.glob(os.path.join(videoapi_src_dir, "*.cpp"))
418
        # exclude tests
419
        base_decoder_src = [x for x in base_decoder_src if "_test.cpp" not in x]
420

421
        combined_src = video_reader_src + base_decoder_src + videoapi_src
422

423
424
        ext_modules.append(
            CppExtension(
425
                "torchvision.video_reader",
426
                combined_src,
427
                include_dirs=[
428
                    base_decoder_src_dir,
429
                    video_reader_src_dir,
430
                    videoapi_src_dir,
431
                    extensions_dir,
432
                    *ffmpeg_include_dir,
433
                    *include_dirs,
434
                ],
435
                library_dirs=ffmpeg_library_dir + library_dirs,
436
                libraries=[
437
438
439
440
441
                    "avcodec",
                    "avformat",
                    "avutil",
                    "swresample",
                    "swscale",
442
                ],
443
444
                extra_compile_args=["-std=c++17"] if os.name != "nt" else ["/std:c++17", "/MP"],
                extra_link_args=["-std=c++17" if os.name != "nt" else "/std:c++17"],
445
446
            )
        )
447

Prabhat Roy's avatar
Prabhat Roy committed
448
449
450
451
452
453
454
455
456
457
458
459
    # Locating video codec
    # CUDA_HOME should be set to the cuda root directory.
    # TORCHVISION_INCLUDE and TORCHVISION_LIBRARY should include the location to
    # video codec header files and libraries respectively.
    video_codec_found = (
        extension is CUDAExtension
        and CUDA_HOME is not None
        and any([os.path.exists(os.path.join(folder, "cuviddec.h")) for folder in vision_include])
        and any([os.path.exists(os.path.join(folder, "nvcuvid.h")) for folder in vision_include])
        and any([os.path.exists(os.path.join(folder, "libnvcuvid.so")) for folder in library_dirs])
    )

460
    use_video_codec = use_video_codec and video_codec_found
Prabhat Roy's avatar
Prabhat Roy committed
461
    if (
462
463
        use_video_codec
        and use_ffmpeg
Prabhat Roy's avatar
Prabhat Roy committed
464
465
        and any([os.path.exists(os.path.join(folder, "libavcodec", "bsf.h")) for folder in ffmpeg_include_dir])
    ):
466
        print("Building torchvision with video codec support")
Prabhat Roy's avatar
Prabhat Roy committed
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
        gpu_decoder_path = os.path.join(extensions_dir, "io", "decoder", "gpu")
        gpu_decoder_src = glob.glob(os.path.join(gpu_decoder_path, "*.cpp"))
        cuda_libs = os.path.join(CUDA_HOME, "lib64")
        cuda_inc = os.path.join(CUDA_HOME, "include")

        ext_modules.append(
            extension(
                "torchvision.Decoder",
                gpu_decoder_src,
                include_dirs=include_dirs + [gpu_decoder_path] + [cuda_inc] + ffmpeg_include_dir,
                library_dirs=ffmpeg_library_dir + library_dirs + [cuda_libs],
                libraries=[
                    "avcodec",
                    "avformat",
                    "avutil",
                    "swresample",
                    "swscale",
                    "nvcuvid",
                    "cuda",
                    "cudart",
                    "z",
                    "pthread",
                    "dl",
490
                    "nppicc",
Prabhat Roy's avatar
Prabhat Roy committed
491
492
493
494
495
                ],
                extra_compile_args=extra_compile_args,
            )
        )
    else:
496
497
498
499
500
501
502
503
504
505
506
        print("Building torchvision without video codec support")
        if (
            use_video_codec
            and use_ffmpeg
            and not any([os.path.exists(os.path.join(folder, "libavcodec", "bsf.h")) for folder in ffmpeg_include_dir])
        ):
            print(
                "  The installed version of ffmpeg is missing the header file 'bsf.h' which is "
                "  required for GPU video decoding. Please install the latest ffmpeg from conda-forge channel:"
                "   `conda install -c conda-forge ffmpeg`."
            )
Prabhat Roy's avatar
Prabhat Roy committed
507

508
509
510
511
512
    return ext_modules


class clean(distutils.command.clean.clean):
    def run(self):
513
        with open(".gitignore") as f:
514
            ignores = f.read()
515
            for wildcard in filter(None, ignores.split("\n")):
516
517
518
519
520
521
522
523
524
525
                for filename in glob.glob(wildcard):
                    try:
                        os.remove(filename)
                    except OSError:
                        shutil.rmtree(filename, ignore_errors=True)

        # It's an old-style class in Python 2.7...
        distutils.command.clean.clean.run(self)


526
if __name__ == "__main__":
527
    print(f"Building wheel {package_name}-{version}")
528
529
530

    write_version_file()

531
    with open("README.md") as f:
532
533
534
535
536
537
        readme = f.read()

    setup(
        # Metadata
        name=package_name,
        version=version,
538
539
540
541
        author="PyTorch Core Team",
        author_email="soumith@pytorch.org",
        url="https://github.com/pytorch/vision",
        description="image and video datasets and models for torch deep learning",
542
        long_description=readme,
543
        long_description_content_type="text/markdown",
544
        license="BSD",
545
        # Package info
546
        packages=find_packages(exclude=("test",)),
547
        package_data={package_name: ["*.dll", "*.dylib", "*.so", "prototype/datasets/_builtin/*.categories"]},
548
549
550
551
552
553
        zip_safe=False,
        install_requires=requirements,
        extras_require={
            "scipy": ["scipy"],
        },
        ext_modules=get_extensions(),
554
        python_requires=">=3.8",
555
        cmdclass={
556
557
558
            "build_ext": BuildExtension.with_options(no_python_abi_suffix=True),
            "clean": clean,
        },
559
    )