Initial migration

2_asyncio_base/example_2.py

@@ -0,0 +1,23 @@
+import time
+import asyncio
+
+start = time.time()  # Время начала эксперимента!)
+
+
+async def sleeping(n):
+    # {time.time() - start:.4f} - время от начала работы программы до текущего момента.
+    # :.4f - ограничение количества знаков после запятой (4).
+    print(f"Начало выполнения длительной операции № {n}: {time.time() - start:.4f}")
+    await asyncio.sleep(1)  # Имитация длительной операции в 1 секунду длиной.
+    print(f"Длительная операция № {n} завершена")
+
+
+async def main():
+    # Запускаю 30 операций.
+    task = [sleeping(i) for i in range(1, 31)]
+    all_results = await asyncio.gather(*task)
+    print(f"Выполнено {len(all_results)} операций.")
+    print(f"Программа завершена за {time.time() - start:.4f}")
+
+# Запуск главной корутины.
+asyncio.run(main())

3_awaitable_objects/awaitable_topic.py

@@ -0,0 +1,21 @@
+import asyncio
+
+
+async def coro(num, seconds):
+    print(f"Задача{num} начала свое выполнение")
+    await asyncio.sleep(seconds)
+    print(f"Задача{num} выполнена за {seconds} секунду(ы)")
+
+
+async def main():
+    # Создание задач из корутины.
+    task1 = asyncio.create_task(coro(1, 1))
+    task2 = asyncio.create_task(coro(2, 2))
+    task3 = asyncio.create_task(coro(3, 3))
+    task4 = asyncio.create_task(coro(4, 4))
+    task5 = asyncio.create_task(coro(5, 5))
+    # Запуск и ожидание выполнения задач.
+    await task5
+
+
+asyncio.run(main())

3_awaitable_objects/sandbox.py

@@ -0,0 +1,26 @@
+import asyncio
+
+
+async def test_cor_1(future: asyncio.Future):
+    print("cor_1 started")
+    await asyncio.sleep(2)
+    print("cor_1 set future result to 100")
+    future.set_result(100)
+    print("cor_1 continue to sleep")
+    await asyncio.sleep(2)
+    print("cor_1 finished")
+
+
+async def test_cor_2():
+    print("cor_2 executed")
+
+
+async def main():
+    future = asyncio.Future()
+    tasks = []
+    tasks.append(asyncio.create_task(test_cor_1(future)))
+    tasks.append(asyncio.create_task(test_cor_2()))
+    await asyncio.gather(*tasks)
+
+
+asyncio.run(main())

3_awaitable_objects/task_3_2_10.py

@@ -0,0 +1,8 @@
+import asyncio
+
+
+async def main():
+    print("Hello, Asyncio!")
+
+
+asyncio.run(main())

3_awaitable_objects/task_3_2_11.py

@@ -0,0 +1,17 @@
+import asyncio
+
+
+async def coro_1():
+    print("coro_1 says, hello coro_2!")
+
+
+async def coro_2():
+    print("coro_2 says, hello coro_1!")
+
+
+async def main():
+    await coro_1()
+    await coro_2()
+
+
+asyncio.run(main())

3_awaitable_objects/task_3_2_13.py

@@ -0,0 +1,13 @@
+import asyncio
+
+
+async def generate(number: int):
+    print(f"Корутина generate с аргументом {number}")
+
+
+async def main():
+    for gen in range(0, 10):
+        await generate(gen)
+
+
+asyncio.run(main())

3_awaitable_objects/task_3_2_14.py

@@ -0,0 +1,28 @@
+import asyncio
+
+
+async def coro_1():
+    print("Вызываю корутину 0")
+
+
+async def coro_5():
+    print("Вызываю корутину 3")
+    await coro_3()
+
+
+async def coro_3():
+    print("Вызываю корутину 2")
+    await coro_2()
+
+
+async def coro_4():
+    print("Вызываю корутину 1")
+    await coro_1()
+
+
+async def coro_2():
+    print("Вызываю корутину 4")
+    await coro_4()
+
+
+asyncio.run(coro_5())

3_awaitable_objects/task_3_3_10.py

@@ -0,0 +1,16 @@
+import asyncio
+
+
+async def print_with_delay(delay: int):
+    await asyncio.sleep(1)
+    print(f"Coroutine {delay} is done")
+
+
+async def main():
+    tasks = []
+    for i in range(10):
+        tasks.append(print_with_delay(i))
+    await asyncio.gather(*tasks)
+
+
+asyncio.run(main())

3_awaitable_objects/task_3_3_11.py

@@ -0,0 +1,19 @@
+import asyncio
+
+max_counts = {"Counter 1": 13, "Counter 2": 7}
+
+
+async def counter(name: str, max_count: int):
+    for i in range(1, max_count + 1):
+        print(f"{name}: {i}")
+        await asyncio.sleep(1)
+
+
+async def main():
+    tasks = []
+    for name, value in max_counts.items():
+        tasks.append(counter(name, value))
+    await asyncio.gather(*tasks)
+
+
+asyncio.run(main())

3_awaitable_objects/task_3_3_12.py

@@ -0,0 +1,20 @@
+import asyncio
+
+max_counts = {"Counter 1": 10, "Counter 2": 5, "Counter 3": 15}
+delays = {"Counter 1": 1, "Counter 2": 2, "Counter 3": 0.5}
+
+
+async def counter(name: str, max_count: int, delay: int):
+    for i in range(1, max_count + 1):
+        print(f"{name}: {i}")
+        await asyncio.sleep(delay)
+
+
+async def main():
+    tasks = []
+    for name, value in max_counts.items():
+        tasks.append(counter(name, value, delays[name]))
+    await asyncio.gather(*tasks)
+
+
+asyncio.run(main())

3_awaitable_objects/task_3_3_9.py

@@ -0,0 +1,25 @@
+import asyncio
+
+
+async def c_1():
+    print("Coroutine 1 is done")
+
+
+async def c_2():
+    print("Coroutine 2 is done")
+
+
+async def c_3():
+    print("Coroutine 3 is done")
+
+
+async def main():
+    tasks = [
+        asyncio.create_task(c_1()),
+        asyncio.create_task(c_2()),
+        asyncio.create_task(c_3()),
+    ]
+    await asyncio.gather(*tasks)
+
+
+asyncio.run(main())

3_awaitable_objects/task_3_4_10.py

@@ -0,0 +1,25 @@
+import asyncio
+
+
+async def set_future_result(value, delay):
+    print(f"Задача начата. Установка результата '{value}' через {delay} секунд.")
+    await asyncio.sleep(delay)
+    print("Результат установлен.")
+    return value
+
+
+async def create_ans_use_future():
+    task = asyncio.create_task(set_future_result("Успех", 2))
+    print(f"Состояние Task до выполнения: {'Завершено' if task.done() else 'Ожидание'}")
+    print("Задача запущена, ожидаем завершения...")
+    await task
+    print(f"Состояние Task до выполнения: {'Завершено' if task.done() else 'Ожидание'}")
+    return task.result()
+
+
+async def main():
+    result = await create_ans_use_future()
+    print("Результат из Task:", result)
+
+
+asyncio.run(main())

3_awaitable_objects/task_3_4_11.py

@@ -0,0 +1,33 @@
+import asyncio
+from asyncio.exceptions import CancelledError
+
+
+async def async_operation():
+    print("Начало асинхронной операции.")
+    try:
+        await asyncio.sleep(2)
+        print("Асинхронная операция успешно завершилась.")
+    except CancelledError:
+        print("Асинхронная операция была отменена в процессе выполнения.")
+        raise
+
+
+async def main():
+    print("Главная корутина запущена.")
+    task = asyncio.create_task(async_operation())
+    await asyncio.sleep(0.1)
+    print("Попытка отмены Task.")
+    task.cancel()
+    try:
+        await task
+        print("Результат Task:", task.result())
+    except CancelledError:
+        print("Обработка исключения: Task был отменен.")
+    if task.cancelled():
+        print("Проверка: Task был отменен.")
+    else:
+        print("Проверка: Task не был отменен.")
+    print("Главная корутина завершена.")
+
+
+asyncio.run(main())

3_awaitable_objects/task_3_4_12.py

@@ -0,0 +1,46 @@
+import asyncio
+
+
+async def first_function(x):
+    print(f"Выполняется первая функция с аргументом {x}")
+    await asyncio.sleep(1)
+    result = x + 1
+    print(f"Первая функция завершилась с результатом {result}")
+    return result
+
+
+async def second_function(x):
+    print(f"Выполняется вторая функция с аргументом {x}")
+    await asyncio.sleep(1)
+    result = x * 2
+    print(f"Вторая функция завершилась с результатом {result}")
+    return result
+
+
+async def third_function(x):
+    print(f"Выполняется третья функция с аргументом {x}")
+    await asyncio.sleep(1)
+    result = x + 3
+    print(f"Третья функция завершилась с результатом {result}")
+    return result
+
+
+async def fourth_function(x):
+    print(f"Выполняется четвертая функция с аргументом {x}")
+    await asyncio.sleep(1)
+    result = x**2
+    print(f"Четвертая функция завершилась с результатом {result}")
+    return result
+
+
+async def main():
+    print("Начало цепочки асинхронных вызовов")
+    x = 1
+    x = await asyncio.create_task(first_function(x))
+    x = await asyncio.create_task(second_function(x))
+    x = await asyncio.create_task(third_function(x))
+    x = await asyncio.create_task(fourth_function(x))
+    print(f"Конечный результат цепочки вызовов: {x}")
+
+
+asyncio.run(main())

3_awaitable_objects/task_3_4_13.py

@@ -0,0 +1,22 @@
+import asyncio
+
+
+async def waiter(future: asyncio.Future):
+    await future
+    print(
+        f"future выполнен, результат {future.result()}. Корутина waiter() может продолжить работу"
+    )
+
+
+async def setter(future: asyncio.Future):
+    await asyncio.sleep(random.randint(1, 3))
+    future.set_result(True)
+
+
+async def main():
+    future = asyncio.Future()
+    tasks = [asyncio.create_task(waiter(future)), asyncio.create_task(setter(future))]
+    await asyncio.gather(*tasks)
+
+
+asyncio.run(main())

3_awaitable_objects/task_3_5_10.py

@@ -0,0 +1,39 @@
+import asyncio
+
+# Полный словарь students вшит в задачу, вставлять его не нужно
+# students = {}
+students = {
+    "Алекс": {"course": "Асинхронный Python", "steps": 515, "speed": 78},
+    "Мария": {"course": "Многопоточный Python", "steps": 431, "speed": 62},
+    "Иван": {"course": "WEB Парсинг на Python", "steps": 491, "speed": 57},
+}
+
+
+async def study_course(student, course, steps, speed):
+    print(f"{student} начал проходить курс {course}.")
+    reading_time = round(steps / speed, 2)
+    await asyncio.sleep(reading_time)
+    print(f"{student} прошел курс {course} за {reading_time} ч.")
+
+
+async def main():
+    tasks = []
+    # Создание задач с помощью asyncio.create_task для каждого студента
+    for student, student_data in students.items():
+        tasks.append(
+            asyncio.create_task(
+                study_course(
+                    student,
+                    student_data["course"],
+                    student_data["steps"],
+                    student_data["speed"],
+                )
+            )
+        )
+
+    # Ожидание завершения каждой задачи индивидуально
+    for task in tasks:
+        await task
+
+
+asyncio.run(main())

3_awaitable_objects/task_3_5_9.py

@@ -0,0 +1,20 @@
+import asyncio
+
+
+async def read_book(student, time):
+    print(f"{student} начал читать книгу.")
+    await asyncio.sleep(time)
+    print(f"{student} закончил читать книгу за {time} секунд.")
+
+
+async def main():
+    # Создаем задачи для асинхронного выполнения
+    task2 = asyncio.create_task(read_book("Алекс", 5))
+    task1 = asyncio.create_task(read_book("Мария", 3))
+    task3 = asyncio.create_task(read_book("Иван", 4))
+    await task1
+    await task2
+    await task3
+
+
+asyncio.run(main())

3_awaitable_objects/task_3_6_10.py

@@ -0,0 +1,19 @@
+import asyncio
+
+
+async def task1():
+    await asyncio.sleep(1)
+    print("Привет из корутины task1")
+
+
+async def task2():
+    await asyncio.sleep(1)
+    print("Привет из корутины task2")
+
+
+async def main():
+    await task1()
+    await task2()
+
+
+asyncio.run(main())

3_awaitable_objects/task_3_6_11.py

@@ -0,0 +1,36 @@
+import asyncio
+
+
+async def task1():
+    print("Начинаем задачу 1")
+    await asyncio.sleep(1)
+    print("Привет из корутины task1")
+    await asyncio.sleep(1)
+    print("Задача 1 завершилась")
+
+
+async def task2():
+    print("Начинаем задачу 2")
+    await asyncio.sleep(2)
+    print("Привет из корутины task2")
+    await asyncio.sleep(2)
+    print("Задача 2 завершилась")
+
+
+async def task3():
+    print("Начинаем задачу 3")
+    await asyncio.sleep(3)
+    print("Привет из корутины task3")
+    await asyncio.sleep(3)
+    print("Задача 3 завершилась")
+
+
+async def main():
+    task_1 = asyncio.create_task(task1())
+    task_2 = asyncio.create_task(task2())
+    task_3 = asyncio.create_task(task3())
+
+    await asyncio.gather(task_1, task_2, task_3)
+
+
+asyncio.run(main())

3_awaitable_objects/task_3_6_12.py

@@ -0,0 +1,19 @@
+import asyncio
+
+
+async def compute_square(x):
+    print(f"Вычисляем квадрат числа: {x}")
+    await asyncio.sleep(1)  # Имитация длительной операции
+    return x * x
+
+
+async def main():
+    # Создаём и запускаем задачи
+    tasks = [asyncio.create_task(compute_square(i)) for i in range(10)]
+    # Ожидаем завершения всех задач и собираем результаты
+    await asyncio.gather(*tasks)
+    for result in tasks:
+        print(f"Результат: {result.result()}")
+
+
+asyncio.run(main())

3_awaitable_objects/tasks_topic.py

@@ -0,0 +1,17 @@
+import asyncio
+
+
+async def example():
+    await asyncio.sleep(1)
+    print("Hello from awake coroutine")
+
+
+async def main():
+    tasks = []
+    for _ in range(10):
+        task = asyncio.create_task(example())
+        tasks.append(task)
+    await asyncio.gather(*tasks)
+
+
+asyncio.run(main())

4_polling/polling.py

@@ -0,0 +1,30 @@
+import asyncio
+
+
+async def print_message():
+    while True:
+        print("Имитация работы функции")
+        await asyncio.sleep(1)
+
+
+async def interrupt_handler(interrupt_flag):
+    while True:
+        # Ждем установки флага. 
+        await interrupt_flag.wait()  
+        print("Произошло прерывание! В этом месте может быть установлен любой обработчик")
+        # Очищаем флаг для следующего использования
+        interrupt_flag.clear()
+
+
+async def main():
+    interrupt_flag = asyncio.Event()
+    asyncio.create_task(print_message())
+    asyncio.create_task(interrupt_handler(interrupt_flag))
+
+    while True:
+        await asyncio.sleep(3)
+        # Устанавливаем флаг для прерывания
+        interrupt_flag.set()
+
+
+asyncio.run(main())

5_asyncio_basis/5_1_8_main_methods.py

@@ -0,0 +1,24 @@
+import asyncio
+
+# Пример данных
+log_events = [
+    {"event": "Запрос на вход", "delay": 0.5},
+    {"event": "Запрос данных пользователя", "delay": 1.0},
+    {"event": "Обновление данных пользователя", "delay": 1.5},
+    {"event": "Обновление конфигурации сервера", "delay": 5.0},
+]
+
+
+async def fetch_log(event):
+    await asyncio.sleep(event.get("delay"))
+    print(f"Событие: '{event['event']}' обработано с задержкой {event['delay']} сек.")
+
+
+async def main():
+    tasks = []
+    for event in log_events:
+        tasks.append(asyncio.create_task(fetch_log(event)))
+    await asyncio.gather(*tasks)
+
+
+asyncio.run(main())

5_asyncio_basis/5_3_10_sleep_task.py

@@ -0,0 +1,42 @@
+import asyncio
+
+
+async def coroutine_1(delay=0.1):
+    print("Первое сообщение от корутины 1")
+    await asyncio.sleep(0.03)  # Первая задержка
+    print("Второе сообщение от корутины 1")
+    await asyncio.sleep(0.14)  # Вторая задержка
+    print("Третье сообщение от корутины 1")
+    await asyncio.sleep(0.20)  # Третья задержка
+    print("Четвертое сообщение от корутины 1")
+
+
+async def coroutine_2(delay=0.1):
+    print("Первое сообщение от корутины 2")
+    await asyncio.sleep(0.02)  # Первая задержка
+    print("Второе сообщение от корутины 2")
+    await asyncio.sleep(0.10)  # Вторая задержка
+    print("Третье сообщение от корутины 2")
+    await asyncio.sleep(0.44)  # Третья задержка
+    print("Четвертое сообщение от корутины 2")
+
+
+async def coroutine_3(delay=0.1):
+    print("Первое сообщение от корутины 3")
+    await asyncio.sleep(0.01)  # Первая задержка
+    print("Второе сообщение от корутины 3")
+    await asyncio.sleep(0.12)  # Вторая задержка
+    print("Третье сообщение от корутины 3")
+    await asyncio.sleep(0.32)  # Третья задержка
+    print("Четвертое сообщение от корутины 3")
+
+
+async def main():
+    await asyncio.gather(
+        coroutine_1(),
+        coroutine_2(),
+        coroutine_3(),
+    )
+
+
+asyncio.run(main())

5_asyncio_basis/5_3_11_sleep_task.py

@@ -0,0 +1,57 @@
+import asyncio
+
+
+async def coroutine_1():
+    await asyncio.sleep(1)  # Задержка для первого сообщения
+    print("Сообщение 1 от корутины 1")
+    await asyncio.sleep(2)  # Задержка для второго сообщения
+    print("Сообщение 2 от корутины 1")
+
+
+async def coroutine_2():
+    await asyncio.sleep(1)
+    print("Сообщение 1 от корутины 2")
+    await asyncio.sleep(2)
+    print("Сообщение 2 от корутины 2")
+
+
+async def coroutine_3():
+    await asyncio.sleep(1)
+    print("Сообщение 1 от корутины 3")
+    await asyncio.sleep(2)
+    print("Сообщение 2 от корутины 3")
+
+
+async def coroutine_4():
+    await asyncio.sleep(1)
+    print("Сообщение 1 от корутины 4")
+    await asyncio.sleep(2)
+    print("Сообщение 2 от корутины 4")
+
+
+async def coroutine_5():
+    await asyncio.sleep(1)
+    print("Сообщение 1 от корутины 5")
+    await asyncio.sleep(2)
+    print("Сообщение 2 от корутины 5")
+
+
+async def coroutine_6():
+    await asyncio.sleep(1)
+    print("Сообщение 1 от корутины 6")
+    await asyncio.sleep(2)
+    print("Сообщение 2 от корутины 6")
+
+
+async def main():
+    await asyncio.gather(
+        coroutine_1(),
+        coroutine_2(),
+        coroutine_3(),
+        coroutine_4(),
+        coroutine_5(),
+        coroutine_6(),
+    )
+
+
+asyncio.run(main())

5_asyncio_basis/5_3_12_sleep_task.py

@@ -0,0 +1,43 @@
+import asyncio
+import random
+
+# Не менять.
+random.seed(1)
+
+
+class MailServer:
+    def __init__(self):
+        self.mailbox = ["Привет!", "Встреча в 15:00", "Важное уведомление", "Реклама"]
+
+    async def check_for_new_mail(self):
+        if random.random() < 0.1:
+            return "Ошибка при проверке новых писем."
+        return random.choice([True, False])
+
+    async def fetch_new_mail(self):
+        mail = random.choice(self.mailbox)
+        return f"Новое письмо: {mail}"
+
+
+# Тут пишите ваш код
+async def check_mail(server: MailServer):
+    while True:
+        check_result = await server.check_for_new_mail()
+        if isinstance(check_result, str):
+            print(check_result)
+            break
+        if check_result:
+            new_mail = await server.fetch_new_mail()
+            print(new_mail)
+        else:
+            print("Новых писем нет.")
+        await asyncio.sleep(1)
+
+
+async def main():
+    # Creating mail server
+    server = MailServer()
+    await check_mail(server)
+
+
+asyncio.run(main())

5_asyncio_basis/5_3_13_sleep_task.py

@@ -0,0 +1,40 @@
+import asyncio
+import time
+
+
+async def process_request(request_name, stages, status):
+    for stage_name in stages:
+        time.sleep(1)  # Симулируем время выполнения этапа
+        status[request_name] = stage_name
+        await asyncio.sleep(0)
+
+
+async def update_status(request_name, status):
+    while True:
+        print(status)
+        if status == {request_name: "Отправка уведомлений"}:
+            break
+        await asyncio.sleep(0)
+
+
+async def main():
+    # Исходные данные по запросу и этапам его обработки
+    request_name = "Запрос 1"
+    stages = [
+        "Загрузка данных",
+        "Проверка данных",
+        "Анализ данных",
+        "Сохранение результатов",
+        "Отправка уведомлений",
+    ]
+
+    status = {request_name: None}
+
+    # Создание задач для каждой корутины
+    process_task = asyncio.create_task(process_request(request_name, stages, status))
+    updater_task = asyncio.create_task(update_status(request_name, status))
+
+    await asyncio.gather(process_task, updater_task)
+
+
+asyncio.run(main())

5_asyncio_basis/5_3_9_sleep_task.py

@@ -0,0 +1,30 @@
+import asyncio
+
+
+async def coroutine_1():
+    print("Первое сообщение от корутины 1")
+    await asyncio.sleep(3)  # Подберите необходимую задержку
+    print("Второе сообщение от корутины 1")
+
+
+async def coroutine_2():
+    print("Первое сообщение от корутины 2")
+    await asyncio.sleep(2)  # Подберите необходимую задержку
+    print("Второе сообщение от корутины 2")
+
+
+async def coroutine_3():
+    print("Первое сообщение от корутины 3")
+    await asyncio.sleep(1)  # Подберите необходимую задержку
+    print("Второе сообщение от корутины 3")
+
+
+async def main():
+    await asyncio.gather(
+        coroutine_1(),
+        coroutine_2(),
+        coroutine_3(),
+    )
+
+
+asyncio.run(main())

5_asyncio_basis/5_4_creating_tasks/10_task.py

@@ -0,0 +1,29 @@
+import asyncio
+
+places = [
+    "начинает путешествие",
+    "находит загадочный лес",
+    "переправляется через реку",
+    "встречает дружелюбного дракона",
+    "находит сокровище",
+]
+
+roles = ["Искатель приключений", "Храбрый рыцарь", "Отважный пират"]
+
+
+async def counter(name, delay=0.1):
+    for place in places:
+        await asyncio.sleep(delay)
+        print(f"{name} {place}...")
+
+
+async def main():
+    task1 = asyncio.create_task(counter(roles[0]))
+    task2 = asyncio.create_task(counter(roles[1]))
+    task3 = asyncio.create_task(counter(roles[2]))
+
+    # Дождитесь выполнения всех созданных задач в главной корутине с помощью await.
+    await asyncio.gather(task1, task2, task3)
+
+
+asyncio.run(main())

5_asyncio_basis/5_4_creating_tasks/11_task.py

@@ -0,0 +1,28 @@
+import asyncio
+
+timers = {
+    "Квест на поиск сокровищ": 10,
+    "Побег от дракона": 5,
+}
+
+
+async def countdown(name, seconds):
+    while seconds:
+        if "Квест" in name:
+            print(f"{name}: Осталось {seconds} сек. Найди скрытые сокровища!")
+        else:
+            print(f"{name}: Осталось {seconds} сек. Беги быстрее, дракон на хвосте!")
+        await asyncio.sleep(1)
+        seconds -= 1
+    print(f"{name}: Задание выполнено! Что дальше?")
+
+
+async def main():
+    tasks = [
+        asyncio.create_task(countdown(name, seconds))
+        for name, seconds in timers.items()
+    ]
+    await asyncio.gather(*tasks)
+
+
+asyncio.run(main())

5_asyncio_basis/5_4_creating_tasks/12_task.py

@@ -0,0 +1,34 @@
+import asyncio
+
+news_list = [
+    "Новая волна COVID-19 обрушилась на Европу",
+    "Рынки игр растут на фоне новостей о вакцине",
+    "Новая волна COVID-19 обрушилась на Европу",
+    "Новая волна COVID-19 обрушилась на Европу",
+    "Рынки игр растут на фоне новостей о вакцине",
+    "Новая волна COVID-19 обрушилась на Европу",
+    "Новая волна COVID-19 обрушилась на Европу",
+    "Рынки игр растут на фоне новостей о вакцине",
+]
+
+
+async def analyze_news(keyword, news_list, delay):
+    for news in news_list:
+        if keyword in news:
+            print(f"Найдено соответствие для '{keyword}': {news}")
+        await asyncio.sleep(delay)
+
+
+async def main():
+    # Создаем асинхронные задачи для каждой корутины с разными ключевыми словами и задержками
+    delay = 1
+    tasks = [
+        asyncio.create_task(analyze_news(keyword, news_list, delay))
+        for keyword in ["COVID-19", "игр", "новый вид"]
+    ]
+
+    # Ожидаем выполнения всех задач
+    await asyncio.gather(*tasks)
+
+
+asyncio.run(main())

5_asyncio_basis/5_4_creating_tasks/13_task.py

@@ -0,0 +1,42 @@
+import asyncio
+
+status_list = [
+    "Отлично",
+    "Хорошо",
+    "Удовлетворительно",
+    "Средне",
+    "Пониженное",
+    "Ниже среднего",
+    "Плохо",
+    "Очень плохо",
+    "Критично",
+    "Катастрофически",
+]
+CPU_TASK_NAME = "CPU"
+MEMORY_TASK_NAME = "Память"
+DISK_SPACE_TASK_NAME = "Дисковое пространство"
+
+
+async def monitor_pc(status):
+    task_name = asyncio.current_task().get_name()
+    print(f"[{task_name}] Статус проверки: {status}")
+    if status == "Катастрофически":
+        print(
+            f"[{task_name}] Критическое состояние достигнуто. Инициируется остановка..."
+        )
+
+
+async def main():
+    tasks = []
+    for status in status_list:
+        tasks.append(asyncio.create_task(coro=monitor_pc(status), name=CPU_TASK_NAME))
+        tasks.append(
+            asyncio.create_task(coro=monitor_pc(status), name=MEMORY_TASK_NAME)
+        )
+        tasks.append(
+            asyncio.create_task(coro=monitor_pc(status), name=DISK_SPACE_TASK_NAME)
+        )
+    await asyncio.gather(*tasks)
+
+
+asyncio.run(main())

5_asyncio_basis/5_5_ensure_future/10_task.py

@@ -0,0 +1,27 @@
+import asyncio
+
+
+async def activate_portal(x):
+    print(f"Активация портала в процессе, требуется времени: {x} единиц")
+    await asyncio.sleep(x)
+    return x * 2
+
+
+async def perform_teleportation(x):
+    print(f"Телепортация в процессе, требуется времени: {x} единиц")
+    await asyncio.sleep(x)
+    return x + 2
+
+
+async def portal_operator():
+    activate_portal_task = asyncio.ensure_future(activate_portal(2))
+    await activate_portal_task
+    pt_task = asyncio.ensure_future(
+        perform_teleportation(activate_portal_task.result())
+    )
+    await pt_task
+    print(f"Результат активации портала: {activate_portal_task.result()} единиц энергии")
+    print(f"Результат телепортации: {pt_task.result()} единиц времени")
+
+
+asyncio.run(portal_operator())

5_asyncio_basis/5_6_gather/sandbox.py

@@ -0,0 +1,23 @@
+import asyncio
+
+
+async def task_1():
+    await asyncio.sleep(2)
+    print("task 1 running after sleep")
+    return "Result from task 1"
+
+
+async def task_2():
+    await asyncio.sleep(1)
+    raise ValueError("An error occurred in task 2")
+
+
+async def main():
+    try:
+        await asyncio.gather(task_1(), task_2())
+    except ValueError:
+        print("Error occurred in task")
+    await asyncio.sleep(3)
+
+
+asyncio.run(main())

poetry.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Poetry 1.4.2 and should not be changed by hand.
+package = []
+
+[metadata]
+lock-version = "2.0"
+python-versions = "^3.10"
+content-hash = "53f2eabc9c26446fbcc00d348c47878e118afc2054778c3c803a0a8028af27d9"

pyproject.toml

@@ -0,0 +1,14 @@
+[tool.poetry]
+name = "python-asyncio-course"
+version = "0.1.0"
+description = ""
+authors = ["t0xa"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"