pythonVSCode/pythonFiles/release/jedi/common.py at codeHealth · sbialobok/pythonVSCode · GitHub

History

executable file

154 lines (124 loc) · 4.82 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

""" 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)

pythonVSCode/pythonFiles/release/jedi/common.py at codeHealth · sbialobok/pythonVSCode · GitHub

Expand file tree

Breadcrumbs

common.py

Latest commit

History

Breadcrumbs

common.py

File metadata and controls