# Пример катастрофической утечки ресурсов (антипаттерн)
def read_all_configs(file_paths):
    configs = []
    for path in file_paths:
        # Файл открывается, но если произойдет ошибка чтения,
        # метод close() никогда не будет вызван!
        f = open(path, 'r', encoding='utf-8')
        data = f.read()
        configs.append(data)
        f.close()  # Это место может быть не достигнуто
    return configs

# Канонический паттерн ручного управления ресурсами (до появления with)
def safe_write_data(file_path, data):
    # 1. Открытие ресурса ДО блока try
    f = open(file_path, 'w', encoding='utf-8')
    try:
        # 2. Выполнение опасных операций внутри try
        print(f"Начинаем запись в файл {file_path}")
        f.write(data)
        # Имитация неожиданной ошибки в процессе работы
        if "error" in data:
            raise ValueError("Обнаружены некорректные данные!")
    finally:
        # 3. Гарантированное закрытие ресурса в finally
        print("Блок finally: гарантированное закрытие файла.")
        f.close()

# Элегантный и безопасный современный подход (Pythonic way)
def safe_write_data_modern(file_path, data):
    # Оператор with берет всю черновую работу на себя
    with open(file_path, 'w', encoding='utf-8') as f:
        print(f"Начинаем безопасную запись в файл {file_path}")
        f.write(data)
        if "error" in data:
            raise ValueError("Обнаружены некорректные данные!")
        # Нет необходимости писать f.close()
        # Даже при возникновении ValueError файл будет закрыт автоматически

class IgnoreSpecificError:
    """Контекстный менеджер, подавляющий только определенные ошибки"""
    def __init__(self, target_error_type):
        self.target_error_type = target_error_type

    def __enter__(self):
        print("[ENTER] Входим в контекст безопасности")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        # Очистка ресурсов (в данном случае ее нет, просто логика)
        print("[EXIT] Выходим из контекста")
        
        # Проверяем, произошла ли ошибка вообще
        if exc_type is not None:
            # Если тип ошибки совпадает с целевым (или является его наследником)
            if issubclass(exc_type, self.target_error_type):
                print(f"[ОБРАБОТАНО] Ошибка {exc_type.__name__} перехвачена и подавлена.")
                return True  # МАГИЯ: Интерпретатор не будет пробрасывать ошибку дальше
            
            # Для всех остальных ошибок мы возвращаем False неявно (по умолчанию None)
            print(f"[ПРОПУСК] Ошибка {exc_type.__name__} критическая, пробрасываем дальше!")
            return False

# Использование
with IgnoreSpecificError(ZeroDivisionError):
    print("Попытка деления на ноль...")
    x = 10 / 0  # Вызовет ZeroDivisionError, но программа не упадет!
    print("Этот текст никогда не выведется")

print("Программа продолжает работу нормально.")

import time

class ExecutionTimer:
    """Контекстный менеджер для точного измерения времени выполнения блока кода."""
    def __init__(self, description="Блок кода"):
        self.description = description
        self.elapsed = 0.0

    def __enter__(self):
        print(f"[Таймер] Запуск: {self.description}")
        # perf_counter имеет наивысшее доступное разрешение для измерения времени
        self.start_time = time.perf_counter()
        return self  # Возвращаем объект, чтобы иметь доступ к self.elapsed, если нужно

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.end_time = time.perf_counter()
        self.elapsed = self.end_time - self.start_time
        
        status = "успешно" if exc_type is None else f"с ошибкой {exc_type.__name__}"
        print(f"[Таймер] Окончание: {self.description} завершился {status}")
        print(f"[Таймер] Затраченное время: {self.elapsed:.5f} секунд\n")
        # Мы не возвращаем True, поэтому ошибки будут проброшены дальше

# Использование таймера
with ExecutionTimer("Генерация большого списка") as timer:
    # Выполняем какую-то ресурсоемкую работу
    data = [x**2 for x in range(1_000_000)]

# Мы можем обратиться к свойству таймера после выхода, так как переменная timer все еще существует в области видимости
print(f"Данные сгенерированы. Время работы составило: {timer.elapsed:.2f} сек.")

class MockDatabaseConnection:
    """Фейковый класс для имитации работы с базой данных"""
    def commit(self):
        print("[DB] Выполнен COMMIT: транзакция сохранена.")
    def rollback(self):
        print("[DB] Выполнен ROLLBACK: изменения отменены!")
    def close(self):
        print("[DB] Соединение закрыто.")
    def execute(self, query):
        print(f"[DB] Выполнение запроса: {query}")

class DBTransaction:
    """Контекстный менеджер для управления ACID транзакциями."""
    def __enter__(self):
        print("\n--- Начало новой транзакции ---")
        self.conn = MockDatabaseConnection()
        # Возвращаем само соединение, чтобы им можно было пользоваться в блоке
        return self.conn

    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type is None:
            # Все прошло гладко, нет ошибок - фиксируем изменения
            print("[Менеджер] Ошибок нет. Фиксация...")
            self.conn.commit()
        else:
            # Произошла ошибка (любая!) - немедленно откатываемся
            print(f"[Менеджер] Обнаружена ошибка ({exc_type.__name__}). Откат...")
            self.conn.rollback()
        
        # В ЛЮБОМ случае освобождаем ресурс (закрываем соединение)
        self.conn.close()
        print("--- Конец транзакции ---\n")
        return False # Пробрасываем ошибку дальше

# Сценарий 1: Успешная транзакция
with DBTransaction() as db:
    db.execute("UPDATE accounts SET balance = balance - 100 WHERE name = 'Alice'")
    db.execute("UPDATE accounts SET balance = balance + 100 WHERE name = 'Bob'")

# Сценарий 2: Транзакция с ошибкой (откат)
try:
    with DBTransaction() as db:
        db.execute("UPDATE accounts SET balance = balance - 1000 WHERE name = 'Alice'")
        # Имитация ошибки бизнес-логики
        raise ValueError("Недостаточно средств на счете Алисы!")
        db.execute("UPDATE accounts SET balance = balance + 1000 WHERE name = 'Bob'") # Никогда не выполнится
except ValueError as e:
    print(f"Поймано исключение: {e}")

from contextlib import contextmanager

@contextmanager
def smart_file_opener(file_path, mode):
    """
    Безопасный контекстный менеджер на основе генератора.
    Обратите внимание на обязательное использование try...finally.
    """
    print(f"[Генератор] Открываем файл {file_path}")
    f = open(file_path, mode, encoding='utf-8')
    
    try:
        # Передаем файловый объект пользователю.
        # ЗДЕСЬ генератор замирает.
        # Сюда же будет вброшено исключение, если оно произойдет в блоке with!
        yield f
    
    except UnicodeDecodeError as e:
        # Пример подавления специфической ошибки
        print(f"[Генератор] Поймана ошибка кодировки, подавляем: {e}")
        # Исключение 'поглощено', программа продолжит работу
    
    finally:
        # Этот блок отработает ВСЕГДА, гарантируя закрытие ресурса
        print(f"[Генератор] Закрываем файл {file_path}")
        f.close()

# Использование
with smart_file_opener('test.txt', 'w') as my_file:
    my_file.write("Привет, мир!")
    # Искусственно вызываем ошибку, не связанную с кодировкой
    # raise ValueError("Имитация сбоя системы")
    # Если раскомментировать строку выше, ValueError пролетит через yield,
    # перейдет в finally, закроет файл, а затем программа упадет с ValueError.

import os
from contextlib import suppress, redirect_stdout

# Пример 1: Использование suppress для игнорирования конкретной ошибки
print("Попытка удалить несуществующий файл...")
# Без suppress этот код вызвал бы FileNotFoundError и падение программы
with suppress(FileNotFoundError):
    os.remove('phantom_file_that_does_not_exist.tmp')
print("Программа продолжает работу, ошибка FileNotFoundError подавлена.\n")

# Пример 2: Перенаправление вывода функции print() в файл
def noisy_function():
    """Функция, которая много пишет в консоль (например, из чужой библиотеки)."""
    print("Инициализация...")
    print("Загрузка данных...")
    print("Процесс завершен!")

log_file_path = 'output.log'

print("Сейчас мы перехватим вывод noisy_function и запишем его в файл...")
with open(log_file_path, 'w', encoding='utf-8') as f:
    # Подменяем стандартный вывод (sys.stdout) на наш открытый файл f
    with redirect_stdout(f):
        noisy_function()  # Все print() внутри полетят в файл
        print("Этот текст тоже окажется в файле.")

print("Мы вышли из блока with. Вывод снова направляется в консоль.")

# Проверим, что записалось в файл
with open(log_file_path, 'r', encoding='utf-8') as f:
    print("\nСодержимое файла output.log:")
    print(f.read())

# Современный синтаксис работы с множественными ресурсами (Python 3.10+)
# Использование круглых скобок позволяет элегантно переносить код на новые строки
import sqlite3

# Допустим, мы читаем из файла, фильтруем и одновременно пишем в новый файл и в БД
try:
    with (
        open('source_data.csv', 'r', encoding='utf-8') as src,
        open('cleaned_data.csv', 'w', encoding='utf-8') as dst,
        sqlite3.connect(':memory:') as db_conn  # in-memory база для примера
    ):
        print("Все 3 ресурса успешно открыты и готовы к работе.")
        # Обратите внимание: уровень отступа (indentation) только один!
        
        cursor = db_conn.cursor()
        cursor.execute("CREATE TABLE IF NOT EXISTS stats (processed_lines INTEGER)")
        
        # Эмуляция чтения и записи
        lines_processed = 0
        for line in src:
            # Какая-то логика обработки
            dst.write(line.upper())
            lines_processed += 1
            
        cursor.execute("INSERT INTO stats VALUES (?)", (lines_processed,))
        print(f"Обработка завершена. Строк: {lines_processed}")

except FileNotFoundError as e:
    print(f"Критическая ошибка: Файл не найден - {e}")

print("Мы вышли из блока with. Файлы закрыты, соединение с БД тоже закрыто.")

from contextlib import ExitStack
import os

# Подготовим несколько тестовых файлов для демонстрации
file_names = ['file1.txt', 'file2.txt', 'file3.txt']
for name in file_names:
    with open(name, 'w') as f: f.write("Текст\n")

def read_multiple_files_dynamically(files):
    """
    Динамически открывает произвольное количество файлов,
    гарантируя безопасное закрытие ВСЕХ открытых файлов даже при сбоях.
    """
    opened_files = []
    
    # Открываем главный контекстный менеджер - ExitStack
    with ExitStack() as stack:
        for file_name in files:
            print(f"Попытка открыть {file_name}...")
            try:
                # stack.enter_context сам вызывает open().__enter__() 
                # и регистрирует open().__exit__() для последующего вызова
                f = stack.enter_context(open(file_name, 'r'))
                opened_files.append(f)
            except IOError as e:
                print(f"Не удалось открыть {file_name}: {e}")
                # В реальном приложении мы могли бы прервать работу raise,
                # и ExitStack гарантированно закрыл бы уже открытые файлы.
        
        print(f"\nУспешно открыто файлов: {len(opened_files)}")
        # Теперь мы можем безопасно работать со списком файловых объектов
        for f in opened_files:
            print(f"Чтение из {f.name}: {f.read().strip()}")
            
        print("\nПокидаем блок ExitStack. Стек сейчас автоматически закроет все файлы...")

# Запуск функции
read_multiple_files_dynamically(file_names)

# Уборка (очистка тестовых файлов)
for name in file_names:
    if os.path.exists(name):
        os.remove(name)

import asyncio
from contextlib import asynccontextmanager

class AsyncDatabaseConnection:
    """Имитация асинхронного драйвера базы данных"""
    async def connect(self):
        print("[Асинхронно] Устанавливаем TCP соединение с БД... (ждем 1 сек)")
        await asyncio.sleep(1) # Имитация сетевой задержки без блокировки потока
        print("[Асинхронно] Соединение установлено.")
        
    async def close(self):
        print("[Асинхронно] Корректное закрытие сессии... (ждем 0.5 сек)")
        await asyncio.sleep(0.5)
        print("[Асинхронно] Сессия закрыта.")

# Вариант 1: Через классы (ООП подход)
class AsyncDBManager:
    def __init__(self):
        self.conn = AsyncDatabaseConnection()
        
    async def __aenter__(self):
        # Асинхронный вход. Можно использовать await!
        await self.conn.connect()
        return self.conn
        
    async def __aexit__(self, exc_type, exc_val, exc_tb):
        # Асинхронный выход. Обязательно await для сетевых операций.
        if exc_type:
            print(f"[Асинхронно] Ошибка: {exc_val}. Выполняем откат...")
        await self.conn.close()

# Вариант 2: Через декоратор (Функциональный подход)
@asynccontextmanager
async def async_http_session(url):
    print(f"[Генератор] Открытие сессии к {url}")
    await asyncio.sleep(0.5) # Имитация handshake
    try:
        # Передаем управление в блок async with
        yield f"<Фейковый HTTP ответ от {url}>"
    finally:
        print(f"[Генератор] Разрыв соединения с {url}")
        await asyncio.sleep(0.5)

async def main():
    print("--- Тестируем классовый асинхронный менеджер ---")
    async with AsyncDBManager() as db:
        print("[Main] Работаем с базой данных внутри async with")
        
    print("\n--- Тестируем генераторный асинхронный менеджер ---")
    async with async_http_session("https://api.python.org") as response:
        print(f"[Main] Получены данные: {response}")

# Запуск асинхронной программы
# asyncio.run(main()) # Раскомментируйте для реального выполнения в среде с asyncio