setup
=====

.. py:module:: setup


Attributes
----------

.. autoapisummary::

   setup.version
   setup.package_data


Classes
-------

.. autoapisummary::

   setup.CMakeExtension
   setup.CMakeBuild


Functions
---------

.. autoapisummary::

   setup.warning
   setup.get_cmake_dir
   setup.get_base_dir


Module Contents
---------------

.. py:function:: warning(s)

.. py:function:: get_cmake_dir() -> pathlib.Path

.. py:function:: get_base_dir() -> pathlib.Path

.. py:data:: version

.. py:class:: CMakeExtension(name, sourcedir='')

   Bases: :py:obj:`setuptools.Extension`


   Describes a single extension module.

   This means that all source files will be compiled into a single binary file
   ``<module path>.<suffix>`` (with ``<module path>`` derived from ``name`` and
   ``<suffix>`` defined by one of the values in
   ``importlib.machinery.EXTENSION_SUFFIXES``).

   In the case ``.pyx`` files are passed as ``sources and`` ``Cython`` is **not**
   installed in the build environment, ``setuptools`` may also try to look for the
   equivalent ``.cpp`` or ``.c`` files.

   :arg str name:
     the full name of the extension, including any packages -- ie.
     *not* a filename or pathname, but Python dotted name

   :arg list[str|os.PathLike[str]] sources:
     list of source filenames, relative to the distribution root
     (where the setup script lives), in Unix form (slash-separated)
     for portability.  Source files may be C, C++, SWIG (.i),
     platform-specific resource files, or whatever else is recognized
     by the "build_ext" command as source for a Python extension.

   :keyword list[str] include_dirs:
     list of directories to search for C/C++ header files (in Unix
     form for portability)

   :keyword list[tuple[str, str|None]] define_macros:
     list of macros to define; each macro is defined using a 2-tuple:
     the first item corresponding to the name of the macro and the second
     item either a string with its value or None to
     define it without a particular value (equivalent of "#define
     FOO" in source or -DFOO on Unix C compiler command line)

   :keyword list[str] undef_macros:
     list of macros to undefine explicitly

   :keyword list[str] library_dirs:
     list of directories to search for C/C++ libraries at link time

   :keyword list[str] libraries:
     list of library names (not filenames or paths) to link against

   :keyword list[str] runtime_library_dirs:
     list of directories to search for C/C++ libraries at run time
     (for shared extensions, this is when the extension is loaded).
     Setting this will cause an exception during build on Windows
     platforms.

   :keyword list[str] extra_objects:
     list of extra files to link with (eg. object files not implied
     by 'sources', static library that must be explicitly specified,
     binary resource files, etc.)

   :keyword list[str] extra_compile_args:
     any extra platform- and compiler-specific information to use
     when compiling the source files in 'sources'.  For platforms and
     compilers where "command line" makes sense, this is typically a
     list of command-line arguments, but for other platforms it could
     be anything.

   :keyword list[str] extra_link_args:
     any extra platform- and compiler-specific information to use
     when linking object files together to create the extension (or
     to create a new static Python interpreter).  Similar
     interpretation as for 'extra_compile_args'.

   :keyword list[str] export_symbols:
     list of symbols to be exported from a shared extension.  Not
     used on all platforms, and not generally necessary for Python
     extensions, which typically export exactly one symbol: "init" +
     extension_name.

   :keyword list[str] swig_opts:
     any extra options to pass to SWIG if a source file has the .i
     extension.

   :keyword list[str] depends:
     list of files that the extension depends on

   :keyword str language:
     extension language (i.e. "c", "c++", "objc"). Will be detected
     from the source extensions if not provided.

   :keyword bool optional:
     specifies that a build failure in the extension should not abort the
     build process, but simply not install the failing extension.

   :keyword bool py_limited_api:
     opt-in flag for the usage of :doc:`Python's limited API <python:c-api/stable>`.

   :raises setuptools.errors.PlatformError: if ``runtime_library_dirs`` is
     specified on Windows. (since v63)


   .. py:attribute:: sourcedir


.. py:class:: CMakeBuild(dist)

   Bases: :py:obj:`setuptools.command.build_ext.build_ext`


   Abstract base class for defining command classes, the "worker bees"
   of the Distutils.  A useful analogy for command classes is to think of
   them as subroutines with local variables called "options".  The options
   are "declared" in 'initialize_options()' and "defined" (given their
   final values, aka "finalized") in 'finalize_options()', both of which
   must be defined by every command class.  The distinction between the
   two is necessary because option values might come from the outside
   world (command line, config file, ...), and any options dependent on
   other options must be computed *after* these outside influences have
   been processed -- hence 'finalize_options()'.  The "body" of the
   subroutine, where it does all its work based on the values of its
   options, is the 'run()' method, which must also be implemented by every
   command class.


   .. py:method:: run()

      Build extensions in build directory, then copy if --inplace



   .. py:method:: build_extension(ext)


.. py:data:: package_data