File Manager

X7ROOT File Manager

Current Path: /opt/alt/python312/lib/python3.12/site-packages/setuptools

opt / alt / python312 / lib / python3.12 / site-packages / setuptools /

ðŸ“ ..
ðŸ“„ __init__.py(9 KB)
ðŸ“ __pycache__
ðŸ“„ _core_metadata.py(8.71 KB)
ðŸ“ _distutils
ðŸ“„ _entry_points.py(2.18 KB)
ðŸ“„ _imp.py(2.38 KB)
ðŸ“„ _importlib.py(1.43 KB)
ðŸ“„ _itertools.py(675 B)
ðŸ“„ _normalization.py(4.12 KB)
ðŸ“„ _path.py(1.03 KB)
ðŸ“„ _reqs.py(1.09 KB)
ðŸ“ _vendor
ðŸ“„ archive_util.py(7.16 KB)
ðŸ“„ build_meta.py(18.23 KB)
ðŸ“ command
ðŸ“ config
ðŸ“„ dep_util.py(659 B)
ðŸ“„ depends.py(5.45 KB)
ðŸ“„ discovery.py(20.65 KB)
ðŸ“„ dist.py(36.33 KB)
ðŸ“„ errors.py(2.61 KB)
ðŸ“„ extension.py(5.46 KB)
ðŸ“ extern
ðŸ“„ glob.py(4.75 KB)
ðŸ“„ installer.py(4.87 KB)
ðŸ“„ launch.py(812 B)
ðŸ“„ logging.py(1.21 KB)
ðŸ“„ modified.py(190 B)
ðŸ“„ monkey.py(4.67 KB)
ðŸ“„ msvc.py(46.31 KB)
ðŸ“„ namespaces.py(3 KB)
ðŸ“„ package_index.py(37.45 KB)
ðŸ“„ py312compat.py(330 B)
ðŸ“„ sandbox.py(14.01 KB)
ðŸ“„ script (dev).tmpl(218 B)
ðŸ“„ script.tmpl(138 B)
ðŸ“„ unicode_utils.py(941 B)
ðŸ“„ version.py(161 B)
ðŸ“„ warnings.py(3.61 KB)
ðŸ“„ wheel.py(8.43 KB)
ðŸ“„ windows_support.py(720 B)

Editing: extension.py

import re
import functools
import distutils.core
import distutils.errors
import distutils.extension

from .monkey import get_unpatched

def _have_cython():
    """
    Return True if Cython can be imported.
    """
    cython_impl = 'Cython.Distutils.build_ext'
    try:
        # from (cython_impl) import build_ext
        __import__(cython_impl, fromlist=['build_ext']).build_ext
        return True
    except Exception:
        pass
    return False

# for compatibility
have_pyrex = _have_cython

_Extension = get_unpatched(distutils.core.Extension)

class Extension(_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] 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)
    """

def __init__(self, name, sources, *args, **kw):
        # The *args is needed for compatibility as calls may use positional
        # arguments. py_limited_api may be set only via keyword.
        self.py_limited_api = kw.pop("py_limited_api", False)
        super().__init__(name, sources, *args, **kw)

def _convert_pyx_sources_to_lang(self):
        """
        Replace sources with .pyx extensions to sources with the target
        language extension. This mechanism allows language authors to supply
        pre-converted sources but to prefer the .pyx sources.
        """
        if _have_cython():
            # the build has Cython, so allow it to compile the .pyx files
            return
        lang = self.language or ''
        target_ext = '.cpp' if lang.lower() == 'c++' else '.c'
        sub = functools.partial(re.sub, '.pyx$', target_ext)
        self.sources = list(map(sub, self.sources))

class Library(Extension):
    """Just like a regular Extension, but built as a library instead"""

X7ROOT File Manager

Editing: extension.py

Upload File

Create Folder