Intermediate changes

32 files changed, 268 insertions, 1266 deletions

diff --git a/contrib/python/backcall/.dist-info/METADATA b/contrib/python/backcall/.dist-info/METADATA
deleted file mode 100644
index df0f708d2d..0000000000
--- a/contrib/python/backcall/.dist-info/METADATA
+++ /dev/null
@@ -1,55 +0,0 @@
-Metadata-Version: 2.1
-Name: backcall
-Version: 0.2.0
-Summary: Specifications for callback functions passed in to an API
-Home-page: https://github.com/takluyver/backcall
-License: UNKNOWN
-Author: Thomas Kluyver
-Author-email: thomas@kluyver.me.uk
-Description-Content-Type: text/x-rst
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-
-========
-backcall
-========
-
-.. image:: https://travis-ci.org/takluyver/backcall.png?branch=master
-        :target: https://travis-ci.org/takluyver/backcall
-
-Specifications for callback functions passed in to an API
-
-If your code lets other people supply callback functions, it's important to
-specify the function signature you expect, and check that functions support that.
-Adding extra parameters later would break other peoples code unless you're careful.
-
-backcall provides a way of specifying the callback signature using a prototype
-function::
-
-    from backcall import callback_prototype
-    
-    @callback_prototype
-    def handle_ping(sender, delay=None):
-        # Specify positional parameters without a default, and keyword
-        # parameters with a default.
-        pass
-    
-    def register_ping_handler(callback):
-        # This checks and adapts the function passed in:
-        callback = handle_ping.adapt(callback)
-        ping_callbacks.append(callback)
-
-If the callback takes fewer parameters than your prototype, *backcall* will wrap
-it in a function that discards the extra arguments. If the callback expects
-more arguments, a TypeError is thrown when it is registered.
-
-For more details, see the `docs <http://backcall.readthedocs.org/en/latest/>`_ or
-the `Demo notebook <http://nbviewer.ipython.org/github/takluyver/backcall/blob/master/Demo.ipynb>`_.
-
-The tests are run with `pytest <http://pytest.org/latest/>`_. In the root directory,
-execute::
-
-    py.test
-
diff --git a/contrib/python/backcall/.dist-info/top_level.txt b/contrib/python/backcall/.dist-info/top_level.txt
deleted file mode 100644
index e46b94d67c..0000000000
--- a/contrib/python/backcall/.dist-info/top_level.txt
+++ /dev/null
@@ -1 +0,0 @@
-backcall
diff --git a/contrib/python/backcall/LICENSE b/contrib/python/backcall/LICENSE
deleted file mode 100644
index 75f097ee3a..0000000000
--- a/contrib/python/backcall/LICENSE
+++ /dev/null
@@ -1,27 +0,0 @@
-Copyright (c) 2014, Thomas Kluyver
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice, this
-  list of conditions and the following disclaimer in the documentation and/or
-  other materials provided with the distribution.
-
-* Neither the name of the {organization} nor the names of its
-  contributors may be used to endorse or promote products derived from
-  this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/contrib/python/backcall/README.rst b/contrib/python/backcall/README.rst
deleted file mode 100644
index dd82168a5d..0000000000
--- a/contrib/python/backcall/README.rst
+++ /dev/null
@@ -1,40 +0,0 @@
-========
-backcall
-========
-
-.. image:: https://travis-ci.org/takluyver/backcall.png?branch=master
-        :target: https://travis-ci.org/takluyver/backcall
-
-Specifications for callback functions passed in to an API
-
-If your code lets other people supply callback functions, it's important to
-specify the function signature you expect, and check that functions support that.
-Adding extra parameters later would break other peoples code unless you're careful.
-
-backcall provides a way of specifying the callback signature using a prototype
-function::
-
-    from backcall import callback_prototype
-    
-    @callback_prototype
-    def handle_ping(sender, delay=None):
-        # Specify positional parameters without a default, and keyword
-        # parameters with a default.
-        pass
-    
-    def register_ping_handler(callback):
-        # This checks and adapts the function passed in:
-        callback = handle_ping.adapt(callback)
-        ping_callbacks.append(callback)
-
-If the callback takes fewer parameters than your prototype, *backcall* will wrap
-it in a function that discards the extra arguments. If the callback expects
-more arguments, a TypeError is thrown when it is registered.
-
-For more details, see the `docs <http://backcall.readthedocs.org/en/latest/>`_ or
-the `Demo notebook <http://nbviewer.ipython.org/github/takluyver/backcall/blob/master/Demo.ipynb>`_.
-
-The tests are run with `pytest <http://pytest.org/latest/>`_. In the root directory,
-execute::
-
-    py.test
diff --git a/contrib/python/backcall/backcall/__init__.py b/contrib/python/backcall/backcall/__init__.py
deleted file mode 100644
index 7a5c36673b..0000000000
--- a/contrib/python/backcall/backcall/__init__.py
+++ /dev/null
@@ -1,7 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Specifications for callback functions passed in to an API"""
-from .backcall import callback_prototype
-
-__author__ = 'Thomas Kluyver'
-__email__ = 'takowl@gmail.com'
-__version__ = '0.2.0'
diff --git a/contrib/python/backcall/backcall/_signatures.py b/contrib/python/backcall/backcall/_signatures.py
deleted file mode 100644
index f37b31c00e..0000000000
--- a/contrib/python/backcall/backcall/_signatures.py
+++ /dev/null
@@ -1,819 +0,0 @@
-"""Function signature objects for callables
-
-Back port of Python 3.3's function signature tools from the inspect module,
-modified to be compatible with Python 2.6, 2.7 and 3.2+.
-"""
-
-#-----------------------------------------------------------------------------
-#  Python 3.3 stdlib inspect.py is public domain
-# 
-#  Backports Copyright (C) 2013 Aaron Iles
-#  Used under Apache License Version 2.0
-#
-#  Further Changes are Copyright (C) 2013 The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-from __future__ import absolute_import, division, print_function
-import itertools
-import functools
-import re
-import types
-
-
-# patch for single-file
-# we don't support 2.6, so we can just import OrderedDict
-from collections import OrderedDict
-
-__version__ = '0.3'
-# end patch
-
-__all__ = ['BoundArguments', 'Parameter', 'Signature', 'signature']
-
-
-_WrapperDescriptor = type(type.__call__)
-_MethodWrapper = type(all.__call__)
-
-_NonUserDefinedCallables = (_WrapperDescriptor,
-                            _MethodWrapper,
-                            types.BuiltinFunctionType)
-
-
-def formatannotation(annotation, base_module=None):
-    if isinstance(annotation, type):
-        if annotation.__module__ in ('builtins', '__builtin__', base_module):
-            return annotation.__name__
-        return annotation.__module__+'.'+annotation.__name__
-    return repr(annotation)
-
-
-def _get_user_defined_method(cls, method_name, *nested):
-    try:
-        if cls is type:
-            return
-        meth = getattr(cls, method_name)
-        for name in nested:
-            meth = getattr(meth, name, meth)
-    except AttributeError:
-        return
-    else:
-        if not isinstance(meth, _NonUserDefinedCallables):
-            # Once '__signature__' will be added to 'C'-level
-            # callables, this check won't be necessary
-            return meth
-
-
-def signature(obj):
-    '''Get a signature object for the passed callable.'''
-
-    if not callable(obj):
-        raise TypeError('{0!r} is not a callable object'.format(obj))
-
-    if isinstance(obj, types.MethodType):
-        # In this case we skip the first parameter of the underlying
-        # function (usually `self` or `cls`).
-        sig = signature(obj.__func__)
-        return sig.replace(parameters=tuple(sig.parameters.values())[1:])
-
-    try:
-        sig = obj.__signature__
-    except AttributeError:
-        pass
-    else:
-        if sig is not None:
-            return sig
-
-    try:
-        # Was this function wrapped by a decorator?
-        wrapped = obj.__wrapped__
-    except AttributeError:
-        pass
-    else:
-        return signature(wrapped)
-
-    if isinstance(obj, types.FunctionType):
-        return Signature.from_function(obj)
-
-    if isinstance(obj, functools.partial):
-        sig = signature(obj.func)
-
-        new_params = OrderedDict(sig.parameters.items())
-
-        partial_args = obj.args or ()
-        partial_keywords = obj.keywords or {}
-        try:
-            ba = sig.bind_partial(*partial_args, **partial_keywords)
-        except TypeError as ex:
-            msg = 'partial object {0!r} has incorrect arguments'.format(obj)
-            raise ValueError(msg)
-
-        for arg_name, arg_value in ba.arguments.items():
-            param = new_params[arg_name]
-            if arg_name in partial_keywords:
-                # We set a new default value, because the following code
-                # is correct:
-                #
-                #   >>> def foo(a): print(a)
-                #   >>> print(partial(partial(foo, a=10), a=20)())
-                #   20
-                #   >>> print(partial(partial(foo, a=10), a=20)(a=30))
-                #   30
-                #
-                # So, with 'partial' objects, passing a keyword argument is
-                # like setting a new default value for the corresponding
-                # parameter
-                #
-                # We also mark this parameter with '_partial_kwarg'
-                # flag.  Later, in '_bind', the 'default' value of this
-                # parameter will be added to 'kwargs', to simulate
-                # the 'functools.partial' real call.
-                new_params[arg_name] = param.replace(default=arg_value,
-                                                     _partial_kwarg=True)
-
-            elif (param.kind not in (_VAR_KEYWORD, _VAR_POSITIONAL) and
-                            not param._partial_kwarg):
-                new_params.pop(arg_name)
-
-        return sig.replace(parameters=new_params.values())
-
-    sig = None
-    if isinstance(obj, type):
-        # obj is a class or a metaclass
-
-        # First, let's see if it has an overloaded __call__ defined
-        # in its metaclass
-        call = _get_user_defined_method(type(obj), '__call__')
-        if call is not None:
-            sig = signature(call)
-        else:
-            # Now we check if the 'obj' class has a '__new__' method
-            new = _get_user_defined_method(obj, '__new__')
-            if new is not None:
-                sig = signature(new)
-            else:
-                # Finally, we should have at least __init__ implemented
-                init = _get_user_defined_method(obj, '__init__')
-                if init is not None:
-                    sig = signature(init)
-    elif not isinstance(obj, _NonUserDefinedCallables):
-        # An object with __call__
-        # We also check that the 'obj' is not an instance of
-        # _WrapperDescriptor or _MethodWrapper to avoid
-        # infinite recursion (and even potential segfault)
-        call = _get_user_defined_method(type(obj), '__call__', 'im_func')
-        if call is not None:
-            sig = signature(call)
-
-    if sig is not None:
-        return sig
-
-    if isinstance(obj, types.BuiltinFunctionType):
-        # Raise a nicer error message for builtins
-        msg = 'no signature found for builtin function {0!r}'.format(obj)
-        raise ValueError(msg)
-
-    raise ValueError('callable {0!r} is not supported by signature'.format(obj))
-
-
-class _void(object):
-    '''A private marker - used in Parameter & Signature'''
-
-
-class _empty(object):
-    pass
-
-
-class _ParameterKind(int):
-    def __new__(self, *args, **kwargs):
-        obj = int.__new__(self, *args)
-        obj._name = kwargs['name']
-        return obj
-
-    def __str__(self):
-        return self._name
-
-    def __repr__(self):
-        return '<_ParameterKind: {0!r}>'.format(self._name)
-
-
-_POSITIONAL_ONLY        = _ParameterKind(0, name='POSITIONAL_ONLY')
-_POSITIONAL_OR_KEYWORD  = _ParameterKind(1, name='POSITIONAL_OR_KEYWORD')
-_VAR_POSITIONAL         = _ParameterKind(2, name='VAR_POSITIONAL')
-_KEYWORD_ONLY           = _ParameterKind(3, name='KEYWORD_ONLY')
-_VAR_KEYWORD            = _ParameterKind(4, name='VAR_KEYWORD')
-
-
-class Parameter(object):
-    '''Represents a parameter in a function signature.
-
-    Has the following public attributes:
-
-    * name : str
-        The name of the parameter as a string.
-    * default : object
-        The default value for the parameter if specified.  If the
-        parameter has no default value, this attribute is not set.
-    * annotation
-        The annotation for the parameter if specified.  If the
-        parameter has no annotation, this attribute is not set.
-    * kind : str
-        Describes how argument values are bound to the parameter.
-        Possible values: `Parameter.POSITIONAL_ONLY`,
-        `Parameter.POSITIONAL_OR_KEYWORD`, `Parameter.VAR_POSITIONAL`,
-        `Parameter.KEYWORD_ONLY`, `Parameter.VAR_KEYWORD`.
-    '''
-
-    __slots__ = ('_name', '_kind', '_default', '_annotation', '_partial_kwarg')
-
-    POSITIONAL_ONLY         = _POSITIONAL_ONLY
-    POSITIONAL_OR_KEYWORD   = _POSITIONAL_OR_KEYWORD
-    VAR_POSITIONAL          = _VAR_POSITIONAL
-    KEYWORD_ONLY            = _KEYWORD_ONLY
-    VAR_KEYWORD             = _VAR_KEYWORD
-
-    empty = _empty
-
-    def __init__(self, name, kind, default=_empty, annotation=_empty,
-                 _partial_kwarg=False):
-
-        if kind not in (_POSITIONAL_ONLY, _POSITIONAL_OR_KEYWORD,
-                        _VAR_POSITIONAL, _KEYWORD_ONLY, _VAR_KEYWORD):
-            raise ValueError("invalid value for 'Parameter.kind' attribute")
-        self._kind = kind
-
-        if default is not _empty:
-            if kind in (_VAR_POSITIONAL, _VAR_KEYWORD):
-                msg = '{0} parameters cannot have default values'.format(kind)
-                raise ValueError(msg)
-        self._default = default
-        self._annotation = annotation
-
-        if name is None:
-            if kind != _POSITIONAL_ONLY:
-                raise ValueError("None is not a valid name for a "
-                                 "non-positional-only parameter")
-            self._name = name
-        else:
-            name = str(name)
-            if kind != _POSITIONAL_ONLY and not re.match(r'[a-z_]\w*$', name, re.I):
-                msg = '{0!r} is not a valid parameter name'.format(name)
-                raise ValueError(msg)
-            self._name = name
-
-        self._partial_kwarg = _partial_kwarg
-
-    @property
-    def name(self):
-        return self._name
-
-    @property
-    def default(self):
-        return self._default
-
-    @property
-    def annotation(self):
-        return self._annotation
-
-    @property
-    def kind(self):
-        return self._kind
-
-    def replace(self, name=_void, kind=_void, annotation=_void,
-                default=_void, _partial_kwarg=_void):
-        '''Creates a customized copy of the Parameter.'''
-
-        if name is _void:
-            name = self._name
-
-        if kind is _void:
-            kind = self._kind
-
-        if annotation is _void:
-            annotation = self._annotation
-
-        if default is _void:
-            default = self._default
-
-        if _partial_kwarg is _void:
-            _partial_kwarg = self._partial_kwarg
-
-        return type(self)(name, kind, default=default, annotation=annotation,
-                          _partial_kwarg=_partial_kwarg)
-
-    def __str__(self):
-        kind = self.kind
-
-        formatted = self._name
-        if kind == _POSITIONAL_ONLY:
-            if formatted is None:
-                formatted = ''
-            formatted = '<{0}>'.format(formatted)
-
-        # Add annotation and default value
-        if self._annotation is not _empty:
-            formatted = '{0}:{1}'.format(formatted,
-                                       formatannotation(self._annotation))
-
-        if self._default is not _empty:
-            formatted = '{0}={1}'.format(formatted, repr(self._default))
-
-        if kind == _VAR_POSITIONAL:
-            formatted = '*' + formatted
-        elif kind == _VAR_KEYWORD:
-            formatted = '**' + formatted
-
-        return formatted
-
-    def __repr__(self):
-        return '<{0} at {1:#x} {2!r}>'.format(self.__class__.__name__,
-                                           id(self), self.name)
-
-    def __hash__(self):
-        msg = "unhashable type: '{0}'".format(self.__class__.__name__)
-        raise TypeError(msg)
-
-    def __eq__(self, other):
-        return (issubclass(other.__class__, Parameter) and
-                self._name == other._name and
-                self._kind == other._kind and
-                self._default == other._default and
-                self._annotation == other._annotation)
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-
-class BoundArguments(object):
-    '''Result of `Signature.bind` call.  Holds the mapping of arguments
-    to the function's parameters.
-
-    Has the following public attributes:
-
-    * arguments : OrderedDict
-        An ordered mutable mapping of parameters' names to arguments' values.
-        Does not contain arguments' default values.
-    * signature : Signature
-        The Signature object that created this instance.
-    * args : tuple
-        Tuple of positional arguments values.
-    * kwargs : dict
-        Dict of keyword arguments values.
-    '''
-
-    def __init__(self, signature, arguments):
-        self.arguments = arguments
-        self._signature = signature
-
-    @property
-    def signature(self):
-        return self._signature
-
-    @property
-    def args(self):
-        args = []
-        for param_name, param in self._signature.parameters.items():
-            if (param.kind in (_VAR_KEYWORD, _KEYWORD_ONLY) or
-                                                    param._partial_kwarg):
-                # Keyword arguments mapped by 'functools.partial'
-                # (Parameter._partial_kwarg is True) are mapped
-                # in 'BoundArguments.kwargs', along with VAR_KEYWORD &
-                # KEYWORD_ONLY
-                break
-
-            try:
-                arg = self.arguments[param_name]
-            except KeyError:
-                # We're done here. Other arguments
-                # will be mapped in 'BoundArguments.kwargs'
-                break
-            else:
-                if param.kind == _VAR_POSITIONAL:
-                    # *args
-                    args.extend(arg)
-                else:
-                    # plain argument
-                    args.append(arg)
-
-        return tuple(args)
-
-    @property
-    def kwargs(self):
-        kwargs = {}
-        kwargs_started = False
-        for param_name, param in self._signature.parameters.items():
-            if not kwargs_started:
-                if (param.kind in (_VAR_KEYWORD, _KEYWORD_ONLY) or
-                                                param._partial_kwarg):
-                    kwargs_started = True
-                else:
-                    if param_name not in self.arguments:
-                        kwargs_started = True
-                        continue
-
-            if not kwargs_started:
-                continue
-
-            try:
-                arg = self.arguments[param_name]
-            except KeyError:
-                pass
-            else:
-                if param.kind == _VAR_KEYWORD:
-                    # **kwargs
-                    kwargs.update(arg)
-                else:
-                    # plain keyword argument
-                    kwargs[param_name] = arg
-
-        return kwargs
-
-    def __hash__(self):
-        msg = "unhashable type: '{0}'".format(self.__class__.__name__)
-        raise TypeError(msg)
-
-    def __eq__(self, other):
-        return (issubclass(other.__class__, BoundArguments) and
-                self.signature == other.signature and
-                self.arguments == other.arguments)
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-
-class Signature(object):
-    '''A Signature object represents the overall signature of a function.
-    It stores a Parameter object for each parameter accepted by the
-    function, as well as information specific to the function itself.
-
-    A Signature object has the following public attributes and methods:
-
-    * parameters : OrderedDict
-        An ordered mapping of parameters' names to the corresponding
-        Parameter objects (keyword-only arguments are in the same order
-        as listed in `code.co_varnames`).
-    * return_annotation : object
-        The annotation for the return type of the function if specified.
-        If the function has no annotation for its return type, this
-        attribute is not set.
-    * bind(*args, **kwargs) -> BoundArguments
-        Creates a mapping from positional and keyword arguments to
-        parameters.
-    * bind_partial(*args, **kwargs) -> BoundArguments
-        Creates a partial mapping from positional and keyword arguments
-        to parameters (simulating 'functools.partial' behavior.)
-    '''
-
-    __slots__ = ('_return_annotation', '_parameters')
-
-    _parameter_cls = Parameter
-    _bound_arguments_cls = BoundArguments
-
-    empty = _empty
-
-    def __init__(self, parameters=None, return_annotation=_empty,
-                 __validate_parameters__=True):
-        '''Constructs Signature from the given list of Parameter
-        objects and 'return_annotation'.  All arguments are optional.
-        '''
-
-        if parameters is None:
-            params = OrderedDict()
-        else:
-            if __validate_parameters__:
-                params = OrderedDict()
-                top_kind = _POSITIONAL_ONLY
-
-                for idx, param in enumerate(parameters):
-                    kind = param.kind
-                    if kind < top_kind:
-                        msg = 'wrong parameter order: {0} before {1}'
-                        msg = msg.format(top_kind, param.kind)
-                        raise ValueError(msg)
-                    else:
-                        top_kind = kind
-
-                    name = param.name
-                    if name is None:
-                        name = str(idx)
-                        param = param.replace(name=name)
-
-                    if name in params:
-                        msg = 'duplicate parameter name: {0!r}'.format(name)
-                        raise ValueError(msg)
-                    params[name] = param
-            else:
-                params = OrderedDict(((param.name, param)
-                                                for param in parameters))
-
-        self._parameters = params
-        self._return_annotation = return_annotation
-
-    @classmethod
-    def from_function(cls, func):
-        '''Constructs Signature for the given python function'''
-
-        if not isinstance(func, types.FunctionType):
-            raise TypeError('{0!r} is not a Python function'.format(func))
-
-        Parameter = cls._parameter_cls
-
-        # Parameter information.
-        func_code = func.__code__
-        pos_count = func_code.co_argcount
-        arg_names = func_code.co_varnames
-        positional = tuple(arg_names[:pos_count])
-        keyword_only_count = getattr(func_code, 'co_kwonlyargcount', 0)
-        keyword_only = arg_names[pos_count:(pos_count + keyword_only_count)]
-        annotations = getattr(func, '__annotations__', {})
-        defaults = func.__defaults__
-        kwdefaults = getattr(func, '__kwdefaults__', None)
-
-        if defaults:
-            pos_default_count = len(defaults)
-        else:
-            pos_default_count = 0
-
-        parameters = []
-
-        # Non-keyword-only parameters w/o defaults.
-        non_default_count = pos_count - pos_default_count
-        for name in positional[:non_default_count]:
-            annotation = annotations.get(name, _empty)
-            parameters.append(Parameter(name, annotation=annotation,
-                                        kind=_POSITIONAL_OR_KEYWORD))
-
-        # ... w/ defaults.
-        for offset, name in enumerate(positional[non_default_count:]):
-            annotation = annotations.get(name, _empty)
-            parameters.append(Parameter(name, annotation=annotation,
-                                        kind=_POSITIONAL_OR_KEYWORD,
-                                        default=defaults[offset]))
-
-        # *args
-        if func_code.co_flags & 0x04:
-            name = arg_names[pos_count + keyword_only_count]
-            annotation = annotations.get(name, _empty)
-            parameters.append(Parameter(name, annotation=annotation,
-                                        kind=_VAR_POSITIONAL))
-
-        # Keyword-only parameters.
-        for name in keyword_only:
-            default = _empty
-            if kwdefaults is not None:
-                default = kwdefaults.get(name, _empty)
-
-            annotation = annotations.get(name, _empty)
-            parameters.append(Parameter(name, annotation=annotation,
-                                        kind=_KEYWORD_ONLY,
-                                        default=default))
-        # **kwargs
-        if func_code.co_flags & 0x08:
-            index = pos_count + keyword_only_count
-            if func_code.co_flags & 0x04:
-                index += 1
-
-            name = arg_names[index]
-            annotation = annotations.get(name, _empty)
-            parameters.append(Parameter(name, annotation=annotation,
-                                        kind=_VAR_KEYWORD))
-
-        return cls(parameters,
-                   return_annotation=annotations.get('return', _empty),
-                   __validate_parameters__=False)
-
-    @property
-    def parameters(self):
-        try:
-            return types.MappingProxyType(self._parameters)
-        except AttributeError:
-            return OrderedDict(self._parameters.items())
-
-    @property
-    def return_annotation(self):
-        return self._return_annotation
-
-    def replace(self, parameters=_void, return_annotation=_void):
-        '''Creates a customized copy of the Signature.
-        Pass 'parameters' and/or 'return_annotation' arguments
-        to override them in the new copy.
-        '''
-
-        if parameters is _void:
-            parameters = self.parameters.values()
-
-        if return_annotation is _void:
-            return_annotation = self._return_annotation
-
-        return type(self)(parameters,
-                          return_annotation=return_annotation)
-
-    def __hash__(self):
-        msg = "unhashable type: '{0}'".format(self.__class__.__name__)
-        raise TypeError(msg)
-
-    def __eq__(self, other):
-        if (not issubclass(type(other), Signature) or
-                    self.return_annotation != other.return_annotation or
-                    len(self.parameters) != len(other.parameters)):
-            return False
-
-        other_positions = dict((param, idx)
-                           for idx, param in enumerate(other.parameters.keys()))
-
-        for idx, (param_name, param) in enumerate(self.parameters.items()):
-            if param.kind == _KEYWORD_ONLY:
-                try:
-                    other_param = other.parameters[param_name]
-                except KeyError:
-                    return False
-                else:
-                    if param != other_param:
-                        return False
-            else:
-                try:
-                    other_idx = other_positions[param_name]
-                except KeyError:
-                    return False
-                else:
-                    if (idx != other_idx or
-                                    param != other.parameters[param_name]):
-                        return False
-
-        return True
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def _bind(self, args, kwargs, partial=False):
-        '''Private method.  Don't use directly.'''
-
-        arguments = OrderedDict()
-
-        parameters = iter(self.parameters.values())
-        parameters_ex = ()
-        arg_vals = iter(args)
-
-        if partial:
-            # Support for binding arguments to 'functools.partial' objects.
-            # See 'functools.partial' case in 'signature()' implementation
-            # for details.
-            for param_name, param in self.parameters.items():
-                if (param._partial_kwarg and param_name not in kwargs):
-                    # Simulating 'functools.partial' behavior
-                    kwargs[param_name] = param.default
-
-        while True:
-            # Let's iterate through the positional arguments and corresponding
-            # parameters
-            try:
-                arg_val = next(arg_vals)
-            except StopIteration:
-                # No more positional arguments
-                try:
-                    param = next(parameters)
-                except StopIteration:
-                    # No more parameters. That's it. Just need to check that
-                    # we have no `kwargs` after this while loop
-                    break
-                else:
-                    if param.kind == _VAR_POSITIONAL:
-                        # That's OK, just empty *args.  Let's start parsing
-                        # kwargs
-                        break
-                    elif param.name in kwargs:
-                        if param.kind == _POSITIONAL_ONLY:
-                            msg = '{arg!r} parameter is positional only, ' \
-                                  'but was passed as a keyword'
-                            msg = msg.format(arg=param.name)
-                            raise TypeError(msg)
-                        parameters_ex = (param,)
-                        break
-                    elif (param.kind == _VAR_KEYWORD or
-                                                param.default is not _empty):
-                        # That's fine too - we have a default value for this
-                        # parameter.  So, lets start parsing `kwargs`, starting
-                        # with the current parameter
-                        parameters_ex = (param,)
-                        break
-                    else:
-                        if partial:
-                            parameters_ex = (param,)
-                            break
-                        else:
-                            msg = '{arg!r} parameter lacking default value'
-                            msg = msg.format(arg=param.name)
-                            raise TypeError(msg)
-            else:
-                # We have a positional argument to process
-                try:
-                    param = next(parameters)
-                except StopIteration:
-                    raise TypeError('too many positional arguments')
-                else:
-                    if param.kind in (_VAR_KEYWORD, _KEYWORD_ONLY):
-                        # Looks like we have no parameter for this positional
-                        # argument
-                        raise TypeError('too many positional arguments')
-
-                    if param.kind == _VAR_POSITIONAL:
-                        # We have an '*args'-like argument, let's fill it with
-                        # all positional arguments we have left and move on to
-                        # the next phase
-                        values = [arg_val]
-                        values.extend(arg_vals)
-                        arguments[param.name] = tuple(values)
-                        break
-
-                    if param.name in kwargs:
-                        raise TypeError('multiple values for argument '
-                                        '{arg!r}'.format(arg=param.name))
-
-                    arguments[param.name] = arg_val
-
-        # Now, we iterate through the remaining parameters to process
-        # keyword arguments
-        kwargs_param = None
-        for param in itertools.chain(parameters_ex, parameters):
-            if param.kind == _POSITIONAL_ONLY:
-                # This should never happen in case of a properly built
-                # Signature object (but let's have this check here
-                # to ensure correct behaviour just in case)
-                raise TypeError('{arg!r} parameter is positional only, '
-                                'but was passed as a keyword'. \
-                                format(arg=param.name))
-
-            if param.kind == _VAR_KEYWORD:
-                # Memorize that we have a '**kwargs'-like parameter
-                kwargs_param = param
-                continue
-
-            param_name = param.name
-            try:
-                arg_val = kwargs.pop(param_name)
-            except KeyError:
-                # We have no value for this parameter.  It's fine though,
-                # if it has a default value, or it is an '*args'-like
-                # parameter, left alone by the processing of positional
-                # arguments.
-                if (not partial and param.kind != _VAR_POSITIONAL and
-                                                    param.default is _empty):
-                    raise TypeError('{arg!r} parameter lacking default value'. \
-                                    format(arg=param_name))
-
-            else:
-                arguments[param_name] = arg_val
-
-        if kwargs:
-            if kwargs_param is not None:
-                # Process our '**kwargs'-like parameter
-                arguments[kwargs_param.name] = kwargs
-            else:
-                raise TypeError('too many keyword arguments')
-
-        return self._bound_arguments_cls(self, arguments)
-
-    def bind(self, *args, **kwargs):
-        '''Get a BoundArguments object, that maps the passed `args`
-        and `kwargs` to the function's signature.  Raises `TypeError`
-        if the passed arguments can not be bound.
-        '''
-        return self._bind(args, kwargs)
-
-    def bind_partial(self, *args, **kwargs):
-        '''Get a BoundArguments object, that partially maps the
-        passed `args` and `kwargs` to the function's signature.
-        Raises `TypeError` if the passed arguments can not be bound.
-        '''
-        return self._bind(args, kwargs, partial=True)
-
-    def __str__(self):
-        result = []
-        render_kw_only_separator = True
-        for idx, param in enumerate(self.parameters.values()):
-            formatted = str(param)
-
-            kind = param.kind
-            if kind == _VAR_POSITIONAL:
-                # OK, we have an '*args'-like parameter, so we won't need
-                # a '*' to separate keyword-only arguments
-                render_kw_only_separator = False
-            elif kind == _KEYWORD_ONLY and render_kw_only_separator:
-                # We have a keyword-only parameter to render and we haven't
-                # rendered an '*args'-like parameter before, so add a '*'
-                # separator to the parameters list ("foo(arg1, *, arg2)" case)
-                result.append('*')
-                # This condition should be only triggered once, so
-                # reset the flag
-                render_kw_only_separator = False
-
-            result.append(formatted)
-
-        rendered = '({0})'.format(', '.join(result))
-
-        if self.return_annotation is not _empty:
-            anno = formatannotation(self.return_annotation)
-            rendered += ' -> {0}'.format(anno)
-
-        return rendered
diff --git a/contrib/python/backcall/backcall/backcall.py b/contrib/python/backcall/backcall/backcall.py
deleted file mode 100644
index fe1fdb5470..0000000000
--- a/contrib/python/backcall/backcall/backcall.py
+++ /dev/null
@@ -1,109 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Mon Jan 13 18:17:15 2014
-
-@author: takluyver
-"""
-import sys
-PY3 = (sys.version_info[0] >= 3)
-
-try:
-    from inspect import signature, Parameter  # Python >= 3.3
-except ImportError:
-    from ._signatures import signature, Parameter
-
-if PY3:
-    from functools import wraps
-else:
-    from functools import wraps as _wraps
-    def wraps(f):
-        def dec(func):
-            _wraps(f)(func)
-            func.__wrapped__ = f
-            return func
-
-        return dec
-
-def callback_prototype(prototype):
-    """Decorator to process a callback prototype.
-    
-    A callback prototype is a function whose signature includes all the values
-    that will be passed by the callback API in question.
-    
-    The original function will be returned, with a ``prototype.adapt`` attribute
-    which can be used to prepare third party callbacks.
-    """
-    protosig = signature(prototype)
-    positional, keyword = [], []
-    for name, param in protosig.parameters.items():
-        if param.kind in (Parameter.VAR_POSITIONAL, Parameter.VAR_KEYWORD):
-            raise TypeError("*args/**kwargs not supported in prototypes")
-
-        if (param.default is not Parameter.empty) \
-            or (param.kind == Parameter.KEYWORD_ONLY):
-            keyword.append(name)
-        else:
-            positional.append(name)
-        
-    kwargs = dict.fromkeys(keyword)
-    def adapt(callback):
-        """Introspect and prepare a third party callback."""
-        sig = signature(callback)
-        try:
-            # XXX: callback can have extra optional parameters - OK?
-            sig.bind(*positional, **kwargs)
-            return callback
-        except TypeError:
-            pass
-        
-        # Match up arguments
-        unmatched_pos = positional[:]
-        unmatched_kw = kwargs.copy()
-        unrecognised = []
-        # TODO: unrecognised parameters with default values - OK?
-        for name, param in sig.parameters.items():
-            # print(name, param.kind) #DBG
-            if param.kind == Parameter.POSITIONAL_ONLY:
-                if len(unmatched_pos) > 0:
-                    unmatched_pos.pop(0)
-                else:
-                    unrecognised.append(name)
-            elif param.kind == Parameter.POSITIONAL_OR_KEYWORD:
-                if (param.default is not Parameter.empty) and (name in unmatched_kw):
-                    unmatched_kw.pop(name)
-                elif len(unmatched_pos) > 0:
-                    unmatched_pos.pop(0)    
-                else:
-                    unrecognised.append(name)
-            elif param.kind == Parameter.VAR_POSITIONAL:
-                unmatched_pos = []
-            elif param.kind == Parameter.KEYWORD_ONLY:
-                if name in unmatched_kw:
-                    unmatched_kw.pop(name)
-                else:
-                    unrecognised.append(name)
-            else:  # VAR_KEYWORD
-                unmatched_kw = {}
-        
-            # print(unmatched_pos, unmatched_kw, unrecognised) #DBG
-        
-        if unrecognised:
-            raise TypeError("Function {!r} had unmatched arguments: {}".format(callback, unrecognised))
-
-        n_positional = len(positional) - len(unmatched_pos)
-
-        @wraps(callback)
-        def adapted(*args, **kwargs):
-            """Wrapper for third party callbacks that discards excess arguments"""
-#            print(args, kwargs)
-            args = args[:n_positional]
-            for name in unmatched_kw:
-                # XXX: Could name not be in kwargs?
-                kwargs.pop(name)
-#            print(args, kwargs, unmatched_pos, cut_positional, unmatched_kw)
-            return callback(*args, **kwargs)
-        
-        return adapted
-
-    prototype.adapt = adapt
-    return prototype
\ No newline at end of file
diff --git a/contrib/python/backcall/tests/__init__.py b/contrib/python/backcall/tests/__init__.py
deleted file mode 100644
index faa18be5bb..0000000000
--- a/contrib/python/backcall/tests/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
diff --git a/contrib/python/backcall/tests/test_callback_prototypes.py b/contrib/python/backcall/tests/test_callback_prototypes.py
deleted file mode 100644
index 09ac150cf8..0000000000
--- a/contrib/python/backcall/tests/test_callback_prototypes.py
+++ /dev/null
@@ -1,38 +0,0 @@
-import sys
-from backcall import callback_prototype
-
-@callback_prototype
-def msg_callback(a, b, c, d=None, e=None, f=None):
-    pass
-
-def test_all_args():
-    @msg_callback.adapt
-    def thingy1(q, w, s, d, e, f):
-        return q, w, s, d, e, f
-    
-    assert not getattr(thingy1, '__wrapped__', None)
-    assert thingy1('A', 'B', 'C', d='D', e='E', f='F') == tuple('ABCDEF')
-
-if sys.version_info[0] >= 3:
-    exec("@msg_callback.adapt\n"
-         "def thingy2(t, *, d=None):\n"
-         "    return t, d")
-    def test_some_args_kwonly():    
-        assert getattr(thingy2, '__wrapped__', None)
-        assert thingy2('A', 'B', 'C', d='D', e='E', f='F') == ('A', 'D')
-
-def test_some_args_defaults():
-    @msg_callback.adapt
-    def thingy2b(t, d=None):
-        return t, d
-    
-    assert getattr(thingy2b, '__wrapped__', None)
-    assert thingy2b('A', 'B', 'C', d='D', e='E', f='F') == ('A', 'D')
-
-def test_no_args():
-    @msg_callback.adapt
-    def thingy3():
-        return 'Success'
-    
-    assert getattr(thingy3, '__wrapped__', None)
-    assert thingy3('A', 'B', 'C', d='D', e='E', f='F') == 'Success'
diff --git a/contrib/python/backcall/tests/ya.make b/contrib/python/backcall/tests/ya.make
deleted file mode 100644
index 4d010f5583..0000000000
--- a/contrib/python/backcall/tests/ya.make
+++ /dev/null
@@ -1,13 +0,0 @@
-PY3TEST()
-
-PEERDIR(
-    contrib/python/backcall
-)
-
-TEST_SRCS(
-    test_callback_prototypes.py
-)
-
-NO_LINT()
-
-END()
diff --git a/contrib/python/backcall/ya.make b/contrib/python/backcall/ya.make
deleted file mode 100644
index a3a97831b8..0000000000
--- a/contrib/python/backcall/ya.make
+++ /dev/null
@@ -1,28 +0,0 @@
-# Generated by devtools/yamaker (pypi).
-
-PY3_LIBRARY()
-
-VERSION(0.2.0)
-
-LICENSE(BSD-3-Clause)
-
-NO_LINT()
-
-PY_SRCS(
-    TOP_LEVEL
-    backcall/__init__.py
-    backcall/_signatures.py
-    backcall/backcall.py
-)
-
-RESOURCE_FILES(
-    PREFIX contrib/python/backcall/
-    .dist-info/METADATA
-    .dist-info/top_level.txt
-)
-
-END()
-
-RECURSE_FOR_TESTS(
-    tests
-)
diff --git a/contrib/python/ipython/py3/.dist-info/METADATA b/contrib/python/ipython/py3/.dist-info/METADATA
index a3e7a39c41..829b1c4f27 100644
--- a/contrib/python/ipython/py3/.dist-info/METADATA
+++ b/contrib/python/ipython/py3/.dist-info/METADATA
@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ipython
-Version: 8.16.1
+Version: 8.17.1
 Summary: IPython: Productive Interactive Computing
 Home-page: https://ipython.org
 Author: The IPython Development Team
@@ -26,11 +26,9 @@ Classifier: Topic :: System :: Shells
 Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: backcall
 Requires-Dist: decorator
 Requires-Dist: jedi >=0.13
 Requires-Dist: matplotlib-inline
-Requires-Dist: pickleshare
 Requires-Dist: prompt-toolkit !=3.0.37,<3.1.0,>=3.0.30
 Requires-Dist: pygments >=2.4.0
 Requires-Dist: stack-data
@@ -55,6 +53,7 @@ Requires-Dist: exceptiongroup ; extra == 'all'
 Requires-Dist: pytest <7.1 ; extra == 'all'
 Requires-Dist: pytest-asyncio ; extra == 'all'
 Requires-Dist: testpath ; extra == 'all'
+Requires-Dist: pickleshare ; extra == 'all'
 Requires-Dist: nbconvert ; extra == 'all'
 Requires-Dist: nbformat ; extra == 'all'
 Requires-Dist: ipywidgets ; extra == 'all'
@@ -63,7 +62,7 @@ Requires-Dist: ipyparallel ; extra == 'all'
 Requires-Dist: qtconsole ; extra == 'all'
 Requires-Dist: curio ; extra == 'all'
 Requires-Dist: matplotlib !=3.2.0 ; extra == 'all'
-Requires-Dist: numpy >=1.21 ; extra == 'all'
+Requires-Dist: numpy >=1.22 ; extra == 'all'
 Requires-Dist: pandas ; extra == 'all'
 Requires-Dist: trio ; extra == 'all'
 Provides-Extra: black
@@ -82,6 +81,7 @@ Requires-Dist: exceptiongroup ; extra == 'doc'
 Requires-Dist: pytest <7.1 ; extra == 'doc'
 Requires-Dist: pytest-asyncio ; extra == 'doc'
 Requires-Dist: testpath ; extra == 'doc'
+Requires-Dist: pickleshare ; extra == 'doc'
 Provides-Extra: kernel
 Requires-Dist: ipykernel ; extra == 'kernel'
 Provides-Extra: nbconvert
@@ -100,14 +100,16 @@ Provides-Extra: test
 Requires-Dist: pytest <7.1 ; extra == 'test'
 Requires-Dist: pytest-asyncio ; extra == 'test'
 Requires-Dist: testpath ; extra == 'test'
+Requires-Dist: pickleshare ; extra == 'test'
 Provides-Extra: test_extra
 Requires-Dist: pytest <7.1 ; extra == 'test_extra'
 Requires-Dist: pytest-asyncio ; extra == 'test_extra'
 Requires-Dist: testpath ; extra == 'test_extra'
+Requires-Dist: pickleshare ; extra == 'test_extra'
 Requires-Dist: curio ; extra == 'test_extra'
 Requires-Dist: matplotlib !=3.2.0 ; extra == 'test_extra'
 Requires-Dist: nbformat ; extra == 'test_extra'
-Requires-Dist: numpy >=1.21 ; extra == 'test_extra'
+Requires-Dist: numpy >=1.22 ; extra == 'test_extra'
 Requires-Dist: pandas ; extra == 'test_extra'
 Requires-Dist: trio ; extra == 'test_extra'
 
diff --git a/contrib/python/ipython/py3/IPython/__main__.py b/contrib/python/ipython/py3/IPython/__main__.py
index 8e9f989a82..3b4605601a 100644
--- a/contrib/python/ipython/py3/IPython/__main__.py
+++ b/contrib/python/ipython/py3/IPython/__main__.py
@@ -2,13 +2,13 @@
 # encoding: utf-8
 """Terminal-based IPython entry point.
 """
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 #  Copyright (c) 2012, IPython Development Team.
 #
 #  Distributed under the terms of the Modified BSD License.
 #
 #  The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 from IPython import start_ipython
 
diff --git a/contrib/python/ipython/py3/IPython/core/completerlib.py b/contrib/python/ipython/py3/IPython/core/completerlib.py
index 65efa42254..74252dcfad 100644
--- a/contrib/python/ipython/py3/IPython/core/completerlib.py
+++ b/contrib/python/ipython/py3/IPython/core/completerlib.py
@@ -238,6 +238,7 @@ def try_import(mod: str, only_modules=False) -> List[str]:
         completions.extend(m_all)
 
     if m_is_init:
+        file_ = m.__file__
         completions.extend(arcadia_module_list(mod))
     completions_set = {c for c in completions if isinstance(c, str)}
     completions_set.discard('__init__')
diff --git a/contrib/python/ipython/py3/IPython/core/display.py b/contrib/python/ipython/py3/IPython/core/display.py
index ffa6e185c4..20e2e34b8f 100644
--- a/contrib/python/ipython/py3/IPython/core/display.py
+++ b/contrib/python/ipython/py3/IPython/core/display.py
@@ -286,7 +286,7 @@ class DisplayObject(object):
         in the frontend. The MIME type of the data should match the
         subclasses used, so the Png subclass should be used for 'image/png'
         data. If the data is a URL, the data will first be downloaded
-        and then displayed. If
+        and then displayed.
 
         Parameters
         ----------
diff --git a/contrib/python/ipython/py3/IPython/core/events.py b/contrib/python/ipython/py3/IPython/core/events.py
index 3a66e75e5a..90ff8f746d 100644
--- a/contrib/python/ipython/py3/IPython/core/events.py
+++ b/contrib/python/ipython/py3/IPython/core/events.py
@@ -13,8 +13,6 @@ events and the arguments which will be passed to them.
    This API is experimental in IPython 2.0, and may be revised in future versions.
 """
 
-from backcall import callback_prototype
-
 
 class EventManager(object):
     """Manage a collection of events and a sequence of callbacks for each.
@@ -63,23 +61,14 @@ class EventManager(object):
         """
         if not callable(function):
             raise TypeError('Need a callable, got %r' % function)
-        callback_proto = available_events.get(event)
         if function not in self.callbacks[event]:
-            self.callbacks[event].append(callback_proto.adapt(function))
+            self.callbacks[event].append(function)
     
     def unregister(self, event, function):
         """Remove a callback from the given event."""
         if function in self.callbacks[event]:
             return self.callbacks[event].remove(function)
 
-        # Remove callback in case ``function`` was adapted by `backcall`.
-        for callback in self.callbacks[event]:
-            try:
-                if callback.__wrapped__ is function:
-                    return self.callbacks[event].remove(callback)
-            except AttributeError:
-                pass
-
         raise ValueError('Function {!r} is not registered as a {} callback'.format(function, event))
 
     def trigger(self, event, *args, **kwargs):
@@ -100,9 +89,8 @@ class EventManager(object):
 available_events = {}
 
 def _define_event(callback_function):
-    callback_proto = callback_prototype(callback_function)
-    available_events[callback_function.__name__] = callback_proto
-    return callback_proto
+    available_events[callback_function.__name__] = callback_function
+    return callback_function
 
 # ------------------------------------------------------------------------------
 # Callback prototypes
diff --git a/contrib/python/ipython/py3/IPython/core/guarded_eval.py b/contrib/python/ipython/py3/IPython/core/guarded_eval.py
index 5d405b2208..a304affc35 100644
--- a/contrib/python/ipython/py3/IPython/core/guarded_eval.py
+++ b/contrib/python/ipython/py3/IPython/core/guarded_eval.py
@@ -1,3 +1,4 @@
+from inspect import signature, Signature
 from typing import (
     Any,
     Callable,
@@ -335,6 +336,7 @@ class _IdentitySubscript:
 
 IDENTITY_SUBSCRIPT = _IdentitySubscript()
 SUBSCRIPT_MARKER = "__SUBSCRIPT_SENTINEL__"
+UNKNOWN_SIGNATURE = Signature()
 
 
 class GuardRejection(Exception):
@@ -415,6 +417,10 @@ UNARY_OP_DUNDERS: Dict[Type[ast.unaryop], Tuple[str, ...]] = {
 }
 
 
+class Duck:
+    """A dummy class used to create objects of other classes without calling their ``__init__``"""
+
+
 def _find_dunder(node_op, dunders) -> Union[Tuple[str, ...], None]:
     dunder = None
     for op, candidate_dunder in dunders.items():
@@ -584,6 +590,27 @@ def eval_node(node: Union[ast.AST, None], context: EvaluationContext):
         if policy.can_call(func) and not node.keywords:
             args = [eval_node(arg, context) for arg in node.args]
             return func(*args)
+        try:
+            sig = signature(func)
+        except ValueError:
+            sig = UNKNOWN_SIGNATURE
+        # if annotation was not stringized, or it was stringized
+        # but resolved by signature call we know the return type
+        not_empty = sig.return_annotation is not Signature.empty
+        not_stringized = not isinstance(sig.return_annotation, str)
+        if not_empty and not_stringized:
+            duck = Duck()
+            # if allow-listed builtin is on type annotation, instantiate it
+            if policy.can_call(sig.return_annotation) and not node.keywords:
+                args = [eval_node(arg, context) for arg in node.args]
+                return sig.return_annotation(*args)
+            try:
+                # if custom class is in type annotation, mock it;
+                # this only works for heap types, not builtins
+                duck.__class__ = sig.return_annotation
+                return duck
+            except TypeError:
+                pass
         raise GuardRejection(
             "Call for",
             func,  # not joined to avoid calling `repr`
diff --git a/contrib/python/ipython/py3/IPython/core/inputsplitter.py b/contrib/python/ipython/py3/IPython/core/inputsplitter.py
index a4401184bd..33ed563221 100644
--- a/contrib/python/ipython/py3/IPython/core/inputsplitter.py
+++ b/contrib/python/ipython/py3/IPython/core/inputsplitter.py
@@ -31,7 +31,8 @@ import sys
 import tokenize
 import warnings
 
-from typing import List
+from typing import List, Tuple, Union, Optional
+from types import CodeType
 
 from IPython.core.inputtransformer import (leading_indent,
                                            classic_prompt,
@@ -91,7 +92,13 @@ def num_ini_spaces(s):
     -------
     n : int
     """
-
+    warnings.warn(
+        "`num_ini_spaces` is Pending Deprecation since IPython 8.17."
+        "It is considered fro removal in in future version. "
+        "Please open an issue if you believe it should be kept.",
+        stacklevel=2,
+        category=PendingDeprecationWarning,
+    )
     ini_spaces = ini_spaces_re.match(s)
     if ini_spaces:
         return ini_spaces.end()
@@ -144,7 +151,7 @@ def partial_tokens(s):
         else:
             raise
 
-def find_next_indent(code):
+def find_next_indent(code) -> int:
     """Find the number of spaces for the next line of indentation"""
     tokens = list(partial_tokens(code))
     if tokens[-1].type == tokenize.ENDMARKER:
@@ -318,7 +325,7 @@ class InputSplitter(object):
     # If self.source matches the first value, the second value is a valid
     # current indentation. Otherwise, the cache is invalid and the indentation
     # must be recalculated.
-    _indent_spaces_cache = None, None
+    _indent_spaces_cache: Union[Tuple[None, None], Tuple[str, int]] = None, None
     # String, indicating the default input encoding.  It is computed by default
     # at initialization time via get_input_encoding(), but it can be reset by a
     # client with specific knowledge of the encoding.
@@ -326,11 +333,11 @@ class InputSplitter(object):
     # String where the current full source input is stored, properly encoded.
     # Reading this attribute is the normal way of querying the currently pushed
     # source code, that has been properly encoded.
-    source = ''
+    source: str = ""
     # Code object corresponding to the current source.  It is automatically
     # synced to the source, so it can be queried at any time to obtain the code
     # object; it will be None if the source doesn't compile to valid Python.
-    code = None
+    code: Optional[CodeType] = None
 
     # Private attributes
 
@@ -339,9 +346,9 @@ class InputSplitter(object):
     # Command compiler
     _compile: codeop.CommandCompiler
     # Boolean indicating whether the current block is complete
-    _is_complete = None
+    _is_complete: Optional[bool] = None
     # Boolean indicating whether the current block has an unrecoverable syntax error
-    _is_invalid = False
+    _is_invalid: bool = False
 
     def __init__(self) -> None:
         """Create a new InputSplitter instance."""
@@ -511,9 +518,10 @@ class InputSplitter(object):
         # General fallback - accept more code
         return True
 
-    def get_indent_spaces(self):
+    def get_indent_spaces(self) -> int:
         sourcefor, n = self._indent_spaces_cache
         if sourcefor == self.source:
+            assert n is not None
             return n
 
         # self.source always has a trailing newline
@@ -562,7 +570,7 @@ class IPythonInputSplitter(InputSplitter):
     # Private attributes
 
     # List with lines of raw input accumulated so far.
-    _buffer_raw = None
+    _buffer_raw: List[str]
 
     def __init__(self, line_input_checker=True, physical_line_transforms=None,
                     logical_line_transforms=None, python_line_transforms=None):
@@ -652,8 +660,8 @@ class IPythonInputSplitter(InputSplitter):
             tmp = transform.reset()
             if tmp is not None:
                 yield tmp
-        
-        out = []
+
+        out: List[str] = []
         for t in self.transforms_in_use:
             out = _flush(t, out)
         
diff --git a/contrib/python/ipython/py3/IPython/core/inputtransformer.py b/contrib/python/ipython/py3/IPython/core/inputtransformer.py
index 81cd1fa08c..bb1061e8dc 100644
--- a/contrib/python/ipython/py3/IPython/core/inputtransformer.py
+++ b/contrib/python/ipython/py3/IPython/core/inputtransformer.py
@@ -71,8 +71,8 @@ class InputTransformer(metaclass=abc.ABCMeta):
         """
         @functools.wraps(func)
         def transformer_factory(**kwargs):
-            return cls(func, **kwargs)
-        
+            return cls(func, **kwargs)  # type: ignore [call-arg]
+
         return transformer_factory
 
 class StatelessInputTransformer(InputTransformer):
@@ -194,7 +194,7 @@ def assemble_logical_lines():
         line = ''.join(parts)
 
 # Utilities
-def _make_help_call(target, esc, lspace):
+def _make_help_call(target: str, esc: str, lspace: str) -> str:
     """Prepares a pinfo(2)/psearch call from a target name and the escape
     (i.e. ? or ??)"""
     method  = 'pinfo2' if esc == '??' \
@@ -212,17 +212,19 @@ def _make_help_call(target, esc, lspace):
 
 
 # These define the transformations for the different escape characters.
-def _tr_system(line_info):
+def _tr_system(line_info: LineInfo):
     "Translate lines escaped with: !"
     cmd = line_info.line.lstrip().lstrip(ESC_SHELL)
     return '%sget_ipython().system(%r)' % (line_info.pre, cmd)
 
-def _tr_system2(line_info):
+
+def _tr_system2(line_info: LineInfo):
     "Translate lines escaped with: !!"
     cmd = line_info.line.lstrip()[2:]
     return '%sget_ipython().getoutput(%r)' % (line_info.pre, cmd)
 
-def _tr_help(line_info):
+
+def _tr_help(line_info: LineInfo):
     "Translate lines escaped with: ?/??"
     # A naked help line should just fire the intro help screen
     if not line_info.line[1:]:
@@ -230,7 +232,8 @@ def _tr_help(line_info):
 
     return _make_help_call(line_info.ifun, line_info.esc, line_info.pre)
 
-def _tr_magic(line_info):
+
+def _tr_magic(line_info: LineInfo):
     "Translate lines escaped with: %"
     tpl = '%sget_ipython().run_line_magic(%r, %r)'
     if line_info.line.startswith(ESC_MAGIC2):
@@ -241,17 +244,20 @@ def _tr_magic(line_info):
     t_magic_name = t_magic_name.lstrip(ESC_MAGIC)
     return tpl % (line_info.pre, t_magic_name, t_magic_arg_s)
 
-def _tr_quote(line_info):
+
+def _tr_quote(line_info: LineInfo):
     "Translate lines escaped with: ,"
     return '%s%s("%s")' % (line_info.pre, line_info.ifun,
                          '", "'.join(line_info.the_rest.split()) )
 
-def _tr_quote2(line_info):
+
+def _tr_quote2(line_info: LineInfo):
     "Translate lines escaped with: ;"
     return '%s%s("%s")' % (line_info.pre, line_info.ifun,
                            line_info.the_rest)
 
-def _tr_paren(line_info):
+
+def _tr_paren(line_info: LineInfo):
     "Translate lines escaped with: /"
     return '%s%s(%s)' % (line_info.pre, line_info.ifun,
                          ", ".join(line_info.the_rest.split()))
@@ -266,9 +272,8 @@ tr = { ESC_SHELL  : _tr_system,
        ESC_PAREN  : _tr_paren }
 
 @StatelessInputTransformer.wrap
-def escaped_commands(line):
-    """Transform escaped commands - %magic, !system, ?help + various autocalls.
-    """
+def escaped_commands(line: str):
+    """Transform escaped commands - %magic, !system, ?help + various autocalls."""
     if not line or line.isspace():
         return line
     lineinf = LineInfo(line)
@@ -342,20 +347,22 @@ def ends_in_comment_or_string(src):
         
 
 @StatelessInputTransformer.wrap
-def help_end(line):
+def help_end(line: str):
     """Translate lines with ?/?? at the end"""
     m = _help_end_re.search(line)
     if m is None or ends_in_comment_or_string(line):
         return line
     target = m.group(1)
     esc = m.group(3)
-    lspace = _initial_space_re.match(line).group(0)
+    match = _initial_space_re.match(line)
+    assert match is not None
+    lspace = match.group(0)
 
     return _make_help_call(target, esc, lspace)
 
 
 @CoroutineInputTransformer.wrap
-def cellmagic(end_on_blank_line=False):
+def cellmagic(end_on_blank_line: bool = False):
     """Captures & transforms cell magics.
 
     After a cell magic is started, this stores up any lines it gets until it is
diff --git a/contrib/python/ipython/py3/IPython/core/interactiveshell.py b/contrib/python/ipython/py3/IPython/core/interactiveshell.py
index 894403f98b..0a528c51f2 100644
--- a/contrib/python/ipython/py3/IPython/core/interactiveshell.py
+++ b/contrib/python/ipython/py3/IPython/core/interactiveshell.py
@@ -21,6 +21,7 @@ import inspect
 import os
 import re
 import runpy
+import shutil
 import subprocess
 import sys
 import tempfile
@@ -36,7 +37,28 @@ from typing import List as ListType, Dict as DictType, Any as AnyType
 from typing import Optional, Sequence, Tuple
 from warnings import warn
 
-from pickleshare import PickleShareDB
+try:
+    from pickleshare import PickleShareDB
+except ModuleNotFoundError:
+
+    class PickleShareDB:  # type: ignore [no-redef]
+        def __init__(self, path):
+            pass
+
+        def get(self, key, default):
+            warn(
+                f"using {key} requires you to install the `pickleshare` library.",
+                stacklevel=2,
+            )
+            return default
+
+        def __setitem__(self, key, value):
+            warn(
+                f"using {key} requires you to install the `pickleshare` library.",
+                stacklevel=2,
+            )
+
+
 from tempfile import TemporaryDirectory
 from traitlets import (
     Any,
@@ -3902,7 +3924,7 @@ class InteractiveShell(SingletonConfigurable):
         del self.tempfiles
         for tdir in self.tempdirs:
             try:
-                tdir.rmdir()
+                shutil.rmtree(tdir)
                 self.tempdirs.remove(tdir)
             except FileNotFoundError:
                 pass
diff --git a/contrib/python/ipython/py3/IPython/core/magics/packaging.py b/contrib/python/ipython/py3/IPython/core/magics/packaging.py
index 2f7652c169..093b0a2ec1 100644
--- a/contrib/python/ipython/py3/IPython/core/magics/packaging.py
+++ b/contrib/python/ipython/py3/IPython/core/magics/packaging.py
@@ -8,6 +8,7 @@
 #  The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
+import functools
 import re
 import shlex
 import sys
@@ -16,33 +17,49 @@ from pathlib import Path
 from IPython.core.magic import Magics, magics_class, line_magic
 
 
-def _is_conda_environment():
-    """Return True if the current Python executable is in a conda env"""
-    # TODO: does this need to change on windows?
-    return Path(sys.prefix, "conda-meta", "history").exists()
+def is_conda_environment(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        """Return True if the current Python executable is in a conda env"""
+        # TODO: does this need to change on windows?
+        if not Path(sys.prefix, "conda-meta", "history").exists():
+            raise ValueError(
+                "The python kernel does not appear to be a conda environment.  "
+                "Please use ``%pip install`` instead."
+            )
+        return func(*args, **kwargs)
 
+    return wrapper
 
-def _get_conda_executable():
-    """Find the path to the conda executable"""
+
+def _get_conda_like_executable(command):
+    """Find the path to the given executable
+
+    Parameters
+    ----------
+
+    executable: string
+        Value should be: conda, mamba or micromamba
+    """
     # Check if there is a conda executable in the same directory as the Python executable.
     # This is the case within conda's root environment.
-    conda = Path(sys.executable).parent / "conda"
-    if conda.is_file():
-        return str(conda)
+    executable = Path(sys.executable).parent / command
+    if executable.is_file():
+        return str(executable)
 
     # Otherwise, attempt to extract the executable from conda history.
     # This applies in any conda environment.
     history = Path(sys.prefix, "conda-meta", "history").read_text(encoding="utf-8")
     match = re.search(
-        r"^#\s*cmd:\s*(?P<command>.*conda)\s[create|install]",
+        rf"^#\s*cmd:\s*(?P<command>.*{executable})\s[create|install]",
         history,
         flags=re.MULTILINE,
     )
     if match:
         return match.groupdict()["command"]
 
-    # Fallback: assume conda is available on the system path.
-    return "conda"
+    # Fallback: assume the executable is available on the system path.
+    return command
 
 
 CONDA_COMMANDS_REQUIRING_PREFIX = {
@@ -76,18 +93,7 @@ class PackagingMagics(Magics):
 
         print("Note: you may need to restart the kernel to use updated packages.")
 
-    @line_magic
-    def conda(self, line):
-        """Run the conda package manager within the current kernel.
-
-        Usage:
-          %conda install [pkgs]
-        """
-        if not _is_conda_environment():
-            raise ValueError("The python kernel does not appear to be a conda environment.  "
-                             "Please use ``%pip install`` instead.")
-
-        conda = _get_conda_executable()
+    def _run_command(self, cmd, line):
         args = shlex.split(line)
         command = args[0] if len(args) > 0 else ""
         args = args[1:] if len(args) > 1 else [""]
@@ -108,5 +114,38 @@ class PackagingMagics(Magics):
         if needs_prefix and not has_prefix:
             extra_args.extend(["--prefix", sys.prefix])
 
-        self.shell.system(' '.join([conda, command] + extra_args + args))
+        self.shell.system(" ".join([cmd, command] + extra_args + args))
         print("\nNote: you may need to restart the kernel to use updated packages.")
+
+    @line_magic
+    @is_conda_environment
+    def conda(self, line):
+        """Run the conda package manager within the current kernel.
+
+        Usage:
+          %conda install [pkgs]
+        """
+        conda = _get_conda_like_executable("conda")
+        self._run_command(conda, line)
+
+    @line_magic
+    @is_conda_environment
+    def mamba(self, line):
+        """Run the mamba package manager within the current kernel.
+
+        Usage:
+          %mamba install [pkgs]
+        """
+        mamba = _get_conda_like_executable("mamba")
+        self._run_command(mamba, line)
+
+    @line_magic
+    @is_conda_environment
+    def micromamba(self, line):
+        """Run the conda package manager within the current kernel.
+
+        Usage:
+          %micromamba install [pkgs]
+        """
+        micromamba = _get_conda_like_executable("micromamba")
+        self._run_command(micromamba, line)
diff --git a/contrib/python/ipython/py3/IPython/core/oinspect.py b/contrib/python/ipython/py3/IPython/core/oinspect.py
index ef6a0d02d7..d77a732267 100644
--- a/contrib/python/ipython/py3/IPython/core/oinspect.py
+++ b/contrib/python/ipython/py3/IPython/core/oinspect.py
@@ -416,6 +416,8 @@ class Inspector(Colorable):
 
         If any exception is generated, None is returned instead and the
         exception is suppressed."""
+        if not callable(obj):
+            return None
         try:
             return _render_signature(signature(obj), oname)
         except:
diff --git a/contrib/python/ipython/py3/IPython/core/release.py b/contrib/python/ipython/py3/IPython/core/release.py
index 152ebcb87b..ee0042d081 100644
--- a/contrib/python/ipython/py3/IPython/core/release.py
+++ b/contrib/python/ipython/py3/IPython/core/release.py
@@ -16,7 +16,7 @@
 # release.  'dev' as a _version_extra string means this is a development
 # version
 _version_major = 8
-_version_minor = 16
+_version_minor = 17
 _version_patch = 1
 _version_extra = ".dev"
 # _version_extra = "rc1"
diff --git a/contrib/python/ipython/py3/IPython/lib/pretty.py b/contrib/python/ipython/py3/IPython/lib/pretty.py
index 3486450786..2575c3b0a9 100644
--- a/contrib/python/ipython/py3/IPython/lib/pretty.py
+++ b/contrib/python/ipython/py3/IPython/lib/pretty.py
@@ -841,17 +841,8 @@ _env_type = type(os.environ)
 if _env_type is not dict:
     _type_pprinters[_env_type] = _dict_pprinter_factory('environ{', '}')
 
-try:
-    # In PyPy, types.DictProxyType is dict, setting the dictproxy printer
-    # using dict.setdefault avoids overwriting the dict printer
-    _type_pprinters.setdefault(types.DictProxyType,
-                               _dict_pprinter_factory('dict_proxy({', '})'))
-    _type_pprinters[types.ClassType] = _type_pprint
-    _type_pprinters[types.SliceType] = _repr_pprint
-except AttributeError: # Python 3
-    _type_pprinters[types.MappingProxyType] = \
-        _dict_pprinter_factory('mappingproxy({', '})')
-    _type_pprinters[slice] = _repr_pprint
+_type_pprinters[types.MappingProxyType] = _dict_pprinter_factory("mappingproxy({", "})")
+_type_pprinters[slice] = _repr_pprint
 
 _type_pprinters[range] = _repr_pprint
 _type_pprinters[bytes] = _repr_pprint
diff --git a/contrib/python/ipython/py3/IPython/utils/_sysinfo.py b/contrib/python/ipython/py3/IPython/utils/_sysinfo.py
index 5e2eeadcf3..8d771a843f 100644
--- a/contrib/python/ipython/py3/IPython/utils/_sysinfo.py
+++ b/contrib/python/ipython/py3/IPython/utils/_sysinfo.py
@@ -1,2 +1,2 @@
 # GENERATED BY setup.py
-commit = "a2af83ddf"
+commit = "0cfced36e"
diff --git a/contrib/python/ipython/py3/IPython/utils/py3compat.py b/contrib/python/ipython/py3/IPython/utils/py3compat.py
index 34af4c58f4..66ef337248 100644
--- a/contrib/python/ipython/py3/IPython/utils/py3compat.py
+++ b/contrib/python/ipython/py3/IPython/utils/py3compat.py
@@ -57,6 +57,7 @@ def execfile(fname, glob, loc=None, compiler=None):
 
 PYPY = platform.python_implementation() == "PyPy"
 
+
 # Cython still rely on that as a Dec 28 2019
 # See https://github.com/cython/cython/pull/3291 and
 # https://github.com/ipython/ipython/issues/12068
diff --git a/contrib/python/ipython/py3/IPython/utils/sysinfo.py b/contrib/python/ipython/py3/IPython/utils/sysinfo.py
index 857f0cf2d8..347123fd53 100644
--- a/contrib/python/ipython/py3/IPython/utils/sysinfo.py
+++ b/contrib/python/ipython/py3/IPython/utils/sysinfo.py
@@ -20,6 +20,8 @@ import pprint
 import sys
 import subprocess
 
+from pathlib import Path
+
 from IPython.core import release
 from IPython.utils import _sysinfo, encoding
 
@@ -27,7 +29,7 @@ from IPython.utils import _sysinfo, encoding
 # Code
 #-----------------------------------------------------------------------------
 
-def pkg_commit_hash(pkg_path):
+def pkg_commit_hash(pkg_path: str) -> tuple[str, str]:
     """Get short form of commit hash given directory `pkg_path`
 
     We get the commit hash from (in order of preference):
@@ -65,7 +67,7 @@ def pkg_commit_hash(pkg_path):
     return '(none found)', '<not found>'
 
 
-def pkg_info(pkg_path):
+def pkg_info(pkg_path: str) -> dict:
     """Return dict describing the context of this package
 
     Parameters
@@ -92,11 +94,10 @@ def pkg_info(pkg_path):
         default_encoding=encoding.DEFAULT_ENCODING,
         )
 
-def get_sys_info():
+def get_sys_info() -> dict:
     """Return useful information about IPython and the system, as a dict."""
-    p = os.path
-    path = p.realpath(p.dirname(p.abspath(p.join(__file__, '..'))))
-    return pkg_info(path)
+    path = Path(__file__, "..").resolve().parent
+    return pkg_info(str(path))
 
 def sys_info():
     """Return useful information about IPython and the system, as a string.
diff --git a/contrib/python/ipython/py3/IPython/utils/text.py b/contrib/python/ipython/py3/IPython/utils/text.py
index 74bccddf68..9b653dcee0 100644
--- a/contrib/python/ipython/py3/IPython/utils/text.py
+++ b/contrib/python/ipython/py3/IPython/utils/text.py
@@ -13,15 +13,12 @@ import re
 import string
 import sys
 import textwrap
+import warnings
 from string import Formatter
 from pathlib import Path
 
+from typing import List, Union, Optional, Dict, Tuple
 
-# datetime.strftime date format for ipython
-if sys.platform == 'win32':
-    date_format = "%B %d, %Y"
-else:
-    date_format = "%B %-d, %Y"
 
 class LSString(str):
     """String derivative with a special access attributes.
@@ -336,7 +333,13 @@ ini_spaces_re = re.compile(r'^(\s+)')
 
 def num_ini_spaces(strng):
     """Return the number of initial spaces in a string"""
-
+    warnings.warn(
+        "`num_ini_spaces` is Pending Deprecation since IPython 8.17."
+        "It is considered fro removal in in future version. "
+        "Please open an issue if you believe it should be kept.",
+        stacklevel=2,
+        category=PendingDeprecationWarning,
+    )
     ini_spaces = ini_spaces_re.match(strng)
     if ini_spaces:
         return ini_spaces.end()
@@ -391,6 +394,13 @@ def wrap_paragraphs(text, ncols=80):
     -------
     list of complete paragraphs, wrapped to fill `ncols` columns.
     """
+    warnings.warn(
+        "`wrap_paragraphs` is Pending Deprecation since IPython 8.17."
+        "It is considered fro removal in in future version. "
+        "Please open an issue if you believe it should be kept.",
+        stacklevel=2,
+        category=PendingDeprecationWarning,
+    )
     paragraph_re = re.compile(r'\n(\s*\n)+', re.MULTILINE)
     text = dedent(text).strip()
     paragraphs = paragraph_re.split(text)[::2] # every other entry is space
@@ -465,6 +475,14 @@ def strip_ansi(source):
     source : str
         Source to remove the ansi from
     """
+    warnings.warn(
+        "`strip_ansi` is Pending Deprecation since IPython 8.17."
+        "It is considered fro removal in in future version. "
+        "Please open an issue if you believe it should be kept.",
+        stacklevel=2,
+        category=PendingDeprecationWarning,
+    )
+
     return re.sub(r'\033\[(\d|;)+?m', '', source)
 
 
@@ -611,7 +629,7 @@ def _col_chunks(l, max_rows, row_first=False):
             yield l[i:(i + max_rows)]
 
 
-def _find_optimal(rlist, row_first=False, separator_size=2, displaywidth=80):
+def _find_optimal(rlist, row_first: bool, separator_size: int, displaywidth: int):
     """Calculate optimal info to columnize a list of string"""
     for max_rows in range(1, len(rlist) + 1):
         col_widths = list(map(max, _col_chunks(rlist, max_rows, row_first)))
@@ -634,7 +652,9 @@ def _get_or_default(mylist, i, default=None):
         return mylist[i]
 
 
-def compute_item_matrix(items, row_first=False, empty=None, *args, **kwargs) :
+def compute_item_matrix(
+    items, row_first: bool = False, empty=None, *, separator_size=2, displaywidth=80
+) -> Tuple[List[List[int]], Dict[str, int]]:
     """Returns a nested list, and info to columnize items
 
     Parameters
@@ -682,8 +702,20 @@ def compute_item_matrix(items, row_first=False, empty=None, *args, **kwargs) :
         In [5]: all((info[k] == ideal[k] for k in ideal.keys()))
         Out[5]: True
     """
-    info = _find_optimal(list(map(len, items)), row_first, *args, **kwargs)
-    nrow, ncol = info['max_rows'], info['num_columns']
+    warnings.warn(
+        "`compute_item_matrix` is Pending Deprecation since IPython 8.17."
+        "It is considered fro removal in in future version. "
+        "Please open an issue if you believe it should be kept.",
+        stacklevel=2,
+        category=PendingDeprecationWarning,
+    )
+    info = _find_optimal(
+        list(map(len, items)),
+        row_first,
+        separator_size=separator_size,
+        displaywidth=displaywidth,
+    )
+    nrow, ncol = info["max_rows"], info["num_columns"]
     if row_first:
         return ([[_get_or_default(items, r * ncol + c, default=empty) for c in range(ncol)] for r in range(nrow)], info)
     else:
@@ -709,14 +741,29 @@ def columnize(items, row_first=False, separator="  ", displaywidth=80, spread=Fa
     -------
     The formatted string.
     """
+    warnings.warn(
+        "`columnize` is Pending Deprecation since IPython 8.17."
+        "It is considered fro removal in in future version. "
+        "Please open an issue if you believe it should be kept.",
+        stacklevel=2,
+        category=PendingDeprecationWarning,
+    )
     if not items:
-        return '\n'
-    matrix, info = compute_item_matrix(items, row_first=row_first, separator_size=len(separator), displaywidth=displaywidth)
+        return "\n"
+    matrix: List[List[int]]
+    matrix, info = compute_item_matrix(
+        items,
+        row_first=row_first,
+        separator_size=len(separator),
+        displaywidth=displaywidth,
+    )
     if spread:
-        separator = separator.ljust(int(info['optimal_separator_width']))
-    fmatrix = [filter(None, x) for x in matrix]
-    sjoin = lambda x : separator.join([ y.ljust(w, ' ') for y, w in zip(x, info['column_widths'])])
-    return '\n'.join(map(sjoin, fmatrix))+'\n'
+        separator = separator.ljust(int(info["optimal_separator_width"]))
+    fmatrix: List[filter[int]] = [filter(None, x) for x in matrix]
+    sjoin = lambda x: separator.join(
+        [y.ljust(w, " ") for y, w in zip(x, info["column_widths"])]
+    )
+    return "\n".join(map(sjoin, fmatrix)) + "\n"
 
 
 def get_text_list(list_, last_sep=' and ', sep=", ", wrap_item_with=""):
diff --git a/contrib/python/ipython/py3/IPython/utils/timing.py b/contrib/python/ipython/py3/IPython/utils/timing.py
index 3a181ae728..d87e5fa8ef 100644
--- a/contrib/python/ipython/py3/IPython/utils/timing.py
+++ b/contrib/python/ipython/py3/IPython/utils/timing.py
@@ -23,8 +23,8 @@ import time
 # If possible (Unix), use the resource module instead of time.clock()
 try:
     import resource
-except ImportError:
-    resource = None
+except ModuleNotFoundError:
+    resource = None  # type: ignore [assignment]
 
 # Some implementations (like jyputerlite) don't have getrusage
 if resource is not None and hasattr(resource, "getrusage"):
diff --git a/contrib/python/ipython/py3/IPython/utils/tokenutil.py b/contrib/python/ipython/py3/IPython/utils/tokenutil.py
index 5fd8a1fbe1..6b99a58ae2 100644
--- a/contrib/python/ipython/py3/IPython/utils/tokenutil.py
+++ b/contrib/python/ipython/py3/IPython/utils/tokenutil.py
@@ -8,12 +8,14 @@ from io import StringIO
 from keyword import iskeyword
 
 import tokenize
+from tokenize import TokenInfo
+from typing import List, Optional
 
 
 Token = namedtuple('Token', ['token', 'text', 'start', 'end', 'line'])
 
 def generate_tokens(readline):
-    """wrap generate_tokens to catch EOF errors"""
+    """wrap generate_tkens to catch EOF errors"""
     try:
         for token in tokenize.generate_tokens(readline):
             yield token
@@ -22,7 +24,9 @@ def generate_tokens(readline):
         return
 
 
-def generate_tokens_catch_errors(readline, extra_errors_to_catch=None):
+def generate_tokens_catch_errors(
+    readline, extra_errors_to_catch: Optional[List[str]] = None
+):
     default_errors_to_catch = [
         "unterminated string literal",
         "invalid non-printable character",
@@ -31,7 +35,7 @@ def generate_tokens_catch_errors(readline, extra_errors_to_catch=None):
     assert extra_errors_to_catch is None or isinstance(extra_errors_to_catch, list)
     errors_to_catch = default_errors_to_catch + (extra_errors_to_catch or [])
 
-    tokens = []
+    tokens: List[TokenInfo] = []
     try:
         for token in tokenize.generate_tokens(readline):
             tokens.append(token)
@@ -84,7 +88,8 @@ def line_at_cursor(cell, cursor_pos=0):
         line = ""
     return (line, offset)
 
-def token_at_cursor(cell, cursor_pos=0):
+
+def token_at_cursor(cell: str, cursor_pos: int = 0):
     """Get the token at a given cursor
 
     Used for introspection.
@@ -94,13 +99,13 @@ def token_at_cursor(cell, cursor_pos=0):
 
     Parameters
     ----------
-    cell : unicode
+    cell : str
         A block of Python code
     cursor_pos : int
         The location of the cursor in the block where the token should be found
     """
-    names = []
-    tokens = []
+    names: List[str] = []
+    tokens: List[Token] = []
     call_names = []
     
     offsets = {1: 0} # lines start at 1
diff --git a/contrib/python/ipython/py3/README.rst b/contrib/python/ipython/py3/README.rst
index b004792e0e..2b179ab280 100644
--- a/contrib/python/ipython/py3/README.rst
+++ b/contrib/python/ipython/py3/README.rst
@@ -10,8 +10,8 @@
 .. image:: https://www.codetriage.com/ipython/ipython/badges/users.svg
     :target: https://www.codetriage.com/ipython/ipython/
 
-.. image:: https://raster.shields.io/badge/Follows-NEP29-brightgreen.png
-    :target: https://numpy.org/neps/nep-0029-deprecation_policy.html
+.. image:: https://raster.shields.io/badge/Follows-SPEC--0000-brightgreen.png
+    :target: https://scientific-python.org/specs/spec-0000/
 
 .. image:: https://tidelift.com/badges/package/pypi/ipython?style=flat
     :target: https://tidelift.com/subscription/pkg/pypi-ipython
@@ -31,6 +31,8 @@ IPython (Interactive Python) is a command shell for interactive computing in mul
 
 **IPython versions and Python Support**
 
+Starting after IPython 8.16, we will progressively transition to `Spec-0000 <https://scientific-python.org/specs/spec-0000/>`_.
+
 Starting with IPython 7.10, IPython follows `NEP 29 <https://numpy.org/neps/nep-0029-deprecation_policy.html>`_
 
 **IPython 7.17+** requires Python version 3.7 and above.
diff --git a/contrib/python/ipython/py3/ya.make b/contrib/python/ipython/py3/ya.make
index 14754c3091..870b9e3579 100644
--- a/contrib/python/ipython/py3/ya.make
+++ b/contrib/python/ipython/py3/ya.make
@@ -2,17 +2,15 @@
 
 PY3_LIBRARY()
 
-VERSION(8.16.1)
+VERSION(8.17.1)
 
 LICENSE(BSD-3-Clause)
 
 PEERDIR(
     contrib/python/Pygments
-    contrib/python/backcall
     contrib/python/decorator
     contrib/python/jedi
     contrib/python/matplotlib-inline
-    contrib/python/pickleshare
     contrib/python/prompt-toolkit
     contrib/python/stack-data
     contrib/python/traitlets