Импровизация замены для оператора «с» для Python 2.4

Question

Можете ли вы предложить способ замещения вставной замены для оператора with, который будет работать в Python 2.4?

Это был бы взлом, но это позволило бы мне более красиво перенести мой проект на Python 2.4.

EDIT: Удален неактуальный эскиз метакласса

Answer 1

Просто используйте try-finally.

На самом деле, это может быть полезно как умственное упражнение, но если вы действительно сделаете это в коде, который вам небезразличен, вы получите уродливый, сложный в обслуживании код.

Answer 2

Вы можете (ab) использовать декораторы, чтобы сделать это, я думаю. Следующие работы, например:

def execute_with_context_manager(man):
    def decorator(f):
        target = man.__enter__()
        exc = True
        try:
            try:
                f(target)
            except:
                exc = False
                if not man.__exit__(*sys.exc_info()):
                    raise
        finally:
            if exc:
                man.__exit__(None, None, None)
        return None
    return decorator

@execute_with_context_manager(open("/etc/motd"))
def inside(motd_file):
    for line in motd_file:
        print line,

(Ну, в файловых объектах Python 2.4 нет методов __enter__ и __exit__, но в остальном это работает)

Идея в том, что вы заменяете на строку в:

with bar() as foo:
    do_something_with(foo)
    do_something_else_with(foo)
    # etc...

с оформленной функцией "объявление" в:

@execute_with_context_manager( bar() )
def dummyname( foo ):
    do_something_with(foo)
    do_something_else_with(foo)
    # etc...

но получаю то же поведение (исполняется код do_something _...). Обратите внимание, что декоратор изменяет объявление функции на немедленный вызов , что является чем-то большим, чем маленькое зло.

Answer 3

Если вы в порядке с использованием def только для получения блока и декораторами, которые выполняются немедленно, вы можете использовать сигнатуру функции, чтобы получить что-то более естественное для названного случая.

import sys
def with(func):
    def decorated(body = func):
        contexts = body.func_defaults
        try:
            exc = None, None, None
            try:
                for context in contexts:
                    context.__enter__()
                body()
            except:
                exc = sys.exc_info()
                raise
        finally:
            for context in reversed(contexts):
                context.__exit__(*exc)
    decorated()

class Context(object):
    def __enter__(self):
        print "Enter %s" % self
    def __exit__(self, *args):
        print "Exit %s(%s)" % (self, args)

x = Context()

@with
def _(it = x):
    print "Body %s" % it

@with
def _(it = x):
    print "Body before %s" % it
    raise "Nothing"
    print "Body after %s" % it

Answer 4

Как насчет этого?

def improvize_context_manager(*args, **kwargs):

    assert (len(args) + len(kwargs)) == 1
    if args:
        context_manager = args[0]
        as_ = None
    else: # It's in kwargs
        (as_, context_manager) = kwargs.items()[0]

    def decorator(f):
        exit_ = context_manager.__exit__  # Not calling it yet
        enter_ = context_manager.__enter__()
        exc = True
        try:
            try:
                if as_:
                    f(*{as_: enter_})
                else:
                    f()
            except:
                exc = False
                if not exit_(*sys.exc_info()):
                    raise
        finally:
            if exc:
            exit_(None, None, None)
        return None
    return decorator

Использование:

@improvize_context_manager(lock)
def null():
    do(stuff)

Что соответствует ключевому слову with без as.

Или:

@improvize_context_manager(my_lock=lock)
def null(my_lock):
    do(stuff_with, my_lock)

Что соответствует ключевому слову with с as.

Answer 5

Поскольку вам нужно выходить из диспетчера контекста как во время ошибок, так и не ошибок, я не думаю, что возможно сделать общий сценарий использования с метаклассами или вообще вообще. Для этого вам понадобятся блоки try / finally.

Но, возможно, в вашем случае можно сделать что-то еще. Это зависит от того, для чего вы используете контекстный менеджер.

Использование __del__ может помочь в некоторых случаях, например, освобождение ресурса, но, поскольку вы не можете быть уверены, что он вызывается, его можно использовать только в том случае, если вам нужно освободить ресурсы, которые будут освобождены при выходе из программы. Это также не сработает, если вы обрабатываете исключения в методе __exit__.

Я предполагаю, что самый чистый метод - это обернуть все управление контекстом в своего рода вызов управления контекстом и извлечь блок кода в метод. Примерно так (непроверенный код, но в основном украденный из PEP 343):

def call_as_context_manager(mgr, function):
    exit = mgr.__exit__
    value = mgr.__enter__()
    exc = True
    try:
        try:
            function(value)
        except:
            exc = False
            if not exit(*sys.exc_info()):
                raise
    finally:
        if exc:
            exit(None, None, None)