omdev 0.0.0.dev7__py3-none-any.whl

omdev/exts/_distutils/extension.py

@@ -0,0 +1,107 @@
+"""Provides the Extension class, used to describe C/C++ extension modules in setup scripts."""
+import warnings
+
+
+class Extension:
+    """
+    Just a collection of attributes that describes an extension module and everything needed to build it (hopefully in a
+    portable way, but there are hooks that let you be as unportable as you need).
+
+    Instance attributes:
+      name : string
+        the full name of the extension, including any packages -- ie. *not* a filename or pathname, but Python dotted
+        name
+      sources : [string]
+        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.
+      include_dirs : [string]
+        list of directories to search for C/C++ header files (in Unix form for portability)
+      define_macros : [(name : string, value : string|None)]
+        list of macros to define; each macro is defined using a 2-tuple, where 'value' is either the string to define it
+        to or None to define it without a particular value (equivalent of "#define FOO" in source or -DFOO on Unix C
+        compiler command line)
+      undef_macros : [string]
+        list of macros to undefine explicitly
+      library_dirs : [string]
+        list of directories to search for C/C++ libraries at link time
+      libraries : [string]
+        list of library names (not filenames or paths) to link against
+      runtime_library_dirs : [string]
+        list of directories to search for C/C++ libraries at run time (for shared extensions, this is when the extension
+        is loaded)
+      extra_objects : [string]
+        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.)
+      extra_compile_args : [string]
+        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.
+      extra_link_args : [string]
+        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'.
+      export_symbols : [string]
+        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.
+      swig_opts : [string]
+        any extra options to pass to SWIG if a source file has the .i extension.
+      depends : [string]
+        list of files that the extension depends on
+      language : string
+        extension language (i.e. "c", "c++", "objc"). Will be detected from the source extensions if not provided.
+      optional : boolean
+        specifies that a build failure in the extension should not abort the build process, but simply not install the
+        failing extension.
+    """
+
+    # When adding arguments to this constructor, be sure to update setup_keywords in core.py.
+    def __init__(
+            self,
+            name: str,
+            sources: list[str],
+            include_dirs: list[str] | None = None,
+            define_macros: list[tuple[str, str]] | None = None,
+            undef_macros: list[str] | None = None,
+            library_dirs: list[str] | None = None,
+            libraries: list[str] | None = None,
+            runtime_library_dirs: list[str] | None = None,
+            extra_objects: list[str] | None = None,
+            extra_compile_args: list[str] | None = None,
+            extra_link_args: list[str] | None = None,
+            export_symbols: list[str] | None = None,
+            swig_opts: list[str] | None = None,
+            depends: list[str] | None = None,
+            language: str | None = None,
+            optional: str | None = None,
+            **kw,  # To catch unknown keywords
+    ):
+        if not isinstance(name, str):
+            raise TypeError("'name' must be a string")
+        if not (isinstance(sources, list) and all(isinstance(v, str) for v in sources)):
+            raise TypeError("'sources' must be a list of strings")
+
+        self.name = name
+        self.sources = sources
+        self.include_dirs = include_dirs or []
+        self.define_macros = define_macros or []
+        self.undef_macros = undef_macros or []
+        self.library_dirs = library_dirs or []
+        self.libraries = libraries or []
+        self.runtime_library_dirs = runtime_library_dirs or []
+        self.extra_objects = extra_objects or []
+        self.extra_compile_args = extra_compile_args or []
+        self.extra_link_args = extra_link_args or []
+        self.export_symbols = export_symbols or []
+        self.swig_opts = swig_opts or []
+        self.depends = depends or []
+        self.language = language
+        self.optional = optional
+
+        # If there are unknown keyword options, warn about them
+        if len(kw) > 0:
+            options = ', '.join(sorted([repr(option) for option in kw]))
+            msg = f'Unknown Extension options: {options}'
+            warnings.warn(msg)
+
+    def __repr__(self):
+        return f'<{self.__class__.__module__}.{self.__class__.__qualname__}({self.name!r}) at {id(self):#x}>'

omdev/exts/_distutils/file_util.py

@@ -0,0 +1,216 @@
+"""Utility functions for operating on single files."""
+import contextlib
+import logging
+import os
+
+from .errors import DistutilsFileError
+
+
+log = logging.getLogger(__name__)
+
+
+# for generating verbose output in 'copy_file()'
+_copy_action = {None: 'copying', 'hard': 'hard linking', 'sym': 'symbolically linking'}
+
+
+def _copy_file_contents(src, dst, buffer_size=16 * 1024):  # noqa: C901
+    """
+    Copy the file 'src' to 'dst'; both must be filenames.  Any error opening either file, reading from 'src', or writing
+    to 'dst', raises DistutilsFileError.  Data is read/written in chunks of 'buffer_size' bytes (default 16k).  No
+    attempt is made to handle anything apart from regular files.
+    """
+    # Stolen from shutil module in the standard library, but with custom error-handling added.
+    fsrc = None
+    fdst = None
+    try:
+        try:
+            fsrc = open(src, 'rb')  # noqa
+        except OSError as e:
+            raise DistutilsFileError(f"could not open '{src}': {e.strerror}") from None
+
+        if os.path.exists(dst):
+            try:
+                os.unlink(dst)
+            except OSError as e:
+                raise DistutilsFileError(f"could not delete '{dst}': {e.strerror}") from None
+
+        try:
+            fdst = open(dst, 'wb')  # noqa
+        except OSError as e:
+            raise DistutilsFileError(f"could not create '{dst}': {e.strerror}") from None
+
+        while True:
+            try:
+                buf = fsrc.read(buffer_size)
+            except OSError as e:
+                raise DistutilsFileError(f"could not read from '{src}': {e.strerror}") from None
+
+            if not buf:
+                break
+
+            try:
+                fdst.write(buf)
+            except OSError as e:
+                raise DistutilsFileError(f"could not write to '{dst}': {e.strerror}") from None
+
+    finally:
+        if fdst:
+            fdst.close()
+        if fsrc:
+            fsrc.close()
+
+
+def copy_file(  # noqa: C901
+        src,
+        dst,
+        preserve_mode=1,
+        preserve_times=1,
+        update=0,
+        link=None,
+        verbose=1,
+        dry_run=False,
+):
+    """
+    Copy a file 'src' to 'dst'.  If 'dst' is a directory, then 'src' is copied there with the same name; otherwise, it
+    must be a filename.  (If the file exists, it will be ruthlessly clobbered.)  If 'preserve_mode' is true (the
+    default), the file's mode (type and permission bits, or whatever is analogous on the current platform) is copied.
+    If 'preserve_times' is true (the default), the last-modified and last-access times are copied as well.  If 'update'
+    is true, 'src' will only be copied if 'dst' does not exist, or if 'dst' does exist but is older than 'src'.
+
+    'link' allows you to make hard links (os.link) or symbolic links (os.symlink) instead of copying: set it to "hard"
+    or "sym"; if it is None (the default), files are copied.  Don't set 'link' on systems that don't support it:
+    'copy_file()' doesn't check if hard or symbolic linking is available. If hardlink fails, falls back to
+    _copy_file_contents().
+
+    Under Mac OS, uses the native file copy function in macostools; on other systems, uses '_copy_file_contents()' to
+    copy file contents.
+
+    Return a tuple (dest_name, copied): 'dest_name' is the actual name of the output file, and 'copied' is true if the
+    file was copied (or would have been copied, if 'dry_run' true).
+    """
+    # if the destination file already exists, we clobber it if copying, but blow up if linking.  Hmmm.  And I don't know
+    # what macostools.copyfile() does.  Should definitely be consistent, and should probably blow up if destination
+    # exists and we would be changing it (ie. it's not already a hard/soft link to src OR (not update) and (src newer
+    # than dst).
+    from stat import S_IMODE
+    from stat import ST_ATIME
+    from stat import ST_MODE
+    from stat import ST_MTIME
+
+    from .modified import newer
+
+    if not os.path.isfile(src):
+        raise DistutilsFileError(f"can't copy '{src}': doesn't exist or not a regular file")
+
+    if os.path.isdir(dst):
+        dir = dst  # noqa
+        dst = os.path.join(dst, os.path.basename(src))
+    else:
+        dir = os.path.dirname(dst)  # noqa
+
+    if update and not newer(src, dst):
+        if verbose >= 1:
+            log.debug('not copying %s (output up-to-date)', src)
+        return (dst, 0)
+
+    try:
+        action = _copy_action[link]
+    except KeyError:
+        raise ValueError(f"invalid value '{link}' for 'link' argument") from None
+
+    if verbose >= 1:
+        if os.path.basename(dst) == os.path.basename(src):
+            log.info('%s %s -> %s', action, src, dir)
+        else:
+            log.info('%s %s -> %s', action, src, dst)
+
+    if dry_run:
+        return (dst, 1)
+
+    # If linking (hard or symbolic), use the appropriate system call (Unix only, of course, but that's the caller's
+    # responsibility)
+    elif link == 'hard':
+        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
+            try:
+                os.link(src, dst)
+            except OSError:
+                # If hard linking fails, fall back on copying file (some special filesystems don't support hard linking
+                # even under Unix, see issue #8876).
+                pass
+            else:
+                return (dst, 1)
+    elif link == 'sym':
+        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
+            os.symlink(src, dst)
+            return (dst, 1)
+
+    # Otherwise (non-Mac, not linking), copy the file contents and (optionally) copy the times and mode.
+    _copy_file_contents(src, dst)
+    if preserve_mode or preserve_times:
+        st = os.stat(src)
+
+        # According to David Ascher <da@ski.org>, utime() should be done before chmod() (at least under NT).
+        if preserve_times:
+            os.utime(dst, (st[ST_ATIME], st[ST_MTIME]))
+        if preserve_mode:
+            os.chmod(dst, S_IMODE(st[ST_MODE]))
+
+    return (dst, 1)
+
+
+# I suspect this is Unix-specific -- need porting help!
+def move_file(src, dst, verbose=1, dry_run=False):  # noqa: C901
+    """
+    Move a file 'src' to 'dst'.  If 'dst' is a directory, the file will be moved into it with the same name; otherwise,
+    'src' is just renamed to 'dst'.  Return the new full name of the file.
+
+    Handles cross-device moves on Unix using 'copy_file()'.  What about other systems???
+    """
+    import errno
+    from os.path import basename
+    from os.path import dirname
+    from os.path import exists
+    from os.path import isdir
+    from os.path import isfile
+
+    if verbose >= 1:
+        log.info('moving %s -> %s', src, dst)
+
+    if dry_run:
+        return dst
+
+    if not isfile(src):
+        raise DistutilsFileError(f"can't move '{src}': not a regular file")
+
+    if isdir(dst):
+        dst = os.path.join(dst, basename(src))
+    elif exists(dst):
+        raise DistutilsFileError(f"can't move '{src}': destination '{dst}' already exists")
+
+    if not isdir(dirname(dst)):
+        raise DistutilsFileError(f"can't move '{src}': destination '{dst}' not a valid path")
+
+    copy_it = False
+    try:
+        os.rename(src, dst)
+    except OSError as e:
+        (num, msg) = e.args
+        if num == errno.EXDEV:
+            copy_it = True
+        else:
+            raise DistutilsFileError(f"couldn't move '{src}' to '{dst}': {msg}") from None
+
+    if copy_it:
+        copy_file(src, dst, verbose=verbose)
+        try:
+            os.unlink(src)
+        except OSError as e:
+            (num, msg) = e.args
+            with contextlib.suppress(OSError):
+                os.unlink(dst)
+            raise DistutilsFileError(
+                f"couldn't move '{src}' to '{dst}' by copy/delete: "
+                f"delete '{src}' failed: {msg}",
+            ) from None
+
+    return dst

omdev/exts/_distutils/modified.py

@@ -0,0 +1,47 @@
+"""Timestamp comparison of files and groups of files."""
+import os.path
+
+from .errors import DistutilsFileError
+
+
+def _newer(source, target):
+    return not os.path.exists(target) or (os.path.getmtime(source) > os.path.getmtime(target))
+
+
+def newer(source, target):
+    """
+    Is source modified more recently than target.
+
+    Returns True if 'source' is modified more recently than 'target' or if 'target' does not exist.
+
+    Raises DistutilsFileError if 'source' does not exist.
+    """
+    if not os.path.exists(source):
+        raise DistutilsFileError(f"file '{os.path.abspath(source)}' does not exist")
+
+    return _newer(source, target)
+
+
+def newer_group(sources, target, missing='error'):
+    """
+    Is target out-of-date with respect to any file in sources.
+
+    Return True if 'target' is out-of-date with respect to any file listed in 'sources'. In other words, if 'target'
+    exists and is newer than every file in 'sources', return False; otherwise return True. ``missing`` controls how to
+    handle a missing source file:
+
+    - error (default): allow the ``stat()`` call to fail.
+    - ignore: silently disregard any missing source files.
+    - newer: treat missing source files as "target out of date". This mode is handy in "dry-run" mode: it will pretend
+      to carry out commands that wouldn't work because inputs are missing, but that doesn't matter because dry-run won't
+      run the commands.
+    """
+
+    def missing_as_newer(source):
+        return missing == 'newer' and not os.path.exists(source)
+
+    ignored = os.path.exists if missing == 'ignore' else None
+    return any(
+        missing_as_newer(source) or _newer(source, target)
+        for source in filter(ignored, sources)
+    )

omdev/exts/_distutils/spawn.py

@@ -0,0 +1,103 @@
+"""
+Provides the 'spawn()' function, a front-end to various platform-
+specific functions for launching another program in a sub-process.
+Also provides the 'find_executable()' to search the path for a given
+executable name.
+"""
+import logging
+import os
+import subprocess
+import sys
+
+from .errors import DistutilsExecError
+
+
+log = logging.getLogger(__name__)
+
+
+def spawn(cmd, search_path=1, verbose=0, dry_run=False, env=None, debug=False):  # noqa: C901
+    """
+    Run another program, specified as a command list 'cmd', in a new process.
+
+    'cmd' is just the argument list for the new process, ie. cmd[0] is the program to run and cmd[1:] are the rest of
+    its arguments. There is no way to run a program with a name different from that of its executable.
+
+    If 'search_path' is true (the default), the system's executable search path will be used to find the program;
+    otherwise, cmd[0] must be the exact path to the executable.  If 'dry_run' is true, the command will not actually be
+    run.
+
+    Raise DistutilsExecError if running the program fails in any way; just return on success.
+    """
+    # cmd is documented as a list, but just in case some code passes a tuple in, protect our %-formatting code against
+    # horrible death
+    cmd = list(cmd)
+
+    log.info(subprocess.list2cmdline(cmd))
+    if dry_run:
+        return
+
+    if search_path:
+        executable = find_executable(cmd[0])
+        if executable is not None:
+            cmd[0] = executable
+
+    env = env if env is not None else dict(os.environ)
+
+    if sys.platform == 'darwin':
+        from .util import MACOSX_VERSION_VAR
+        from .util import get_macosx_target_ver
+
+        macosx_target_ver = get_macosx_target_ver()
+        if macosx_target_ver:
+            env[MACOSX_VERSION_VAR] = macosx_target_ver
+
+    try:
+        proc = subprocess.Popen(cmd, env=env)
+        proc.wait()
+        exitcode = proc.returncode
+    except OSError as exc:
+        if not debug:
+            cmd = cmd[0]
+        raise DistutilsExecError(f'command {cmd!r} failed: {exc.args[-1]}') from exc
+
+    if exitcode:
+        if not debug:
+            cmd = cmd[0]
+        raise DistutilsExecError(f'command {cmd!r} failed with exit code {exitcode}')
+
+
+def find_executable(executable, path=None):
+    """
+    Tries to find 'executable' in the directories listed in 'path'.
+
+    A string listing directories separated by 'os.pathsep'; defaults to os.environ['PATH'].  Returns the complete
+    filename or None if not found.
+    """
+    _, ext = os.path.splitext(executable)
+    if (sys.platform == 'win32') and (ext != '.exe'):
+        executable = executable + '.exe'
+
+    if os.path.isfile(executable):
+        return executable
+
+    if path is None:
+        path = os.environ.get('PATH', None)
+        if path is None:
+            try:
+                path = os.confstr('CS_PATH')
+            except (AttributeError, ValueError):
+                # os.confstr() or CS_PATH is not available
+                path = os.defpath
+        # bpo-35755: Don't use os.defpath if the PATH environment variable is set to an empty string
+
+    # PATH='' doesn't match, whereas PATH=':' looks in the current directory
+    if not path:
+        return None
+
+    paths = path.split(os.pathsep)
+    for p in paths:
+        f = os.path.join(p, executable)
+        if os.path.isfile(f):
+            # the file exists, we have a shot at spawn working
+            return f
+    return None