Source code for SCons.Util

# MIT License
# Copyright The SCons Foundation
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.

SCons utility functions

This package contains routines for use by other parts of SCons.
Candidates for inclusion here are routines that do not need other parts
of SCons (other than Util), and have a reasonable chance of being useful
in multiple places, rather then being topical only to one module/package.

# Warning: SCons.Util may not be able to import other parts of SCons
# globally without hitting import loops, as various modules import
# SCons.Util themselves. If a top-level import fails, try a local import.
# If local imports work, please annotate them for pylint (and for human
# readers) to know why, with:
#   importstuff  # pylint: disable=import-outside-toplevel
# Be aware that Black will break this if the annotated line is too long -
# which it almost certainly will be. It will split it like this:
#       from SCons.Errors import (
#           SConsEnvironmentError,
#       )  # pylint: disable=import-outside-toplevel
# That's syntactically valid as far as Python goes, but pylint will not
# recorgnize the annotation comment unless it's on the first line, like:
#       from SCons.Errors import (  # pylint: disable=import-outside-toplevel
#           SConsEnvironmentError,
#       )
# (issue filed on this upstream, for now just be aware)

import copy
import hashlib
import logging
import os
import re
import sys
import time
from collections import UserDict, UserList, deque
from contextlib import suppress
from types import MethodType, FunctionType
from typing import Optional, Union, Any, List
from logging import Formatter

# Util split into a package. Make sure things that used to work
# when importing just Util itself still work:
from .sctypes import (
from .hashes import (
from .envs import (
from .filelock import FileLock, SConsLockFailure

PYPY = hasattr(sys, 'pypy_translation_info')

# this string will be hashed if a Node refers to a file that doesn't exist
# in order to distinguish from a file that exists but is empty.

# unused?
[docs]def dictify(keys, values, result=None) -> dict: if result is None: result = {} result.update(zip(keys, values)) return result
_ALTSEP = os.altsep if _ALTSEP is None and sys.platform == 'win32': # My ActivePython 2.0.1 doesn't set os.altsep! What gives? _ALTSEP = '/' if _ALTSEP: def rightmost_separator(path, sep): return max(path.rfind(sep), path.rfind(_ALTSEP)) else:
[docs] def rightmost_separator(path, sep): return path.rfind(sep)
# First two from the Python Cookbook, just for completeness. # (Yeah, yeah, YAGNI...)
[docs]def containsAny(s, pat) -> bool: """Check whether string `s` contains ANY of the items in `pat`.""" return any(c in s for c in pat)
[docs]def containsAll(s, pat) -> bool: """Check whether string `s` contains ALL of the items in `pat`.""" return all(c in s for c in pat)
[docs]def containsOnly(s, pat) -> bool: """Check whether string `s` contains ONLY items in `pat`.""" for c in s: if c not in pat: return False return True
# TODO: Verify this method is STILL faster than os.path.splitext
[docs]def splitext(path) -> tuple: """Split `path` into a (root, ext) pair. Same as :mod:`os.path.splitext` but faster. """ sep = rightmost_separator(path, os.sep) dot = path.rfind('.') # An ext is only real if it has at least one non-digit char if dot > sep and not path[dot + 1:].isdigit(): return path[:dot], path[dot:] return path, ""
[docs]def updrive(path) -> str: """Make the drive letter (if any) upper case. This is useful because Windows is inconsistent on the case of the drive letter, which can cause inconsistencies when calculating command signatures. """ drive, rest = os.path.splitdrive(path) if drive: path = drive.upper() + rest return path
[docs]class NodeList(UserList): """A list of Nodes with special attribute retrieval. Unlike an ordinary list, access to a member's attribute returns a `NodeList` containing the same attribute for each member. Although this can hold any object, it is intended for use when processing Nodes, where fetching an attribute of each member is very commone, for example getting the content signature of each node. The term "attribute" here includes the string representation. >>> someList = NodeList([' foo ', ' bar ']) >>> someList.strip() ['foo', 'bar'] """ def __bool__(self) -> bool: return bool( def __str__(self) -> str: return ' '.join(map(str, def __iter__(self): return iter( def __call__(self, *args, **kwargs) -> 'NodeList': result = [x(*args, **kwargs) for x in] return self.__class__(result)
[docs] def __getattr__(self, name) -> 'NodeList': """Returns a NodeList of `name` from each member.""" result = [getattr(x, name) for x in] return self.__class__(result)
[docs] def __getitem__(self, index): """Returns one item, forces a `NodeList` if `index` is a slice.""" # TODO: annotate return how? Union[] - don't know type of single item if isinstance(index, slice): return self.__class__([index]) return[index]
[docs]class DisplayEngine: """A callable class used to display SCons messages.""" print_it = True def __call__(self, text, append_newline: int=1) -> None: if not self.print_it: return if append_newline: text = text + '\n' # Stdout might be connected to a pipe that has been closed # by now. The most likely reason for the pipe being closed # is that the user has press ctrl-c. It this is the case, # then SCons is currently shutdown. We therefore ignore # IOError's here so that SCons can continue and shutdown # properly so that the .sconsign is correctly written # before SCons exits. with suppress(IOError): sys.stdout.write(str(text))
[docs] def set_mode(self, mode) -> None: self.print_it = mode
display = DisplayEngine() # TODO: check if this could cause problems # pylint: disable=dangerous-default-value
[docs]def render_tree( root, child_func, prune: bool = False, margin: List[bool] = [False], visited: Optional[dict] = None, ) -> str: """Render a tree of nodes into an ASCII tree view. Args: root: the root node of the tree child_func: the function called to get the children of a node prune: don't visit the same node twice margin: the format of the left margin to use for children of *root*. Each entry represents a column where a true value will display a vertical bar and a false one a blank. visited: a dictionary of visited nodes in the current branch if *prune* is false, or in the whole tree if *prune* is true. """ rname = str(root) # Initialize 'visited' dict, if required if visited is None: visited = {} children = child_func(root) retval = "" for pipe in margin[:-1]: if pipe: retval = retval + "| " else: retval = retval + " " if rname in visited: return retval + "+-[" + rname + "]\n" retval = retval + "+-" + rname + "\n" if not prune: visited = copy.copy(visited) visited[rname] = True for i, child in enumerate(children): margin.append(i < len(children) - 1) retval = retval + render_tree(child, child_func, prune, margin, visited) margin.pop() return retval
[docs]def IDX(n) -> bool: """Generate in index into strings from the tree legends. These are always a choice between two, so bool works fine. """ return bool(n)
# unicode line drawing chars: BOX_HORIZ = chr(0x2500) # '─' BOX_VERT = chr(0x2502) # '│' BOX_UP_RIGHT = chr(0x2514) # '└' BOX_DOWN_RIGHT = chr(0x250c) # '┌' BOX_DOWN_LEFT = chr(0x2510) # '┐' BOX_UP_LEFT = chr(0x2518) # '┘' BOX_VERT_RIGHT = chr(0x251c) # '├' BOX_HORIZ_DOWN = chr(0x252c) # '┬' # TODO: check if this could cause problems # pylint: disable=dangerous-default-value
[docs]def do_flatten( # pylint: disable=redefined-outer-name,redefined-builtin sequence, result, isinstance=isinstance, StringTypes=StringTypes, SequenceTypes=SequenceTypes, ) -> None: for item in sequence: if isinstance(item, StringTypes) or not isinstance(item, SequenceTypes): result.append(item) else: do_flatten(item, result)
[docs]def flatten( # pylint: disable=redefined-outer-name,redefined-builtin obj, isinstance=isinstance, StringTypes=StringTypes, SequenceTypes=SequenceTypes, do_flatten=do_flatten, ) -> list: """Flatten a sequence to a non-nested list. Converts either a single scalar or a nested sequence to a non-nested list. Note that :func:`flatten` considers strings to be scalars instead of sequences like pure Python would. """ if isinstance(obj, StringTypes) or not isinstance(obj, SequenceTypes): return [obj] result = [] for item in obj: if isinstance(item, StringTypes) or not isinstance(item, SequenceTypes): result.append(item) else: do_flatten(item, result) return result
[docs]def flatten_sequence( # pylint: disable=redefined-outer-name,redefined-builtin sequence, isinstance=isinstance, StringTypes=StringTypes, SequenceTypes=SequenceTypes, do_flatten=do_flatten, ) -> list: """Flatten a sequence to a non-nested list. Same as :func:`flatten`, but it does not handle the single scalar case. This is slightly more efficient when one knows that the sequence to flatten can not be a scalar. """ result = [] for item in sequence: if isinstance(item, StringTypes) or not isinstance(item, SequenceTypes): result.append(item) else: do_flatten(item, result) return result
# The SCons "semi-deep" copy. # # This makes separate copies of lists (including UserList objects) # dictionaries (including UserDict objects) and tuples, but just copies # references to anything else it finds. # # A special case is any object that has a __semi_deepcopy__() method, # which we invoke to create the copy. Currently only used by # BuilderDict to actually prevent the copy operation (as invalid on that object). # # The dispatch table approach used here is a direct rip-off from the # normal Python copy module.
[docs]def semi_deepcopy_dict(obj, exclude=None) -> dict: if exclude is None: exclude = [] return {k: semi_deepcopy(v) for k, v in obj.items() if k not in exclude}
[docs]def _semi_deepcopy_list(obj) -> list: return [semi_deepcopy(item) for item in obj]
[docs]def _semi_deepcopy_tuple(obj) -> tuple: return tuple(map(semi_deepcopy, obj))
_semi_deepcopy_dispatch = { dict: semi_deepcopy_dict, list: _semi_deepcopy_list, tuple: _semi_deepcopy_tuple, }
[docs]def semi_deepcopy(obj): copier = _semi_deepcopy_dispatch.get(type(obj)) if copier: return copier(obj) if hasattr(obj, '__semi_deepcopy__') and callable(obj.__semi_deepcopy__): return obj.__semi_deepcopy__() if isinstance(obj, UserDict): return obj.__class__(semi_deepcopy_dict(obj)) if isinstance(obj, (UserList, deque)): return obj.__class__(_semi_deepcopy_list(obj)) return obj
[docs]class Proxy: """A simple generic Proxy class, forwarding all calls to subject. This means you can take an object, let's call it `'obj_a``, and wrap it in this Proxy class, with a statement like this:: proxy_obj = Proxy(obj_a) Then, if in the future, you do something like this:: x = proxy_obj.var1 since the :class:`Proxy` class does not have a :attr:`var1` attribute (but presumably ``obj_a`` does), the request actually is equivalent to saying:: x = obj_a.var1 Inherit from this class to create a Proxy. With Python 3.5+ this does *not* work transparently for :class:`Proxy` subclasses that use special dunder method names, because those names are now bound to the class, not the individual instances. You now need to know in advance which special method names you want to pass on to the underlying Proxy object, and specifically delegate their calls like this:: class Foo(Proxy): __str__ = Delegate('__str__') """ def __init__(self, subject) -> None: """Wrap an object as a Proxy object""" self._subject = subject
[docs] def __getattr__(self, name): """Retrieve an attribute from the wrapped object. Raises: AttributeError: if attribute `name` doesn't exist. """ return getattr(self._subject, name)
[docs] def get(self): """Retrieve the entire wrapped object""" return self._subject
def __eq__(self, other): if issubclass(other.__class__, self._subject.__class__): return self._subject == other return self.__dict__ == other.__dict__
[docs]class Delegate: """A Python Descriptor class that delegates attribute fetches to an underlying wrapped subject of a Proxy. Typical use:: class Foo(Proxy): __str__ = Delegate('__str__') """ def __init__(self, attribute) -> None: self.attribute = attribute def __get__(self, obj, cls): if isinstance(obj, cls): return getattr(obj._subject, self.attribute) return self
# attempt to load the windows registry module: can_read_reg = False try: import winreg can_read_reg = True hkey_mod = winreg except ImportError:
[docs] class _NoError(Exception): pass
RegError = _NoError if can_read_reg: HKEY_CLASSES_ROOT = hkey_mod.HKEY_CLASSES_ROOT HKEY_LOCAL_MACHINE = hkey_mod.HKEY_LOCAL_MACHINE HKEY_CURRENT_USER = hkey_mod.HKEY_CURRENT_USER HKEY_USERS = hkey_mod.HKEY_USERS RegOpenKeyEx = winreg.OpenKeyEx RegEnumKey = winreg.EnumKey RegEnumValue = winreg.EnumValue RegQueryValueEx = winreg.QueryValueEx RegError = winreg.error def RegGetValue(root, key): r"""Returns a registry value without having to open the key first. Only available on Windows platforms with a version of Python that can read the registry. Returns the same thing as :func:`RegQueryValueEx`, except you just specify the entire path to the value, and don't have to bother opening the key first. So, instead of:: k = SCons.Util.RegOpenKeyEx(SCons.Util.HKEY_LOCAL_MACHINE, r'SOFTWARE\Microsoft\Windows\CurrentVersion') out = SCons.Util.RegQueryValueEx(k, 'ProgramFilesDir') You can write:: out = SCons.Util.RegGetValue(SCons.Util.HKEY_LOCAL_MACHINE, r'SOFTWARE\Microsoft\Windows\CurrentVersion\ProgramFilesDir') """ # I would use os.path.split here, but it's not a filesystem # path... p = key.rfind('\\') + 1 keyp = key[: p - 1] # -1 to omit trailing slash val = key[p:] k = RegOpenKeyEx(root, keyp) return RegQueryValueEx(k, val) else: HKEY_CLASSES_ROOT = None HKEY_LOCAL_MACHINE = None HKEY_CURRENT_USER = None HKEY_USERS = None
[docs] def RegGetValue(root, key): raise OSError
[docs] def RegOpenKeyEx(root, key): raise OSError
if sys.platform == 'win32': def WhereIs(file, path=None, pathext=None, reject=None) -> Optional[str]: if path is None: try: path = os.environ['PATH'] except KeyError: return None if is_String(path): path = path.split(os.pathsep) if pathext is None: try: pathext = os.environ['PATHEXT'] except KeyError: pathext = '.COM;.EXE;.BAT;.CMD' if is_String(pathext): pathext = pathext.split(os.pathsep) for ext in pathext: if ext.lower() == file[-len(ext):].lower(): pathext = [''] break if reject is None: reject = [] if not is_List(reject) and not is_Tuple(reject): reject = [reject] for p in path: f = os.path.join(p, file) for ext in pathext: fext = f + ext if os.path.isfile(fext): try: reject.index(fext) except ValueError: return os.path.normpath(fext) continue return None elif == 'os2': def WhereIs(file, path=None, pathext=None, reject=None) -> Optional[str]: if path is None: try: path = os.environ['PATH'] except KeyError: return None if is_String(path): path = path.split(os.pathsep) if pathext is None: pathext = ['.exe', '.cmd'] for ext in pathext: if ext.lower() == file[-len(ext):].lower(): pathext = [''] break if reject is None: reject = [] if not is_List(reject) and not is_Tuple(reject): reject = [reject] for p in path: f = os.path.join(p, file) for ext in pathext: fext = f + ext if os.path.isfile(fext): try: reject.index(fext) except ValueError: return os.path.normpath(fext) continue return None else:
[docs] def WhereIs(file, path=None, pathext=None, reject=None) -> Optional[str]: import stat # pylint: disable=import-outside-toplevel if path is None: try: path = os.environ['PATH'] except KeyError: return None if is_String(path): path = path.split(os.pathsep) if reject is None: reject = [] if not is_List(reject) and not is_Tuple(reject): reject = [reject] for p in path: f = os.path.join(p, file) if os.path.isfile(f): try: mode = os.stat(f).st_mode except OSError: # os.stat() raises OSError, not IOError if the file # doesn't exist, so in this case we let IOError get # raised so as to not mask possibly serious disk or # network issues. continue if stat.S_IXUSR & mode: try: reject.index(f) except ValueError: return os.path.normpath(f) continue return None
WhereIs.__doc__ = """\ Return the path to an executable that matches *file*. Searches the given *path* for *file*, considering any filename extensions in *pathext* (on the Windows platform only), and returns the full path to the matching command of the first match, or ``None`` if there are no matches. Will not select any path name or names in the optional *reject* list. If *path* is ``None`` (the default), :attr:`os.environ[PATH]` is used. On Windows, If *pathext* is ``None`` (the default), :attr:`os.environ[PATHEXT]` is used. The construction environment method of the same name wraps a call to this function by filling in *path* from the execution environment if it is ``None`` (and for *pathext* on Windows, if necessary), so if called from there, this function will not backfill from :attr:`os.environ`. Note: Finding things in :attr:`os.environ` may answer the question "does *file* exist on the system", but not the question "can SCons use that executable", unless the path element that yields the match is also in the the Execution Environment (e.g. ``env['ENV']['PATH']``). Since this utility function has no environment reference, it cannot make that determination. """ if sys.platform == 'cygwin': import subprocess # pylint: disable=import-outside-toplevel def get_native_path(path: str) -> str: cp ='cygpath', '-w', path), check=False, stdout=subprocess.PIPE) return cp.stdout.decode().replace('\n', '') else:
[docs] def get_native_path(path: str) -> str: return path
get_native_path.__doc__ = """\ Transform an absolute path into a native path for the system. In Cygwin, this converts from a Cygwin path to a Windows path, without regard to whether *path* refers to an existing file system object. For other platforms, *path* is unchanged. """
[docs]def Split(arg) -> list: """Returns a list of file names or other objects. If *arg* is a string, it will be split on whitespace within the string. If *arg* is already a list, the list will be returned untouched. If *arg* is any other type of object, it will be returned in a single-item list. >>> print(Split(" this is a string ")) ['this', 'is', 'a', 'string'] >>> print(Split(["stringlist", " preserving ", " spaces "])) ['stringlist', ' preserving ', ' spaces '] """ if is_List(arg) or is_Tuple(arg): return arg if is_String(arg): return arg.split() return [arg]
[docs]class CLVar(UserList): """A container for command-line construction variables. Forces the use of a list of strings intended as command-line arguments. Like :class:`collections.UserList`, but the argument passed to the initializter will be processed by the :func:`Split` function, which includes special handling for string types: they will be split into a list of words, not coereced directly to a list. The same happens if a string is added to a :class:`CLVar`, which allows doing the right thing with both :func:`Append`/:func:`Prepend` methods, as well as with pure Python addition, regardless of whether adding a list or a string to a construction variable. Side effect: spaces will be stripped from individual string arguments. If you need spaces preserved, pass strings containing spaces inside a list argument. >>> u = UserList("--some --opts and args") >>> print(len(u), repr(u)) 22 ['-', '-', 's', 'o', 'm', 'e', ' ', '-', '-', 'o', 'p', 't', 's', ' ', 'a', 'n', 'd', ' ', 'a', 'r', 'g', 's'] >>> c = CLVar("--some --opts and args") >>> print(len(c), repr(c)) 4 ['--some', '--opts', 'and', 'args'] >>> c += " strips spaces " >>> print(len(c), repr(c)) 6 ['--some', '--opts', 'and', 'args', 'strips', 'spaces'] >>> c += [" does not split or strip "] 7 ['--some', '--opts', 'and', 'args', 'strips', 'spaces', ' does not split or strip '] """ def __init__(self, initlist=None) -> None: super().__init__(Split(initlist if initlist is not None else [])) def __add__(self, other): return super().__add__(CLVar(other)) def __radd__(self, other): return super().__radd__(CLVar(other)) def __iadd__(self, other): return super().__iadd__(CLVar(other)) def __str__(self) -> str: # Some cases the data can contain Nodes, so make sure they # processed to string before handing them over to join. return ' '.join([str(d) for d in])
[docs]class Selector(dict): """A callable dict for file suffix lookup. Often used to associate actions or emitters with file types. Depends on insertion order being preserved so that :meth:`get_suffix` calls always return the first suffix added. """ def __call__(self, env, source, ext=None): if ext is None: try: ext = source[0].get_suffix() except IndexError: ext = "" try: return self[ext] except KeyError as exc: # Try to perform Environment substitution on the keys of # the dictionary before giving up. s_dict = {} for (k, v) in self.items(): if k is not None: s_k = env.subst(k) if s_k in s_dict: # We only raise an error when variables point # to the same suffix. If one suffix is literal # and a variable suffix contains this literal, # the literal wins and we don't raise an error. raise KeyError(s_dict[s_k][0], k, s_k) from exc s_dict[s_k] = (k, v) try: return s_dict[ext][1] except KeyError: try: return self[None] except KeyError: return None
if sys.platform == 'cygwin': # On Cygwin, os.path.normcase() lies, so just report back the # fact that the underlying Windows OS is case-insensitive. def case_sensitive_suffixes(s1: str, s2: str) -> bool: # pylint: disable=unused-argument return False else:
[docs] def case_sensitive_suffixes(s1: str, s2: str) -> bool: return os.path.normcase(s1) != os.path.normcase(s2)
case_sensitive_suffixes.__doc__ = """\ Returns whether platform distinguishes case in file suffixes."""
[docs]def adjustixes(fname, pre, suf, ensure_suffix: bool=False) -> str: """Adjust filename prefixes and suffixes as needed. Add `prefix` to `fname` if specified. Add `suffix` to `fname` if specified and if `ensure_suffix` is ``True`` """ if pre: path, fn = os.path.split(os.path.normpath(fname)) # Handle the odd case where the filename = the prefix. # In that case, we still want to add the prefix to the file if not fn.startswith(pre) or fn == pre: fname = os.path.join(path, pre + fn) # Only append a suffix if the suffix we're going to add isn't already # there, and if either we've been asked to ensure the specific suffix # is present or there's no suffix on it at all. # Also handle the odd case where the filename = the suffix. # in that case we still want to append the suffix if suf and not fname.endswith(suf) and \ (ensure_suffix or not splitext(fname)[1]): fname = fname + suf return fname
# From Tim Peters, # # ASPN: Python Cookbook: Remove duplicates from a sequence # (Also in the printed Python Cookbook.) # Updated. This algorithm is used by some scanners and tools.
[docs]def unique(seq): """Return a list of the elements in seq without duplicates, ignoring order. For best speed, all sequence elements should be hashable. Then :func:`unique` will usually work in linear time. If not possible, the sequence elements should enjoy a total ordering, and if ``list(s).sort()`` doesn't raise ``TypeError`` it is assumed that they do enjoy a total ordering. Then :func:`unique` will usually work in O(N*log2(N)) time. If that's not possible either, the sequence elements must support equality-testing. Then :func:`unique` will usually work in quadratic time. >>> mylist = unique([1, 2, 3, 1, 2, 3]) >>> print(sorted(mylist)) [1, 2, 3] >>> mylist = unique("abcabc") >>> print(sorted(mylist)) ['a', 'b', 'c'] >>> mylist = unique(([1, 2], [2, 3], [1, 2])) >>> print(sorted(mylist)) [[1, 2], [2, 3]] """ if not seq: return [] # Try using a dict first, as that's the fastest and will usually # work. If it doesn't work, it will usually fail quickly, so it # usually doesn't cost much to *try* it. It requires that all the # sequence elements be hashable, and support equality comparison. # TODO: should be even faster: return(list(set(seq))) with suppress(TypeError): return list(dict.fromkeys(seq)) # We couldn't hash all the elements (got a TypeError). # Next fastest is to sort, which brings the equal elements together; # then duplicates are easy to weed out in a single pass. # NOTE: Python's list.sort() was designed to be efficient in the # presence of many duplicate elements. This isn't true of all # sort functions in all languages or libraries, so this approach # is more effective in Python than it may be elsewhere. n = len(seq) try: t = sorted(seq) except TypeError: pass # move on to the next method else: last = t[0] lasti = i = 1 while i < n: if t[i] != last: t[lasti] = last = t[i] lasti = lasti + 1 i = i + 1 return t[:lasti] # Brute force is all that's left. u = [] for x in seq: if x not in u: u.append(x) return u
# Best way (assuming Python 3.7, but effectively 3.6) to remove # duplicates from a list in while preserving order, according to #
[docs]def uniquer_hashables(seq): return list(dict.fromkeys(seq))
# Recipe 19.11 "Reading Lines with Continuation Characters", # by Alex Martelli, straight from the Python CookBook (2nd edition).
[docs]def logical_lines(physical_lines, joiner=''.join): logical_line = [] for line in physical_lines: stripped = line.rstrip() if stripped.endswith('\\'): # a line which continues w/the next physical line logical_line.append(stripped[:-1]) else: # a line which does not continue, end of logical line logical_line.append(line) yield joiner(logical_line) logical_line = [] if logical_line: # end of sequence implies end of last logical line yield joiner(logical_line)
[docs]class LogicalLines: """Wrapper class for the :func:`logical_lines` function. Allows us to read all "logical" lines at once from a given file object. """ def __init__(self, fileobj) -> None: self.fileobj = fileobj
[docs] def readlines(self): return list(logical_lines(self.fileobj))
[docs]class UniqueList(UserList): """A list which maintains uniqueness. Uniquing is lazy: rather than being enforced on list changes, it is fixed up on access by those methods which need to act on a unique list to be correct. That means things like membership tests don't have to eat the uniquing time. """ def __init__(self, initlist=None) -> None: super().__init__(initlist) self.unique = True def __make_unique(self) -> None: if not self.unique: = uniquer_hashables( self.unique = True def __repr__(self) -> str: self.__make_unique() return super().__repr__() def __lt__(self, other): self.__make_unique() return super().__lt__(other) def __le__(self, other): self.__make_unique() return super().__le__(other) def __eq__(self, other): self.__make_unique() return super().__eq__(other) def __ne__(self, other): self.__make_unique() return super().__ne__(other) def __gt__(self, other): self.__make_unique() return super().__gt__(other) def __ge__(self, other): self.__make_unique() return super().__ge__(other) # __contains__ doesn't need to worry about uniquing, inherit def __len__(self) -> int: self.__make_unique() return super().__len__() def __getitem__(self, i): self.__make_unique() return super().__getitem__(i) def __setitem__(self, i, item) -> None: super().__setitem__(i, item) self.unique = False # __delitem__ doesn't need to worry about uniquing, inherit def __add__(self, other): result = super().__add__(other) result.unique = False return result def __radd__(self, other): result = super().__radd__(other) result.unique = False return result def __iadd__(self, other): result = super().__iadd__(other) result.unique = False return result def __mul__(self, other): result = super().__mul__(other) result.unique = False return result def __rmul__(self, other): result = super().__rmul__(other) result.unique = False return result def __imul__(self, other): result = super().__imul__(other) result.unique = False return result
[docs] def append(self, item) -> None: super().append(item) self.unique = False
[docs] def insert(self, i, item) -> None: super().insert(i, item) self.unique = False
[docs] def count(self, item): self.__make_unique() return super().count(item)
[docs] def index(self, item, *args): self.__make_unique() return super().index(item, *args)
[docs] def reverse(self) -> None: self.__make_unique() super().reverse()
# TODO: Py3.8: def sort(self, /, *args, **kwds):
[docs] def sort(self, *args, **kwds): self.__make_unique() return super().sort(*args, **kwds)
[docs] def extend(self, other) -> None: super().extend(other) self.unique = False
[docs]class Unbuffered: """A proxy that wraps a file object, flushing after every write. Delegates everything else to the wrapped object. """ def __init__(self, file) -> None: self.file = file
[docs] def write(self, arg) -> None: # Stdout might be connected to a pipe that has been closed # by now. The most likely reason for the pipe being closed # is that the user has press ctrl-c. It this is the case, # then SCons is currently shutdown. We therefore ignore # IOError's here so that SCons can continue and shutdown # properly so that the .sconsign is correctly written # before SCons exits. with suppress(IOError): self.file.write(arg) self.file.flush()
[docs] def writelines(self, arg) -> None: with suppress(IOError): self.file.writelines(arg) self.file.flush()
def __getattr__(self, attr): return getattr(self.file, attr)
[docs]def make_path_relative(path) -> str: """Converts an absolute path name to a relative pathname.""" if os.path.isabs(path): drive_s, path = os.path.splitdrive(path) if not drive_s: path = re.compile(r"/*(.*)").findall(path)[0] else: path = path[1:] assert not os.path.isabs(path), path return path
[docs]def silent_intern(__string: Any) -> str: """Intern a string without failing. Perform :mod:`sys.intern` on the passed argument and return the result. If the input is ineligible for interning the original argument is returned and no exception is thrown. """ try: return sys.intern(__string) except TypeError: return __string
[docs]def cmp(a, b) -> bool: """A cmp function because one is no longer available in Python3.""" return (a > b) - (a < b)
[docs]def wait_for_process_to_die(pid) -> None: """ Wait for specified process to die, or alternatively kill it NOTE: This function operates best with psutil pypi package TODO: Add timeout which raises exception """ # wait for the process to fully killed try: import psutil # pylint: disable=import-outside-toplevel while True: if pid not in [ for proc in psutil.process_iter()]: break time.sleep(0.1) except ImportError: # if psutil is not installed we can do this the hard way while True: if sys.platform == 'win32': import ctypes # pylint: disable=import-outside-toplevel PROCESS_QUERY_INFORMATION = 0x1000 processHandle = ctypes.windll.kernel32.OpenProcess(PROCESS_QUERY_INFORMATION, 0, pid) if processHandle == 0: break ctypes.windll.kernel32.CloseHandle(processHandle) time.sleep(0.1) else: try: os.kill(pid, 0) except OSError: break time.sleep(0.1)
# From:
[docs]class DispatchingFormatter(Formatter): """Logging formatter which dispatches to various formatters.""" def __init__(self, formatters, default_formatter) -> None: self._formatters = formatters self._default_formatter = default_formatter
[docs] def format(self, record): # Search from record's logger up to its parents: logger = logging.getLogger( while logger: # Check if suitable formatter for current logger exists: if in self._formatters: formatter = self._formatters[] break logger = logger.parent else: # If no formatter found, just use default: formatter = self._default_formatter return formatter.format(record)
[docs]def sanitize_shell_env(execution_env: dict) -> dict: """Sanitize all values in *execution_env* The execution environment (typically comes from ``env['ENV']``) is propagated to the shell, and may need to be cleaned first. Args: execution_env: The shell environment variables to be propagated to the spawned shell. Returns: sanitized dictionary of env variables (similar to what you'd get from :data:`os.environ`) """ # Ensure that the ENV values are all strings: new_env = {} for key, value in execution_env.items(): if is_List(value): # If the value is a list, then we assume it is a path list, # because that's a pretty common list-like value to stick # in an environment variable: value = flatten_sequence(value) new_env[key] = os.pathsep.join(map(str, value)) else: # It's either a string or something else. If it isn't a # string or a list, then we just coerce it to a string, which # is the proper way to handle Dir and File instances and will # produce something reasonable for just about everything else: new_env[key] = str(value) return new_env
# Local Variables: # tab-width:4 # indent-tabs-mode:nil # End: # vim: set expandtab tabstop=4 shiftwidth=4: