@motiadev/core 0.2.1-beta.58 → 0.2.1-beta.60

package/python_modules/lib/python3.11/site-packages/setuptools/_distutils/text_file.py

@@ -1,287 +0,0 @@
-"""text_file
-
-provides the TextFile class, which gives an interface to text files
-that (optionally) takes care of stripping comments, ignoring blank
-lines, and joining lines with backslashes."""
-
-import sys
-
-
-class TextFile:
-    """Provides a file-like object that takes care of all the things you
-    commonly want to do when processing a text file that has some
-    line-by-line syntax: strip comments (as long as "#" is your
-    comment character), skip blank lines, join adjacent lines by
-    escaping the newline (ie. backslash at end of line), strip
-    leading and/or trailing whitespace.  All of these are optional
-    and independently controllable.
-
-    Provides a 'warn()' method so you can generate warning messages that
-    report physical line number, even if the logical line in question
-    spans multiple physical lines.  Also provides 'unreadline()' for
-    implementing line-at-a-time lookahead.
-
-    Constructor is called as:
-
-        TextFile (filename=None, file=None, **options)
-
-    It bombs (RuntimeError) if both 'filename' and 'file' are None;
-    'filename' should be a string, and 'file' a file object (or
-    something that provides 'readline()' and 'close()' methods).  It is
-    recommended that you supply at least 'filename', so that TextFile
-    can include it in warning messages.  If 'file' is not supplied,
-    TextFile creates its own using 'io.open()'.
-
-    The options are all boolean, and affect the value returned by
-    'readline()':
-      strip_comments [default: true]
-        strip from "#" to end-of-line, as well as any whitespace
-        leading up to the "#" -- unless it is escaped by a backslash
-      lstrip_ws [default: false]
-        strip leading whitespace from each line before returning it
-      rstrip_ws [default: true]
-        strip trailing whitespace (including line terminator!) from
-        each line before returning it
-      skip_blanks [default: true}
-        skip lines that are empty *after* stripping comments and
-        whitespace.  (If both lstrip_ws and rstrip_ws are false,
-        then some lines may consist of solely whitespace: these will
-        *not* be skipped, even if 'skip_blanks' is true.)
-      join_lines [default: false]
-        if a backslash is the last non-newline character on a line
-        after stripping comments and whitespace, join the following line
-        to it to form one "logical line"; if N consecutive lines end
-        with a backslash, then N+1 physical lines will be joined to
-        form one logical line.
-      collapse_join [default: false]
-        strip leading whitespace from lines that are joined to their
-        predecessor; only matters if (join_lines and not lstrip_ws)
-      errors [default: 'strict']
-        error handler used to decode the file content
-
-    Note that since 'rstrip_ws' can strip the trailing newline, the
-    semantics of 'readline()' must differ from those of the builtin file
-    object's 'readline()' method!  In particular, 'readline()' returns
-    None for end-of-file: an empty string might just be a blank line (or
-    an all-whitespace line), if 'rstrip_ws' is true but 'skip_blanks' is
-    not."""
-
-    default_options = {
-        'strip_comments': 1,
-        'skip_blanks': 1,
-        'lstrip_ws': 0,
-        'rstrip_ws': 1,
-        'join_lines': 0,
-        'collapse_join': 0,
-        'errors': 'strict',
-    }
-
-    def __init__(self, filename=None, file=None, **options):
-        """Construct a new TextFile object.  At least one of 'filename'
-        (a string) and 'file' (a file-like object) must be supplied.
-        They keyword argument options are described above and affect
-        the values returned by 'readline()'."""
-        if filename is None and file is None:
-            raise RuntimeError(
-                "you must supply either or both of 'filename' and 'file'"
-            )
-
-        # set values for all options -- either from client option hash
-        # or fallback to default_options
-        for opt in self.default_options.keys():
-            if opt in options:
-                setattr(self, opt, options[opt])
-            else:
-                setattr(self, opt, self.default_options[opt])
-
-        # sanity check client option hash
-        for opt in options.keys():
-            if opt not in self.default_options:
-                raise KeyError("invalid TextFile option '%s'" % opt)
-
-        if file is None:
-            self.open(filename)
-        else:
-            self.filename = filename
-            self.file = file
-            self.current_line = 0  # assuming that file is at BOF!
-
-        # 'linebuf' is a stack of lines that will be emptied before we
-        # actually read from the file; it's only populated by an
-        # 'unreadline()' operation
-        self.linebuf = []
-
-    def open(self, filename):
-        """Open a new file named 'filename'.  This overrides both the
-        'filename' and 'file' arguments to the constructor."""
-        self.filename = filename
-        self.file = open(self.filename, errors=self.errors)
-        self.current_line = 0
-
-    def close(self):
-        """Close the current file and forget everything we know about it
-        (filename, current line number)."""
-        file = self.file
-        self.file = None
-        self.filename = None
-        self.current_line = None
-        file.close()
-
-    def gen_error(self, msg, line=None):
-        outmsg = []
-        if line is None:
-            line = self.current_line
-        outmsg.append(self.filename + ", ")
-        if isinstance(line, (list, tuple)):
-            outmsg.append("lines %d-%d: " % tuple(line))
-        else:
-            outmsg.append("line %d: " % line)
-        outmsg.append(str(msg))
-        return "".join(outmsg)
-
-    def error(self, msg, line=None):
-        raise ValueError("error: " + self.gen_error(msg, line))
-
-    def warn(self, msg, line=None):
-        """Print (to stderr) a warning message tied to the current logical
-        line in the current file.  If the current logical line in the
-        file spans multiple physical lines, the warning refers to the
-        whole range, eg. "lines 3-5".  If 'line' supplied, it overrides
-        the current line number; it may be a list or tuple to indicate a
-        range of physical lines, or an integer for a single physical
-        line."""
-        sys.stderr.write("warning: " + self.gen_error(msg, line) + "\n")
-
-    def readline(self):  # noqa: C901
-        """Read and return a single logical line from the current file (or
-        from an internal buffer if lines have previously been "unread"
-        with 'unreadline()').  If the 'join_lines' option is true, this
-        may involve reading multiple physical lines concatenated into a
-        single string.  Updates the current line number, so calling
-        'warn()' after 'readline()' emits a warning about the physical
-        line(s) just read.  Returns None on end-of-file, since the empty
-        string can occur if 'rstrip_ws' is true but 'strip_blanks' is
-        not."""
-        # If any "unread" lines waiting in 'linebuf', return the top
-        # one.  (We don't actually buffer read-ahead data -- lines only
-        # get put in 'linebuf' if the client explicitly does an
-        # 'unreadline()'.
-        if self.linebuf:
-            line = self.linebuf[-1]
-            del self.linebuf[-1]
-            return line
-
-        buildup_line = ''
-
-        while True:
-            # read the line, make it None if EOF
-            line = self.file.readline()
-            if line == '':
-                line = None
-
-            if self.strip_comments and line:
-
-                # Look for the first "#" in the line.  If none, never
-                # mind.  If we find one and it's the first character, or
-                # is not preceded by "\", then it starts a comment --
-                # strip the comment, strip whitespace before it, and
-                # carry on.  Otherwise, it's just an escaped "#", so
-                # unescape it (and any other escaped "#"'s that might be
-                # lurking in there) and otherwise leave the line alone.
-
-                pos = line.find("#")
-                if pos == -1:  # no "#" -- no comments
-                    pass
-
-                # It's definitely a comment -- either "#" is the first
-                # character, or it's elsewhere and unescaped.
-                elif pos == 0 or line[pos - 1] != "\\":
-                    # Have to preserve the trailing newline, because it's
-                    # the job of a later step (rstrip_ws) to remove it --
-                    # and if rstrip_ws is false, we'd better preserve it!
-                    # (NB. this means that if the final line is all comment
-                    # and has no trailing newline, we will think that it's
-                    # EOF; I think that's OK.)
-                    eol = (line[-1] == '\n') and '\n' or ''
-                    line = line[0:pos] + eol
-
-                    # If all that's left is whitespace, then skip line
-                    # *now*, before we try to join it to 'buildup_line' --
-                    # that way constructs like
-                    #   hello \\
-                    #   # comment that should be ignored
-                    #   there
-                    # result in "hello there".
-                    if line.strip() == "":
-                        continue
-                else:  # it's an escaped "#"
-                    line = line.replace("\\#", "#")
-
-            # did previous line end with a backslash? then accumulate
-            if self.join_lines and buildup_line:
-                # oops: end of file
-                if line is None:
-                    self.warn("continuation line immediately precedes " "end-of-file")
-                    return buildup_line
-
-                if self.collapse_join:
-                    line = line.lstrip()
-                line = buildup_line + line
-
-                # careful: pay attention to line number when incrementing it
-                if isinstance(self.current_line, list):
-                    self.current_line[1] = self.current_line[1] + 1
-                else:
-                    self.current_line = [self.current_line, self.current_line + 1]
-            # just an ordinary line, read it as usual
-            else:
-                if line is None:  # eof
-                    return None
-
-                # still have to be careful about incrementing the line number!
-                if isinstance(self.current_line, list):
-                    self.current_line = self.current_line[1] + 1
-                else:
-                    self.current_line = self.current_line + 1
-
-            # strip whitespace however the client wants (leading and
-            # trailing, or one or the other, or neither)
-            if self.lstrip_ws and self.rstrip_ws:
-                line = line.strip()
-            elif self.lstrip_ws:
-                line = line.lstrip()
-            elif self.rstrip_ws:
-                line = line.rstrip()
-
-            # blank line (whether we rstrip'ed or not)? skip to next line
-            # if appropriate
-            if (line == '' or line == '\n') and self.skip_blanks:
-                continue
-
-            if self.join_lines:
-                if line[-1] == '\\':
-                    buildup_line = line[:-1]
-                    continue
-
-                if line[-2:] == '\\\n':
-                    buildup_line = line[0:-2] + '\n'
-                    continue
-
-            # well, I guess there's some actual content there: return it
-            return line
-
-    def readlines(self):
-        """Read and return the list of all logical lines remaining in the
-        current file."""
-        lines = []
-        while True:
-            line = self.readline()
-            if line is None:
-                return lines
-            lines.append(line)
-
-    def unreadline(self, line):
-        """Push 'line' (a string) onto an internal buffer that will be
-        checked by future 'readline()' calls.  Handy for implementing
-        a parser with line-at-a-time lookahead."""
-        self.linebuf.append(line)

package/python_modules/lib/python3.11/site-packages/setuptools/_distutils/unixccompiler.py

@@ -1,401 +0,0 @@
-"""distutils.unixccompiler
-
-Contains the UnixCCompiler class, a subclass of CCompiler that handles
-the "typical" Unix-style command-line C compiler:
-  * macros defined with -Dname[=value]
-  * macros undefined with -Uname
-  * include search directories specified with -Idir
-  * libraries specified with -lllib
-  * library search directories specified with -Ldir
-  * compile handled by 'cc' (or similar) executable with -c option:
-    compiles .c to .o
-  * link static library handled by 'ar' command (possibly with 'ranlib')
-  * link shared library handled by 'cc -shared'
-"""
-
-import os
-import sys
-import re
-import shlex
-import itertools
-
-from distutils import sysconfig
-from distutils.dep_util import newer
-from distutils.ccompiler import CCompiler, gen_preprocess_options, gen_lib_options
-from distutils.errors import DistutilsExecError, CompileError, LibError, LinkError
-from distutils import log
-from ._macos_compat import compiler_fixup
-
-# XXX Things not currently handled:
-#   * optimization/debug/warning flags; we just use whatever's in Python's
-#     Makefile and live with it.  Is this adequate?  If not, we might
-#     have to have a bunch of subclasses GNUCCompiler, SGICCompiler,
-#     SunCCompiler, and I suspect down that road lies madness.
-#   * even if we don't know a warning flag from an optimization flag,
-#     we need some way for outsiders to feed preprocessor/compiler/linker
-#     flags in to us -- eg. a sysadmin might want to mandate certain flags
-#     via a site config file, or a user might want to set something for
-#     compiling this module distribution only via the setup.py command
-#     line, whatever.  As long as these options come from something on the
-#     current system, they can be as system-dependent as they like, and we
-#     should just happily stuff them into the preprocessor/compiler/linker
-#     options and carry on.
-
-
-def _split_env(cmd):
-    """
-    For macOS, split command into 'env' portion (if any)
-    and the rest of the linker command.
-
-    >>> _split_env(['a', 'b', 'c'])
-    ([], ['a', 'b', 'c'])
-    >>> _split_env(['/usr/bin/env', 'A=3', 'gcc'])
-    (['/usr/bin/env', 'A=3'], ['gcc'])
-    """
-    pivot = 0
-    if os.path.basename(cmd[0]) == "env":
-        pivot = 1
-        while '=' in cmd[pivot]:
-            pivot += 1
-    return cmd[:pivot], cmd[pivot:]
-
-
-def _split_aix(cmd):
-    """
-    AIX platforms prefix the compiler with the ld_so_aix
-    script, so split that from the linker command.
-
-    >>> _split_aix(['a', 'b', 'c'])
-    ([], ['a', 'b', 'c'])
-    >>> _split_aix(['/bin/foo/ld_so_aix', 'gcc'])
-    (['/bin/foo/ld_so_aix'], ['gcc'])
-    """
-    pivot = os.path.basename(cmd[0]) == 'ld_so_aix'
-    return cmd[:pivot], cmd[pivot:]
-
-
-def _linker_params(linker_cmd, compiler_cmd):
-    """
-    The linker command usually begins with the compiler
-    command (possibly multiple elements), followed by zero or more
-    params for shared library building.
-
-    If the LDSHARED env variable overrides the linker command,
-    however, the commands may not match.
-
-    Return the best guess of the linker parameters by stripping
-    the linker command. If the compiler command does not
-    match the linker command, assume the linker command is
-    just the first element.
-
-    >>> _linker_params('gcc foo bar'.split(), ['gcc'])
-    ['foo', 'bar']
-    >>> _linker_params('gcc foo bar'.split(), ['other'])
-    ['foo', 'bar']
-    >>> _linker_params('ccache gcc foo bar'.split(), 'ccache gcc'.split())
-    ['foo', 'bar']
-    >>> _linker_params(['gcc'], ['gcc'])
-    []
-    """
-    c_len = len(compiler_cmd)
-    pivot = c_len if linker_cmd[:c_len] == compiler_cmd else 1
-    return linker_cmd[pivot:]
-
-
-class UnixCCompiler(CCompiler):
-
-    compiler_type = 'unix'
-
-    # These are used by CCompiler in two places: the constructor sets
-    # instance attributes 'preprocessor', 'compiler', etc. from them, and
-    # 'set_executable()' allows any of these to be set.  The defaults here
-    # are pretty generic; they will probably have to be set by an outsider
-    # (eg. using information discovered by the sysconfig about building
-    # Python extensions).
-    executables = {
-        'preprocessor': None,
-        'compiler': ["cc"],
-        'compiler_so': ["cc"],
-        'compiler_cxx': ["cc"],
-        'linker_so': ["cc", "-shared"],
-        'linker_exe': ["cc"],
-        'archiver': ["ar", "-cr"],
-        'ranlib': None,
-    }
-
-    if sys.platform[:6] == "darwin":
-        executables['ranlib'] = ["ranlib"]
-
-    # Needed for the filename generation methods provided by the base
-    # class, CCompiler.  NB. whoever instantiates/uses a particular
-    # UnixCCompiler instance should set 'shared_lib_ext' -- we set a
-    # reasonable common default here, but it's not necessarily used on all
-    # Unices!
-
-    src_extensions = [".c", ".C", ".cc", ".cxx", ".cpp", ".m"]
-    obj_extension = ".o"
-    static_lib_extension = ".a"
-    shared_lib_extension = ".so"
-    dylib_lib_extension = ".dylib"
-    xcode_stub_lib_extension = ".tbd"
-    static_lib_format = shared_lib_format = dylib_lib_format = "lib%s%s"
-    xcode_stub_lib_format = dylib_lib_format
-    if sys.platform == "cygwin":
-        exe_extension = ".exe"
-
-    def preprocess(
-        self,
-        source,
-        output_file=None,
-        macros=None,
-        include_dirs=None,
-        extra_preargs=None,
-        extra_postargs=None,
-    ):
-        fixed_args = self._fix_compile_args(None, macros, include_dirs)
-        ignore, macros, include_dirs = fixed_args
-        pp_opts = gen_preprocess_options(macros, include_dirs)
-        pp_args = self.preprocessor + pp_opts
-        if output_file:
-            pp_args.extend(['-o', output_file])
-        if extra_preargs:
-            pp_args[:0] = extra_preargs
-        if extra_postargs:
-            pp_args.extend(extra_postargs)
-        pp_args.append(source)
-
-        # reasons to preprocess:
-        # - force is indicated
-        # - output is directed to stdout
-        # - source file is newer than the target
-        preprocess = self.force or output_file is None or newer(source, output_file)
-        if not preprocess:
-            return
-
-        if output_file:
-            self.mkpath(os.path.dirname(output_file))
-
-        try:
-            self.spawn(pp_args)
-        except DistutilsExecError as msg:
-            raise CompileError(msg)
-
-    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
-        compiler_so = compiler_fixup(self.compiler_so, cc_args + extra_postargs)
-        try:
-            self.spawn(compiler_so + cc_args + [src, '-o', obj] + extra_postargs)
-        except DistutilsExecError as msg:
-            raise CompileError(msg)
-
-    def create_static_lib(
-        self, objects, output_libname, output_dir=None, debug=0, target_lang=None
-    ):
-        objects, output_dir = self._fix_object_args(objects, output_dir)
-
-        output_filename = self.library_filename(output_libname, output_dir=output_dir)
-
-        if self._need_link(objects, output_filename):
-            self.mkpath(os.path.dirname(output_filename))
-            self.spawn(self.archiver + [output_filename] + objects + self.objects)
-
-            # Not many Unices required ranlib anymore -- SunOS 4.x is, I
-            # think the only major Unix that does.  Maybe we need some
-            # platform intelligence here to skip ranlib if it's not
-            # needed -- or maybe Python's configure script took care of
-            # it for us, hence the check for leading colon.
-            if self.ranlib:
-                try:
-                    self.spawn(self.ranlib + [output_filename])
-                except DistutilsExecError as msg:
-                    raise LibError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-    def link(
-        self,
-        target_desc,
-        objects,
-        output_filename,
-        output_dir=None,
-        libraries=None,
-        library_dirs=None,
-        runtime_library_dirs=None,
-        export_symbols=None,
-        debug=0,
-        extra_preargs=None,
-        extra_postargs=None,
-        build_temp=None,
-        target_lang=None,
-    ):
-        objects, output_dir = self._fix_object_args(objects, output_dir)
-        fixed_args = self._fix_lib_args(libraries, library_dirs, runtime_library_dirs)
-        libraries, library_dirs, runtime_library_dirs = fixed_args
-
-        lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs, libraries)
-        if not isinstance(output_dir, (str, type(None))):
-            raise TypeError("'output_dir' must be a string or None")
-        if output_dir is not None:
-            output_filename = os.path.join(output_dir, output_filename)
-
-        if self._need_link(objects, output_filename):
-            ld_args = objects + self.objects + lib_opts + ['-o', output_filename]
-            if debug:
-                ld_args[:0] = ['-g']
-            if extra_preargs:
-                ld_args[:0] = extra_preargs
-            if extra_postargs:
-                ld_args.extend(extra_postargs)
-            self.mkpath(os.path.dirname(output_filename))
-            try:
-                # Select a linker based on context: linker_exe when
-                # building an executable or linker_so (with shared options)
-                # when building a shared library.
-                building_exe = target_desc == CCompiler.EXECUTABLE
-                linker = (self.linker_exe if building_exe else self.linker_so)[:]
-
-                if target_lang == "c++" and self.compiler_cxx:
-                    env, linker_ne = _split_env(linker)
-                    aix, linker_na = _split_aix(linker_ne)
-                    _, compiler_cxx_ne = _split_env(self.compiler_cxx)
-                    _, linker_exe_ne = _split_env(self.linker_exe)
-
-                    params = _linker_params(linker_na, linker_exe_ne)
-                    linker = env + aix + compiler_cxx_ne + params
-
-                linker = compiler_fixup(linker, ld_args)
-
-                self.spawn(linker + ld_args)
-            except DistutilsExecError as msg:
-                raise LinkError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-    # -- Miscellaneous methods -----------------------------------------
-    # These are all used by the 'gen_lib_options() function, in
-    # ccompiler.py.
-
-    def library_dir_option(self, dir):
-        return "-L" + dir
-
-    def _is_gcc(self):
-        cc_var = sysconfig.get_config_var("CC")
-        compiler = os.path.basename(shlex.split(cc_var)[0])
-        return "gcc" in compiler or "g++" in compiler
-
-    def runtime_library_dir_option(self, dir):
-        # XXX Hackish, at the very least.  See Python bug #445902:
-        # http://sourceforge.net/tracker/index.php
-        #   ?func=detail&aid=445902&group_id=5470&atid=105470
-        # Linkers on different platforms need different options to
-        # specify that directories need to be added to the list of
-        # directories searched for dependencies when a dynamic library
-        # is sought.  GCC on GNU systems (Linux, FreeBSD, ...) has to
-        # be told to pass the -R option through to the linker, whereas
-        # other compilers and gcc on other systems just know this.
-        # Other compilers may need something slightly different.  At
-        # this time, there's no way to determine this information from
-        # the configuration data stored in the Python installation, so
-        # we use this hack.
-        if sys.platform[:6] == "darwin":
-            from distutils.util import get_macosx_target_ver, split_version
-
-            macosx_target_ver = get_macosx_target_ver()
-            if macosx_target_ver and split_version(macosx_target_ver) >= [10, 5]:
-                return "-Wl,-rpath," + dir
-            else:  # no support for -rpath on earlier macOS versions
-                return "-L" + dir
-        elif sys.platform[:7] == "freebsd":
-            return "-Wl,-rpath=" + dir
-        elif sys.platform[:5] == "hp-ux":
-            return [
-                "-Wl,+s" if self._is_gcc() else "+s",
-                "-L" + dir,
-            ]
-
-        # For all compilers, `-Wl` is the presumed way to
-        # pass a compiler option to the linker and `-R` is
-        # the way to pass an RPATH.
-        if sysconfig.get_config_var("GNULD") == "yes":
-            # GNU ld needs an extra option to get a RUNPATH
-            # instead of just an RPATH.
-            return "-Wl,--enable-new-dtags,-R" + dir
-        else:
-            return "-Wl,-R" + dir
-
-    def library_option(self, lib):
-        return "-l" + lib
-
-    @staticmethod
-    def _library_root(dir):
-        """
-        macOS users can specify an alternate SDK using'-isysroot'.
-        Calculate the SDK root if it is specified.
-
-        Note that, as of Xcode 7, Apple SDKs may contain textual stub
-        libraries with .tbd extensions rather than the normal .dylib
-        shared libraries installed in /.  The Apple compiler tool
-        chain handles this transparently but it can cause problems
-        for programs that are being built with an SDK and searching
-        for specific libraries.  Callers of find_library_file need to
-        keep in mind that the base filename of the returned SDK library
-        file might have a different extension from that of the library
-        file installed on the running system, for example:
-          /Applications/Xcode.app/Contents/Developer/Platforms/
-              MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk/
-              usr/lib/libedit.tbd
-        vs
-          /usr/lib/libedit.dylib
-        """
-        cflags = sysconfig.get_config_var('CFLAGS')
-        match = re.search(r'-isysroot\s*(\S+)', cflags)
-
-        apply_root = (
-            sys.platform == 'darwin'
-            and match
-            and (
-                dir.startswith('/System/')
-                or (dir.startswith('/usr/') and not dir.startswith('/usr/local/'))
-            )
-        )
-
-        return os.path.join(match.group(1), dir[1:]) if apply_root else dir
-
-    def find_library_file(self, dirs, lib, debug=0):
-        r"""
-        Second-guess the linker with not much hard
-        data to go on: GCC seems to prefer the shared library, so
-        assume that *all* Unix C compilers do,
-        ignoring even GCC's "-static" option.
-
-        >>> compiler = UnixCCompiler()
-        >>> compiler._library_root = lambda dir: dir
-        >>> monkeypatch = getfixture('monkeypatch')
-        >>> monkeypatch.setattr(os.path, 'exists', lambda d: 'existing' in d)
-        >>> dirs = ('/foo/bar/missing', '/foo/bar/existing')
-        >>> compiler.find_library_file(dirs, 'abc').replace('\\', '/')
-        '/foo/bar/existing/libabc.dylib'
-        >>> compiler.find_library_file(reversed(dirs), 'abc').replace('\\', '/')
-        '/foo/bar/existing/libabc.dylib'
-        >>> monkeypatch.setattr(os.path, 'exists',
-        ...     lambda d: 'existing' in d and '.a' in d)
-        >>> compiler.find_library_file(dirs, 'abc').replace('\\', '/')
-        '/foo/bar/existing/libabc.a'
-        >>> compiler.find_library_file(reversed(dirs), 'abc').replace('\\', '/')
-        '/foo/bar/existing/libabc.a'
-        """
-        lib_names = (
-            self.library_filename(lib, lib_type=type)
-            for type in 'dylib xcode_stub shared static'.split()
-        )
-
-        roots = map(self._library_root, dirs)
-
-        searched = (
-            os.path.join(root, lib_name)
-            for root, lib_name in itertools.product(roots, lib_names)
-        )
-
-        found = filter(os.path.exists, searched)
-
-        # Return None if it could not be found in any dir.
-        return next(found, None)