So setzen Sie das Klassenattribut mit await in __init__

Wie kann ich eine Klasse mit awaitim Konstruktor oder im Klassenkörper definieren?

Zum Beispiel was ich will:

import asyncio

# some code


class Foo(object):

    async def __init__(self, settings):
        self.settings = settings
        self.pool = await create_pool(dsn)

foo = Foo(settings)
# it raises:
# TypeError: __init__() should return None, not 'coroutine'

oder Beispiel mit Klassenkörperattribut:

class Foo(object):

    self.pool = await create_pool(dsn)  # Sure it raises syntax Error

    def __init__(self, settings):
        self.settings = settings

foo = Foo(settings)

Meine Lösung (aber ich würde gerne einen eleganteren Weg sehen)

class Foo(object):

    def __init__(self, settings):
        self.settings = settings

    async def init(self):
        self.pool = await create_pool(dsn)

foo = Foo(settings)
await foo.init()

Die meisten magischen Methoden sind nicht zur Arbeit entwickelt , um mit async def/ await- in der Regel sollten Sie nur verwenden werden awaitinnerhalb der dedizierten asynchronen magischen Methoden - __aiter__, __anext__, __aenter__, und __aexit__. Die Verwendung in anderen magischen Methoden funktioniert entweder überhaupt nicht, wie dies der Fall ist __init__(es sei denn, Sie verwenden einige Tricks, die in anderen Antworten hier beschrieben sind), oder zwingt Sie, immer das zu verwenden, was den Aufruf der magischen Methode in einem asynchronen Kontext auslöst.

Bestehende asyncioBibliotheken können dies auf zwei Arten behandeln: Erstens habe ich das verwendete Factory-Muster gesehen ( asyncio-rediszum Beispiel):

import asyncio

dsn = "..."

class Foo(object):
    @classmethod
    async def create(cls, settings):
        self = Foo()
        self.settings = settings
        self.pool = await create_pool(dsn)
        return self

async def main(settings):
    settings = "..."
    foo = await Foo.create(settings)

Andere Bibliotheken verwenden eine Coroutine-Funktion der obersten Ebene, die das Objekt erstellt, und keine Factory-Methode:

import asyncio

dsn = "..."

async def create_foo(settings):
    foo = Foo(settings)
    await foo._init()
    return foo

class Foo(object):
    def __init__(self, settings):
        self.settings = settings

    async def _init(self):
        self.pool = await create_pool(dsn)

async def main():
    settings = "..."
    foo = await create_foo(settings)

Die create_poolFunktion, von aiopgder aus Sie aufrufen möchten, __init__verwendet genau dieses Muster.

Dies behebt zumindest das __init__Problem. Ich habe keine Klassenvariablen gesehen, die asynchrone Aufrufe in freier Wildbahn ausführen, an die ich mich erinnern kann, daher weiß ich nicht, dass etablierte Muster entstanden sind.

Ein anderer Weg, dies für Funsies zu tun:

class aobject(object):
    """Inheriting this class allows you to define an async __init__.

    So you can create objects by doing something like `await MyClass(params)`
    """
    async def __new__(cls, *a, **kw):
        instance = super().__new__(cls)
        await instance.__init__(*a, **kw)
        return instance

    async def __init__(self):
        pass

#With non async super classes

class A:
    def __init__(self):
        self.a = 1

class B(A):
    def __init__(self):
        self.b = 2
        super().__init__()

class C(B, aobject):
    async def __init__(self):
        super().__init__()
        self.c=3

#With async super classes

class D(aobject):
    async def __init__(self, a):
        self.a = a

class E(D):
    async def __init__(self):
        self.b = 2
        await super().__init__(1)

# Overriding __new__

class F(aobject):
    async def __new__(cls):
        print(cls)
        return await super().__new__(cls)

    async def __init__(self):
        await asyncio.sleep(1)
        self.f = 6

async def main():
    e = await E()
    print(e.b) # 2
    print(e.a) # 1

    c = await C()
    print(c.a) # 1
    print(c.b) # 2
    print(c.c) # 3

    f = await F() # Prints F class
    print(f.f) # 6

import asyncio
loop = asyncio.get_event_loop()
loop.run_until_complete(main())

Ich würde eine separate Factory-Methode empfehlen. Es ist sicher und unkompliziert. Wenn Sie jedoch auf einer asyncVersion von bestehen __init__(), finden Sie hier ein Beispiel:

def asyncinit(cls):
    __new__ = cls.__new__

    async def init(obj, *arg, **kwarg):
        await obj.__init__(*arg, **kwarg)
        return obj

    def new(cls, *arg, **kwarg):
        obj = __new__(cls, *arg, **kwarg)
        coro = init(obj, *arg, **kwarg)
        #coro.__init__ = lambda *_1, **_2: None
        return coro

    cls.__new__ = new
    return cls

Verwendung:

@asyncinit
class Foo(object):
    def __new__(cls):
        '''Do nothing. Just for test purpose.'''
        print(cls)
        return super().__new__(cls)

    async def __init__(self):
        self.initialized = True

async def f():
    print((await Foo()).initialized)

loop = asyncio.get_event_loop()
loop.run_until_complete(f())

Ausgabe:

<class '__main__.Foo'>
True

Erläuterung:

Ihre Klassenkonstruktion muss ein coroutineObjekt anstelle einer eigenen Instanz zurückgeben.

Besser noch, Sie können so etwas tun, was sehr einfach ist:

import asyncio

class Foo:
    def __init__(self, settings):
        self.settings = settings

    async def async_init(self):
        await create_pool(dsn)

    def __await__(self):
        return self.async_init().__await__()

loop = asyncio.get_event_loop()
foo = loop.run_until_complete(Foo(settings))

Grundsätzlich wird hier __init__() wie gewohnt zuerst aufgerufen. Dann __await__()wird gerufen, was dann wartet async_init().

[Fast] kanonische Antwort von @ojii

@dataclass
class Foo:
    settings: Settings
    pool: Pool

    @classmethod
    async def create(cls, settings: Settings, dsn):
        return cls(settings, await create_pool(dsn))