Разбираюсь с асинхронностью

from __future__ import unicode_literals
import youtube_dl
import misc
import glob 
import os
import telebot
import json
import requests
import psutil
import logging
import requests
import youtube_dl
import asyncio
from unicodedata import normalize
from telebot import util
from sys import argv
from time import sleep
from time import time
from bs4 import BeautifulSoup
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters
 
 
global last_update_id 
last_update_id = 0
TOKEN = misc.token
bot = telebot.AsyncTeleBot(TOKEN)
 
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
                    level=logging.INFO)
 
URL = 'https://api.telegram.org/bot' + TOKEN + '/'
 
# Download data and config
 
download_options = {
    'format': 'bestaudio/best',
    'outtmpl': '%(title)s.%(ext)s',
    'nocheckcertificate': True,
    'postprocessors': [{
        'key': 'FFmpegExtractAudio',
        'preferredcodec': 'm4a',
        'preferredquality': '192',
    }],
}
 
# Song Directory
if not os.path.exists('Songs'):
    os.mkdir('Songs')
else:
    os.chdir('Songs')
 
def normalize_special_char(txt):
    return normalize('NFKD', txt).encode('ASCII', 'ignore').decode('ASCII')
 
 
def search_youtube(text):
    url = 'https://www.youtube.com'
 
    r = requests.get(url + '/results', params={'search_query': text})
    soup = BeautifulSoup(r.content, 'html.parser')
    for tag in soup.find_all('a', {'rel': 'spf-prefetch'}):
        title, video_url = tag.text, url + tag['href']
        if 'googleads' not in video_url:
            return normalize_special_char(video_url) 
 
async def music():
    global text
    video_url = search_youtube(text)
    global chat_id
    music_dict = await skachat(chat_id, video_url)
    
    shlyah = r'C:\pybot\Songs' + '\\' + str(chat_id)
    files_path = os.path.join(shlyah, '*')
    files = sorted(glob.iglob(files_path), key=os.path.getctime, reverse=True)
    
 
# Отправка пользователю аудио файла
async def send_audio(files, text = 'ПАДАЖи ....'):
    #print("send_audio")
    t0 = time()
    
    global chat_id
    for i in files:
        lf = files[0]
        audio = open(i, 'rb')
        bot.send_audio(chat_id, audio)
 
    print(str(time() - t0) + "is end of send_audio")
    del_dl_file(audio, files)
    
# Метод для скачивания аудио из ютуб
 
async def skachat(chat_id, text):
    #print("skachivau")
 
    t0 = time()
    
    with youtube_dl.YoutubeDL(download_options) as dl:
        if 'playlist' in text:
            bot.send_message(chat_id,'skachivau playlist')
        else:
            bot.send_message(chat_id,'skachivau trek')
        dl.download([text])
        
        bot.send_message(chat_id,"fail skachan")
        shlyah = r'C:\pybot\Songs' + '\\' + str(chat_id)
        files_path = os.path.join(shlyah, '*')
        files = sorted(glob.iglob(files_path), key=os.path.getctime, reverse=True)
        await send_audio(files)
    
    print(str(time() - t0) + 'is end of skachat')
 
def del_dl_file(audio, files):
    #sleep(2)
    for i in files:
        try:
            if os.access(i, os.R_OK and os.X_OK):
                os.remove(i)
        except PermissionError:
            audio.close()
            del_dl_file(audio, files)   
    #ist = i.split('\\')[-2]#take chat_id from name of file
    
#проверка: если в названии папки ist есть чат айди пользователя -> отправить ему трек, если же нет -> ist = chat_id (или bot.send_audio(ist, audio))
 
# Метод для проверки новых апдейтов (нет ли новых запросов)
 
async def get_updates():
    #print("get_updates")
    url = URL + 'getupdates'
    r = requests.get(url)
    return r.json()
 
# Метод получения и разбора сообщений от пользователя
 
async def get_message():
    #while True:
    #print("get_message")
    data = await get_updates()
 
    if data :
        last_object = data['result'][-1]
        current_update_id = last_object['update_id']
        global last_update_id
        if last_update_id != current_update_id: 
            last_update_id = current_update_id
            chat_id = last_object['message']['chat']['id']
            message_text = last_object['message']['text']
            message = {'chat_id': chat_id,
                   'message_text': message_text}
            return message
            await get_updates()
            data = None
        return None
    else :
        sleep(1)
 
# Метод для проверки наличия папки пользователя (если ее нет - создать и выбрать ее для загрузки)
 
async def direct():
    #print("direct")
    t0 = time()
 
    if not os.path.exists(r'C:\\pybot\\Songs' + r'\\' + str(chat_id)):
        os.mkdir(r'C:\\pybot\\Songs' + r'\\' + str(chat_id))
        os.chdir(r'C:\\pybot\\Songs' + r'\\' + str(chat_id))
    else:
        os.chdir(r'C:\\pybot\\Songs' + r'\\' + str(chat_id))
    print(str(time() - t0 ) + "is end of direct")
 
# Метод отправки текстовых сообщений пользователям
 
async def send_message(chat_id, text = 'ПАДАЖи ....'):
    #print("send_message")
    url = URL + 'sendmessage?chat_id={}&text={}'.format(chat_id, text)
    requests.get(url)
 
# Запуск скрипта
 
async def main():
    #print("main")
    while True:
        answer = await get_message()
        tasks = []
        if answer:
            global chat_id
            chat_id = answer['chat_id']
            global text
            text = answer['message_text']
            if 'youtube' in text or 'youtu.be' in text:
                #Create or select directory
                t0 = time()
                await direct()
                loop = asyncio.get_event_loop()
                tasks = [loop.create_task(skachat(chat_id, text)), loop.create_task(main())]
                loop.run_until_complete(asyncio.wait(tasks))
 
            elif text == '/start':
                large_text = open("large_text.txt", "rb").read()
                splitted_text = util.split_string(large_text, 3000)
                for text in splitted_text:
                    bot.send_message(chat_id, text)
            else: 
                await direct()
                await music()           
        else :
            continue
        #print(time() - t0)
        
 
if __name__ == '__main__':
    asyncio.run(main())

await direct()
loop = asyncio.get_event_loop()
tasks = [loop.create_task(skachat(chat_id, text)), loop.create_task(main())]
loop.run_until_complete(asyncio.wait(tasks))

loop.create_task(main())

tasks = [loop.create_task(fetch(session,url,conf)) 
                for url in conf.urls
            ]
            # итерация по заданиям не ожидая завершения всех
            for task in asyncio.as_completed(tasks):
                data = await task

 coroutines = [fetch(session,url,conf) for url in conf.urls]
            # ожидаем завершения корутин
            # return_exceptions возврат исключений как объектов; 
            # то есть в корутинах они не поднимаются
            completed = await asyncio.gather(
                *coroutines,
                return_exceptions=conf.return_exceptions
            ) 
            
            for data in completed:
                  ....