Cách đặt thuộc tính lớp với await trong __init__

Làm cách nào tôi có thể xác định một lớp với awaittrong hàm tạo hoặc thân lớp?

Ví dụ những gì tôi muốn:

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'

hoặc ví dụ với thuộc tính class body:

class Foo(object):

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

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

foo = Foo(settings)

Giải pháp của tôi (Nhưng tôi muốn xem một cách thanh lịch hơn)

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()

Hầu hết các phương pháp kỳ diệu không được thiết kế để làm việc với async def/ await- nói chung, bạn chỉ nên sử dụng awaitbên trong các phương pháp kỳ diệu không đồng bộ chuyên dụng - __aiter__, __anext__, __aenter__, và __aexit__. Sử dụng nó bên trong các phương pháp ma thuật khác sẽ không hoạt động chút nào, như trường hợp của nó __init__(trừ khi bạn sử dụng một số thủ thuật được mô tả trong các câu trả lời khác ở đây), hoặc sẽ buộc bạn phải luôn sử dụng bất kỳ thứ gì kích hoạt lệnh gọi phương thức ma thuật trong bối cảnh không đồng bộ.

Các asynciothư viện hiện tại có xu hướng xử lý vấn đề này theo một trong hai cách: Đầu tiên, tôi đã thấy mẫu gốc được sử dụng ( asyncio-redisví dụ:):

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)

Các thư viện khác sử dụng một hàm coroutine cấp cao nhất để tạo đối tượng, thay vì một phương thức gốc:

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)

Các create_poolchức năng từ aiopgmà bạn muốn gọi __init__được thực sự sử dụng mô hình này chính xác.

Điều này ít nhất giải quyết __init__vấn đề. Tôi chưa thấy các biến lớp thực hiện lệnh gọi không đồng bộ trong tự nhiên mà tôi có thể nhớ lại, vì vậy tôi không biết rằng bất kỳ mẫu được thiết lập tốt nào đã xuất hiện.

Một cách khác để làm điều này, dành cho những người yêu thích:

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())

Tôi muốn giới thiệu một phương pháp nhà máy riêng biệt. Nó an toàn và đơn giản. Tuy nhiên, nếu bạn nhấn mạnh vào một asyncphiên bản của __init__(), đây là một ví dụ:

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

Sử dụng:

@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())

Đầu ra:

<class '__main__.Foo'>
True

Giải trình:

Cấu trúc lớp của bạn phải trả về một coroutineđối tượng thay vì thể hiện của chính nó.

Tốt hơn hết là bạn có thể làm điều gì đó như thế này, rất dễ dàng:

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))

Về cơ bản những gì xảy ra ở đây __init__() được gọi là đầu tiên như bình thường. Sau đó, __await__()được gọi mà sau đó chờ đợi async_init().

[Hầu như] câu trả lời chuẩn của @ojii

@dataclass
class Foo:
    settings: Settings
    pool: Pool

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