155 lines
4.8 KiB
Python
155 lines
4.8 KiB
Python
""" A universal module with functions / classes without dependencies. """
|
|
import sys
|
|
import contextlib
|
|
import functools
|
|
import re
|
|
from ast import literal_eval
|
|
|
|
from jedi._compatibility import unicode, reraise
|
|
from jedi import settings
|
|
|
|
|
|
class UncaughtAttributeError(Exception):
|
|
"""
|
|
Important, because `__getattr__` and `hasattr` catch AttributeErrors
|
|
implicitly. This is really evil (mainly because of `__getattr__`).
|
|
`hasattr` in Python 2 is even more evil, because it catches ALL exceptions.
|
|
Therefore this class originally had to be derived from `BaseException`
|
|
instead of `Exception`. But because I removed relevant `hasattr` from
|
|
the code base, we can now switch back to `Exception`.
|
|
|
|
:param base: return values of sys.exc_info().
|
|
"""
|
|
|
|
|
|
def safe_property(func):
|
|
return property(reraise_uncaught(func))
|
|
|
|
|
|
def reraise_uncaught(func):
|
|
"""
|
|
Re-throw uncaught `AttributeError`.
|
|
|
|
Usage: Put ``@rethrow_uncaught`` in front of the function
|
|
which does **not** suppose to raise `AttributeError`.
|
|
|
|
AttributeError is easily get caught by `hasattr` and another
|
|
``except AttributeError`` clause. This becomes problem when you use
|
|
a lot of "dynamic" attributes (e.g., using ``@property``) because you
|
|
can't distinguish if the property does not exist for real or some code
|
|
inside of the "dynamic" attribute through that error. In a well
|
|
written code, such error should not exist but getting there is very
|
|
difficult. This decorator is to help us getting there by changing
|
|
`AttributeError` to `UncaughtAttributeError` to avoid unexpected catch.
|
|
This helps us noticing bugs earlier and facilitates debugging.
|
|
|
|
.. note:: Treating StopIteration here is easy.
|
|
Add that feature when needed.
|
|
"""
|
|
@functools.wraps(func)
|
|
def wrapper(*args, **kwds):
|
|
try:
|
|
return func(*args, **kwds)
|
|
except AttributeError:
|
|
exc_info = sys.exc_info()
|
|
reraise(UncaughtAttributeError(exc_info[1]), exc_info[2])
|
|
return wrapper
|
|
|
|
|
|
class PushBackIterator(object):
|
|
def __init__(self, iterator):
|
|
self.pushes = []
|
|
self.iterator = iterator
|
|
self.current = None
|
|
|
|
def push_back(self, value):
|
|
self.pushes.append(value)
|
|
|
|
def __iter__(self):
|
|
return self
|
|
|
|
def next(self):
|
|
""" Python 2 Compatibility """
|
|
return self.__next__()
|
|
|
|
def __next__(self):
|
|
if self.pushes:
|
|
self.current = self.pushes.pop()
|
|
else:
|
|
self.current = next(self.iterator)
|
|
return self.current
|
|
|
|
|
|
@contextlib.contextmanager
|
|
def scale_speed_settings(factor):
|
|
a = settings.max_executions
|
|
b = settings.max_until_execution_unique
|
|
settings.max_executions *= factor
|
|
settings.max_until_execution_unique *= factor
|
|
try:
|
|
yield
|
|
finally:
|
|
settings.max_executions = a
|
|
settings.max_until_execution_unique = b
|
|
|
|
|
|
def indent_block(text, indention=' '):
|
|
"""This function indents a text block with a default of four spaces."""
|
|
temp = ''
|
|
while text and text[-1] == '\n':
|
|
temp += text[-1]
|
|
text = text[:-1]
|
|
lines = text.split('\n')
|
|
return '\n'.join(map(lambda s: indention + s, lines)) + temp
|
|
|
|
|
|
@contextlib.contextmanager
|
|
def ignored(*exceptions):
|
|
"""
|
|
Context manager that ignores all of the specified exceptions. This will
|
|
be in the standard library starting with Python 3.4.
|
|
"""
|
|
try:
|
|
yield
|
|
except exceptions:
|
|
pass
|
|
|
|
|
|
def source_to_unicode(source, encoding=None):
|
|
def detect_encoding():
|
|
"""
|
|
For the implementation of encoding definitions in Python, look at:
|
|
- http://www.python.org/dev/peps/pep-0263/
|
|
- http://docs.python.org/2/reference/lexical_analysis.html#encoding-declarations
|
|
"""
|
|
byte_mark = literal_eval(r"b'\xef\xbb\xbf'")
|
|
if source.startswith(byte_mark):
|
|
# UTF-8 byte-order mark
|
|
return 'utf-8'
|
|
|
|
first_two_lines = re.match(r'(?:[^\n]*\n){0,2}', str(source)).group(0)
|
|
possible_encoding = re.search(r"coding[=:]\s*([-\w.]+)",
|
|
first_two_lines)
|
|
if possible_encoding:
|
|
return possible_encoding.group(1)
|
|
else:
|
|
# the default if nothing else has been set -> PEP 263
|
|
return encoding if encoding is not None else 'iso-8859-1'
|
|
|
|
if isinstance(source, unicode):
|
|
# only cast str/bytes
|
|
return source
|
|
|
|
# cast to unicode by default
|
|
return unicode(source, detect_encoding(), 'replace')
|
|
|
|
|
|
def splitlines(string):
|
|
"""
|
|
A splitlines for Python code. In contrast to Python's ``str.splitlines``,
|
|
looks at form feeds and other special characters as normal text. Just
|
|
splits ``\n`` and ``\r\n``.
|
|
Also different: Returns ``['']`` for an empty string input.
|
|
"""
|
|
return re.split('\n|\r\n', string)
|