[pypy-commit] pypy py3.7: Update stdlib to 3.7.4
rlamy
pypy.commits at gmail.com
Thu Aug 29 12:04:16 EDT 2019
Author: Ronan Lamy <ronan.lamy at gmail.com>
Branch: py3.7
Changeset: r97331:c252447e48e9
Date: 2019-08-29 17:03 +0100
http://bitbucket.org/pypy/pypy/changeset/c252447e48e9/
Log: Update stdlib to 3.7.4
diff too long, truncating to 2000 out of 107794 lines
diff --git a/lib-python/3/__future__.py b/lib-python/3/__future__.py
--- a/lib-python/3/__future__.py
+++ b/lib-python/3/__future__.py
@@ -57,13 +57,14 @@
"unicode_literals",
"barry_as_FLUFL",
"generator_stop",
+ "annotations",
]
__all__ = ["all_feature_names"] + all_feature_names
-# The CO_xxx symbols are defined here under the same names used by
-# compile.h, so that an editor search will find them here. However,
-# they're not exported in __all__, because they don't really belong to
+# The CO_xxx symbols are defined here under the same names defined in
+# code.h and used by compile.h, so that an editor search will find them here.
+# However, they're not exported in __all__, because they don't really belong to
# this module.
CO_NESTED = 0x0010 # nested_scopes
CO_GENERATOR_ALLOWED = 0 # generators (obsolete, was 0x1000)
@@ -74,6 +75,7 @@
CO_FUTURE_UNICODE_LITERALS = 0x20000 # unicode string literals
CO_FUTURE_BARRY_AS_BDFL = 0x40000
CO_FUTURE_GENERATOR_STOP = 0x80000 # StopIteration becomes RuntimeError in generators
+CO_FUTURE_ANNOTATIONS = 0x100000 # annotations become strings at runtime
class _Feature:
def __init__(self, optionalRelease, mandatoryRelease, compiler_flag):
@@ -132,9 +134,13 @@
CO_FUTURE_UNICODE_LITERALS)
barry_as_FLUFL = _Feature((3, 1, 0, "alpha", 2),
- (3, 9, 0, "alpha", 0),
- CO_FUTURE_BARRY_AS_BDFL)
+ (3, 9, 0, "alpha", 0),
+ CO_FUTURE_BARRY_AS_BDFL)
generator_stop = _Feature((3, 5, 0, "beta", 1),
- (3, 7, 0, "alpha", 0),
- CO_FUTURE_GENERATOR_STOP)
+ (3, 7, 0, "alpha", 0),
+ CO_FUTURE_GENERATOR_STOP)
+
+annotations = _Feature((3, 7, 0, "beta", 1),
+ (4, 0, 0, "alpha", 0),
+ CO_FUTURE_ANNOTATIONS)
diff --git a/lib-python/3/_bootlocale.py b/lib-python/3/_bootlocale.py
--- a/lib-python/3/_bootlocale.py
+++ b/lib-python/3/_bootlocale.py
@@ -9,19 +9,31 @@
if sys.platform.startswith("win"):
def getpreferredencoding(do_setlocale=True):
+ if sys.flags.utf8_mode:
+ return 'UTF-8'
return _locale._getdefaultlocale()[1]
else:
try:
_locale.CODESET
except AttributeError:
- def getpreferredencoding(do_setlocale=True):
- # This path for legacy systems needs the more complex
- # getdefaultlocale() function, import the full locale module.
- import locale
- return locale.getpreferredencoding(do_setlocale)
+ if hasattr(sys, 'getandroidapilevel'):
+ # On Android langinfo.h and CODESET are missing, and UTF-8 is
+ # always used in mbstowcs() and wcstombs().
+ def getpreferredencoding(do_setlocale=True):
+ return 'UTF-8'
+ else:
+ def getpreferredencoding(do_setlocale=True):
+ if sys.flags.utf8_mode:
+ return 'UTF-8'
+ # This path for legacy systems needs the more complex
+ # getdefaultlocale() function, import the full locale module.
+ import locale
+ return locale.getpreferredencoding(do_setlocale)
else:
def getpreferredencoding(do_setlocale=True):
assert not do_setlocale
+ if sys.flags.utf8_mode:
+ return 'UTF-8'
result = _locale.nl_langinfo(_locale.CODESET)
if not result and sys.platform == 'darwin':
# nl_langinfo can return an empty string
diff --git a/lib-python/3/_collections_abc.py b/lib-python/3/_collections_abc.py
--- a/lib-python/3/_collections_abc.py
+++ b/lib-python/3/_collections_abc.py
@@ -589,7 +589,7 @@
try:
value = next(it)
except StopIteration:
- raise KeyError
+ raise KeyError from None
self.discard(value)
return value
@@ -746,7 +746,7 @@
ItemsView.register(dict_items)
-class ValuesView(MappingView):
+class ValuesView(MappingView, Collection):
__slots__ = ()
@@ -808,7 +808,7 @@
try:
key = next(iter(self))
except StopIteration:
- raise KeyError
+ raise KeyError from None
value = self[key]
del self[key]
return key, value
diff --git a/lib-python/3/_dummy_thread.py b/lib-python/3/_dummy_thread.py
--- a/lib-python/3/_dummy_thread.py
+++ b/lib-python/3/_dummy_thread.py
@@ -14,7 +14,7 @@
# Exports only things specified by thread documentation;
# skipping obsolete synonyms allocate(), start_new(), exit_thread().
__all__ = ['error', 'start_new_thread', 'exit', 'get_ident', 'allocate_lock',
- 'interrupt_main', 'LockType']
+ 'interrupt_main', 'LockType', 'RLock']
# A dummy value
TIMEOUT_MAX = 2**31
@@ -69,7 +69,7 @@
available, it is safe to assume that the current process is the
only thread. Thus a constant can be safely returned.
"""
- return -1
+ return 1
def allocate_lock():
"""Dummy implementation of _thread.allocate_lock()."""
@@ -148,6 +148,36 @@
hex(id(self))
)
+
+class RLock(LockType):
+ """Dummy implementation of threading._RLock.
+
+ Re-entrant lock can be aquired multiple times and needs to be released
+ just as many times. This dummy implemention does not check wheter the
+ current thread actually owns the lock, but does accounting on the call
+ counts.
+ """
+ def __init__(self):
+ super().__init__()
+ self._levels = 0
+
+ def acquire(self, waitflag=None, timeout=-1):
+ """Aquire the lock, can be called multiple times in succession.
+ """
+ locked = super().acquire(waitflag, timeout)
+ if locked:
+ self._levels += 1
+ return locked
+
+ def release(self):
+ """Release needs to be called once for every call to acquire().
+ """
+ if self._levels == 0:
+ raise error
+ if self._levels == 1:
+ super().release()
+ self._levels -= 1
+
# Used to signal that interrupt_main was called in a "thread"
_interrupt = False
# True when not executing in a "thread"
diff --git a/lib-python/3/_py_abc.py b/lib-python/3/_py_abc.py
new file mode 100644
--- /dev/null
+++ b/lib-python/3/_py_abc.py
@@ -0,0 +1,147 @@
+from _weakrefset import WeakSet
+
+
+def get_cache_token():
+ """Returns the current ABC cache token.
+
+ The token is an opaque object (supporting equality testing) identifying the
+ current version of the ABC cache for virtual subclasses. The token changes
+ with every call to ``register()`` on any ABC.
+ """
+ return ABCMeta._abc_invalidation_counter
+
+
+class ABCMeta(type):
+ """Metaclass for defining Abstract Base Classes (ABCs).
+
+ Use this metaclass to create an ABC. An ABC can be subclassed
+ directly, and then acts as a mix-in class. You can also register
+ unrelated concrete classes (even built-in classes) and unrelated
+ ABCs as 'virtual subclasses' -- these and their descendants will
+ be considered subclasses of the registering ABC by the built-in
+ issubclass() function, but the registering ABC won't show up in
+ their MRO (Method Resolution Order) nor will method
+ implementations defined by the registering ABC be callable (not
+ even via super()).
+ """
+
+ # A global counter that is incremented each time a class is
+ # registered as a virtual subclass of anything. It forces the
+ # negative cache to be cleared before its next use.
+ # Note: this counter is private. Use `abc.get_cache_token()` for
+ # external code.
+ _abc_invalidation_counter = 0
+
+ def __new__(mcls, name, bases, namespace, **kwargs):
+ cls = super().__new__(mcls, name, bases, namespace, **kwargs)
+ # Compute set of abstract method names
+ abstracts = {name
+ for name, value in namespace.items()
+ if getattr(value, "__isabstractmethod__", False)}
+ for base in bases:
+ for name in getattr(base, "__abstractmethods__", set()):
+ value = getattr(cls, name, None)
+ if getattr(value, "__isabstractmethod__", False):
+ abstracts.add(name)
+ cls.__abstractmethods__ = frozenset(abstracts)
+ # Set up inheritance registry
+ cls._abc_registry = WeakSet()
+ cls._abc_cache = WeakSet()
+ cls._abc_negative_cache = WeakSet()
+ cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
+ return cls
+
+ def register(cls, subclass):
+ """Register a virtual subclass of an ABC.
+
+ Returns the subclass, to allow usage as a class decorator.
+ """
+ if not isinstance(subclass, type):
+ raise TypeError("Can only register classes")
+ if issubclass(subclass, cls):
+ return subclass # Already a subclass
+ # Subtle: test for cycles *after* testing for "already a subclass";
+ # this means we allow X.register(X) and interpret it as a no-op.
+ if issubclass(cls, subclass):
+ # This would create a cycle, which is bad for the algorithm below
+ raise RuntimeError("Refusing to create an inheritance cycle")
+ cls._abc_registry.add(subclass)
+ ABCMeta._abc_invalidation_counter += 1 # Invalidate negative cache
+ return subclass
+
+ def _dump_registry(cls, file=None):
+ """Debug helper to print the ABC registry."""
+ print(f"Class: {cls.__module__}.{cls.__qualname__}", file=file)
+ print(f"Inv. counter: {get_cache_token()}", file=file)
+ for name in cls.__dict__:
+ if name.startswith("_abc_"):
+ value = getattr(cls, name)
+ if isinstance(value, WeakSet):
+ value = set(value)
+ print(f"{name}: {value!r}", file=file)
+
+ def _abc_registry_clear(cls):
+ """Clear the registry (for debugging or testing)."""
+ cls._abc_registry.clear()
+
+ def _abc_caches_clear(cls):
+ """Clear the caches (for debugging or testing)."""
+ cls._abc_cache.clear()
+ cls._abc_negative_cache.clear()
+
+ def __instancecheck__(cls, instance):
+ """Override for isinstance(instance, cls)."""
+ # Inline the cache checking
+ subclass = instance.__class__
+ if subclass in cls._abc_cache:
+ return True
+ subtype = type(instance)
+ if subtype is subclass:
+ if (cls._abc_negative_cache_version ==
+ ABCMeta._abc_invalidation_counter and
+ subclass in cls._abc_negative_cache):
+ return False
+ # Fall back to the subclass check.
+ return cls.__subclasscheck__(subclass)
+ return any(cls.__subclasscheck__(c) for c in (subclass, subtype))
+
+ def __subclasscheck__(cls, subclass):
+ """Override for issubclass(subclass, cls)."""
+ if not isinstance(subclass, type):
+ raise TypeError('issubclass() arg 1 must be a class')
+ # Check cache
+ if subclass in cls._abc_cache:
+ return True
+ # Check negative cache; may have to invalidate
+ if cls._abc_negative_cache_version < ABCMeta._abc_invalidation_counter:
+ # Invalidate the negative cache
+ cls._abc_negative_cache = WeakSet()
+ cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
+ elif subclass in cls._abc_negative_cache:
+ return False
+ # Check the subclass hook
+ ok = cls.__subclasshook__(subclass)
+ if ok is not NotImplemented:
+ assert isinstance(ok, bool)
+ if ok:
+ cls._abc_cache.add(subclass)
+ else:
+ cls._abc_negative_cache.add(subclass)
+ return ok
+ # Check if it's a direct subclass
+ if cls in getattr(subclass, '__mro__', ()):
+ cls._abc_cache.add(subclass)
+ return True
+ # Check if it's a subclass of a registered class (recursive)
+ for rcls in cls._abc_registry:
+ if issubclass(subclass, rcls):
+ cls._abc_cache.add(subclass)
+ return True
+ # Check if it's a subclass of a subclass (recursive)
+ for scls in cls.__subclasses__():
+ if issubclass(subclass, scls):
+ cls._abc_cache.add(subclass)
+ return True
+ # No dice; update negative cache
+ cls._abc_negative_cache.add(subclass)
+ return False
diff --git a/lib-python/3/_pydecimal.py b/lib-python/3/_pydecimal.py
--- a/lib-python/3/_pydecimal.py
+++ b/lib-python/3/_pydecimal.py
@@ -431,80 +431,34 @@
##### Context Functions ##################################################
# The getcontext() and setcontext() function manage access to a thread-local
-# current context. Py2.4 offers direct support for thread locals. If that
-# is not available, use threading.current_thread() which is slower but will
-# work for older Pythons. If threads are not part of the build, create a
-# mock threading object with threading.local() returning the module namespace.
-
-try:
- import threading
-except ImportError:
- # Python was compiled without threads; create a mock object instead
- class MockThreading(object):
- def local(self, sys=sys):
- return sys.modules[__xname__]
- threading = MockThreading()
- del MockThreading
-
-try:
- threading.local
-
-except AttributeError:
-
- # To fix reloading, force it to create a new context
- # Old contexts have different exceptions in their dicts, making problems.
- if hasattr(threading.current_thread(), '__decimal_context__'):
- del threading.current_thread().__decimal_context__
-
- def setcontext(context):
- """Set this thread's context to context."""
- if context in (DefaultContext, BasicContext, ExtendedContext):
- context = context.copy()
- context.clear_flags()
- threading.current_thread().__decimal_context__ = context
-
- def getcontext():
- """Returns this thread's context.
-
- If this thread does not yet have a context, returns
- a new context and sets this thread's context.
- New contexts are copies of DefaultContext.
- """
- try:
- return threading.current_thread().__decimal_context__
- except AttributeError:
- context = Context()
- threading.current_thread().__decimal_context__ = context
- return context
-
-else:
-
- local = threading.local()
- if hasattr(local, '__decimal_context__'):
- del local.__decimal_context__
-
- def getcontext(_local=local):
- """Returns this thread's context.
-
- If this thread does not yet have a context, returns
- a new context and sets this thread's context.
- New contexts are copies of DefaultContext.
- """
- try:
- return _local.__decimal_context__
- except AttributeError:
- context = Context()
- _local.__decimal_context__ = context
- return context
-
- def setcontext(context, _local=local):
- """Set this thread's context to context."""
- if context in (DefaultContext, BasicContext, ExtendedContext):
- context = context.copy()
- context.clear_flags()
- _local.__decimal_context__ = context
-
- del threading, local # Don't contaminate the namespace
+# current context.
+
+import contextvars
+
+_current_context_var = contextvars.ContextVar('decimal_context')
+
+def getcontext():
+ """Returns this thread's context.
+
+ If this thread does not yet have a context, returns
+ a new context and sets this thread's context.
+ New contexts are copies of DefaultContext.
+ """
+ try:
+ return _current_context_var.get()
+ except LookupError:
+ context = Context()
+ _current_context_var.set(context)
+ return context
+
+def setcontext(context):
+ """Set this thread's context to context."""
+ if context in (DefaultContext, BasicContext, ExtendedContext):
+ context = context.copy()
+ context.clear_flags()
+ _current_context_var.set(context)
+
+del contextvars # Don't contaminate the namespace
def localcontext(ctx=None):
"""Return a context manager for a copy of the supplied context
@@ -734,18 +688,23 @@
"""
if isinstance(f, int): # handle integer inputs
- return cls(f)
- if not isinstance(f, float):
+ sign = 0 if f >= 0 else 1
+ k = 0
+ coeff = str(abs(f))
+ elif isinstance(f, float):
+ if _math.isinf(f) or _math.isnan(f):
+ return cls(repr(f))
+ if _math.copysign(1.0, f) == 1.0:
+ sign = 0
+ else:
+ sign = 1
+ n, d = abs(f).as_integer_ratio()
+ k = d.bit_length() - 1
+ coeff = str(n*5**k)
+ else:
raise TypeError("argument must be int or float.")
- if _math.isinf(f) or _math.isnan(f):
- return cls(repr(f))
- if _math.copysign(1.0, f) == 1.0:
- sign = 0
- else:
- sign = 1
- n, d = abs(f).as_integer_ratio()
- k = d.bit_length() - 1
- result = _dec_from_triple(sign, str(n*5**k), -k)
+
+ result = _dec_from_triple(sign, coeff, -k)
if cls is Decimal:
return result
else:
@@ -1669,13 +1628,13 @@
__trunc__ = __int__
+ @property
def real(self):
return self
- real = property(real)
-
+
+ @property
def imag(self):
return Decimal(0)
- imag = property(imag)
def conjugate(self):
return self
diff --git a/lib-python/3/_pyio.py b/lib-python/3/_pyio.py
--- a/lib-python/3/_pyio.py
+++ b/lib-python/3/_pyio.py
@@ -9,10 +9,7 @@
import stat
import sys
# Import _thread instead of threading to reduce startup cost
-try:
- from _thread import allocate_lock as Lock
-except ImportError:
- from _dummy_thread import allocate_lock as Lock
+from _thread import allocate_lock as Lock
if sys.platform in {'win32', 'cygwin'}:
from msvcrt import setmode as _setmode
else:
@@ -290,16 +287,15 @@
derived classes can override selectively; the default implementations
represent a file that cannot be read, written or seeked.
- Even though IOBase does not declare read, readinto, or write because
+ Even though IOBase does not declare read or write because
their signatures will vary, implementations and clients should
consider those methods part of the interface. Also, implementations
may raise UnsupportedOperation when operations they do not support are
called.
The basic type used for binary data read from or written to a file is
- bytes. Other bytes-like objects are accepted as method arguments too. In
- some cases (such as readinto), a writable object is required. Text I/O
- classes work with str data.
+ bytes. Other bytes-like objects are accepted as method arguments too.
+ Text I/O classes work with str data.
Note that calling any method (even inquiries) on a closed stream is
undefined. Implementations may raise OSError in this case.
@@ -504,8 +500,13 @@
return 1
if size is None:
size = -1
- elif not isinstance(size, int):
- raise TypeError("size must be an integer")
+ else:
+ try:
+ size_index = size.__index__
+ except AttributeError:
+ raise TypeError(f"{size!r} is not an integer")
+ else:
+ size = size_index()
res = bytearray()
while size < 0 or len(res) < size:
b = self.read(nreadahead())
@@ -545,6 +546,11 @@
return lines
def writelines(self, lines):
+ """Write a list of lines to the stream.
+
+ Line separators are not added, so it is usual for each of the lines
+ provided to have a line separator at the end.
+ """
self._checkClosed()
for line in lines:
self.write(line)
@@ -635,7 +641,7 @@
implementation, but wrap one.
"""
- def read(self, size=None):
+ def read(self, size=-1):
"""Read and return up to size bytes, where size is an int.
If the argument is omitted, None, or negative, reads and
@@ -655,7 +661,7 @@
"""
self._unsupported("read")
- def read1(self, size=None):
+ def read1(self, size=-1):
"""Read up to size bytes with at most one read() system call,
where size is an int.
"""
@@ -766,7 +772,7 @@
def flush(self):
if self.closed:
- raise ValueError("flush of closed file")
+ raise ValueError("flush on closed file")
self.raw.flush()
def close(self):
@@ -833,6 +839,10 @@
"""Buffered I/O implementation using an in-memory bytes buffer."""
+ # Initialize _buffer as soon as possible since it's used by __del__()
+ # which calls close()
+ _buffer = None
+
def __init__(self, initial_bytes=None):
buf = bytearray()
if initial_bytes is not None:
@@ -860,14 +870,22 @@
return memoryview(self._buffer)
def close(self):
- self._buffer.clear()
+ if self._buffer is not None:
+ self._buffer.clear()
super().close()
- def read(self, size=None):
+ def read(self, size=-1):
if self.closed:
raise ValueError("read from closed file")
if size is None:
size = -1
+ else:
+ try:
+ size_index = size.__index__
+ except AttributeError:
+ raise TypeError(f"{size!r} is not an integer")
+ else:
+ size = size_index()
if size < 0:
size = len(self._buffer)
if len(self._buffer) <= self._pos:
@@ -877,7 +895,7 @@
self._pos = newpos
return bytes(b)
- def read1(self, size):
+ def read1(self, size=-1):
"""This is the same as read.
"""
return self.read(size)
@@ -905,9 +923,11 @@
if self.closed:
raise ValueError("seek on closed file")
try:
- pos.__index__
- except AttributeError as err:
- raise TypeError("an integer is required") from err
+ pos_index = pos.__index__
+ except AttributeError:
+ raise TypeError(f"{pos!r} is not an integer")
+ else:
+ pos = pos_index()
if whence == 0:
if pos < 0:
raise ValueError("negative seek position %r" % (pos,))
@@ -932,9 +952,11 @@
pos = self._pos
else:
try:
- pos.__index__
- except AttributeError as err:
- raise TypeError("an integer is required") from err
+ pos_index = pos.__index__
+ except AttributeError:
+ raise TypeError(f"{pos!r} is not an integer")
+ else:
+ pos = pos_index()
if pos < 0:
raise ValueError("negative truncate position %r" % (pos,))
del self._buffer[pos:]
@@ -1073,12 +1095,12 @@
self._read_pos = 0
return self._read_buf[self._read_pos:]
- def read1(self, size):
+ def read1(self, size=-1):
"""Reads up to size bytes, with at most one read() system call."""
# Returns up to size bytes. If at least one byte is buffered, we
# only return buffered bytes. Otherwise, we do one raw read.
if size < 0:
- raise ValueError("number of bytes to read must be positive")
+ size = self.buffer_size
if size == 0:
return b""
with self._read_lock:
@@ -1174,11 +1196,11 @@
return self.raw.writable()
def write(self, b):
- if self.closed:
- raise ValueError("write to closed file")
if isinstance(b, str):
raise TypeError("can't write str to binary stream")
with self._write_lock:
+ if self.closed:
+ raise ValueError("write to closed file")
# XXX we can implement some more tricks to try and avoid
# partial writes
if len(self._write_buf) > self.buffer_size:
@@ -1214,7 +1236,7 @@
def _flush_unlocked(self):
if self.closed:
- raise ValueError("flush of closed file")
+ raise ValueError("flush on closed file")
while self._write_buf:
try:
n = self.raw.write(self._write_buf)
@@ -1239,6 +1261,21 @@
self._flush_unlocked()
return _BufferedIOMixin.seek(self, pos, whence)
+ def close(self):
+ with self._write_lock:
+ if self.raw is None or self.closed:
+ return
+ # We have to release the lock and call self.flush() (which will
+ # probably just re-take the lock) in case flush has been overridden in
+ # a subclass or the user set self.flush to something. This is the same
+ # behavior as the C implementation.
+ try:
+ # may raise BlockingIOError or BrokenPipeError etc
+ self.flush()
+ finally:
+ with self._write_lock:
+ self.raw.close()
+
class BufferedRWPair(BufferedIOBase):
@@ -1270,7 +1307,7 @@
self.reader = BufferedReader(reader, buffer_size)
self.writer = BufferedWriter(writer, buffer_size)
- def read(self, size=None):
+ def read(self, size=-1):
if size is None:
size = -1
return self.reader.read(size)
@@ -1284,7 +1321,7 @@
def peek(self, size=0):
return self.reader.peek(size)
- def read1(self, size):
+ def read1(self, size=-1):
return self.reader.read1(size)
def readinto1(self, b):
@@ -1370,7 +1407,7 @@
self.flush()
return BufferedReader.peek(self, size)
- def read1(self, size):
+ def read1(self, size=-1):
self.flush()
return BufferedReader.read1(self, size)
@@ -1731,8 +1768,7 @@
"""Base class for text I/O.
This class provides a character and line based interface to stream
- I/O. There is no readinto method because Python's character strings
- are immutable. There is no public constructor.
+ I/O. There is no public constructor.
"""
def read(self, size=-1):
@@ -1905,15 +1941,16 @@
_CHUNK_SIZE = 2048
+ # Initialize _buffer as soon as possible since it's used by __del__()
+ # which calls close()
+ _buffer = None
+
# The write_through argument has no effect here since this
# implementation always writes through. The argument is present only
# so that the signature can match the signature of the C version.
def __init__(self, buffer, encoding=None, errors=None, newline=None,
line_buffering=False, write_through=False):
- if newline is not None and not isinstance(newline, str):
- raise TypeError("illegal newline type: %r" % (type(newline),))
- if newline not in (None, "", "\n", "\r", "\r\n"):
- raise ValueError("illegal newline value: %r" % (newline,))
+ self._check_newline(newline)
if encoding is None:
try:
encoding = os.device_encoding(buffer.fileno())
@@ -1943,23 +1980,38 @@
raise ValueError("invalid errors: %r" % errors)
self._buffer = buffer
- self._line_buffering = line_buffering
+ self._decoded_chars = '' # buffer for text returned from decoder
+ self._decoded_chars_used = 0 # offset into _decoded_chars for read()
+ self._snapshot = None # info for reconstructing decoder state
+ self._seekable = self._telling = self.buffer.seekable()
+ self._has_read1 = hasattr(self.buffer, 'read1')
+ self._configure(encoding, errors, newline,
+ line_buffering, write_through)
+
+ def _check_newline(self, newline):
+ if newline is not None and not isinstance(newline, str):
+ raise TypeError("illegal newline type: %r" % (type(newline),))
+ if newline not in (None, "", "\n", "\r", "\r\n"):
+ raise ValueError("illegal newline value: %r" % (newline,))
+
+ def _configure(self, encoding=None, errors=None, newline=None,
+ line_buffering=False, write_through=False):
self._encoding = encoding
self._errors = errors
+ self._encoder = None
+ self._decoder = None
+ self._b2cratio = 0.0
+
self._readuniversal = not newline
self._readtranslate = newline is None
self._readnl = newline
self._writetranslate = newline != ''
self._writenl = newline or os.linesep
- self._encoder = None
- self._decoder = None
- self._decoded_chars = '' # buffer for text returned from decoder
- self._decoded_chars_used = 0 # offset into _decoded_chars for read()
- self._snapshot = None # info for reconstructing decoder state
- self._seekable = self._telling = self.buffer.seekable()
- self._has_read1 = hasattr(self.buffer, 'read1')
- self._b2cratio = 0.0
-
+
+ self._line_buffering = line_buffering
+ self._write_through = write_through
+
+ # don't write a BOM in the middle of a file
if self._seekable and self.writable():
position = self.buffer.tell()
if position != 0:
@@ -2008,9 +2060,54 @@
return self._line_buffering
@property
+ def write_through(self):
+ return self._write_through
+
+ @property
def buffer(self):
return self._buffer
+ def reconfigure(self, *,
+ encoding=None, errors=None, newline=Ellipsis,
+ line_buffering=None, write_through=None):
+ """Reconfigure the text stream with new parameters.
+
+ This also flushes the stream.
+ """
+ if (self._decoder is not None
+ and (encoding is not None or errors is not None
+ or newline is not Ellipsis)):
+ raise UnsupportedOperation(
+ "It is not possible to set the encoding or newline of stream "
+ "after the first read")
+
+ if errors is None:
+ if encoding is None:
+ errors = self._errors
+ else:
+ errors = 'strict'
+ elif not isinstance(errors, str):
+ raise TypeError("invalid errors: %r" % errors)
+
+ if encoding is None:
+ encoding = self._encoding
+ else:
+ if not isinstance(encoding, str):
+ raise TypeError("invalid encoding: %r" % encoding)
+
+ if newline is Ellipsis:
+ newline = self._readnl
+ self._check_newline(newline)
+
+ if line_buffering is None:
+ line_buffering = self.line_buffering
+ if write_through is None:
+ write_through = self.write_through
+
+ self.flush()
+ self._configure(encoding, errors, newline,
+ line_buffering, write_through)
+
def seekable(self):
if self.closed:
raise ValueError("I/O operation on closed file.")
@@ -2358,11 +2455,14 @@
self._checkReadable()
if size is None:
size = -1
+ else:
+ try:
+ size_index = size.__index__
+ except AttributeError:
+ raise TypeError(f"{size!r} is not an integer")
+ else:
+ size = size_index()
decoder = self._decoder or self._get_decoder()
- try:
- size.__index__
- except AttributeError as err:
- raise TypeError("an integer is required") from err
if size < 0:
# Read everything.
result = (self._get_decoded_chars() +
@@ -2393,8 +2493,13 @@
raise ValueError("read from closed file")
if size is None:
size = -1
- elif not isinstance(size, int):
- raise TypeError("size must be an integer")
+ else:
+ try:
+ size_index = size.__index__
+ except AttributeError:
+ raise TypeError(f"{size!r} is not an integer")
+ else:
+ size = size_index()
# Grab all the decoded text (we will rewind any extra bits later).
line = self._get_decoded_chars()
diff --git a/lib-python/3/_strptime.py b/lib-python/3/_strptime.py
--- a/lib-python/3/_strptime.py
+++ b/lib-python/3/_strptime.py
@@ -19,10 +19,7 @@
from datetime import (date as datetime_date,
timedelta as datetime_timedelta,
timezone as datetime_timezone)
-try:
- from _thread import allocate_lock as _thread_allocate_lock
-except ImportError:
- from _dummy_thread import allocate_lock as _thread_allocate_lock
+from _thread import allocate_lock as _thread_allocate_lock
__all__ = []
@@ -213,7 +210,7 @@
#XXX: Does 'Y' need to worry about having less or more than
# 4 digits?
'Y': r"(?P<Y>\d\d\d\d)",
- 'z': r"(?P<z>[+-]\d\d[0-5]\d)",
+ 'z': r"(?P<z>[+-]\d\d:?[0-5]\d(:?[0-5]\d(\.\d{1,6})?)?|Z)",
'A': self.__seqToRE(self.locale_time.f_weekday, 'A'),
'a': self.__seqToRE(self.locale_time.a_weekday, 'a'),
'B': self.__seqToRE(self.locale_time.f_month[1:], 'B'),
@@ -368,7 +365,8 @@
month = day = 1
hour = minute = second = fraction = 0
tz = -1
- tzoffset = None
+ gmtoff = None
+ gmtoff_fraction = 0
# Default to -1 to signify that values not known; not critical to have,
# though
iso_week = week_of_year = None
@@ -458,9 +456,27 @@
iso_week = int(found_dict['V'])
elif group_key == 'z':
z = found_dict['z']
- tzoffset = int(z[1:3]) * 60 + int(z[3:5])
- if z.startswith("-"):
- tzoffset = -tzoffset
+ if z == 'Z':
+ gmtoff = 0
+ else:
+ if z[3] == ':':
+ z = z[:3] + z[4:]
+ if len(z) > 5:
+ if z[5] != ':':
+ msg = f"Inconsistent use of : in {found_dict['z']}"
+ raise ValueError(msg)
+ z = z[:5] + z[6:]
+ hours = int(z[1:3])
+ minutes = int(z[3:5])
+ seconds = int(z[5:7] or 0)
+ gmtoff = (hours * 60 * 60) + (minutes * 60) + seconds
+ gmtoff_remainder = z[8:]
+ # Pad to always return microseconds.
+ gmtoff_remainder_padding = "0" * (6 - len(gmtoff_remainder))
+ gmtoff_fraction = int(gmtoff_remainder + gmtoff_remainder_padding)
+ if z.startswith("-"):
+ gmtoff = -gmtoff
+ gmtoff_fraction = -gmtoff_fraction
elif group_key == 'Z':
# Since -1 is default value only need to worry about setting tz if
# it can be something other than -1.
@@ -538,10 +554,6 @@
weekday = datetime_date(year, month, day).weekday()
# Add timezone info
tzname = found_dict.get("Z")
- if tzoffset is not None:
- gmtoff = tzoffset * 60
- else:
- gmtoff = None
if leap_year_fix:
# the caller didn't supply a year but asked for Feb 29th. We couldn't
@@ -551,7 +563,7 @@
return (year, month, day,
hour, minute, second,
- weekday, julian, tz, tzname, gmtoff), fraction
+ weekday, julian, tz, tzname, gmtoff), fraction, gmtoff_fraction
def _strptime_time(data_string, format="%a %b %d %H:%M:%S %Y"):
"""Return a time struct based on the input string and the
@@ -562,11 +574,11 @@
def _strptime_datetime(cls, data_string, format="%a %b %d %H:%M:%S %Y"):
"""Return a class cls instance based on the input string and the
format string."""
- tt, fraction = _strptime(data_string, format)
+ tt, fraction, gmtoff_fraction = _strptime(data_string, format)
tzname, gmtoff = tt[-2:]
args = tt[:6] + (fraction,)
if gmtoff is not None:
- tzdelta = datetime_timedelta(seconds=gmtoff)
+ tzdelta = datetime_timedelta(seconds=gmtoff, microseconds=gmtoff_fraction)
if tzname:
tz = datetime_timezone(tzdelta, tzname)
else:
diff --git a/lib-python/3/_weakrefset.py b/lib-python/3/_weakrefset.py
--- a/lib-python/3/_weakrefset.py
+++ b/lib-python/3/_weakrefset.py
@@ -105,7 +105,7 @@
try:
itemref = self.data.pop()
except KeyError:
- raise KeyError('pop from empty WeakSet')
+ raise KeyError('pop from empty WeakSet') from None
item = itemref()
if item is not None:
return item
@@ -164,19 +164,19 @@
__le__ = issubset
def __lt__(self, other):
- return self.data < set(ref(item) for item in other)
+ return self.data < set(map(ref, other))
def issuperset(self, other):
return self.data.issuperset(ref(item) for item in other)
__ge__ = issuperset
def __gt__(self, other):
- return self.data > set(ref(item) for item in other)
+ return self.data > set(map(ref, other))
def __eq__(self, other):
if not isinstance(other, self.__class__):
return NotImplemented
- return self.data == set(ref(item) for item in other)
+ return self.data == set(map(ref, other))
def symmetric_difference(self, other):
newset = self.copy()
diff --git a/lib-python/3/abc.py b/lib-python/3/abc.py
--- a/lib-python/3/abc.py
+++ b/lib-python/3/abc.py
@@ -3,8 +3,6 @@
"""Abstract Base Classes (ABCs) according to PEP 3119."""
-from _weakrefset import WeakSet
-
def abstractmethod(funcobj):
"""A decorator indicating abstract methods.
@@ -27,8 +25,7 @@
class abstractclassmethod(classmethod):
- """
- A decorator indicating abstract classmethods.
+ """A decorator indicating abstract classmethods.
Similar to abstractmethod.
@@ -51,8 +48,7 @@
class abstractstaticmethod(staticmethod):
- """
- A decorator indicating abstract staticmethods.
+ """A decorator indicating abstract staticmethods.
Similar to abstractmethod.
@@ -75,8 +71,7 @@
class abstractproperty(property):
- """
- A decorator indicating abstract properties.
+ """A decorator indicating abstract properties.
Requires that the metaclass is ABCMeta or derived from it. A
class that has a metaclass derived from ABCMeta cannot be
@@ -106,145 +101,70 @@
__isabstractmethod__ = True
-class ABCMeta(type):
+try:
+ from _abc import (get_cache_token, _abc_init, _abc_register,
+ _abc_instancecheck, _abc_subclasscheck, _get_dump,
+ _reset_registry, _reset_caches)
+except ImportError:
+ from _py_abc import ABCMeta, get_cache_token
+ ABCMeta.__module__ = 'abc'
+else:
+ class ABCMeta(type):
+ """Metaclass for defining Abstract Base Classes (ABCs).
- """Metaclass for defining Abstract Base Classes (ABCs).
+ Use this metaclass to create an ABC. An ABC can be subclassed
+ directly, and then acts as a mix-in class. You can also register
+ unrelated concrete classes (even built-in classes) and unrelated
+ ABCs as 'virtual subclasses' -- these and their descendants will
+ be considered subclasses of the registering ABC by the built-in
+ issubclass() function, but the registering ABC won't show up in
+ their MRO (Method Resolution Order) nor will method
+ implementations defined by the registering ABC be callable (not
+ even via super()).
+ """
+ def __new__(mcls, name, bases, namespace, **kwargs):
+ cls = super().__new__(mcls, name, bases, namespace, **kwargs)
+ _abc_init(cls)
+ return cls
- Use this metaclass to create an ABC. An ABC can be subclassed
- directly, and then acts as a mix-in class. You can also register
- unrelated concrete classes (even built-in classes) and unrelated
- ABCs as 'virtual subclasses' -- these and their descendants will
- be considered subclasses of the registering ABC by the built-in
- issubclass() function, but the registering ABC won't show up in
- their MRO (Method Resolution Order) nor will method
- implementations defined by the registering ABC be callable (not
- even via super()).
+ def register(cls, subclass):
+ """Register a virtual subclass of an ABC.
- """
+ Returns the subclass, to allow usage as a class decorator.
+ """
+ return _abc_register(cls, subclass)
- # A global counter that is incremented each time a class is
- # registered as a virtual subclass of anything. It forces the
- # negative cache to be cleared before its next use.
- # Note: this counter is private. Use `abc.get_cache_token()` for
- # external code.
- _abc_invalidation_counter = 0
+ def __instancecheck__(cls, instance):
+ """Override for isinstance(instance, cls)."""
+ return _abc_instancecheck(cls, instance)
- def __new__(mcls, name, bases, namespace, **kwargs):
- cls = super().__new__(mcls, name, bases, namespace, **kwargs)
- # Compute set of abstract method names
- abstracts = {name
- for name, value in namespace.items()
- if getattr(value, "__isabstractmethod__", False)}
- for base in bases:
- for name in getattr(base, "__abstractmethods__", set()):
- value = getattr(cls, name, None)
- if getattr(value, "__isabstractmethod__", False):
- abstracts.add(name)
- cls.__abstractmethods__ = frozenset(abstracts)
- # Set up inheritance registry
- cls._abc_registry = WeakSet()
- cls._abc_cache = WeakSet()
- cls._abc_negative_cache = WeakSet()
- cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
- return cls
+ def __subclasscheck__(cls, subclass):
+ """Override for issubclass(subclass, cls)."""
+ return _abc_subclasscheck(cls, subclass)
- def register(cls, subclass):
- """Register a virtual subclass of an ABC.
+ def _dump_registry(cls, file=None):
+ """Debug helper to print the ABC registry."""
+ print(f"Class: {cls.__module__}.{cls.__qualname__}", file=file)
+ print(f"Inv. counter: {get_cache_token()}", file=file)
+ (_abc_registry, _abc_cache, _abc_negative_cache,
+ _abc_negative_cache_version) = _get_dump(cls)
+ print(f"_abc_registry: {_abc_registry!r}", file=file)
+ print(f"_abc_cache: {_abc_cache!r}", file=file)
+ print(f"_abc_negative_cache: {_abc_negative_cache!r}", file=file)
+ print(f"_abc_negative_cache_version: {_abc_negative_cache_version!r}",
+ file=file)
- Returns the subclass, to allow usage as a class decorator.
- """
- if not isinstance(subclass, type):
- raise TypeError("Can only register classes")
- if issubclass(subclass, cls):
- return subclass # Already a subclass
- # Subtle: test for cycles *after* testing for "already a subclass";
- # this means we allow X.register(X) and interpret it as a no-op.
- if issubclass(cls, subclass):
- # This would create a cycle, which is bad for the algorithm below
- raise RuntimeError("Refusing to create an inheritance cycle")
- cls._abc_registry.add(subclass)
- ABCMeta._abc_invalidation_counter += 1 # Invalidate negative cache
- return subclass
+ def _abc_registry_clear(cls):
+ """Clear the registry (for debugging or testing)."""
+ _reset_registry(cls)
- def _dump_registry(cls, file=None):
- """Debug helper to print the ABC registry."""
- print("Class: %s.%s" % (cls.__module__, cls.__qualname__), file=file)
- print("Inv.counter: %s" % ABCMeta._abc_invalidation_counter, file=file)
- for name in sorted(cls.__dict__):
- if name.startswith("_abc_"):
- value = getattr(cls, name)
- if isinstance(value, WeakSet):
- value = set(value)
- print("%s: %r" % (name, value), file=file)
-
- def __instancecheck__(cls, instance):
- """Override for isinstance(instance, cls)."""
- # Inline the cache checking
- subclass = instance.__class__
- if subclass in cls._abc_cache:
- return True
- subtype = type(instance)
- if subtype is subclass:
- if (cls._abc_negative_cache_version ==
- ABCMeta._abc_invalidation_counter and
- subclass in cls._abc_negative_cache):
- return False
- # Fall back to the subclass check.
- return cls.__subclasscheck__(subclass)
- return any(cls.__subclasscheck__(c) for c in {subclass, subtype})
-
- def __subclasscheck__(cls, subclass):
- """Override for issubclass(subclass, cls)."""
- # Check cache
- if subclass in cls._abc_cache:
- return True
- # Check negative cache; may have to invalidate
- if cls._abc_negative_cache_version < ABCMeta._abc_invalidation_counter:
- # Invalidate the negative cache
- cls._abc_negative_cache = WeakSet()
- cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
- elif subclass in cls._abc_negative_cache:
- return False
- # Check the subclass hook
- ok = cls.__subclasshook__(subclass)
- if ok is not NotImplemented:
- assert isinstance(ok, bool)
- if ok:
- cls._abc_cache.add(subclass)
- else:
- cls._abc_negative_cache.add(subclass)
- return ok
- # Check if it's a direct subclass
- if cls in getattr(subclass, '__mro__', ()):
- cls._abc_cache.add(subclass)
- return True
- # Check if it's a subclass of a registered class (recursive)
- for rcls in cls._abc_registry:
- if issubclass(subclass, rcls):
- cls._abc_cache.add(subclass)
- return True
- # Check if it's a subclass of a subclass (recursive)
- for scls in cls.__subclasses__():
- if issubclass(subclass, scls):
- cls._abc_cache.add(subclass)
- return True
- # No dice; update negative cache
- cls._abc_negative_cache.add(subclass)
- return False
+ def _abc_caches_clear(cls):
+ """Clear the caches (for debugging or testing)."""
+ _reset_caches(cls)
class ABC(metaclass=ABCMeta):
"""Helper class that provides a standard way to create an ABC using
inheritance.
"""
- pass
-
-
-def get_cache_token():
- """Returns the current ABC cache token.
-
- The token is an opaque object (supporting equality testing) identifying the
- current version of the ABC cache for virtual subclasses. The token changes
- with every call to ``register()`` on any ABC.
- """
- return ABCMeta._abc_invalidation_counter
+ __slots__ = ()
diff --git a/lib-python/3/aifc.py b/lib-python/3/aifc.py
--- a/lib-python/3/aifc.py
+++ b/lib-python/3/aifc.py
@@ -149,25 +149,25 @@
try:
return struct.unpack('>l', file.read(4))[0]
except struct.error:
- raise EOFError
+ raise EOFError from None
def _read_ulong(file):
try:
return struct.unpack('>L', file.read(4))[0]
except struct.error:
- raise EOFError
+ raise EOFError from None
def _read_short(file):
try:
return struct.unpack('>h', file.read(2))[0]
except struct.error:
- raise EOFError
+ raise EOFError from None
def _read_ushort(file):
try:
return struct.unpack('>H', file.read(2))[0]
except struct.error:
- raise EOFError
+ raise EOFError from None
def _read_string(file):
length = ord(file.read(1))
@@ -467,6 +467,10 @@
self._nframes = _read_long(chunk)
self._sampwidth = (_read_short(chunk) + 7) // 8
self._framerate = int(_read_float(chunk))
+ if self._sampwidth <= 0:
+ raise Error('bad sample width')
+ if self._nchannels <= 0:
+ raise Error('bad # of channels')
self._framesize = self._nchannels * self._sampwidth
if self._aifc:
#DEBUG: SGI's soundeditor produces a bad size :-(
@@ -916,7 +920,10 @@
else:
raise Error("mode must be 'r', 'rb', 'w', or 'wb'")
-openfp = open # B/W compatibility
+def openfp(f, mode=None):
+ warnings.warn("aifc.openfp is deprecated since Python 3.7. "
+ "Use aifc.open instead.", DeprecationWarning, stacklevel=2)
+ return open(f, mode=mode)
if __name__ == '__main__':
import sys
diff --git a/lib-python/3/argparse.py b/lib-python/3/argparse.py
--- a/lib-python/3/argparse.py
+++ b/lib-python/3/argparse.py
@@ -83,16 +83,12 @@
]
-import collections as _collections
-import copy as _copy
import os as _os
import re as _re
import sys as _sys
-import textwrap as _textwrap
from gettext import gettext as _, ngettext
-
SUPPRESS = '==SUPPRESS=='
OPTIONAL = '?'
@@ -137,10 +133,16 @@
return []
-def _ensure_value(namespace, name, value):
- if getattr(namespace, name, None) is None:
- setattr(namespace, name, value)
- return getattr(namespace, name)
+def _copy_items(items):
+ if items is None:
+ return []
+ # The copy module is used only in the 'append' and 'append_const'
+ # actions, and it is needed only when the default value isn't a list.
+ # Delay its import for speeding up the common case.
+ if type(items) is list:
+ return items[:]
+ import copy
+ return copy.copy(items)
# ===============
@@ -591,6 +593,8 @@
result = '...'
elif action.nargs == PARSER:
result = '%s ...' % get_metavar(1)
+ elif action.nargs == SUPPRESS:
+ result = ''
else:
formats = ['%s' for _ in range(action.nargs)]
result = ' '.join(formats) % get_metavar(action.nargs)
@@ -621,12 +625,17 @@
def _split_lines(self, text, width):
text = self._whitespace_matcher.sub(' ', text).strip()
- return _textwrap.wrap(text, width)
+ # The textwrap module is used only for formatting help.
+ # Delay its import for speeding up the common usage of argparse.
+ import textwrap
+ return textwrap.wrap(text, width)
def _fill_text(self, text, width, indent):
text = self._whitespace_matcher.sub(' ', text).strip()
- return _textwrap.fill(text, width, initial_indent=indent,
- subsequent_indent=indent)
+ import textwrap
+ return textwrap.fill(text, width,
+ initial_indent=indent,
+ subsequent_indent=indent)
def _get_help_string(self, action):
return action.help
@@ -954,7 +963,8 @@
metavar=metavar)
def __call__(self, parser, namespace, values, option_string=None):
- items = _copy.copy(_ensure_value(namespace, self.dest, []))
+ items = getattr(namespace, self.dest, None)
+ items = _copy_items(items)
items.append(values)
setattr(namespace, self.dest, items)
@@ -980,7 +990,8 @@
metavar=metavar)
def __call__(self, parser, namespace, values, option_string=None):
- items = _copy.copy(_ensure_value(namespace, self.dest, []))
+ items = getattr(namespace, self.dest, None)
+ items = _copy_items(items)
items.append(self.const)
setattr(namespace, self.dest, items)
@@ -1002,8 +1013,10 @@
help=help)
def __call__(self, parser, namespace, values, option_string=None):
- new_count = _ensure_value(namespace, self.dest, 0) + 1
- setattr(namespace, self.dest, new_count)
+ count = getattr(namespace, self.dest, None)
+ if count is None:
+ count = 0
+ setattr(namespace, self.dest, count + 1)
class _HelpAction(Action):
@@ -1068,12 +1081,13 @@
prog,
parser_class,
dest=SUPPRESS,
+ required=False,
help=None,
metavar=None):
self._prog_prefix = prog
self._parser_class = parser_class
- self._name_parser_map = _collections.OrderedDict()
+ self._name_parser_map = {}
self._choices_actions = []
super(_SubParsersAction, self).__init__(
@@ -1081,6 +1095,7 @@
dest=dest,
nargs=PARSER,
choices=self._name_parser_map,
+ required=required,
help=help,
metavar=metavar)
@@ -2228,6 +2243,10 @@
elif nargs == PARSER:
nargs_pattern = '(-*A[-AO]*)'
+ # suppress action, like nargs=0
+ elif nargs == SUPPRESS:
+ nargs_pattern = '(-*-*)'
+
# all others should be integers
else:
nargs_pattern = '(-*%s-*)' % '-*'.join('A' * nargs)
@@ -2241,6 +2260,91 @@
return nargs_pattern
# ========================
+ # Alt command line argument parsing, allowing free intermix
+ # ========================
+
+ def parse_intermixed_args(self, args=None, namespace=None):
+ args, argv = self.parse_known_intermixed_args(args, namespace)
+ if argv:
+ msg = _('unrecognized arguments: %s')
+ self.error(msg % ' '.join(argv))
+ return args
+
+ def parse_known_intermixed_args(self, args=None, namespace=None):
+ # returns a namespace and list of extras
+ #
+ # positional can be freely intermixed with optionals. optionals are
+ # first parsed with all positional arguments deactivated. The 'extras'
+ # are then parsed. If the parser definition is incompatible with the
+ # intermixed assumptions (e.g. use of REMAINDER, subparsers) a
+ # TypeError is raised.
+ #
+ # positionals are 'deactivated' by setting nargs and default to
+ # SUPPRESS. This blocks the addition of that positional to the
+ # namespace
+
+ positionals = self._get_positional_actions()
+ a = [action for action in positionals
+ if action.nargs in [PARSER, REMAINDER]]
+ if a:
+ raise TypeError('parse_intermixed_args: positional arg'
+ ' with nargs=%s'%a[0].nargs)
+
+ if [action.dest for group in self._mutually_exclusive_groups
+ for action in group._group_actions if action in positionals]:
+ raise TypeError('parse_intermixed_args: positional in'
+ ' mutuallyExclusiveGroup')
+
+ try:
+ save_usage = self.usage
+ try:
+ if self.usage is None:
+ # capture the full usage for use in error messages
+ self.usage = self.format_usage()[7:]
+ for action in positionals:
+ # deactivate positionals
+ action.save_nargs = action.nargs
+ # action.nargs = 0
+ action.nargs = SUPPRESS
+ action.save_default = action.default
+ action.default = SUPPRESS
+ namespace, remaining_args = self.parse_known_args(args,
+ namespace)
+ for action in positionals:
+ # remove the empty positional values from namespace
+ if (hasattr(namespace, action.dest)
+ and getattr(namespace, action.dest)==[]):
+ from warnings import warn
+ warn('Do not expect %s in %s' % (action.dest, namespace))
+ delattr(namespace, action.dest)
+ finally:
+ # restore nargs and usage before exiting
+ for action in positionals:
+ action.nargs = action.save_nargs
+ action.default = action.save_default
+ optionals = self._get_optional_actions()
+ try:
+ # parse positionals. optionals aren't normally required, but
+ # they could be, so make sure they aren't.
+ for action in optionals:
+ action.save_required = action.required
+ action.required = False
+ for group in self._mutually_exclusive_groups:
+ group.save_required = group.required
+ group.required = False
+ namespace, extras = self.parse_known_args(remaining_args,
+ namespace)
+ finally:
+ # restore parser values before exiting
+ for action in optionals:
+ action.required = action.save_required
+ for group in self._mutually_exclusive_groups:
+ group.required = group.save_required
+ finally:
+ self.usage = save_usage
+ return namespace, extras
+
+ # ========================
# Value conversion methods
# ========================
def _get_values(self, action, arg_strings):
@@ -2286,6 +2390,10 @@
value = [self._get_value(action, v) for v in arg_strings]
self._check_value(action, value[0])
+ # SUPPRESS argument does not put anything in the namespace
+ elif action.nargs == SUPPRESS:
+ value = SUPPRESS
+
# all other types of nargs produce a list
else:
value = [self._get_value(action, v) for v in arg_strings]
diff --git a/lib-python/3/ast.py b/lib-python/3/ast.py
--- a/lib-python/3/ast.py
+++ b/lib-python/3/ast.py
@@ -35,8 +35,6 @@
return compile(source, filename, mode, PyCF_ONLY_AST)
-_NUM_TYPES = (int, float, complex)
-
def literal_eval(node_or_string):
"""
Safely evaluate an expression node or a string containing a Python
@@ -48,6 +46,21 @@
node_or_string = parse(node_or_string, mode='eval')
if isinstance(node_or_string, Expression):
node_or_string = node_or_string.body
+ def _convert_num(node):
+ if isinstance(node, Constant):
+ if isinstance(node.value, (int, float, complex)):
+ return node.value
+ elif isinstance(node, Num):
+ return node.n
+ raise ValueError('malformed node or string: ' + repr(node))
+ def _convert_signed_num(node):
+ if isinstance(node, UnaryOp) and isinstance(node.op, (UAdd, USub)):
+ operand = _convert_num(node.operand)
+ if isinstance(node.op, UAdd):
+ return + operand
+ else:
+ return - operand
+ return _convert_num(node)
def _convert(node):
if isinstance(node, Constant):
return node.value
@@ -62,26 +75,19 @@
elif isinstance(node, Set):
return set(map(_convert, node.elts))
elif isinstance(node, Dict):
- return dict((_convert(k), _convert(v)) for k, v
- in zip(node.keys, node.values))
+ return dict(zip(map(_convert, node.keys),
+ map(_convert, node.values)))
elif isinstance(node, NameConstant):
return node.value
- elif isinstance(node, UnaryOp) and isinstance(node.op, (UAdd, USub)):
- operand = _convert(node.operand)
- if isinstance(operand, _NUM_TYPES):
- if isinstance(node.op, UAdd):
- return + operand
- else:
- return - operand
elif isinstance(node, BinOp) and isinstance(node.op, (Add, Sub)):
- left = _convert(node.left)
- right = _convert(node.right)
- if isinstance(left, _NUM_TYPES) and isinstance(right, _NUM_TYPES):
+ left = _convert_signed_num(node.left)
+ right = _convert_num(node.right)
+ if isinstance(left, (int, float)) and isinstance(right, complex):
if isinstance(node.op, Add):
return left + right
else:
return left - right
- raise ValueError('malformed node or string: ' + repr(node))
+ return _convert_signed_num(node)
return _convert(node_or_string)
@@ -194,18 +200,21 @@
Return the docstring for the given node or None if no docstring can
be found. If the node provided does not have docstrings a TypeError
will be raised.
+
+ If *clean* is `True`, all tabs are expanded to spaces and any whitespace
+ that can be uniformly removed from the second line onwards is removed.
"""
if not isinstance(node, (AsyncFunctionDef, FunctionDef, ClassDef, Module)):
raise TypeError("%r can't have docstrings" % node.__class__.__name__)
if not(node.body and isinstance(node.body[0], Expr)):
- return
+ return None
node = node.body[0].value
if isinstance(node, Str):
text = node.s
elif isinstance(node, Constant) and isinstance(node.value, str):
text = node.value
else:
- return
+ return None
if clean:
import inspect
text = inspect.cleandoc(text)
diff --git a/lib-python/3/asyncio/__init__.py b/lib-python/3/asyncio/__init__.py
--- a/lib-python/3/asyncio/__init__.py
+++ b/lib-python/3/asyncio/__init__.py
@@ -1,22 +1,9 @@
"""The asyncio package, tracking PEP 3156."""
+# flake8: noqa
+
import sys
-# The selectors module is in the stdlib in Python 3.4 but not in 3.3.
-# Do this first, so the other submodules can use "from . import selectors".
-# Prefer asyncio/selectors.py over the stdlib one, as ours may be newer.
-try:
- from . import selectors
-except ImportError:
- import selectors # Will also be exported.
-
-if sys.platform == 'win32':
- # Similar thing for _overlapped.
- try:
- from . import _overlapped
- except ImportError:
- import _overlapped # Will also be exported.
-
# This relies on each of the submodules having an __all__ variable.
from .base_events import *
from .coroutines import *
@@ -24,18 +11,24 @@
from .futures import *
from .locks import *
from .protocols import *
+from .runners import *
from .queues import *
from .streams import *
from .subprocess import *
from .tasks import *
from .transports import *
+# Exposed for _asynciomodule.c to implement now deprecated
+# Task.all_tasks() method. This function will be removed in 3.9.
+from .tasks import _all_tasks_compat # NoQA
+
__all__ = (base_events.__all__ +
coroutines.__all__ +
events.__all__ +
futures.__all__ +
locks.__all__ +
protocols.__all__ +
+ runners.__all__ +
queues.__all__ +
streams.__all__ +
subprocess.__all__ +
diff --git a/lib-python/3/asyncio/base_events.py b/lib-python/3/asyncio/base_events.py
--- a/lib-python/3/asyncio/base_events.py
+++ b/lib-python/3/asyncio/base_events.py
@@ -14,9 +14,9 @@
"""
import collections
+import collections.abc
import concurrent.futures
import heapq
-import inspect
import itertools
import logging
import os
@@ -29,16 +29,23 @@
import warnings
import weakref
-from . import compat
+try:
+ import ssl
+except ImportError: # pragma: no cover
+ ssl = None
+
+from . import constants
from . import coroutines
from . import events
from . import futures
+from . import protocols
+from . import sslproto
from . import tasks
-from .coroutines import coroutine
+from . import transports
from .log import logger
-__all__ = ['BaseEventLoop']
+__all__ = 'BaseEventLoop',
# Minimum number of _scheduled timer handles before cleanup of
@@ -49,11 +56,6 @@
# before cleanup of cancelled handles is performed.
_MIN_CANCELLED_TIMER_HANDLES_FRACTION = 0.5
-# Exceptions which must not call the exception handler in fatal error
-# methods (_fatal_error())
-_FATAL_ERROR_IGNORE = (BrokenPipeError,
- ConnectionResetError, ConnectionAbortedError)
-
_HAS_IPv6 = hasattr(socket, 'AF_INET6')
# Maximum timeout passed to select to avoid OS limitations
@@ -89,27 +91,7 @@
'SO_REUSEPORT defined but not implemented.')
-def _is_stream_socket(sock_type):
- if hasattr(socket, 'SOCK_NONBLOCK'):
- # Linux's socket.type is a bitmask that can include extra info
- # about socket (like SOCK_NONBLOCK bit), therefore we can't do simple
- # `sock_type == socket.SOCK_STREAM`, see
- # https://github.com/torvalds/linux/blob/v4.13/include/linux/net.h#L77
- # for more details.
- return (sock_type & 0xF) == socket.SOCK_STREAM
- else:
- return sock_type == socket.SOCK_STREAM
-
-
-def _is_dgram_socket(sock_type):
- if hasattr(socket, 'SOCK_NONBLOCK'):
- # See the comment in `_is_stream_socket`.
- return (sock_type & 0xF) == socket.SOCK_DGRAM
- else:
- return sock_type == socket.SOCK_DGRAM
-
-
-def _ipaddr_info(host, port, family, type, proto):
+def _ipaddr_info(host, port, family, type, proto, flowinfo=0, scopeid=0):
# Try to skip getaddrinfo if "host" is already an IP. Users might have
# handled name resolution in their own code and pass in resolved IPs.
if not hasattr(socket, 'inet_pton'):
@@ -119,9 +101,9 @@
host is None:
return None
- if _is_stream_socket(type):
+ if type == socket.SOCK_STREAM:
proto = socket.IPPROTO_TCP
- elif _is_dgram_socket(type):
+ elif type == socket.SOCK_DGRAM:
proto = socket.IPPROTO_UDP
else:
return None
@@ -158,7 +140,7 @@
socket.inet_pton(af, host)
# The host has already been resolved.
if _HAS_IPv6 and af == socket.AF_INET6:
- return af, type, proto, '', (host, port, 0, 0)
+ return af, type, proto, '', (host, port, flowinfo, scopeid)
else:
return af, type, proto, '', (host, port)
except OSError:
@@ -168,24 +150,20 @@
return None
-def _ensure_resolved(address, *, family=0, type=socket.SOCK_STREAM, proto=0,
- flags=0, loop):
- host, port = address[:2]
- info = _ipaddr_info(host, port, family, type, proto)
- if info is not None:
- # "host" is already a resolved IP.
- fut = loop.create_future()
- fut.set_result([info])
- return fut
- else:
- return loop.getaddrinfo(host, port, family=family, type=type,
- proto=proto, flags=flags)
+def _run_until_complete_cb(fut):
+ if not fut.cancelled():
+ exc = fut.exception()
+ if isinstance(exc, BaseException) and not isinstance(exc, Exception):
+ # Issue #22429: run_forever() already finished, no need to
+ # stop it.
+ return
+ futures._get_loop(fut).stop()
if hasattr(socket, 'TCP_NODELAY'):
def _set_nodelay(sock):
if (sock.family in {socket.AF_INET, socket.AF_INET6} and
- _is_stream_socket(sock.type) and
+ sock.type == socket.SOCK_STREAM and
sock.proto == socket.IPPROTO_TCP):
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
else:
@@ -193,45 +171,100 @@
pass
-def _run_until_complete_cb(fut):
- exc = fut._exception
- if (isinstance(exc, BaseException)
- and not isinstance(exc, Exception)):
- # Issue #22429: run_forever() already finished, no need to
- # stop it.
- return
- fut._loop.stop()
+class _SendfileFallbackProtocol(protocols.Protocol):
+ def __init__(self, transp):
+ if not isinstance(transp, transports._FlowControlMixin):
+ raise TypeError("transport should be _FlowControlMixin instance")
+ self._transport = transp
+ self._proto = transp.get_protocol()
+ self._should_resume_reading = transp.is_reading()
+ self._should_resume_writing = transp._protocol_paused
+ transp.pause_reading()
+ transp.set_protocol(self)
+ if self._should_resume_writing:
+ self._write_ready_fut = self._transport._loop.create_future()
+ else:
+ self._write_ready_fut = None
+
+ async def drain(self):
+ if self._transport.is_closing():
+ raise ConnectionError("Connection closed by peer")
+ fut = self._write_ready_fut
+ if fut is None:
+ return
+ await fut
+
+ def connection_made(self, transport):
+ raise RuntimeError("Invalid state: "
+ "connection should have been established already.")
+
+ def connection_lost(self, exc):
+ if self._write_ready_fut is not None:
+ # Never happens if peer disconnects after sending the whole content
+ # Thus disconnection is always an exception from user perspective
+ if exc is None:
+ self._write_ready_fut.set_exception(
+ ConnectionError("Connection is closed by peer"))
+ else:
+ self._write_ready_fut.set_exception(exc)
+ self._proto.connection_lost(exc)
+
+ def pause_writing(self):
+ if self._write_ready_fut is not None:
+ return
+ self._write_ready_fut = self._transport._loop.create_future()
+
+ def resume_writing(self):
+ if self._write_ready_fut is None:
+ return
+ self._write_ready_fut.set_result(False)
+ self._write_ready_fut = None
+
+ def data_received(self, data):
+ raise RuntimeError("Invalid state: reading should be paused")
+
+ def eof_received(self):
+ raise RuntimeError("Invalid state: reading should be paused")
+
+ async def restore(self):
+ self._transport.set_protocol(self._proto)
+ if self._should_resume_reading:
+ self._transport.resume_reading()
+ if self._write_ready_fut is not None:
+ # Cancel the future.
+ # Basically it has no effect because protocol is switched back,
+ # no code should wait for it anymore.
+ self._write_ready_fut.cancel()
+ if self._should_resume_writing:
+ self._proto.resume_writing()
class Server(events.AbstractServer):
- def __init__(self, loop, sockets):
+ def __init__(self, loop, sockets, protocol_factory, ssl_context, backlog,
+ ssl_handshake_timeout):
self._loop = loop
- self.sockets = sockets
+ self._sockets = sockets
self._active_count = 0
self._waiters = []
+ self._protocol_factory = protocol_factory
+ self._backlog = backlog
+ self._ssl_context = ssl_context
+ self._ssl_handshake_timeout = ssl_handshake_timeout
+ self._serving = False
+ self._serving_forever_fut = None
def __repr__(self):
- return '<%s sockets=%r>' % (self.__class__.__name__, self.sockets)
+ return f'<{self.__class__.__name__} sockets={self.sockets!r}>'
def _attach(self):
- assert self.sockets is not None
+ assert self._sockets is not None
self._active_count += 1
def _detach(self):
assert self._active_count > 0
self._active_count -= 1
- if self._active_count == 0 and self.sockets is None:
- self._wakeup()
-
- def close(self):
- sockets = self.sockets
- if sockets is None:
- return
- self.sockets = None
- for sock in sockets:
- self._loop._stop_serving(sock)
- if self._active_count == 0:
+ if self._active_count == 0 and self._sockets is None:
self._wakeup()
def _wakeup(self):
@@ -241,13 +274,80 @@
if not waiter.done():
waiter.set_result(waiter)
- @coroutine
- def wait_closed(self):
- if self.sockets is None or self._waiters is None:
+ def _start_serving(self):
+ if self._serving:
+ return
More information about the pypy-commit
mailing list