kopia lustrzana https://github.com/micropython/micropython-lib
161 wiersze
4.6 KiB
Python
161 wiersze
4.6 KiB
Python
"""Utilities for with-statement contexts. See PEP 343.
|
|
|
|
Original source code: https://hg.python.org/cpython/file/3.4/Lib/contextlib.py
|
|
|
|
Not implemented:
|
|
- redirect_stdout;
|
|
- ExitStack.
|
|
|
|
"""
|
|
|
|
class ContextDecorator(object):
|
|
"A base class or mixin that enables context managers to work as decorators."
|
|
|
|
def _recreate_cm(self):
|
|
"""Return a recreated instance of self.
|
|
|
|
Allows an otherwise one-shot context manager like
|
|
_GeneratorContextManager to support use as
|
|
a decorator via implicit recreation.
|
|
|
|
This is a private interface just for _GeneratorContextManager.
|
|
See issue #11647 for details.
|
|
"""
|
|
return self
|
|
|
|
def __call__(self, func):
|
|
def inner(*args, **kwds):
|
|
with self._recreate_cm():
|
|
return func(*args, **kwds)
|
|
return inner
|
|
|
|
|
|
class _GeneratorContextManager(ContextDecorator):
|
|
"""Helper for @contextmanager decorator."""
|
|
|
|
def __init__(self, func, *args, **kwds):
|
|
self.gen = func(*args, **kwds)
|
|
self.func, self.args, self.kwds = func, args, kwds
|
|
|
|
def _recreate_cm(self):
|
|
# _GCM instances are one-shot context managers, so the
|
|
# CM must be recreated each time a decorated function is
|
|
# called
|
|
return self.__class__(self.func, *self.args, **self.kwds)
|
|
|
|
def __enter__(self):
|
|
try:
|
|
return next(self.gen)
|
|
except StopIteration:
|
|
raise RuntimeError("generator didn't yield") from None
|
|
|
|
def __exit__(self, type, value, traceback):
|
|
if type is None:
|
|
try:
|
|
next(self.gen)
|
|
except StopIteration:
|
|
return
|
|
else:
|
|
raise RuntimeError("generator didn't stop")
|
|
else:
|
|
if value is None:
|
|
# Need to force instantiation so we can reliably
|
|
# tell if we get the same exception back
|
|
value = type()
|
|
try:
|
|
self.gen.throw(type, value, traceback)
|
|
raise RuntimeError("generator didn't stop after throw()")
|
|
except StopIteration as exc:
|
|
# Suppress the exception *unless* it's the same exception that
|
|
# was passed to throw(). This prevents a StopIteration
|
|
# raised inside the "with" statement from being suppressed
|
|
return exc is not value
|
|
|
|
|
|
def contextmanager(func):
|
|
"""@contextmanager decorator.
|
|
|
|
Typical usage:
|
|
|
|
@contextmanager
|
|
def some_generator(<arguments>):
|
|
<setup>
|
|
try:
|
|
yield <value>
|
|
finally:
|
|
<cleanup>
|
|
|
|
This makes this:
|
|
|
|
with some_generator(<arguments>) as <variable>:
|
|
<body>
|
|
|
|
equivalent to this:
|
|
|
|
<setup>
|
|
try:
|
|
<variable> = <value>
|
|
<body>
|
|
finally:
|
|
<cleanup>
|
|
|
|
"""
|
|
def helper(*args, **kwds):
|
|
return _GeneratorContextManager(func, *args, **kwds)
|
|
return helper
|
|
|
|
|
|
class closing(object):
|
|
"""Context to automatically close something at the end of a block.
|
|
|
|
Code like this:
|
|
|
|
with closing(<module>.open(<arguments>)) as f:
|
|
<block>
|
|
|
|
is equivalent to this:
|
|
|
|
f = <module>.open(<arguments>)
|
|
try:
|
|
<block>
|
|
finally:
|
|
f.close()
|
|
|
|
"""
|
|
def __init__(self, thing):
|
|
self.thing = thing
|
|
def __enter__(self):
|
|
return self.thing
|
|
def __exit__(self, *exc_info):
|
|
self.thing.close()
|
|
|
|
|
|
class suppress:
|
|
"""Context manager to suppress specified exceptions
|
|
|
|
After the exception is suppressed, execution proceeds with the next
|
|
statement following the with statement.
|
|
|
|
with suppress(FileNotFoundError):
|
|
os.remove(somefile)
|
|
# Execution still resumes here if the file was already removed
|
|
"""
|
|
|
|
def __init__(self, *exceptions):
|
|
self._exceptions = exceptions
|
|
|
|
def __enter__(self):
|
|
pass
|
|
|
|
def __exit__(self, exctype, excinst, exctb):
|
|
# Unlike isinstance and issubclass, CPython exception handling
|
|
# currently only looks at the concrete type hierarchy (ignoring
|
|
# the instance and subclass checking hooks). While Guido considers
|
|
# that a bug rather than a feature, it's a fairly hard one to fix
|
|
# due to various internal implementation details. suppress provides
|
|
# the simpler issubclass based semantics, rather than trying to
|
|
# exactly reproduce the limitations of the CPython interpreter.
|
|
#
|
|
# See http://bugs.python.org/issue12029 for more details
|
|
return exctype is not None and issubclass(exctype, self._exceptions)
|