AbstractSequence -> AbstractIterable.

jedi/evaluate/analysis.py

@@ -160,7 +160,7 @@ def _check_for_exception_catch(node_context, jedi_name, exception, payload=None)
                 except_classes = node_context.eval_node(node)
                 for cls in except_classes:
                     from jedi.evaluate import iterable
-                    if isinstance(cls, iterable.AbstractSequence) and \
+                    if isinstance(cls, iterable.AbstractIterable) and \
                             cls.array_type == 'tuple':
                         # multiple exceptions
                         for lazy_context in cls.py__iter__():

jedi/evaluate/base_context.py

@@ -81,7 +81,7 @@ class Context(BaseContext):
 
     def get_item(self, index_contexts, contextualized_node):
         from jedi.evaluate.compiled import CompiledObject
-        from jedi.evaluate.iterable import Slice, AbstractSequence
+        from jedi.evaluate.iterable import Slice, AbstractIterable
         result = ContextSet()
 
         for index in index_contexts:
@@ -91,7 +91,7 @@ class Context(BaseContext):
             if type(index) not in (float, int, str, unicode, slice, type(Ellipsis)):
                 # If the index is not clearly defined, we have to get all the
                 # possiblities.
-                if isinstance(self, AbstractSequence) and self.array_type == 'dict':
+                if isinstance(self, AbstractIterable) and self.array_type == 'dict':
                     result |= self.dict_values()
                 else:
                     result |= iterate_contexts(ContextSet(self))

jedi/evaluate/finder.py

@@ -248,7 +248,7 @@ def _check_isinstance_type(context, element, search_name):
 
     context_set = ContextSet()
     for cls_or_tup in lazy_context_cls.infer():
-        if isinstance(cls_or_tup, iterable.AbstractSequence) and \
+        if isinstance(cls_or_tup, iterable.AbstractIterable) and \
                 cls_or_tup.array_type == 'tuple':
             for lazy_context in cls_or_tup.py__iter__():
                 for context in lazy_context.infer():

jedi/evaluate/iterable.py

@@ -22,14 +22,14 @@ It is important to note that:
 """
 from jedi import debug
 from jedi import settings
-from jedi.evaluate.utils import safe_property
-from jedi.evaluate.utils import to_list
 from jedi.evaluate import compiled
 from jedi.evaluate import helpers
 from jedi.evaluate import analysis
 from jedi.evaluate import context
 from jedi.evaluate import recursion
 from jedi.evaluate.helpers import is_string
+from jedi.evaluate.utils import safe_property
+from jedi.evaluate.utils import to_list
 from jedi.evaluate.cache import evaluator_method_cache
 from jedi.evaluate.filters import ParserTreeFilter, has_builtin_methods, \
     register_builtin_method, SpecialMethodFilter
@@ -38,12 +38,12 @@ from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS, Context, \
 from jedi.parser_utils import get_comp_fors
 
 
-class AbstractSequence(Context):
+class AbstractIterable(Context):
     builtin_methods = {}
     api_type = 'instance'
 
     def __init__(self, evaluator):
-        super(AbstractSequence, self).__init__(evaluator, evaluator.BUILTINS)
+        super(AbstractIterable, self).__init__(evaluator, evaluator.BUILTINS)
 
     def get_filters(self, search_global, until_position=None, origin_scope=None):
         raise NotImplementedError
@@ -111,7 +111,7 @@ class CompForContext(TreeContext):
         yield ParserTreeFilter(self.evaluator, self)
 
 
-class Comprehension(AbstractSequence):
+class Comprehension(AbstractIterable):
     @staticmethod
     def from_atom(evaluator, context, atom):
         bracket = atom.children[0]
@@ -278,7 +278,7 @@ class GeneratorComprehension(GeneratorMixin, Comprehension):
     pass
 
 
-class SequenceLiteralContext(ArrayMixin, AbstractSequence):
+class SequenceLiteralContext(ArrayMixin, AbstractIterable):
     mapping = {'(': 'tuple',
                '[': 'list',
                '{': 'set'}

jedi/evaluate/param.py

@@ -390,7 +390,7 @@ def _star_star_dict(context, array, input_node, funcdef):
         # For now ignore this case. In the future add proper iterators and just
         # make one call without crazy isinstance checks.
         return {}
-    elif isinstance(array, iterable.AbstractSequence) and array.array_type == 'dict':
+    elif isinstance(array, iterable.AbstractIterable) and array.array_type == 'dict':
         return array.exact_key_items()
     else:
         if funcdef is not None:

jedi/evaluate/stdlib.py

@@ -268,7 +268,7 @@ def collections_namedtuple(evaluator, obj, arguments):
     _fields = list(_follow_param(evaluator, arguments, 1))[0]
     if isinstance(_fields, compiled.CompiledObject):
         fields = _fields.obj.replace(',', ' ').split()
-    elif isinstance(_fields, iterable.AbstractSequence):
+    elif isinstance(_fields, iterable.AbstractIterable):
         fields = [
             v.obj
             for lazy_context in _fields.py__iter__()

jedi/evaluate/syntax_tree.py

@@ -367,11 +367,11 @@ def _eval_comparison(evaluator, context, left_contexts, operator, right_contexts
 
 
 def _is_tuple(context):
-    return isinstance(context, iterable.AbstractSequence) and context.array_type == 'tuple'
+    return isinstance(context, iterable.AbstractIterable) and context.array_type == 'tuple'
 
 
 def _is_list(context):
-    return isinstance(context, iterable.AbstractSequence) and context.array_type == 'list'
+    return isinstance(context, iterable.AbstractIterable) and context.array_type == 'list'
 
 
 def _eval_comparison_part(evaluator, context, left, operator, right):
@@ -379,9 +379,9 @@ def _eval_comparison_part(evaluator, context, left, operator, right):
     r_is_num = is_number(right)
     if operator == '*':
         # for iterables, ignore * operations
-        if isinstance(left, iterable.AbstractSequence) or is_string(left):
+        if isinstance(left, iterable.AbstractIterable) or is_string(left):
             return ContextSet(left)
-        elif isinstance(right, iterable.AbstractSequence) or is_string(right):
+        elif isinstance(right, iterable.AbstractIterable) or is_string(right):
             return ContextSet(right)
     elif operator == '+':
         if l_is_num and r_is_num or is_string(left) and is_string(right):