Can I use aiofile.async_open without a with statement? about aiofile HOT 4 CLOSED

    async def test():
        f = aiofile.async_open('filename.txt', mode='w')
        try:
            await f.file
            await f.write('123')
        finally:
            pass
            # await f.close()

    asyncio.run(test())

    @asynccontextmanager
    async def foo():
        async with aiofile.async_open('filename.txt', mode='w') as afp:
            await afp.write('123')
            yield afp

    async def bar():
        async with foo() as afp:
            await afp.write('456')

    asyncio.run(bar())

import asyncio
from datetime import datetime
from pathlib import Path

from aiofile import AIOFile, Writer


class AsyncRotatedLog:
    def __init__(self, directory='./logs/'):
        self._aio_file = None
        self._current_log_path = None
        self._writer = None
        self._directory = Path(directory).resolve()
        self._lock = asyncio.Lock()

    async def __aenter__(self):
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        if self._aio_file:
            await self._aio_file.close()

    async def _get_writer(self):
        async with self._lock:
            filename = self._directory / f'{datetime.now().strftime("%Y.%m.%d_%H:%M:%S")}.log'
            if filename != self._current_log_path:
                if self._aio_file:
                    await self._aio_file.close()
                self._aio_file = await AIOFile(filename, 'w')
                self._current_log_path = filename
                self._writer = Writer(self._aio_file)
            return self._writer

    async def write(self, msg: str):
        msg = msg.strip('\n') + '\n'
        writer = await self._get_writer()
        await writer(msg)


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

    async def log_message(self, msg):
        await self.async_logger.write(msg)

    async def on_x(self, msg):  # Runs concurrently as a task
        ...
        await self.log_message(msg)

    async def on_y(self, msg):  # Runs concurrently as a task
        ...
        await self.log_message(msg)

    async def on_z(self, msg):  # Runs concurrently as a task
        ...
        await self.log_message(msg)

    async def listen_for_xyz(self):
        await self.on_x('X happened')
        await asyncio.sleep(0.2)
        await self.on_y('Y happened')
        await asyncio.sleep(1.5)
        await self.on_z('Z happened')


async def main():
    async with AsyncRotatedLog() as logger:
        foo = Foo(logger)
        await foo.listen_for_xyz()


asyncio.run(main())

import asyncio
import atexit
import os
from tempfile import mktemp

from aiofile import async_open


TMP_NAME = mktemp()
atexit.register(os.unlink, TMP_NAME)


async def main():
    afp = await async_open(TMP_NAME, "w")
    await afp.write("Hello")
    await afp.close()


asyncio.run(main())
assert open(TMP_NAME, "r").read() == "Hello"