update to boost 1.78 and python 3.10.1

Author: chcg

PythonLib/full/__future__.py

@@ -42,7 +42,7 @@
 argument to the builtin function compile() to enable the feature in
 dynamically compiled code.  This flag is stored in the .compiler_flag
 attribute on _Future instances.  These values must match the appropriate
-#defines of CO_xxx flags in Include/compile.h.
+#defines of CO_xxx flags in Include/cpython/compile.h.
 
 No feature line is ever to be deleted from this file.
 """
@@ -143,5 +143,5 @@ def __repr__(self):
                           CO_FUTURE_GENERATOR_STOP)
 
 annotations = _Feature((3, 7, 0, "beta", 1),
-                       (3, 10, 0, "alpha", 0),
+                       (3, 11, 0, "alpha", 0),
                        CO_FUTURE_ANNOTATIONS)

PythonLib/full/_aix_support.py

@@ -15,9 +15,8 @@ def _aix_tag(vrtl, bd):
     # type: (List[int], int) -> str
     # Infer the ABI bitwidth from maxsize (assuming 64 bit as the default)
     _sz = 32 if sys.maxsize == (2**31-1) else 64
-    _bd = bd if bd != 0 else 9988
     # vrtl[version, release, technology_level]
-    return "aix-{:1x}{:1d}{:02d}-{:04d}-{}".format(vrtl[0], vrtl[1], vrtl[2], _bd, _sz)
+    return "aix-{:1x}{:1d}{:02d}-{:04d}-{}".format(vrtl[0], vrtl[1], vrtl[2], bd, _sz)
 
 
 # extract version, release and technology level from a VRMF string
@@ -27,20 +26,19 @@ def _aix_vrtl(vrmf):
     return [int(v[-1]), int(r), int(tl)]
 
 
-def _aix_bos_rte():
+def _aix_bosmp64():
     # type: () -> Tuple[str, int]
     """
     Return a Tuple[str, int] e.g., ['7.1.4.34', 1806]
-    The fileset bos.rte represents the current AIX run-time level. It's VRMF and
-    builddate reflect the current ABI levels of the runtime environment.
-    If no builddate is found give a value that will satisfy pep425 related queries
+    The fileset bos.mp64 is the AIX kernel. It's VRMF and builddate
+    reflect the current ABI levels of the runtime environment.
     """
-    # All AIX systems to have lslpp installed in this location
-    out = subprocess.check_output(["/usr/bin/lslpp", "-Lqc", "bos.rte"])
+    # We expect all AIX systems to have lslpp installed in this location
+    out = subprocess.check_output(["/usr/bin/lslpp", "-Lqc", "bos.mp64"])
     out = out.decode("utf-8")
     out = out.strip().split(":")  # type: ignore
-    _bd = int(out[-1]) if out[-1] != '' else 9988
-    return (str(out[2]), _bd)
+    # Use str() and int() to help mypy see types
+    return (str(out[2]), int(out[-1]))
 
 
 def aix_platform():
@@ -49,11 +47,11 @@ def aix_platform():
     AIX filesets are identified by four decimal values: V.R.M.F.
     V (version) and R (release) can be retreived using ``uname``
     Since 2007, starting with AIX 5.3 TL7, the M value has been
-    included with the fileset bos.rte and represents the Technology
+    included with the fileset bos.mp64 and represents the Technology
     Level (TL) of AIX. The F (Fix) value also increases, but is not
     relevant for comparing releases and binary compatibility.
     For binary compatibility the so-called builddate is needed.
-    Again, the builddate of an AIX release is associated with bos.rte.
+    Again, the builddate of an AIX release is associated with bos.mp64.
     AIX ABI compatibility is described  as guaranteed at: https://www.ibm.com/\
     support/knowledgecenter/en/ssw_aix_72/install/binary_compatability.html
 
@@ -62,7 +60,7 @@ def aix_platform():
     e.g., "aix-6107-1415-32" for AIX 6.1 TL7 bd 1415, 32-bit
     and, "aix-6107-1415-64" for AIX 6.1 TL7 bd 1415, 64-bit
     """
-    vrmf, bd = _aix_bos_rte()
+    vrmf, bd = _aix_bosmp64()
     return _aix_tag(_aix_vrtl(vrmf), bd)
 
 
@@ -81,7 +79,7 @@ def aix_buildtag():
     Return the platform_tag of the system Python was built on.
     """
     # AIX_BUILDDATE is defined by configure with:
-    # lslpp -Lcq bos.rte | awk -F:  '{ print $NF }'
+    # lslpp -Lcq bos.mp64 | awk -F:  '{ print $NF }'
     build_date = sysconfig.get_config_var("AIX_BUILDDATE")
     try:
         build_date = int(build_date)

PythonLib/full/_bootlocale.py

@@ -416,7 +416,7 @@ def __subclasshook__(cls, C):
 class _CallableGenericAlias(GenericAlias):
     """ Represent `Callable[argtypes, resulttype]`.
 
-    This sets ``__args__`` to a tuple containing the flattened``argtypes``
+    This sets ``__args__`` to a tuple containing the flattened ``argtypes``
     followed by ``resulttype``.
 
     Example: ``Callable[[int, str], float]`` sets ``__args__`` to
@@ -426,53 +426,107 @@ class _CallableGenericAlias(GenericAlias):
     __slots__ = ()
 
     def __new__(cls, origin, args):
-        try:
-            return cls.__create_ga(origin, args)
-        except TypeError as exc:
-            import warnings
-            warnings.warn(f'{str(exc)} '
-                          f'(This will raise a TypeError in Python 3.10.)',
-                          DeprecationWarning)
-            return GenericAlias(origin, args)
-
-    @classmethod
-    def __create_ga(cls, origin, args):
-        if not isinstance(args, tuple) or len(args) != 2:
+        if not (isinstance(args, tuple) and len(args) == 2):
             raise TypeError(
                 "Callable must be used as Callable[[arg, ...], result].")
         t_args, t_result = args
-        if isinstance(t_args, (list, tuple)):
-            ga_args = tuple(t_args) + (t_result,)
-        # This relaxes what t_args can be on purpose to allow things like
-        # PEP 612 ParamSpec.  Responsibility for whether a user is using
-        # Callable[...] properly is deferred to static type checkers.
-        else:
-            ga_args = args
-        return super().__new__(cls, origin, ga_args)
+        if isinstance(t_args, list):
+            args = (*t_args, t_result)
+        elif not _is_param_expr(t_args):
+            raise TypeError(f"Expected a list of types, an ellipsis, "
+                            f"ParamSpec, or Concatenate. Got {t_args}")
+        return super().__new__(cls, origin, args)
+
+    @property
+    def __parameters__(self):
+        params = []
+        for arg in self.__args__:
+            # Looks like a genericalias
+            if hasattr(arg, "__parameters__") and isinstance(arg.__parameters__, tuple):
+                params.extend(arg.__parameters__)
+            else:
+                if _is_typevarlike(arg):
+                    params.append(arg)
+        return tuple(dict.fromkeys(params))
 
     def __repr__(self):
-        if len(self.__args__) == 2 and self.__args__[0] is Ellipsis:
+        if len(self.__args__) == 2 and _is_param_expr(self.__args__[0]):
             return super().__repr__()
         return (f'collections.abc.Callable'
                 f'[[{", ".join([_type_repr(a) for a in self.__args__[:-1]])}], '
                 f'{_type_repr(self.__args__[-1])}]')
 
     def __reduce__(self):
         args = self.__args__
-        if not (len(args) == 2 and args[0] is Ellipsis):
+        if not (len(args) == 2 and _is_param_expr(args[0])):
             args = list(args[:-1]), args[-1]
         return _CallableGenericAlias, (Callable, args)
 
     def __getitem__(self, item):
         # Called during TypeVar substitution, returns the custom subclass
-        # rather than the default types.GenericAlias object.
-        ga = super().__getitem__(item)
-        args = ga.__args__
-        t_result = args[-1]
-        t_args = args[:-1]
-        args = (t_args, t_result)
-        return _CallableGenericAlias(Callable, args)
-
+        # rather than the default types.GenericAlias object.  Most of the
+        # code is copied from typing's _GenericAlias and the builtin
+        # types.GenericAlias.
+
+        # A special case in PEP 612 where if X = Callable[P, int],
+        # then X[int, str] == X[[int, str]].
+        param_len = len(self.__parameters__)
+        if param_len == 0:
+            raise TypeError(f'{self} is not a generic class')
+        if not isinstance(item, tuple):
+            item = (item,)
+        if (param_len == 1 and _is_param_expr(self.__parameters__[0])
+                and item and not _is_param_expr(item[0])):
+            item = (list(item),)
+        item_len = len(item)
+        if item_len != param_len:
+            raise TypeError(f'Too {"many" if item_len > param_len else "few"}'
+                            f' arguments for {self};'
+                            f' actual {item_len}, expected {param_len}')
+        subst = dict(zip(self.__parameters__, item))
+        new_args = []
+        for arg in self.__args__:
+            if _is_typevarlike(arg):
+                if _is_param_expr(arg):
+                    arg = subst[arg]
+                    if not _is_param_expr(arg):
+                        raise TypeError(f"Expected a list of types, an ellipsis, "
+                                        f"ParamSpec, or Concatenate. Got {arg}")
+                else:
+                    arg = subst[arg]
+            # Looks like a GenericAlias
+            elif hasattr(arg, '__parameters__') and isinstance(arg.__parameters__, tuple):
+                subparams = arg.__parameters__
+                if subparams:
+                    subargs = tuple(subst[x] for x in subparams)
+                    arg = arg[subargs]
+            new_args.append(arg)
+
+        # args[0] occurs due to things like Z[[int, str, bool]] from PEP 612
+        if not isinstance(new_args[0], list):
+            t_result = new_args[-1]
+            t_args = new_args[:-1]
+            new_args = (t_args, t_result)
+        return _CallableGenericAlias(Callable, tuple(new_args))
+
+
+def _is_typevarlike(arg):
+    obj = type(arg)
+    # looks like a TypeVar/ParamSpec
+    return (obj.__module__ == 'typing'
+            and obj.__name__ in {'ParamSpec', 'TypeVar'})
+
+def _is_param_expr(obj):
+    """Checks if obj matches either a list of types, ``...``, ``ParamSpec`` or
+    ``_ConcatenateGenericAlias`` from typing.py
+    """
+    if obj is Ellipsis:
+        return True
+    if isinstance(obj, list):
+        return True
+    obj = type(obj)
+    names = ('ParamSpec', '_ConcatenateGenericAlias')
+    return obj.__module__ == 'typing' and any(obj.__name__ == name for name in names)
 
 def _type_repr(obj):
     """Return the repr() of an object, special-casing types (internal helper).
@@ -514,7 +568,6 @@ def __subclasshook__(cls, C):
 
 
 class Set(Collection):
-
     """A set is a finite, iterable container.
 
     This class provides concrete generic implementations of all
@@ -740,19 +793,19 @@ def __isub__(self, it):
 
 ### MAPPINGS ###
 
-
 class Mapping(Collection):
-
-    __slots__ = ()
-
     """A Mapping is a generic container for associating key/value
     pairs.
 
     This class provides concrete generic implementations of all
     methods except for __getitem__, __iter__, and __len__.
-
     """
 
+    __slots__ = ()
+
+    # Tell ABCMeta.__new__ that this class should have TPFLAGS_MAPPING set.
+    __abc_tpflags__ = 1 << 6 # Py_TPFLAGS_MAPPING
+
     @abstractmethod
     def __getitem__(self, key):
         raise KeyError
@@ -791,7 +844,6 @@ def __eq__(self, other):
 
     __reversed__ = None
 
-
 Mapping.register(mappingproxy)
 
 
@@ -874,18 +926,16 @@ def __iter__(self):
 
 
 class MutableMapping(Mapping):
-
-    __slots__ = ()
-
     """A MutableMapping is a generic container for associating
     key/value pairs.
 
     This class provides concrete generic implementations of all
     methods except for __getitem__, __setitem__, __delitem__,
     __iter__, and __len__.
-
     """
 
+    __slots__ = ()
+
     @abstractmethod
     def __setitem__(self, key, value):
         raise KeyError
@@ -962,9 +1012,7 @@ def setdefault(self, key, default=None):
 
 ### SEQUENCES ###
 
-
 class Sequence(Reversible, Collection):
-
     """All the operations on a read-only sequence.
 
     Concrete subclasses must override __new__ or __init__,
@@ -973,6 +1021,9 @@ class Sequence(Reversible, Collection):
 
     __slots__ = ()
 
+    # Tell ABCMeta.__new__ that this class should have TPFLAGS_SEQUENCE set.
+    __abc_tpflags__ = 1 << 5 # Py_TPFLAGS_SEQUENCE
+
     @abstractmethod
     def __getitem__(self, index):
         raise IndexError
@@ -1024,15 +1075,13 @@ def count(self, value):
         'S.count(value) -> integer -- return number of occurrences of value'
         return sum(1 for v in self if v is value or v == value)
 
-
 Sequence.register(tuple)
 Sequence.register(str)
 Sequence.register(range)
 Sequence.register(memoryview)
 
 
 class ByteString(Sequence):
-
     """This unifies bytes and bytearray.
 
     XXX Should add all their methods.
@@ -1045,16 +1094,14 @@ class ByteString(Sequence):
 
 
 class MutableSequence(Sequence):
-
-    __slots__ = ()
-
     """All the operations on a read-write sequence.
 
     Concrete subclasses must provide __new__ or __init__,
     __getitem__, __setitem__, __delitem__, __len__, and insert().
-
     """
 
+    __slots__ = ()
+
     @abstractmethod
     def __setitem__(self, index, value):
         raise IndexError