Introduction to Disasync

Disasync is a powerful Python library designed to simplify asynchronous programming. It provides a wide range of APIs that allow developers to write efficient and scalable asynchronous code with ease. This library is particularly useful for IO-bound tasks, concurrent network connections, and other asynchronous operations.

APIs and Code Snippets

1. Async Function Decorator

The @disasync decorator turns a regular function into an asynchronous function:

  
    from disasync import disasync

    @disasync
    async def example():
        print("Hello, Async!")
  

2. Async Context Manager

Disasync provides an easy way to create async context managers:

  
    from disasync import asynccontextmanager

    @asynccontextmanager
    async def example_manager():
        print("Entering context...")
        yield
        print("Exiting context...")
  

3. Asynchronous Generators

Create efficient async generators with disasync:

  
    from disasync import async_generator

    @async_generator
    async def example_generator(count):
        for i in range(count):
            await yield_(i)
  

4. Task Scheduling

Schedule tasks to run asynchronously:

  
    from disasync import schedule_task

    async def my_task():
        print("Running Task")

    task = schedule_task(my_task())
  

5. Timeout Handling

Easily handle timeouts for async operations:

  
    from disasync import timeout

    async def example():
        try:
            await timeout(5)
            print("Operation completed")
        except TimeoutError:
            print("Operation timed out")
  

6. Delayed Execution

Delay the execution of tasks:

  
    from disasync import delayed

    async def delayed_task():
        print("This task is delayed by 5 seconds")
        await delayed(5)

    await delayed_task()
  

7. Lock Management

Manage locks in async code:

  
    from disasync import AsyncLock

    lock = AsyncLock()

    async def task_with_lock():
        async with lock:
            print("Task is running within lock")
  

8. Semaphore Management

Control access to limited resources with semaphores:

  
    from disasync import AsyncSemaphore

    semaphore = AsyncSemaphore(3)

    async def limited_access_task():
        async with semaphore:
            print("Task has limited access")
  

9. Producer-Consumer Model

Implement efficient producer-consumer patterns:

  
    from disasync import AsyncQueue

    queue = AsyncQueue()

    async def producer():
        for i in range(5):
            await queue.put(i)
            print(f"Produced {i}")

    async def consumer():
        while True:
            item = await queue.get()
            if item is None:
                break
            print(f"Consumed {item}")

    await producer()
    await queue.put(None)  # Signal consumer to stop
    await consumer()
  

10. HTTP Handling

Perform asynchronous HTTP requests:

  
    from disasync import AsyncHTTPClient

    async def fetch_url(url):
        async with AsyncHTTPClient() as client:
            response = await client.get(url)
            print(response.status)

    await fetch_url('https://example.com')
  

App Example

Here’s an example of a small application using the introduced APIs:

  
    from disasync import AsyncScheduler

    scheduler = AsyncScheduler()

    async def periodic_task():
        print("Periodic Task Running")

    async def main():
        scheduler.add(periodic_task, interval=5)
        await scheduler.start()

    await main()
  

Disasync makes it easy to build robust asynchronous applications. Happy coding!

Hash: 294aa32238d3d09128b94ad47826119ca95881b07ca5da180de81143d55ddb39