Merge branch '3.15' into backport-6b58f9a-3.15

Author: gpshead

Doc/howto/annotations.rst

@@ -243,10 +243,22 @@ If you use a class with a custom metaclass and access ``__annotations__``
 on the class, you may observe unexpected behavior; see
 :pep:`749 <749#pep749-metaclasses>` for some examples. You can avoid these
 quirks by using :func:`annotationlib.get_annotations` on Python 3.14+ or
-:func:`inspect.get_annotations` on Python 3.10+. On earlier versions of
-Python, you can avoid these bugs by accessing the annotations from the
-class's :attr:`~type.__dict__`
-(for example, ``cls.__dict__.get('__annotations__', None)``).
+:func:`inspect.get_annotations` on Python 3.10+.
+
+.. note::
+
+   On Python 3.14 and later, annotations are evaluated lazily (see
+   :pep:`649` and :pep:`749`), and how the annotations dict is stored in
+   the class's :attr:`~type.__dict__` is a private implementation detail.
+   Reading ``cls.__dict__.get('__annotations__', None)`` may therefore
+   return ``None`` even when the class has annotations. On these versions,
+   always use :func:`annotationlib.get_annotations` (or
+   :func:`inspect.get_annotations`) rather than accessing
+   :attr:`~type.__dict__` directly.
+
+Only on Python 3.9 and earlier, where neither function is available, can you
+avoid these bugs by reading the annotations from the class's
+:attr:`~type.__dict__` (for example, ``cls.__dict__.get('__annotations__', None)``).
 
 In some versions of Python, instances of classes may have an ``__annotations__``
 attribute. However, this is not supported functionality. If you need the

Lib/codecs.py

@@ -400,9 +400,10 @@ def reset(self):
         pass
 
     def seek(self, offset, whence=0):
-        self.stream.seek(offset, whence)
+        # reset() may write to the stream: call it at the old position.
         if whence == 0 and offset == 0:
             self.reset()
+        self.stream.seek(offset, whence)
 
     def __getattr__(self, name,
                     getattr=getattr):
@@ -739,10 +740,11 @@ def reset(self):
         self.writer.reset()
 
     def seek(self, offset, whence=0):
-        self.stream.seek(offset, whence)
-        self.reader.reset()
+        # writer.reset() may write to the stream: call it at the old position.
         if whence == 0 and offset == 0:
             self.writer.reset()
+        self.stream.seek(offset, whence)
+        self.reader.reset()
 
     def __getattr__(self, name,
                     getattr=getattr):
@@ -862,8 +864,8 @@ def reset(self):
     def seek(self, offset, whence=0):
         # Seeks must be propagated to both the readers and writers
         # as they might need to reset their internal buffers.
-        self.reader.seek(offset, whence)
         self.writer.seek(offset, whence)
+        self.reader.seek(offset, whence)
 
     def __getattr__(self, name,
                     getattr=getattr):

Lib/configparser.py

@@ -923,12 +923,20 @@ def popitem(self):
 
         The section DEFAULT is never returned because it cannot be removed.
         """
-        for key in self.sections():
+        for key in self._sections:
             value = self[key]
             del self[key]
             return key, value
         raise KeyError
 
+    def clear(self):
+        """Remove all sections from the parser.
+
+        The section DEFAULT is left intact because it cannot be removed.
+        """
+        for section in self.sections():
+            del self[section]
+
     def optionxform(self, optionstr):
         return optionstr.lower()
 
@@ -1341,6 +1349,39 @@ def _options(self):
         else:
             return self._parser.defaults()
 
+    # MutableMapping.popitem() and MutableMapping.clear() create a new
+    # iterator for every removed option, and __iter__() copies the names
+    # of all options.  Emptying a section that way takes quadratic time.
+
+    def popitem(self):
+        """Remove an option from the section and return it as
+        an (option_name, value) tuple. If no option is present, raise KeyError.
+
+        Options of the section DEFAULT are only returned for that section
+        because they cannot be removed from other sections.
+        """
+        if self._name != self._parser.default_section:
+            try:
+                options = self._parser._sections[self._name]
+            except KeyError:
+                raise NoSectionError(self._name) from None
+        else:
+            options = self._parser.defaults()
+        for key in options:
+            value = self[key]
+            del self[key]
+            return key, value
+        raise KeyError
+
+    def clear(self):
+        """Remove all options from the section.
+
+        Options of the section DEFAULT are left intact for other sections
+        because they cannot be removed from them.
+        """
+        for key in list(self._options()):
+            self._parser.remove_option(self._name, key)
+
     @property
     def parser(self):
         # The parser object of the proxy is read-only.

Lib/encodings/idna.py

@@ -348,6 +348,9 @@ def _buffer_decode(self, input, errors, final):
         result = []
         size = 0
         for label in labels:
+            if result:
+                # Join with U+002E
+                size += 1
             try:
                 u_label = ToUnicode(label)
             except (UnicodeEncodeError, UnicodeDecodeError) as exc:
@@ -360,8 +363,6 @@ def _buffer_decode(self, input, errors, final):
                 )
             else:
                 result.append(u_label)
-            if size:
-                size += 1
             size += len(label)
 
         result = ".".join(result) + trailing_dot

Lib/gzip.py

@@ -762,7 +762,7 @@ def main():
                              compresslevel=compresslevel)
             else:
                 f = builtins.open(arg, "rb")
-                g = open(arg + ".gz", "wb")
+                g = open(arg + ".gz", "wb", compresslevel=compresslevel)
         while True:
             chunk = f.read(READ_BUFFER_SIZE)
             if not chunk:

Lib/ipaddress.py

@@ -2272,7 +2272,7 @@ def with_hostmask(self):
 
     @property
     def is_unspecified(self):
-        return self._ip == 0 and self.network.is_unspecified
+        return super().is_unspecified and self.network.is_unspecified
 
     @property
     def is_loopback(self):

Lib/multiprocessing/shared_memory.py

@@ -305,14 +305,21 @@ def _extract_recreation_code(value):
         else:
             return 3  # NoneType
 
+    @staticmethod
+    def _encode_value(value):
+        if not isinstance(value, str):
+            return value
+        else:
+            return value.encode(_encoding)
+
     def __init__(self, sequence=None, *, name=None):
         if name is None or sequence is not None:
             sequence = sequence or ()
             _formats = [
                 self._types_mapping[type(item)]
                     if not isinstance(item, (str, bytes))
                     else self._types_mapping[type(item)] % (
-                        self._alignment * (len(item) // self._alignment + 1),
+                        self._alignment * ((len(self._encode_value(item)) - 1) // self._alignment + 1),
                     )
                 for item in sequence
             ]
@@ -342,31 +349,40 @@ def __init__(self, sequence=None, *, name=None):
 
         if sequence is not None:
             _enc = _encoding
-            struct.pack_into(
-                "q" + self._format_size_metainfo,
-                self.shm.buf,
-                0,
-                self._list_len,
-                *(self._allocated_offsets)
-            )
-            struct.pack_into(
-                "".join(_formats),
-                self.shm.buf,
-                self._offset_data_start,
-                *(v.encode(_enc) if isinstance(v, str) else v for v in sequence)
-            )
-            struct.pack_into(
-                self._format_packing_metainfo,
-                self.shm.buf,
-                self._offset_packing_formats,
-                *(v.encode(_enc) for v in _formats)
-            )
-            struct.pack_into(
-                self._format_back_transform_codes,
-                self.shm.buf,
-                self._offset_back_transform_codes,
-                *(_recreation_codes)
-            )
+            try:
+                struct.pack_into(
+                    "q" + self._format_size_metainfo,
+                    self.shm.buf,
+                    0,
+                    self._list_len,
+                    *(self._allocated_offsets)
+                )
+                struct.pack_into(
+                    "".join(_formats),
+                    self.shm.buf,
+                    self._offset_data_start,
+                    *(self._encode_value(v) for v in sequence)
+                )
+                struct.pack_into(
+                    self._format_packing_metainfo,
+                    self.shm.buf,
+                    self._offset_packing_formats,
+                    *(v.encode(_enc) for v in _formats)
+                )
+                struct.pack_into(
+                    self._format_back_transform_codes,
+                    self.shm.buf,
+                    self._offset_back_transform_codes,
+                    *(_recreation_codes)
+                )
+            except BaseException:
+                # A value of a supported type may still be unpackable, such as
+                # an int outside the signed 64-bit range.  The block was created
+                # above and the caller gets no object to release it with, so
+                # destroy it here.
+                self.shm.close()
+                self.shm.unlink()
+                raise
 
         else:
             self._list_len = len(self)  # Obtains size from offset 0 in buffer.
@@ -463,8 +479,7 @@ def __setitem__(self, position, value):
         else:
             allocated_length = self._allocated_offsets[position + 1] - item_offset
 
-            encoded_value = (value.encode(_encoding)
-                             if isinstance(value, str) else value)
+            encoded_value = self._encode_value(value)
             if len(encoded_value) > allocated_length:
                 raise ValueError("bytes/str item exceeds available storage")
             if current_format[-1] == "s":

Lib/plistlib.py

@@ -699,7 +699,7 @@ def write(self, value):
         top_object = self._getrefnum(value)
         offset_table_offset = self._fp.tell()
         offset_size = _count_to_size(offset_table_offset)
-        offset_format = '>' + _BINARY_FORMAT[offset_size] * num_objects
+        offset_format = f'>{num_objects}{_BINARY_FORMAT[offset_size]}'
         self._fp.write(struct.pack(offset_format, *self._object_offsets))
 
         # Write trailer
@@ -846,7 +846,7 @@ def _write_object(self, value):
             refs = [self._getrefnum(o) for o in value]
             s = len(refs)
             self._write_size(0xA0, s)
-            self._fp.write(struct.pack('>' + self._ref_format * s, *refs))
+            self._fp.write(struct.pack(f'>{s}{self._ref_format}', *refs))
 
         elif isinstance(value, (dict, frozendict)):
             keyRefs, valRefs = [], []
@@ -862,8 +862,8 @@ def _write_object(self, value):
 
             s = len(keyRefs)
             self._write_size(0xD0, s)
-            self._fp.write(struct.pack('>' + self._ref_format * s, *keyRefs))
-            self._fp.write(struct.pack('>' + self._ref_format * s, *valRefs))
+            self._fp.write(struct.pack(f'>{s}{self._ref_format}', *keyRefs))
+            self._fp.write(struct.pack(f'>{s}{self._ref_format}', *valRefs))
 
         else:
             raise TypeError(value)

Lib/shutil.py

@@ -1101,6 +1101,7 @@ def _make_zipfile(base_name, base_dir, verbose=0, dry_run=0,
             if root_dir is not None:
                 base_dir = os.path.join(root_dir, base_dir)
             base_dir = os.path.normpath(base_dir)
+            zip_stat = os.stat(zip_filename)
             if arcname != os.curdir:
                 zf.write(base_dir, arcname)
                 if logger is not None:
@@ -1119,7 +1120,13 @@ def _make_zipfile(base_name, base_dir, verbose=0, dry_run=0,
                 for name in filenames:
                     path = os.path.join(dirpath, name)
                     path = os.path.normpath(path)
-                    if os.path.isfile(path):
+                    try:
+                        st = os.stat(path)
+                    except OSError:
+                        continue
+                    # Do not add the archive to itself.
+                    if (stat.S_ISREG(st.st_mode) and
+                            not os.path.samestat(st, zip_stat)):
                         arcname = os.path.join(arcdirpath, name)
                         zf.write(path, arcname)
                         if logger is not None:

Lib/tarfile.py

@@ -2722,6 +2722,13 @@ def _extract_member(self, tarinfo, targetpath, set_attrs=True,
         else:
             self.makefile(tarinfo, targetpath)
 
+        if tarinfo.islnk() and os.path.islink(targetpath):
+            # makelink_with_filter() fell back to extracting a copy of a
+            # symlink member, which already has its own attributes set.
+            # Setting the hard link's attributes here would follow the
+            # symlink, possibly to a file outside the destination directory.
+            set_attrs = False
+
         if set_attrs:
             self.chown(tarinfo, targetpath, numeric_owner)
             if not tarinfo.issym():