eric: comparison eric7/DebugClients/Python/coverage/misc.py

-:d728227e8ebb
+:0802ae193343
 # Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
 # For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
 """Miscellaneous stuff for coverage.py."""
+import contextlib
 import errno
 import hashlib
+import importlib
+import importlib.util
 import inspect
 import locale
 import os
 import os.path
 import random
 import socket
 import sys
 import types
 from coverage import env
-from coverage.backward import to_bytes, unicode_class
+from coverage.exceptions import CoverageException
+# In 6.0, the exceptions moved from misc.py to exceptions.py.  But a number of
+# other packages were importing the exceptions from misc, so import them here.
+# pylint: disable=unused-wildcard-import
+from coverage.exceptions import *   # pylint: disable=wildcard-import
 ISOLATED_MODULES = {}
 def isolate_module(mod):
 return ISOLATED_MODULES[mod]
 os = isolate_module(os)
+class SysModuleSaver:
+"""Saves the contents of sys.modules, and removes new modules later."""
+def __init__(self):
+self.old_modules = set(sys.modules)
+def restore(self):
+"""Remove any modules imported since this object started."""
+new_modules = set(sys.modules) - self.old_modules
+for m in new_modules:
+del sys.modules[m]
+@contextlib.contextmanager
+def sys_modules_saved():
+"""A context manager to remove any modules imported during a block."""
+saver = SysModuleSaver()
+try:
+yield
+finally:
+saver.restore()
+def import_third_party(modname):
+"""Import a third-party module we need, but might not be installed.
+This also cleans out the module after the import, so that coverage won't
+appear to have imported it.  This lets the third party use coverage for
+their own tests.
+Arguments:
+modname (str): the name of the module to import.
+Returns:
+The imported module, or None if the module couldn't be imported.
+"""
+with sys_modules_saved():
+try:
+return importlib.import_module(modname)
+except ImportError:
+return None
 def dummy_decorator_with_args(*args_unused, **kwargs_unused):
 """Dummy no-op implementation of a decorator with arguments."""
 def _decorator(func):
 return func
 return _decorator
-# Environment COVERAGE_NO_CONTRACTS=1 can turn off contracts while debugging
-# tests to remove noise from stack traces.
-# $set_env.py: COVERAGE_NO_CONTRACTS - Disable PyContracts to simplify stack traces.
-USE_CONTRACTS = env.TESTING and not bool(int(os.environ.get("COVERAGE_NO_CONTRACTS", 0)))
 # Use PyContracts for assertion testing on parameters and returns, but only if
 # we are running our own test suite.
-if USE_CONTRACTS:
+if env.USE_CONTRACTS:
 from contracts import contract              # pylint: disable=unused-import
 from contracts import new_contract as raw_new_contract
 def new_contract(*args, **kwargs):
 """A proxy for contracts.new_contract that doesn't mind happening twice."""
 # PyContracts doesn't like redefining contracts. It's OK.
 pass
 # Define contract words that PyContract doesn't have.
 new_contract('bytes', lambda v: isinstance(v, bytes))
-if env.PY3:
+new_contract('unicode', lambda v: isinstance(v, str))
-new_contract('unicode', lambda v: isinstance(v, unicode_class))
 def one_of(argnames):
 """Ensure that only one of the argnames is non-None."""
 def _decorator(func):
 argnameset = {name.strip() for name in argnames.split(",")}
 if env.TESTING:
 attr = "_once_" + fn.__name__
 def _wrapper(self):
 if hasattr(self, attr):
-raise AssertionError("Shouldn't have called %s more than once" % fn.__name__)
+raise AssertionError(f"Shouldn't have called {fn.__name__} more than once")
 setattr(self, attr, True)
 return fn(self)
 return _wrapper
 else:
 return fn                   # pragma: not testing
 def ensure_dir(directory):
 """Make sure the directory exists.
 If `directory` is None or empty, do nothing.
 """
-if directory and not os.path.isdir(directory):
+if directory:
-os.makedirs(directory)
+os.makedirs(directory, exist_ok=True)
 def ensure_dir_for_file(path):
 """Make sure the directory for the path exists."""
 ensure_dir(os.path.dirname(path))
 dice = random.Random(os.urandom(8)).randint(0, 999999)
 suffix = "%s.%s.%06d" % (socket.gethostname(), os.getpid(), dice)
 return suffix
-class Hasher(object):
+class Hasher:
-"""Hashes Python data into md5."""
+"""Hashes Python data for fingerprinting."""
 def __init__(self):
-self.md5 = hashlib.md5()
+self.hash = hashlib.new("sha3_256")
 def update(self, v):
 """Add `v` to the hash, recursively if needed."""
-self.md5.update(to_bytes(str(type(v))))
+self.hash.update(str(type(v)).encode("utf-8"))
-if isinstance(v, unicode_class):
+if isinstance(v, str):
-self.md5.update(v.encode('utf8'))
+self.hash.update(v.encode("utf-8"))
 elif isinstance(v, bytes):
-self.md5.update(v)
+self.hash.update(v)
 elif v is None:
 pass
 elif isinstance(v, (int, float)):
-self.md5.update(to_bytes(str(v)))
+self.hash.update(str(v).encode("utf-8"))
 elif isinstance(v, (tuple, list)):
 for e in v:
 self.update(e)
 elif isinstance(v, dict):
 keys = v.keys()
 a = getattr(v, k)
 if inspect.isroutine(a):
 continue
 self.update(k)
 self.update(a)
-self.md5.update(b'.')
+self.hash.update(b'.')
 def hexdigest(self):
 """Retrieve the hex digest of the hash."""
-return self.md5.hexdigest()
+return self.hash.hexdigest()[:32]
 def _needs_to_implement(that, func_name):
 """Helper to raise NotImplementedError in interface stubs."""
 if hasattr(that, "_coverage_plugin_name"):
 thing = "Plugin"
 name = that._coverage_plugin_name
 else:
 thing = "Class"
 klass = that.__class__
-name = "{klass.__module__}.{klass.__name__}".format(klass=klass)
+name = f"{klass.__module__}.{klass.__name__}"
 raise NotImplementedError(
-"{thing} {name!r} needs to implement {func_name}()".format(
+f"{thing} {name!r} needs to implement {func_name}()"
-thing=thing, name=name, func_name=func_name
-)
 )
-class DefaultValue(object):
+class DefaultValue:
 """A sentinel object to use for unusual default-value needs.
 Construct with a string that will be used as the repr, for display in help
 and Sphinx output.
 )?                      # maybe.
 }
 )
 """
+dollar_groups = ('dollar', 'word1', 'word2')
 def dollar_replace(match):
 """Called for each $replacement."""
 # Only one of the groups will have matched, just get its text.
-word = next(g for g in match.group('dollar', 'word1', 'word2') if g)
+word = next(g for g in match.group(*dollar_groups) if g)    # pragma: always breaks
 if word == "$":
 return "$"
 elif word in variables:
 return variables[word]
 elif match.group('strict'):
-msg = "Variable {} is undefined: {!r}".format(word, text)
+msg = f"Variable {word} is undefined: {text!r}"
 raise CoverageException(msg)
 else:
 return match.group('defval')
 text = re.sub(dollar_pattern, dollar_replace, text)
 return text
-class BaseCoverageException(Exception):
+def format_local_datetime(dt):
-"""The base of all Coverage exceptions."""
+"""Return a string with local timezone representing the date.
-pass
+"""
+return dt.astimezone().strftime('%Y-%m-%d %H:%M %z')
-class CoverageException(BaseCoverageException):
-"""An exception raised by a coverage.py function."""
+def import_local_file(modname, modfile=None):
-pass
+"""Import a local file as a module.
+Opens a file in the current directory named `modname`.py, imports it
-class NoSource(CoverageException):
+as `modname`, and returns the module object.  `modfile` is the file to
-"""We couldn't find the source for a module."""
+import if it isn't in the current directory.
-pass
+"""
+if modfile is None:
-class NoCode(NoSource):
+modfile = modname + '.py'
-"""We couldn't find any code at all."""
+spec = importlib.util.spec_from_file_location(modname, modfile)
-pass
+mod = importlib.util.module_from_spec(spec)
+sys.modules[modname] = mod
+spec.loader.exec_module(mod)
-class NotPython(CoverageException):
-"""A source file turned out not to be parsable Python."""
+return mod
-pass
+def human_key(s):
-class ExceptionDuringRun(CoverageException):
+"""Turn a string into a list of string and number chunks.
-"""An exception happened while running customer code.
+"z23a" -> ["z", 23, "a"]
+"""
-Construct it with three arguments, the values from `sys.exc_info`.
+def tryint(s):
+"""If `s` is a number, return an int, else `s` unchanged."""
-"""
+try:
-pass
+return int(s)
+except ValueError:
+return s
-class StopEverything(BaseCoverageException):
-"""An exception that means everything should stop.
+return [tryint(c) for c in re.split(r"(\d+)", s)]
-The CoverageTest class converts these to SkipTest, so that when running
+def human_sorted(strings):
-tests, raising this exception will automatically skip the test.
+"""Sort the given iterable of strings the way that humans expect.
-"""
+Numeric components in the strings are sorted as numbers.
-pass
+Returns the sorted list.
+"""
+return sorted(strings, key=human_key)
+def human_sorted_items(items, reverse=False):
+"""Sort the (string, value) items the way humans expect.
+Returns the sorted list of items.
+"""
+return sorted(items, key=lambda pair: (human_key(pair[0]), pair[1]), reverse=reverse)

Mercurial Repositories > eric / file comparison

comparison: eric7/DebugClients/Python/coverage/misc.py

eric7/DebugClients/Python/coverage/misc.py