You Want It Darker

IPython/core/completer.py

@@ -923,8 +923,8 b' class Completer(Configurable):'
     ).tag(config=True)
 
     evaluation = Enum(
-        ('forbidden', 'minimal', 'limitted', 'unsafe', 'dangerous'),
-        default_value='limitted',
+        ("forbidden", "minimal", "limitted", "unsafe", "dangerous"),
+        default_value="limitted",
         help="""Code evaluation under completion.
 
         Successive options allow to enable more eager evaluation for more accurate completion suggestions,
@@ -961,8 +961,7 b' class Completer(Configurable):'
              "unicode characters back to latex commands.").tag(config=True)
 
     auto_close_dict_keys = Bool(
-        False,
-        help="""Enable auto-closing dictionary keys."""
+        False, help="""Enable auto-closing dictionary keys."""
     ).tag(config=True)
 
     def __init__(self, namespace=None, global_namespace=None, **kwargs):
@@ -1066,7 +1065,7 b' class Completer(Configurable):'
         m2 = re.match(r"(.+)\.(\w*)$", self.line_buffer)
         if not m2:
             return []
-        expr, attr = m2.group(1,2)
+        expr, attr = m2.group(1, 2)
 
         obj = self._evaluate_expr(expr)
 
@@ -1090,8 +1089,7 b' class Completer(Configurable):'
             pass
         # Build match list to return
         n = len(attr)
-        return ["%s.%s" % (expr, w) for w in words if w[:n] == attr ]
-
+        return ["%s.%s" % (expr, w) for w in words if w[:n] == attr]
 
     def _evaluate_expr(self, expr):
         obj = not_found
@@ -1103,13 +1101,13 b' class Completer(Configurable):'
                     EvaluationContext(
                         globals_=self.global_namespace,
                         locals_=self.namespace,
-                        evaluation=self.evaluation
-                    )
+                        evaluation=self.evaluation,
+                    ),
                 )
                 done = True
             except Exception as e:
                 if self.debug:
-                    print('Evaluation exception', e)
+                    print("Evaluation exception", e)
                 # trim the expression to remove any invalid prefix
                 # e.g. user starts `(d[`, so we get `expr = '(d'`,
                 # where parenthesis is not closed.
@@ -1135,6 +1133,7 b' class DictKeyState(enum.Flag):'
     - given `d3 = {('a', 'b'): 1}`: `d3['<tab>` will yield `{'a': IN_TUPLE}` as `'a'` can be added.
     - given `d4 = {'a': 1, ('a', 'b'): 2}`: `d4['<tab>` will yield `{'a': END_OF_ITEM & END_OF_TUPLE}`
     """
+
     BASELINE = 0
     END_OF_ITEM = enum.auto()
     END_OF_TUPLE = enum.auto()
@@ -1179,9 +1178,9 b' def _match_number_in_dict_key_prefix(prefix: str) -> Union[str, None]:'
                 # we did not match a number
                 return None
         if token.type == tokenize.OP:
-            if token.string == ',':
+            if token.string == ",":
                 break
-            if token.string in {'+', '-'}:
+            if token.string in {"+", "-"}:
                 number = token.string + number
         else:
             return None
@@ -1189,9 +1188,9 b' def _match_number_in_dict_key_prefix(prefix: str) -> Union[str, None]:'
 
 
 _INT_FORMATS = {
-    '0b': bin,
-    '0o': oct,
-    '0x': hex,
+    "0b": bin,
+    "0o": oct,
+    "0x": hex,
 }
 
 
@@ -1199,7 +1198,7 b' def match_dict_keys('
     keys: List[Union[str, bytes, Tuple[Union[str, bytes], ...]]],
     prefix: str,
     delims: str,
-    extra_prefix: Optional[Tuple[Union[str, bytes], ...]] = None
+    extra_prefix: Optional[Tuple[Union[str, bytes], ...]] = None,
 ) -> Tuple[str, int, Dict[str, DictKeyState]]:
     """Used by dict_key_matches, matching the prefix to a list of keys
 
@@ -1225,11 +1224,13 b' def match_dict_keys('
     """
     prefix_tuple = extra_prefix if extra_prefix else ()
 
-    prefix_tuple_size = sum([
-        # for pandas, do not count slices as taking space
-        not isinstance(k, slice)
-        for k in prefix_tuple
-    ])
+    prefix_tuple_size = sum(
+        [
+            # for pandas, do not count slices as taking space
+            not isinstance(k, slice)
+            for k in prefix_tuple
+        ]
+    )
     text_serializable_types = (str, bytes, int, float, slice)
 
     def filter_prefix_tuple(key):
@@ -1247,7 +1248,9 b' def match_dict_keys('
         # All checks passed!
         return True
 
-    filtered_key_is_final: Dict[Union[str, bytes, int, float], DictKeyState] = defaultdict(lambda: DictKeyState.BASELINE)
+    filtered_key_is_final: Dict[
+        Union[str, bytes, int, float], DictKeyState
+    ] = defaultdict(lambda: DictKeyState.BASELINE)
 
     for k in keys:
         # If at least one of the matches is not final, mark as undetermined.
@@ -1259,8 +1262,8 b' def match_dict_keys('
                 key_fragment = k[prefix_tuple_size]
                 filtered_key_is_final[key_fragment] |= (
                     DictKeyState.END_OF_TUPLE
-                    if len(k) == prefix_tuple_size + 1 else
-                    DictKeyState.IN_TUPLE
+                    if len(k) == prefix_tuple_size + 1
+                    else DictKeyState.IN_TUPLE
                 )
         elif prefix_tuple_size > 0:
             # we are completing a tuple but this key is not a tuple,
@@ -1273,9 +1276,9 b' def match_dict_keys('
     filtered_keys = filtered_key_is_final.keys()
 
     if not prefix:
-        return '', 0, {repr(k): v for k, v in filtered_key_is_final.items()}
+        return "", 0, {repr(k): v for k, v in filtered_key_is_final.items()}
 
-    quote_match = re.search('(?:"|\')', prefix)
+    quote_match = re.search("(?:\"|')", prefix)
     is_user_prefix_numeric = False
 
     if quote_match:
@@ -1284,7 +1287,7 b' def match_dict_keys('
         try:
             prefix_str = literal_eval(valid_prefix)
         except Exception:
-            return '', 0, {}
+            return "", 0, {}
     else:
         # If it does not look like a string, let's assume
         # we are dealing with a number or variable.
@@ -1294,11 +1297,11 b' def match_dict_keys('
         if number_match is None:
             # The alternative would be to assume that user forgort the quote
             # and if the substring matches, suggest adding it at the start.
-            return '', 0, {}
+            return "", 0, {}
 
         prefix_str = number_match
         is_user_prefix_numeric = True
-        quote = ''
+        quote = ""
 
     pattern = '[^' + ''.join('\\' + c for c in delims) + ']*$'
     token_match = re.search(pattern, prefix, re.UNICODE)
@@ -1333,7 +1336,7 b' def match_dict_keys('
             continue
 
         # reformat remainder of key to begin with prefix
-        rem = str_key[len(prefix_str):]
+        rem = str_key[len(prefix_str) :]
         # force repr wrapped in '
         rem_repr = repr(rem + '"') if isinstance(rem, str) else repr(rem + b'"')
         rem_repr = rem_repr[1 + rem_repr.index("'"):-2]
@@ -1344,7 +1347,7 b' def match_dict_keys('
             rem_repr = rem_repr.replace('"', '\\"')
 
         # then reinsert prefix from start of token
-        match = '%s%s' % (token_prefix, rem_repr)
+        match = "%s%s" % (token_prefix, rem_repr)
 
         matched[match] = filtered_key_is_final[key]
     return quote, token_start, matched
@@ -1572,7 +1575,8 b' def _make_signature(completion)-> str:'
 _CompleteResult = Dict[str, MatcherResult]
 
 
-DICT_MATCHER_REGEX = re.compile(r"""(?x)
+DICT_MATCHER_REGEX = re.compile(
+    r"""(?x)
 (  # match dict-referring - or any get item object - expression
     .+
 )
@@ -1616,7 +1620,9 b' DICT_MATCHER_REGEX = re.compile(r"""(?x)'
     )
 )?
 $
-""")
+"""
+)
+
 
 def _convert_matcher_v1_result_to_v2(
     matches: Sequence[str],
@@ -1640,12 +1646,12 b' class IPCompleter(Completer):'
     @observe('greedy')
     def _greedy_changed(self, change):
         """update the splitter and readline delims when greedy is changed"""
-        if change['new']:
-            self.evaluation = 'unsafe'
+        if change["new"]:
+            self.evaluation = "unsafe"
             self.auto_close_dict_keys = True
             self.splitter.delims = GREEDY_DELIMS
         else:
-            self.evaluation = 'limitted'
+            self.evaluation = "limitted"
             self.auto_close_dict_keys = False
             self.splitter.delims = DELIMS
 
@@ -2375,13 +2381,12 b' class IPCompleter(Completer):'
             return method()
 
         # Special case some common in-memory dict-like types
-        if (isinstance(obj, dict) or
-           _safe_isinstance(obj, 'pandas', 'DataFrame')):
+        if isinstance(obj, dict) or _safe_isinstance(obj, "pandas", "DataFrame"):
             try:
                 return list(obj.keys())
             except Exception:
                 return []
-        elif _safe_isinstance(obj, 'pandas', 'core', 'indexing', '_LocIndexer'):
+        elif _safe_isinstance(obj, "pandas", "core", "indexing", "_LocIndexer"):
             try:
                 return list(obj.obj.keys())
             except Exception:
@@ -2408,7 +2413,7 b' class IPCompleter(Completer):'
 
         # Short-circuit on closed dictionary (regular expression would
         # not match anyway, but would take quite a while).
-        if self.text_until_cursor.strip().endswith(']'):
+        if self.text_until_cursor.strip().endswith("]"):
             return []
 
         match = DICT_MATCHER_REGEX.search(self.text_until_cursor)
@@ -2433,15 +2438,12 b' class IPCompleter(Completer):'
                 globals_=self.global_namespace,
                 locals_=self.namespace,
                 evaluation=self.evaluation,
-                in_subscript=True
-            )
+                in_subscript=True,
+            ),
         )
 
         closing_quote, token_offset, matches = match_dict_keys(
-            keys,
-            key_prefix,
-            self.splitter.delims,
-            extra_prefix=tuple_prefix
+            keys, key_prefix, self.splitter.delims, extra_prefix=tuple_prefix
         )
         if not matches:
             return []
@@ -2469,11 +2471,11 b' class IPCompleter(Completer):'
         can_close_quote = False
         can_close_bracket = False
 
-        continuation = self.line_buffer[len(self.text_until_cursor):].strip()
+        continuation = self.line_buffer[len(self.text_until_cursor) :].strip()
 
         if continuation.startswith(closing_quote):
             # do not close if already closed, e.g. `d['a<tab>'`
-            continuation = continuation[len(closing_quote):]
+            continuation = continuation[len(closing_quote) :]
         else:
             can_close_quote = True
 
@@ -2483,8 +2485,14 b' class IPCompleter(Completer):'
         # handling it is out of scope, so let's avoid appending suffixes.
         has_known_tuple_handling = isinstance(obj, dict)
 
-        can_close_bracket = not continuation.startswith(']') and self.auto_close_dict_keys
-        can_close_tuple_item = not continuation.startswith(',') and has_known_tuple_handling and self.auto_close_dict_keys
+        can_close_bracket = (
+            not continuation.startswith("]") and self.auto_close_dict_keys
+        )
+        can_close_tuple_item = (
+            not continuation.startswith(",")
+            and has_known_tuple_handling
+            and self.auto_close_dict_keys
+        )
         can_close_quote = can_close_quote and self.auto_close_dict_keys
 
         # fast path if closing qoute should be appended but not suffix is allowed
@@ -2507,9 +2515,9 b' class IPCompleter(Completer):'
                 pass
 
             if state_flag in end_of_tuple_or_item and can_close_bracket:
-                result += ']'
+                result += "]"
             if state_flag == DictKeyState.IN_TUPLE and can_close_tuple_item:
-                result += ', '
+                result += ", "
             results.append(result)
         return results
 

IPython/core/guarded_eval.py

@@ -16,20 +16,24 b' else:'
 
 
 class HasGetItem(Protocol):
-    def __getitem__(self, key) -> None: ...
+    def __getitem__(self, key) -> None:
+        ...
 
 
 class InstancesHaveGetItem(Protocol):
-    def __call__(self) -> HasGetItem: ...
+    def __call__(self) -> HasGetItem:
+        ...
 
 
 class HasGetAttr(Protocol):
-    def __getattr__(self, key) -> None: ...
+    def __getattr__(self, key) -> None:
+        ...
 
 
 class DoesNotHaveGetAttr(Protocol):
     pass
 
+
 # By default `__getattr__` is not explicitly implemented on most objects
 MayHaveGetattr = Union[HasGetAttr, DoesNotHaveGetAttr]
 
@@ -38,22 +42,16 b' def unbind_method(func: Callable) -> Union[Callable, None]:'
     """Get unbound method for given bound method.
 
     Returns None if cannot get unbound method."""
-    owner = getattr(func, '__self__', None)
+    owner = getattr(func, "__self__", None)
     owner_class = type(owner)
-    name = getattr(func, '__name__', None)
-    instance_dict_overrides = getattr(owner, '__dict__', None)
+    name = getattr(func, "__name__", None)
+    instance_dict_overrides = getattr(owner, "__dict__", None)
     if (
         owner is not None
-        and
-        name
-        and
-        (
+        and name
+        and (
             not instance_dict_overrides
-            or
-            (
-                instance_dict_overrides
-                and name not in instance_dict_overrides
-            )
+            or (instance_dict_overrides and name not in instance_dict_overrides)
         )
     ):
         return getattr(owner_class, name)
@@ -86,7 +84,13 b' class EvaluationPolicy:'
         if owner_method and owner_method in self.allowed_calls:
             return True
 
-def has_original_dunder_external(value, module_name, access_path, method_name,):
+
+def has_original_dunder_external(
+    value,
+    module_name,
+    access_path,
+    method_name,
+):
     try:
         if module_name not in sys.modules:
             return False
@@ -106,11 +110,7 b' def has_original_dunder_external(value, module_name, access_path, method_name,):'
 
 
 def has_original_dunder(
-    value,
-    allowed_types,
-    allowed_methods,
-    allowed_external,
-    method_name
+    value, allowed_types, allowed_methods, allowed_external, method_name
 ):
     # note: Python ignores `__getattr__`/`__getitem__` on instances,
     # we only need to check at class level
@@ -148,14 +148,14 b' class SelectivePolicy(EvaluationPolicy):'
             allowed_types=self.allowed_getattr,
             allowed_methods=self._getattribute_methods,
             allowed_external=self.allowed_getattr_external,
-            method_name='__getattribute__'
+            method_name="__getattribute__",
         )
         has_original_attr = has_original_dunder(
             value,
             allowed_types=self.allowed_getattr,
             allowed_methods=self._getattr_methods,
             allowed_external=self.allowed_getattr_external,
-            method_name='__getattr__'
+            method_name="__getattr__",
         )
         # Many objects do not have `__getattr__`, this is fine
         if has_original_attr is None and has_original_attribute:
@@ -168,7 +168,6 b' class SelectivePolicy(EvaluationPolicy):'
         if self.can_get_attr(value, attr):
             return getattr(value, attr)
 
-
     def can_get_item(self, value, item):
         """Allow accessing `__getiitem__` of allow-listed instances unless it was not modified."""
         return has_original_dunder(
@@ -176,29 +175,20 b' class SelectivePolicy(EvaluationPolicy):'
             allowed_types=self.allowed_getitem,
             allowed_methods=self._getitem_methods,
             allowed_external=self.allowed_getitem_external,
-            method_name='__getitem__'
+            method_name="__getitem__",
         )
 
     @cached_property
     def _getitem_methods(self) -> Set[Callable]:
-        return self._safe_get_methods(
-            self.allowed_getitem,
-            '__getitem__'
-        )
+        return self._safe_get_methods(self.allowed_getitem, "__getitem__")
 
     @cached_property
     def _getattr_methods(self) -> Set[Callable]:
-        return self._safe_get_methods(
-            self.allowed_getattr,
-            '__getattr__'
-        )
+        return self._safe_get_methods(self.allowed_getattr, "__getattr__")
 
     @cached_property
     def _getattribute_methods(self) -> Set[Callable]:
-        return self._safe_get_methods(
-            self.allowed_getattr,
-            '__getattribute__'
-        )
+        return self._safe_get_methods(self.allowed_getattr, "__getattribute__")
 
     def _safe_get_methods(self, classes, name) -> Set[Callable]:
         return {
@@ -216,7 +206,9 b' class DummyNamedTuple(NamedTuple):'
 class EvaluationContext(NamedTuple):
     locals_: dict
     globals_: dict
-    evaluation: Literal['forbidden', 'minimal', 'limitted', 'unsafe', 'dangerous'] = 'forbidden'
+    evaluation: Literal[
+        "forbidden", "minimal", "limitted", "unsafe", "dangerous"
+    ] = "forbidden"
     in_subscript: bool = False
 
 
@@ -224,21 +216,20 b' class IdentitySubscript:'
     def __getitem__(self, key):
         return key
 
+
 IDENTITY_SUBSCRIPT = IdentitySubscript()
-SUBSCRIPT_MARKER = '__SUBSCRIPT_SENTINEL__'
+SUBSCRIPT_MARKER = "__SUBSCRIPT_SENTINEL__"
+
 
 class GuardRejection(ValueError):
     pass
 
 
-def guarded_eval(
-    code: str,
-    context: EvaluationContext
-):
+def guarded_eval(code: str, context: EvaluationContext):
     locals_ = context.locals_
 
-    if context.evaluation == 'forbidden':
-        raise GuardRejection('Forbidden mode')
+    if context.evaluation == "forbidden":
+        raise GuardRejection("Forbidden mode")
 
     # note: not using `ast.literal_eval` as it does not implement
     # getitem at all, for example it fails on simple `[0][1]`
@@ -252,19 +243,17 b' def guarded_eval('
             return tuple()
         locals_ = locals_.copy()
         locals_[SUBSCRIPT_MARKER] = IDENTITY_SUBSCRIPT
-        code = SUBSCRIPT_MARKER + '[' + code + ']'
-        context = EvaluationContext(**{
-            **context._asdict(),
-            **{'locals_': locals_}
-        })
+        code = SUBSCRIPT_MARKER + "[" + code + "]"
+        context = EvaluationContext(**{**context._asdict(), **{"locals_": locals_}})
 
-    if context.evaluation == 'dangerous':
+    if context.evaluation == "dangerous":
         return eval(code, context.globals_, context.locals_)
 
-    expression = ast.parse(code, mode='eval')
+    expression = ast.parse(code, mode="eval")
 
     return eval_node(expression, context)
 
+
 def eval_node(node: Union[ast.AST, None], context: EvaluationContext):
     """
     Evaluate AST node in provided context.
@@ -314,7 +303,7 b' def eval_node(node: Union[ast.AST, None], context: EvaluationContext):'
         if isinstance(node.op, ast.Mod):
             return left % right
         if isinstance(node.op, ast.Pow):
-            return left ** right
+            return left**right
         if isinstance(node.op, ast.LShift):
             return left << right
         if isinstance(node.op, ast.RShift):
@@ -332,36 +321,26 b' def eval_node(node: Union[ast.AST, None], context: EvaluationContext):'
     if isinstance(node, ast.Index):
         return eval_node(node.value, context)
     if isinstance(node, ast.Tuple):
-        return tuple(
-            eval_node(e, context)
-            for e in node.elts
-        )
+        return tuple(eval_node(e, context) for e in node.elts)
     if isinstance(node, ast.List):
-        return [
-            eval_node(e, context)
-            for e in node.elts
-        ]
+        return [eval_node(e, context) for e in node.elts]
     if isinstance(node, ast.Set):
-        return {
-            eval_node(e, context)
-            for e in node.elts
-        }
+        return {eval_node(e, context) for e in node.elts}
     if isinstance(node, ast.Dict):
-        return dict(zip(
-            [eval_node(k, context) for k in node.keys],
-            [eval_node(v, context) for v in node.values]
-        ))
+        return dict(
+            zip(
+                [eval_node(k, context) for k in node.keys],
+                [eval_node(v, context) for v in node.values],
+            )
+        )
     if isinstance(node, ast.Slice):
         return slice(
             eval_node(node.lower, context),
             eval_node(node.upper, context),
-            eval_node(node.step, context)
+            eval_node(node.step, context),
         )
     if isinstance(node, ast.ExtSlice):
-        return tuple([
-            eval_node(dim, context) 
-            for dim in node.dims
-        ])
+        return tuple([eval_node(dim, context) for dim in node.dims])
     if isinstance(node, ast.UnaryOp):
         # TODO: add guards
         value = eval_node(node.operand, context)
@@ -373,16 +352,16 b' def eval_node(node: Union[ast.AST, None], context: EvaluationContext):'
             return ~value
         if isinstance(node.op, ast.Not):
             return not value
-        raise ValueError('Unhandled unary operation:', node.op)
+        raise ValueError("Unhandled unary operation:", node.op)
     if isinstance(node, ast.Subscript):
         value = eval_node(node.value, context)
         slice_ = eval_node(node.slice, context)
         if policy.can_get_item(value, slice_):
             return value[slice_]
         raise GuardRejection(
-            'Subscript access (`__getitem__`) for',
-            type(value), # not joined to avoid calling `repr`
-            f' not allowed in {context.evaluation} mode'
+            "Subscript access (`__getitem__`) for",
+            type(value),  # not joined to avoid calling `repr`
+            f" not allowed in {context.evaluation} mode",
         )
     if isinstance(node, ast.Name):
         if policy.allow_locals_access and node.id in context.locals_:
@@ -393,49 +372,46 b' def eval_node(node: Union[ast.AST, None], context: EvaluationContext):'
             return __builtins__[node.id]
         if not policy.allow_globals_access and not policy.allow_locals_access:
             raise GuardRejection(
-                f'Namespace access not allowed in {context.evaluation} mode'
+                f"Namespace access not allowed in {context.evaluation} mode"
             )
         else:
-            raise NameError(f'{node.id} not found in locals nor globals')
+            raise NameError(f"{node.id} not found in locals nor globals")
     if isinstance(node, ast.Attribute):
         value = eval_node(node.value, context)
         if policy.can_get_attr(value, node.attr):
             return getattr(value, node.attr)
         raise GuardRejection(
-            'Attribute access (`__getattr__`) for',
-            type(value), # not joined to avoid calling `repr`
-            f'not allowed in {context.evaluation} mode'
+            "Attribute access (`__getattr__`) for",
+            type(value),  # not joined to avoid calling `repr`
+            f"not allowed in {context.evaluation} mode",
         )
     if isinstance(node, ast.IfExp):
         test = eval_node(node.test, context)
         if test:
-             return eval_node(node.body, context)
+            return eval_node(node.body, context)
         else:
             return eval_node(node.orelse, context)
     if isinstance(node, ast.Call):
         func = eval_node(node.func, context)
         print(node.keywords)
         if policy.can_call(func) and not node.keywords:
-            args = [
-                eval_node(arg, context)
-                for arg in node.args
-            ]
+            args = [eval_node(arg, context) for arg in node.args]
             return func(*args)
         raise GuardRejection(
-            'Call for',
-            func, # not joined to avoid calling `repr`
-            f'not allowed in {context.evaluation} mode'
+            "Call for",
+            func,  # not joined to avoid calling `repr`
+            f"not allowed in {context.evaluation} mode",
         )
-    raise ValueError('Unhandled node', node)
+    raise ValueError("Unhandled node", node)
 
 
 SUPPORTED_EXTERNAL_GETITEM = {
-    ('pandas', 'core', 'indexing', '_iLocIndexer'),
-    ('pandas', 'core', 'indexing', '_LocIndexer'),
-    ('pandas', 'DataFrame'),
-    ('pandas', 'Series'),
-    ('numpy', 'ndarray'),
-    ('numpy', 'void')
+    ("pandas", "core", "indexing", "_iLocIndexer"),
+    ("pandas", "core", "indexing", "_LocIndexer"),
+    ("pandas", "DataFrame"),
+    ("pandas", "Series"),
+    ("numpy", "ndarray"),
+    ("numpy", "void"),
 }
 
 BUILTIN_GETITEM = {
@@ -452,20 +428,17 b' BUILTIN_GETITEM = {'
     collections.UserList,
     collections.UserString,
     DummyNamedTuple,
-    IdentitySubscript
+    IdentitySubscript,
 }
 
 
 def _list_methods(cls, source=None):
     """For use on immutable objects or with methods returning a copy"""
-    return [
-        getattr(cls, k)
-        for k in (source if source else dir(cls))
-    ]
+    return [getattr(cls, k) for k in (source if source else dir(cls))]
 
 
-dict_non_mutating_methods = ('copy', 'keys', 'values', 'items')
-list_non_mutating_methods = ('copy', 'index', 'count')
+dict_non_mutating_methods = ("copy", "keys", "values", "items")
+list_non_mutating_methods = ("copy", "index", "count")
 set_non_mutating_methods = set(dir(set)) & set(dir(frozenset))
 
 
@@ -504,20 +477,20 b' ALLOWED_CALLS = {'
     collections.Counter,
     *_list_methods(collections.Counter, dict_non_mutating_methods),
     collections.Counter.elements,
-    collections.Counter.most_common
+    collections.Counter.most_common,
 }
 
 EVALUATION_POLICIES = {
-    'minimal': EvaluationPolicy(
+    "minimal": EvaluationPolicy(
         allow_builtins_access=True,
         allow_locals_access=False,
         allow_globals_access=False,
         allow_item_access=False,
         allow_attr_access=False,
         allowed_calls=set(),
-        allow_any_calls=False
+        allow_any_calls=False,
     ),
-    'limitted': SelectivePolicy(
+    "limitted": SelectivePolicy(
         # TODO:
         # - should reject binary and unary operations if custom methods would be dispatched
         allowed_getitem=BUILTIN_GETITEM,
@@ -529,24 +502,24 b' EVALUATION_POLICIES = {'
             object,
             type,  # `type` handles a lot of generic cases, e.g. numbers as in `int.real`.
             dict_keys,
-            method_descriptor
+            method_descriptor,
         },
         allowed_getattr_external={
             # pandas Series/Frame implements custom `__getattr__`
-            ('pandas', 'DataFrame'),
-            ('pandas', 'Series')
+            ("pandas", "DataFrame"),
+            ("pandas", "Series"),
         },
         allow_builtins_access=True,
         allow_locals_access=True,
         allow_globals_access=True,
-        allowed_calls=ALLOWED_CALLS
+        allowed_calls=ALLOWED_CALLS,
     ),
-    'unsafe': EvaluationPolicy(
+    "unsafe": EvaluationPolicy(
         allow_builtins_access=True,
         allow_locals_access=True,
         allow_globals_access=True,
         allow_attr_access=True,
         allow_item_access=True,
-        allow_any_calls=True
-    )
-}
  No newline at end of file
+        allow_any_calls=True,
+    ),
+}

IPython/core/tests/test_completer.py

@@ -868,21 +868,16 b' class TestCompleter(unittest.TestCase):'
         assert match(keys, '"f', delims=delims) == ('"', 1, ["foo"])
 
         # Completion on first item of tuple
-        keys = [("foo", 1111), ("foo", 2222), (3333, "bar"), (3333, 'test')]
+        keys = [("foo", 1111), ("foo", 2222), (3333, "bar"), (3333, "test")]
         assert match(keys, "'f", delims=delims) == ("'", 1, ["foo"])
         assert match(keys, "33", delims=delims) == ("", 0, ["3333"])
 
         # Completion on numbers
-        keys = [
-            0xdeadbeef,   # 3735928559
-            1111, 1234, "1999",
-            0b10101,   # 21
-            22
-        ]
+        keys = [0xDEADBEEF, 1111, 1234, "1999", 0b10101, 22]  # 3735928559  # 21
         assert match(keys, "0xdead", delims=delims) == ("", 0, ["0xdeadbeef"])
         assert match(keys, "1", delims=delims) == ("", 0, ["1111", "1234"])
         assert match(keys, "2", delims=delims) == ("", 0, ["21", "22"])
-        assert match(keys, "0b101", delims=delims) == ("", 0, ['0b10101', '0b10110'])
+        assert match(keys, "0b101", delims=delims) == ("", 0, ["0b10101", "0b10110"])
 
     def test_match_dict_keys_tuple(self):
         """
@@ -898,30 +893,90 b' class TestCompleter(unittest.TestCase):'
             return quote, offset, list(matches)
 
         # Completion on first key == "foo"
-        assert match(keys, "'", delims=delims, extra_prefix=("foo",)) == ("'", 1, ["bar", "oof"])
-        assert match(keys, "\"", delims=delims, extra_prefix=("foo",)) == ("\"", 1, ["bar", "oof"])
-        assert match(keys, "'o", delims=delims, extra_prefix=("foo",)) == ("'", 1, ["oof"])
-        assert match(keys, "\"o", delims=delims, extra_prefix=("foo",)) == ("\"", 1, ["oof"])
-        assert match(keys, "b'", delims=delims, extra_prefix=("foo",)) == ("'", 2, ["bar"])
-        assert match(keys, "b\"", delims=delims, extra_prefix=("foo",)) == ("\"", 2, ["bar"])
-        assert match(keys, "b'b", delims=delims, extra_prefix=("foo",)) == ("'", 2, ["bar"])
-        assert match(keys, "b\"b", delims=delims, extra_prefix=("foo",)) == ("\"", 2, ["bar"])
+        assert match(keys, "'", delims=delims, extra_prefix=("foo",)) == (
+            "'",
+            1,
+            ["bar", "oof"],
+        )
+        assert match(keys, '"', delims=delims, extra_prefix=("foo",)) == (
+            '"',
+            1,
+            ["bar", "oof"],
+        )
+        assert match(keys, "'o", delims=delims, extra_prefix=("foo",)) == (
+            "'",
+            1,
+            ["oof"],
+        )
+        assert match(keys, '"o', delims=delims, extra_prefix=("foo",)) == (
+            '"',
+            1,
+            ["oof"],
+        )
+        assert match(keys, "b'", delims=delims, extra_prefix=("foo",)) == (
+            "'",
+            2,
+            ["bar"],
+        )
+        assert match(keys, 'b"', delims=delims, extra_prefix=("foo",)) == (
+            '"',
+            2,
+            ["bar"],
+        )
+        assert match(keys, "b'b", delims=delims, extra_prefix=("foo",)) == (
+            "'",
+            2,
+            ["bar"],
+        )
+        assert match(keys, 'b"b', delims=delims, extra_prefix=("foo",)) == (
+            '"',
+            2,
+            ["bar"],
+        )
 
         # No Completion
         assert match(keys, "'", delims=delims, extra_prefix=("no_foo",)) == ("'", 1, [])
         assert match(keys, "'", delims=delims, extra_prefix=("fo",)) == ("'", 1, [])
 
-        keys = [('foo1', 'foo2', 'foo3', 'foo4'), ('foo1', 'foo2', 'bar', 'foo4')]
-        assert match(keys, "'foo", delims=delims, extra_prefix=('foo1',)) == ("'", 1, ["foo2"])
-        assert match(keys, "'foo", delims=delims, extra_prefix=('foo1', 'foo2')) == ("'", 1, ["foo3"])
-        assert match(keys, "'foo", delims=delims, extra_prefix=('foo1', 'foo2', 'foo3')) == ("'", 1, ["foo4"])
-        assert match(keys, "'foo", delims=delims, extra_prefix=('foo1', 'foo2', 'foo3', 'foo4')) == ("'", 1, [])
+        keys = [("foo1", "foo2", "foo3", "foo4"), ("foo1", "foo2", "bar", "foo4")]
+        assert match(keys, "'foo", delims=delims, extra_prefix=("foo1",)) == (
+            "'",
+            1,
+            ["foo2"],
+        )
+        assert match(keys, "'foo", delims=delims, extra_prefix=("foo1", "foo2")) == (
+            "'",
+            1,
+            ["foo3"],
+        )
+        assert match(
+            keys, "'foo", delims=delims, extra_prefix=("foo1", "foo2", "foo3")
+        ) == ("'", 1, ["foo4"])
+        assert match(
+            keys, "'foo", delims=delims, extra_prefix=("foo1", "foo2", "foo3", "foo4")
+        ) == ("'", 1, [])
 
         keys = [("foo", 1111), ("foo", "2222"), (3333, "bar"), (3333, 4444)]
-        assert match(keys, "'", delims=delims, extra_prefix=("foo",)) == ("'", 1, ["2222"])
-        assert match(keys, "", delims=delims, extra_prefix=("foo",)) == ("", 0, ["1111", "'2222'"])
-        assert match(keys, "'", delims=delims, extra_prefix=(3333,)) == ("'", 1, ["bar"])
-        assert match(keys, "", delims=delims, extra_prefix=(3333,)) == ("", 0, ["'bar'", "4444"])
+        assert match(keys, "'", delims=delims, extra_prefix=("foo",)) == (
+            "'",
+            1,
+            ["2222"],
+        )
+        assert match(keys, "", delims=delims, extra_prefix=("foo",)) == (
+            "",
+            0,
+            ["1111", "'2222'"],
+        )
+        assert match(keys, "'", delims=delims, extra_prefix=(3333,)) == (
+            "'",
+            1,
+            ["bar"],
+        )
+        assert match(keys, "", delims=delims, extra_prefix=(3333,)) == (
+            "",
+            0,
+            ["'bar'", "4444"],
+        )
         assert match(keys, "'", delims=delims, extra_prefix=("3333",)) == ("'", 1, [])
         assert match(keys, "33", delims=delims) == ("", 0, ["3333"])
 
@@ -932,16 +987,16 b' class TestCompleter(unittest.TestCase):'
 
         ip.user_ns["d"] = {
             # tuple only
-            ('aa', 11): None,
+            ("aa", 11): None,
             # tuple and non-tuple
-            ('bb', 22): None,
-            'bb': None,
+            ("bb", 22): None,
+            "bb": None,
             # non-tuple only
-            'cc': None,
+            "cc": None,
             # numeric tuple only
-            (77, 'x'): None,
+            (77, "x"): None,
             # numeric tuple and non-tuple
-            (88, 'y'): None,
+            (88, "y"): None,
             88: None,
             # numeric non-tuple only
             99: None,
@@ -1133,12 +1188,12 b' class TestCompleter(unittest.TestCase):'
         complete = ip.Completer.complete
 
         ip.user_ns["d"] = {
-            0xdeadbeef: None,   # 3735928559
+            0xDEADBEEF: None,  # 3735928559
             1111: None,
             1234: None,
             "1999": None,
-            0b10101: None,   # 21
-            22: None
+            0b10101: None,  # 21
+            22: None,
         }
         _, matches = complete(line_buffer="d[1")
         self.assertIn("1111", matches)
@@ -1169,7 +1224,7 b' class TestCompleter(unittest.TestCase):'
 
         ip.user_ns["C"] = C
         ip.user_ns["get"] = lambda: d
-        ip.user_ns["nested"] = {'x': d}
+        ip.user_ns["nested"] = {"x": d}
 
         def assert_no_completion(**kwargs):
             _, matches = complete(**kwargs)
@@ -1198,7 +1253,7 b' class TestCompleter(unittest.TestCase):'
         # nested dict completion
         assert_completion(line_buffer="nested['x'][")
 
-        with evaluation_level('minimal'):
+        with evaluation_level("minimal"):
             with pytest.raises(AssertionError):
                 assert_completion(line_buffer="nested['x'][")
 
@@ -1289,6 +1344,7 b' class TestCompleter(unittest.TestCase):'
         _, matches = complete(line_buffer="d['")
         self.assertIn("my_head", matches)
         self.assertIn("my_data", matches)
+
         def completes_on_nested():
             ip.user_ns["d"] = numpy.zeros(2, dtype=dt)
             _, matches = complete(line_buffer="d[1]['my_head']['")
@@ -1298,10 +1354,10 b' class TestCompleter(unittest.TestCase):'
         with greedy_completion():
             completes_on_nested()
 
-        with evaluation_level('limitted'):
+        with evaluation_level("limitted"):
             completes_on_nested()
 
-        with evaluation_level('minimal'):
+        with evaluation_level("minimal"):
             with pytest.raises(AssertionError):
                 completes_on_nested()
 
@@ -1653,32 +1709,32 b' class TestCompleter(unittest.TestCase):'
 
 
 @pytest.mark.parametrize(
-    'input, expected',
+    "input, expected",
     [
-        ['1.234', '1.234'],
+        ["1.234", "1.234"],
         # should match signed numbers
-        ['+1', '+1'],
-        ['-1', '-1'],
-        ['-1.0', '-1.0'],
-        ['-1.', '-1.'],
-        ['+1.', '+1.'],
-        ['.1', '.1'],
+        ["+1", "+1"],
+        ["-1", "-1"],
+        ["-1.0", "-1.0"],
+        ["-1.", "-1."],
+        ["+1.", "+1."],
+        [".1", ".1"],
         # should not match non-numbers
-        ['1..', None],
-        ['..', None],
-        ['.1.', None],
+        ["1..", None],
+        ["..", None],
+        [".1.", None],
         # should match after comma
-        [',1', '1'],
-        [', 1', '1'],
-        [', .1', '.1'],
-        [', +.1', '+.1'],
+        [",1", "1"],
+        [", 1", "1"],
+        [", .1", ".1"],
+        [", +.1", "+.1"],
         # should not match after trailing spaces
-        ['.1 ', None],
+        [".1 ", None],
         # some complex cases
-        ['0b_0011_1111_0100_1110', '0b_0011_1111_0100_1110'],
-        ['0xdeadbeef', '0xdeadbeef'],
-        ['0b_1110_0101', '0b_1110_0101']
-    ]
+        ["0b_0011_1111_0100_1110", "0b_0011_1111_0100_1110"],
+        ["0xdeadbeef", "0xdeadbeef"],
+        ["0b_1110_0101", "0b_1110_0101"],
+    ],
 )
 def test_match_numeric_literal_for_dict_key(input, expected):
     assert _match_number_in_dict_key_prefix(input) == expected

IPython/core/tests/test_guarded_eval.py

@@ -1,53 +1,54 b''
 from typing import NamedTuple
-from IPython.core.guarded_eval import EvaluationContext, GuardRejection, guarded_eval, unbind_method
+from IPython.core.guarded_eval import (
+    EvaluationContext,
+    GuardRejection,
+    guarded_eval,
+    unbind_method,
+)
 from IPython.testing import decorators as dec
 import pytest
 
 
 def limitted(**kwargs):
-    return EvaluationContext(
-        locals_=kwargs,
-        globals_={},
-        evaluation='limitted'
-    )
+    return EvaluationContext(locals_=kwargs, globals_={}, evaluation="limitted")
 
 
 def unsafe(**kwargs):
-    return EvaluationContext(
-        locals_=kwargs,
-        globals_={},
-        evaluation='unsafe'
-    )
+    return EvaluationContext(locals_=kwargs, globals_={}, evaluation="unsafe")
+
 
[e-mail]_without('pandas')
[e-mail]_without("pandas")
 def test_pandas_series_iloc():
     import pandas as pd
-    series = pd.Series([1], index=['a'])
+
+    series = pd.Series([1], index=["a"])
     context = limitted(data=series)
-    assert guarded_eval('data.iloc[0]', context) == 1
+    assert guarded_eval("data.iloc[0]", context) == 1
 
 
[e-mail]_without('pandas')
[e-mail]_without("pandas")
 def test_pandas_series():
     import pandas as pd
-    context = limitted(data=pd.Series([1], index=['a']))
+
+    context = limitted(data=pd.Series([1], index=["a"]))
     assert guarded_eval('data["a"]', context) == 1
     with pytest.raises(KeyError):
         guarded_eval('data["c"]', context)
 
 
[e-mail]_without('pandas')
[e-mail]_without("pandas")
 def test_pandas_bad_series():
     import pandas as pd
+
     class BadItemSeries(pd.Series):
         def __getitem__(self, key):
-            return 'CUSTOM_ITEM'
+            return "CUSTOM_ITEM"
 
     class BadAttrSeries(pd.Series):
         def __getattr__(self, key):
-            return 'CUSTOM_ATTR'
+            return "CUSTOM_ATTR"
 
-    bad_series = BadItemSeries([1], index=['a'])
+    bad_series = BadItemSeries([1], index=["a"])
     context = limitted(data=bad_series)
 
     with pytest.raises(GuardRejection):
@@ -58,121 +59,108 b' def test_pandas_bad_series():'
     # note: here result is a bit unexpected because
     # pandas `__getattr__` calls `__getitem__`;
     # FIXME - special case to handle it?
-    assert guarded_eval('data.a', context) == 'CUSTOM_ITEM'
+    assert guarded_eval("data.a", context) == "CUSTOM_ITEM"
 
     context = unsafe(data=bad_series)
-    assert guarded_eval('data["a"]', context) == 'CUSTOM_ITEM'
+    assert guarded_eval('data["a"]', context) == "CUSTOM_ITEM"
 
-    bad_attr_series = BadAttrSeries([1], index=['a'])
+    bad_attr_series = BadAttrSeries([1], index=["a"])
     context = limitted(data=bad_attr_series)
     assert guarded_eval('data["a"]', context) == 1
     with pytest.raises(GuardRejection):
-        guarded_eval('data.a', context)
+        guarded_eval("data.a", context)
 
 
[e-mail]_without('pandas')
[e-mail]_without("pandas")
 def test_pandas_dataframe_loc():
     import pandas as pd
     from pandas.testing import assert_series_equal
-    data = pd.DataFrame([{'a': 1}])
+
+    data = pd.DataFrame([{"a": 1}])
     context = limitted(data=data)
-    assert_series_equal(
-        guarded_eval('data.loc[:, "a"]', context),
-        data['a']
-    )
+    assert_series_equal(guarded_eval('data.loc[:, "a"]', context), data["a"])
 
 
 def test_named_tuple():
-
     class GoodNamedTuple(NamedTuple):
         a: str
         pass
 
     class BadNamedTuple(NamedTuple):
         a: str
+
         def __getitem__(self, key):
             return None
 
-    good = GoodNamedTuple(a='x')
-    bad = BadNamedTuple(a='x')
+    good = GoodNamedTuple(a="x")
+    bad = BadNamedTuple(a="x")
 
     context = limitted(data=good)
-    assert guarded_eval('data[0]', context) == 'x'
+    assert guarded_eval("data[0]", context) == "x"
 
     context = limitted(data=bad)
     with pytest.raises(GuardRejection):
-        guarded_eval('data[0]', context)
+        guarded_eval("data[0]", context)
 
 
 def test_dict():
-    context = limitted(
-        data={'a': 1, 'b': {'x': 2}, ('x', 'y'): 3}
-    )
+    context = limitted(data={"a": 1, "b": {"x": 2}, ("x", "y"): 3})
     assert guarded_eval('data["a"]', context) == 1
-    assert guarded_eval('data["b"]', context) == {'x': 2}
+    assert guarded_eval('data["b"]', context) == {"x": 2}
     assert guarded_eval('data["b"]["x"]', context) == 2
     assert guarded_eval('data["x", "y"]', context) == 3
 
-    assert guarded_eval('data.keys', context)
+    assert guarded_eval("data.keys", context)
 
 
 def test_set():
-    context = limitted(data={'a', 'b'})
-    assert guarded_eval('data.difference', context)
+    context = limitted(data={"a", "b"})
+    assert guarded_eval("data.difference", context)
 
 
 def test_list():
     context = limitted(data=[1, 2, 3])
-    assert guarded_eval('data[1]', context) == 2
-    assert guarded_eval('data.copy', context)
+    assert guarded_eval("data[1]", context) == 2
+    assert guarded_eval("data.copy", context)
 
 
 def test_dict_literal():
     context = limitted()
-    assert guarded_eval('{}', context) == {}
+    assert guarded_eval("{}", context) == {}
     assert guarded_eval('{"a": 1}', context) == {"a": 1}
 
 
 def test_list_literal():
     context = limitted()
-    assert guarded_eval('[]', context) == []
+    assert guarded_eval("[]", context) == []
     assert guarded_eval('[1, "a"]', context) == [1, "a"]
 
 
 def test_set_literal():
     context = limitted()
-    assert guarded_eval('set()', context) == set()
+    assert guarded_eval("set()", context) == set()
     assert guarded_eval('{"a"}', context) == {"a"}
 
 
 def test_if_expression():
     context = limitted()
-    assert guarded_eval('2 if True else 3', context) == 2
-    assert guarded_eval('4 if False else 5', context) == 5
+    assert guarded_eval("2 if True else 3", context) == 2
+    assert guarded_eval("4 if False else 5", context) == 5
 
 
 def test_object():
     obj = object()
     context = limitted(obj=obj)
-    assert guarded_eval('obj.__dir__', context) == obj.__dir__
+    assert guarded_eval("obj.__dir__", context) == obj.__dir__
 
 
 @pytest.mark.parametrize(
     "code,expected",
     [
-        [
-            'int.numerator',
-            int.numerator
-        ],
-        [
-            'float.is_integer',
-            float.is_integer
-        ],
-        [
-            'complex.real',
-            complex.real
-        ]
-    ]
+        ["int.numerator", int.numerator],
+        ["float.is_integer", float.is_integer],
+        ["complex.real", complex.real],
+    ],
 )
 def test_number_attributes(code, expected):
     assert guarded_eval(code, limitted()) == expected
@@ -180,25 +168,15 b' def test_number_attributes(code, expected):'
 
 def test_method_descriptor():
     context = limitted()
-    assert guarded_eval('list.copy.__name__', context) == 'copy'
+    assert guarded_eval("list.copy.__name__", context) == "copy"
 
 
 @pytest.mark.parametrize(
     "data,good,bad,expected",
     [
-        [
-            [1, 2, 3],
-            'data.index(2)',
-            'data.append(4)',
-            1
-        ],
-        [
-            {'a': 1},
-            'data.keys().isdisjoint({})',
-            'data.update()',
-            True
-        ]
-    ]
+        [[1, 2, 3], "data.index(2)", "data.append(4)", 1],
+        [{"a": 1}, "data.keys().isdisjoint({})", "data.update()", True],
+    ],
 )
 def test_calls(data, good, bad, expected):
     context = limitted(data=data)
@@ -211,19 +189,10 b' def test_calls(data, good, bad, expected):'
 @pytest.mark.parametrize(
     "code,expected",
     [
-        [
-            '(1\n+\n1)',
-            2
-        ],
-        [
-            'list(range(10))[-1:]',
-            [9]
-        ],
-        [
-            'list(range(20))[3:-2:3]',
-            [3, 6, 9, 12, 15]
-        ]
-    ]
+        ["(1\n+\n1)", 2],
+        ["list(range(10))[-1:]", [9]],
+        ["list(range(20))[3:-2:3]", [3, 6, 9, 12, 15]],
+    ],
 )
 def test_literals(code, expected):
     context = limitted()
@@ -232,22 +201,20 b' def test_literals(code, expected):'
 
 def test_subscript():
     context = EvaluationContext(
-        locals_={},
-        globals_={},
-        evaluation='limitted',
-        in_subscript=True
+        locals_={}, globals_={}, evaluation="limitted", in_subscript=True
     )
     empty_slice = slice(None, None, None)
-    assert guarded_eval('', context) == tuple()
-    assert guarded_eval(':', context) == empty_slice
-    assert guarded_eval('1:2:3', context) == slice(1, 2, 3)
+    assert guarded_eval("", context) == tuple()
+    assert guarded_eval(":", context) == empty_slice
+    assert guarded_eval("1:2:3", context) == slice(1, 2, 3)
     assert guarded_eval(':, "a"', context) == (empty_slice, "a")
 
 
 def test_unbind_method():
     class X(list):
         def index(self, k):
-            return 'CUSTOM'
+            return "CUSTOM"
+
     x = X()
     assert unbind_method(x.index) is X.index
     assert unbind_method([].index) is list.index
@@ -261,16 +228,19 b' def test_assumption_instance_attr_do_not_matter():'
     versions could invalidate this assumptions. This test
     is meant to catch such a change if it ever comes true.
     """
+
     class T:
         def __getitem__(self, k):
-            return 'a'
+            return "a"
+
         def __getattr__(self, k):
-            return 'a'
+            return "a"
+
     t = T()
-    t.__getitem__ = lambda f: 'b'
-    t.__getattr__ = lambda f: 'b'
-    assert t[1] == 'a'
-    assert t[1] == 'a'
+    t.__getitem__ = lambda f: "b"
+    t.__getattr__ = lambda f: "b"
+    assert t[1] == "a"
+    assert t[1] == "a"
 
 
 def test_assumption_named_tuples_share_getitem():