Vk_api и asyncio

import asyncio
from math import ceil
from vk_api import VkApi
from vk_api.exceptions import ApiError, AccessDenied, VkApiError, AuthError
from pprint import pprint
 
async def get_wall_ids(session, group_id, unix_time):
    try:
        temp = (await session.wall.get(owner_id=-group_id))['count']
        num_pages = ceil(temp/100)
        group_walls = []
        for page in range(num_pages):
            walls = await session.wall.get(owner_id=-group_id, offset=100*page, count=100)
            for wall in walls['items']:
                if wall['date'] >= unix_time:
                    group_walls.append(wall['id'])
        return group_id, group_walls, {'posts': len(group_walls)}
    except AccessDenied:
        print("Access denied: this wall is available only for community members")
        return group_id, [], {'posts': 0}
    except VkApiError as e:
        if isinstance(e, ApiError) and e.error_code == 29:
            print(f"Rate limit reached. Sleeping for {e.error['retry_after']} seconds.")
            await asyncio.sleep(e.error['retry_after'])
        else:
            print(f"Unexpected error: {e}")
        return group_id, [], {'posts': 0}
 
async def get_wall_ids_for_groups(session, groups, unix_time):
    tasks = []
    for group_id in groups:
        task = asyncio.create_task(get_wall_ids(session, group_id, unix_time))
        tasks.append(task)
    results = await asyncio.gather(*tasks, return_exceptions=True)
    dict_wall = {}
    dict_wall_count = {}
    for result in results:
        if isinstance(result, Exception):
            continue
        group_id, group_walls, group_count = result
        dict_wall[str(group_id)] = group_walls
        dict_wall_count[str(group_id)] = group_count
    return dict_wall, dict_wall_count
 
async def get_groups_by_tag(session, tag, market_on1_off0):
    groups = []
    pages = ceil((await session.groups.search(q=tag))['count'] / 999)
    for page in range(pages):
        groups_date = await session.groups.search(q=tag, market=market_on1_off0, offset=1000*page, count=1000)
        for group_date in groups_date['items']:
            groups.append(group_date['id'])
    return groups
 
async def get_wall_ids_async(token, tag, market_on1_off0, unix_time):
    async with VkApi(token=token) as session:
        groups = await get_groups_by_tag(session, tag, market_on1_off0)
        return await get_wall_ids_for_groups(session, groups, unix_time)
 
 
from MethodsGetVK.Date import MyDate
from time import mktime, strptime
 
async def main():
    try:
        session = VkApi(login=MyDate.MyPhone, password=MyDate.MyPassword)
        await session.auth(token_only=True)
        dict_wall, dict_wall_count = await get_wall_ids_async(
                session,
                tag='example',
                market_on1_off0=1,
                unix_time = int(mktime(strptime("2022-01-01", "%Y-%m-%d")))
            )
        pprint(dict_wall)
        pprint(dict_wall_count)
    except AuthError:
        print("Failed to authenticate")
 
 
if __name__ == '__main__':
    asyncio.run(main())