eric: comparison DebugClients/Python/coverage/backward.py

-:456c58fc64b0
+:d0d6e4ad31bd
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
 """Add things to old Pythons so I can pretend they are newer."""
-# This file does lots of tricky stuff, so disable a bunch of lintisms.
+# This file does lots of tricky stuff, so disable a bunch of pylint warnings.
-# pylint: disable=F0401,W0611,W0622
+# pylint: disable=redefined-builtin
-# F0401: Unable to import blah
+# pylint: disable=unused-import
-# W0611: Unused import blah
+# pylint: disable=no-name-in-module
-# W0622: Redefining built-in blah
-import os, re, sys
+import sys
-# Python 2.3 doesn't have `set`
+from coverage import env
-try:
-set = set       # new in 2.4
-except NameError:
-from sets import Set as set
-# Python 2.3 doesn't have `sorted`.
-try:
-sorted = sorted
-except NameError:
-def sorted(iterable):
-"""A 2.3-compatible implementation of `sorted`."""
-lst = list(iterable)
-lst.sort()
-return lst
-# Python 2.3 doesn't have `reversed`.
+# Pythons 2 and 3 differ on where to get StringIO.
-try:
-reversed = reversed
-except NameError:
-def reversed(iterable):
-"""A 2.3-compatible implementation of `reversed`."""
-lst = list(iterable)
-return lst[::-1]
-# rpartition is new in 2.5
-try:
-"".rpartition
-except AttributeError:
-def rpartition(s, sep):
-"""Implement s.rpartition(sep) for old Pythons."""
-i = s.rfind(sep)
-if i == -1:
-return ('', '', s)
-else:
-return (s[:i], sep, s[i+len(sep):])
-else:
-def rpartition(s, sep):
-"""A common interface for new Pythons."""
-return s.rpartition(sep)
-# Pythons 2 and 3 differ on where to get StringIO
 try:
 from cStringIO import StringIO
-BytesIO = StringIO
 except ImportError:
-from io import StringIO, BytesIO
+from io import StringIO
+# In py3, ConfigParser was renamed to the more-standard configparser
+try:
+import configparser
+except ImportError:
+import ConfigParser as configparser
 # What's a string called?
 try:
 string_class = basestring
 except NameError:
 string_class = str
+# What's a Unicode string called?
+try:
+unicode_class = unicode
+except NameError:
+unicode_class = str
 # Where do pickles come from?
 try:
 import cPickle as pickle
 except ImportError:
 else:
 def iitems(d):
 """Produce the items from dict `d`."""
 return d.iteritems()
-# Exec is a statement in Py2, a function in Py3
+# Getting the `next` function from an iterator is different in 2 and 3.
-if sys.version_info >= (3, 0):
+try:
-def exec_code_object(code, global_map):
+iter([]).next
-"""A wrapper around exec()."""
+except AttributeError:
-exec(code, global_map)
+def iternext(seq):
+"""Get the `next` function for iterating over `seq`."""
+return iter(seq).__next__
 else:
-# OK, this is pretty gross.  In Py2, exec was a statement, but that will
+def iternext(seq):
-# be a syntax error if we try to put it in a Py3 file, even if it is never
+"""Get the `next` function for iterating over `seq`."""
-# executed.  So hide it inside an evaluated string literal instead.
+return iter(seq).next
-eval(
-compile(
-"def exec_code_object(code, global_map):\n"
-"    exec code in global_map\n",
-"<exec_function>", "exec"
-)
-)
-# Reading Python source and interpreting the coding comment is a big deal.
-if sys.version_info >= (3, 0):
-# Python 3.2 provides `tokenize.open`, the best way to open source files.
-import tokenize
-try:
-open_source = tokenize.open     # pylint: disable=E1101
-except AttributeError:
-from io import TextIOWrapper
-detect_encoding = tokenize.detect_encoding  # pylint: disable=E1101
-# Copied from the 3.2 stdlib:
-def open_source(fname):
-"""Open a file in read only mode using the encoding detected by
-detect_encoding().
-"""
-buffer = open(fname, 'rb')
-encoding, _ = detect_encoding(buffer.readline)
-buffer.seek(0)
-text = TextIOWrapper(buffer, encoding, line_buffering=True)
-text.mode = 'r'
-return text
-else:
-def open_source(fname):
-"""Open a source file the best way."""
-return open(fname, "rU")
 # Python 3.x is picky about bytes and strings, so provide methods to
 # get them right, and make them no-ops in 2.x
-if sys.version_info >= (3, 0):
+if env.PY3:
 def to_bytes(s):
 """Convert string `s` to bytes."""
 return s.encode('utf8')
-def to_string(b):
-"""Convert bytes `b` to a string."""
-return b.decode('utf8')
 def binary_bytes(byte_values):
 """Produce a byte string with the ints from `byte_values`."""
 return bytes(byte_values)
 """Turn an element of a bytes object into an int."""
 return byte_value
 def bytes_to_ints(bytes_value):
 """Turn a bytes object into a sequence of ints."""
-# In Py3, iterating bytes gives ints.
+# In Python 3, iterating bytes gives ints.
 return bytes_value
 else:
 def to_bytes(s):
 """Convert string `s` to bytes (no-op in 2.x)."""
 return s
-def to_string(b):
-"""Convert bytes `b` to a string (no-op in 2.x)."""
-return b
 def binary_bytes(byte_values):
 """Produce a byte string with the ints from `byte_values`."""
-return "".join([chr(b) for b in byte_values])
+return "".join(chr(b) for b in byte_values)
 def byte_to_int(byte_value):
 """Turn an element of a bytes object into an int."""
 return ord(byte_value)
 def bytes_to_ints(bytes_value):
 """Turn a bytes object into a sequence of ints."""
 for byte in bytes_value:
 yield ord(byte)
-# Md5 is available in different places.
 try:
-import hashlib
+# In Python 2.x, the builtins were in __builtin__
-md5 = hashlib.md5
+BUILTINS = sys.modules['__builtin__']
+except KeyError:
+# In Python 3.x, they're in builtins
+BUILTINS = sys.modules['builtins']
+# imp was deprecated in Python 3.3
+try:
+import importlib
+import importlib.util
+imp = None
 except ImportError:
-import md5
+importlib = None
-md5 = md5.new
-#
+# We only want to use importlib if it has everything we need.
-# eflag: FileType = Python2
+try:
+importlib_util_find_spec = importlib.util.find_spec
+except Exception:
+import imp
+importlib_util_find_spec = None
+# What is the .pyc magic number for this version of Python?
+try:
+PYC_MAGIC_NUMBER = importlib.util.MAGIC_NUMBER
+except AttributeError:
+PYC_MAGIC_NUMBER = imp.get_magic()
+def import_local_file(modname):
+"""Import a local file as a module.
+Opens a file in the current directory named `modname`.py, imports it
+as `modname`, and returns the module object.
+"""
+try:
+from importlib.machinery import SourceFileLoader
+except ImportError:
+SourceFileLoader = None
+modfile = modname + '.py'
+if SourceFileLoader:
+mod = SourceFileLoader(modname, modfile).load_module()
+else:
+for suff in imp.get_suffixes():                 # pragma: part covered
+if suff[0] == '.py':
+break
+with open(modfile, 'r') as f:
+# pylint: disable=undefined-loop-variable
+mod = imp.load_module(modname, f, modfile, suff)
+return mod

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python/coverage/backward.py

DebugClients/Python/coverage/backward.py