class Bird:
    def fly(self):
        return "I can fly!"

class Duck(Bird):
    def quack(self):
        return "Quack!"

class Airplane:
    def fly(self):
        return "I can also fly!"

def make_it_fly(flyable_thing):
    print(flyable_thing.fly())

# Создаем объекты
duck = Duck()
airplane = Airplane()

# Используем их, не смотря на разные типы
make_it_fly(duck)      # Выведет: I can fly!
make_it_fly(airplane)  # Выведет: I can also fly!

import whylogs as why
import pandas as pd

# Создание примера данных
data = {
    "age": [25, 30, 35, 40, 45],
    "income": [50000, 60000, 70000, 80000, 90000]
}
df = pd.DataFrame(data)

# Инициализация логгера
logger = why.logger()

# Логируем данные
logger.log_dataframe(df)

# Генерируем отчет
report = logger.report()

# Сохраняем отчет
report.save("report.whylog")

# Выводим на экран
print(report)

# Без slots
class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

# Со slots
class OptimizedUser:
    __slots__ = ['name', 'age']
    
    def __init__(self, name, age):
        self.name = name
        self.age = age

class DataPoint:
    __slots__ = ['timestamp', 'value', 'sensor_id']
    
    def __init__(self, timestamp, value, sensor_id):
        self.timestamp = timestamp
        self.value = value
        self.sensor_id = sensor_id

# Представьте, что таких объектов у вас миллионы
data_points = [DataPoint(time.time(), random.random(), i) for i in range(1_000_000)]

def main():

# Точка входа в программу 
if __name__ == '__main__':
    main()

def create_power_function(power):
    def power_func(x):
        return x ** power
    return power_func

# Создаём функции на лету
square = create_power_function(2)
cube = create_power_function(3)

import types

def create_dynamic_function(func_name, args, body):
    namespace = {}
    func_code = f"def {func_name}({', '.join(args)}):\n{body}"
    exec(func_code, globals(), namespace)
    return namespace[func_name]

# Магия в действии
greet = create_dynamic_function(
    "greet",
    ["name"],
    "    return f'Привет, {name}!'"
)

# Старый подход с os.path
import os.path
file_path = os.path.join('data', 'users', 'config.json')
parent_dir = os.path.dirname(file_path)
file_name = os.path.basename(file_path)

# Новый подход с pathlib
from pathlib import Path
file_path = Path('data') / 'users' / 'config.json'
parent_dir = file_path.parent
file_name = file_path.name

path = Path('config.json')
if path.exists():
    print('Файл существует!')

Path('nested/directories/structure').mkdir(parents=True, exist_ok=True)

# Найти все .py файлы в текущей директории
python_files = list(Path('.').glob('*.py'))

path = Path('document.pdf')
print(path.suffix)  # .pdf
print(path.stem)    # document

config_path = (Path.home() / 'projects' / 'app' / 'config.json')
if config_path.exists():
    data = json.loads(config_path.read_text())

with Path('log.txt').open('w') as f:
    f.write('Logging started')

import humanize
import datetime

# Пример: время, прошедшее с 24 сентября 2023 года
dt = datetime.datetime(2023, 9, 24)
print(humanize.naturaltime(dt))  # Вывод: "1 месяц назад" (на момент текущей даты)

import humanize

number = 1500
print(humanize.intcomma(number))  # Вывод: "1,500"
print(humanize.intword(number))    # Вывод: "1.5 k"

import humanize

duration = 3661  # время в секундах
print(humanize.precisedelta(datetime.timedelta(seconds=duration))) 
# Вывод: "1 час, 1 минутa, 1 секунда"

os.rename(old_name, new_name)

import os

# Переименуем файл 'старый_файл.txt' в 'новый_файл.txt'
old_name = 'старый_файл.txt'
new_name = 'новый_файл.txt'

# Проверяем, существует ли старый файл
if os.path.exists(old_name):
    os.rename(old_name, new_name)
    print(f'Файл переименован в {new_name}')
else:
    print(f'Файл {old_name} не найден')

# Открываем файл для записи
with open('example.txt', 'w') as f:
    f.write('Hello, World!')
    # Получаем текущую позицию курсора
    position = f.tell()
    print(f'Current position after writing: {position}')  # Вывод: 13, т.к. длина строки "Hello, World!" = 13

# Открываем файл для чтения
with open('example.txt', 'r') as f:
    content = f.read(5)  # Читаем первые 5 символов
    position = f.tell()
    print(f'Content read: {content}')  # Вывод: Hello
    print(f'Current position after reading: {position}')  # Вывод: 5

class MyClass:
    def __init__(self, name):
        self.name = name
        print(f"Объект {self.name} создан.")

    def __del__(self):
        print(f"Объект {self.name} уничтожен.")

# Создаем объект класса
obj = MyClass("TestObject")

# Удаляем объект
del obj

# Если вы хотите избежать автоматического освобождения памяти,
# можете использовать осмысленное завершение программы, например:
import time
time.sleep(1)  # daем немного времени, чтобы увидеть сообщение деструктора

from rich import print  

# Выводим текст с цветами и стилями
print("[bold red]Ошибка:[/] Неверный ввод!")  
print("[green]Успех:[/] Данные сохранены.")  
print("Это [italic cyan]пример[/italic cyan] текста с [underline magenta]разными[/underline magenta] стилями.")  

from rich.console import Console  
from rich.json import JSON  

console = Console()

# Пример JSON-данных
data = '{"name": "Python3", "type": "Programming Language", "year": 2008}'  

# Форматированный вывод JSON
console.print(JSON(data))

from rich.table import Table  
from rich.console import Console  

console = Console()

table = Table(title="Сравнение языков программирования")

table.add_column("Язык", style="bold", justify="left")  
table.add_column("Скорость", justify="right")  
table.add_column("Простота", justify="right")  

table.add_row("Python", "Средняя", "Высокая")  
table.add_row("Rust", "Высокая", "Средняя")  
table.add_row("C++", "Высокая", "Низкая")  

console.print(table)

from time import sleep  
from rich.progress import Progress  

with Progress() as progress:  
    task = progress.add_task("[cyan]Обработка данных...", total=100)  
    
    for i in range(100):  
        sleep(0.05)  
        progress.update(task, advance=1)  

from rich.tree import Tree  
from rich.console import Console  

console = Console()

tree = Tree("Проект")  
src = tree.add("src")  
src.add("main.py")  
src.add("utils.py")  
tree.add("README.md")  
tree.add("requirements.txt")  

console.print(tree)

from rich.console import Console  
from rich.syntax import Syntax  

console = Console()

code = '''
def greet(name: str) -> str:
    return f"Hello, {name}!"
'''

# Подсвечиваем код
syntax = Syntax(code, "python", theme="monokai", line_numbers=True)  
console.print(syntax)

from rich.logging import RichHandler  
import logging  

logging.basicConfig(  
    level=logging.INFO,  
    format="%(message)s",  
    handlers=[RichHandler()]  
)  

log = logging.getLogger("rich")  

log.info("Это [bold green]информация[/bold green].")  
log.warning("Это [bold yellow]предупреждение[/bold yellow].")  
log.error("Это [bold red]ошибка[/bold red].")  

import plotly.graph_objects as go

# Создаем данные для графика
x = [1, 2, 3, 4, 5]
y1 = [10, 11, 12, 13, 14]
y2 = [8, 9, 10, 11, 12]

# Создаем объект Figure
fig = go.Figure()

# Добавляем первый линейный график
fig.add_trace(go.Scatter(x=x, y=y1, mode="lines+markers", name="Линия 1"))

# Добавляем второй линейный график
fig.add_trace(go.Scatter(x=x, y=y2, mode="lines+markers", name="Линия 2"))

# Настраиваем заголовок и подписи осей
fig.update_layout(title="Интерактивный линейный график",
                  xaxis_title="X",
                  yaxis_title="Y")

# Отображаем график
fig.show()

# Сохраняем график в HTML-файл
# fig.write_html("my_plotly_chart.html")

import httpx

# Отправка GET-запроса
response = httpx.get("https://api.github.com")

# Проверка статуса ответа
if response.status_code == 200:
    print("Успешный запрос!")
    print("Содержимое ответа:", response.text)
else:
    print("Ошибка:", response.status_code)

# Отправка POST-запроса
data = {"key1": "value1", "key2": "value2"}
response = httpx.post("https://httpbin.org/post", data=data)

# Проверка статуса ответа
if response.status_code == 200:
    print("Успешный POST-запрос!")
    print("Содержимое ответа:", response.json())
else:
    print("Ошибка:", response.status_code)

from abc import ABC, abstractmethod

class Animal(ABC):  # Animal - абстрактный базовый класс

    @abstractmethod
    def make_sound(self):
        pass

    @abstractmethod
    def move(self):
        pass


class Dog(Animal):
    def make_sound(self):
        return "Woof!"

    def move(self):
        return "Runs"


class Cat(Animal):
    def make_sound(self):
        return "Meow!"

    def move(self):
        return "Walks"


dog = Dog()
print(dog.make_sound())  # Вывод: Woof!
print(dog.move()) # Вывод: Runs

cat = Cat()
print(cat.make_sound()) # Вывод: Meow!
print(cat.move()) # Вывод: Walks



try:
    animal = Animal() # Попытка создать экземпляр абстрактного класса
except TypeError as e:
    print(e) # Вывод: Can't instantiate abstract class Animal with abstract methods make_sound, move


animals = [Dog(), Cat()]
for animal in animals:
    print(animal.make_sound()) #  Полиморфизм: вызов метода make_sound для разных животных


class Fish(Animal):
    def make_sound(self):
        return "Blub!"


    # Забыли реализовать метод move


try:
    fish = Fish() #  Попытка создать экземпляр класса с нереализованным абстрактным методом
except TypeError as e:
    print(e) # Вывод: Can't instantiate abstract class Fish with abstract methods move

from trafilatura import extract

downloaded_html = """
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Example Page</title>
</head>
<body>
    <h1>This is a heading</h1>
    <p>This is some text in a paragraph.</p>
    <aside>This is some text in a sidebar.</aside>
    <p>This is more text in another paragraph.</p>
    <footer>This is a footer.</footer>
</body>
</html>
"""

extracted_text = extract(downloaded_html)

print(extracted_text)

# Вывод:
# This is a heading
# This is some text in a paragraph.
# This is more text in another paragraph.

from trafilatura import fetch_url

url = "https://www.example.com" #  Замените на реальный URL

try:
    extracted_text = fetch_url(url)
    if extracted_text:
        print(extracted_text)
    else:
        print("Не удалось извлечь текст с URL")
except Exception as e:
    print(f"Произошла ошибка: {e}")


from trafilatura import bare_extraction

extracted_text_with_metadata = bare_extraction(downloaded_html, include_comments=False, include_tables=True, deduplicate=True)
print(extracted_text_with_metadata)

# Пример вывода (может варьироваться в зависимости от контента страницы):
# {'title': 'Example Page', 'text': 'This is a heading\nThis is some text in a paragraph.\nThis is more text in another paragraph.', 'author': None, 'url': None, 'hostname': None, 'description': None, 'date': None}

import asyncio
import asyncpg


async def run():
    conn = await asyncpg.connect(user="user", password="password", database="database", host="127.0.0.1") # Подставьте свои учетные данные

    try:
        # Выполнение запроса на создание таблицы (если она не существует)
        await conn.execute('''
            CREATE TABLE IF NOT EXISTS users (
                id SERIAL PRIMARY KEY,
                name TEXT
            )
        ''')

        # Выполнение запроса на вставку данных
        await conn.execute("INSERT INTO users (name) VALUES ($1)", "Alice")

        # Выполнение запроса на выборку данных
        result = await conn.fetch("SELECT * FROM users")
        print(result) # Вывод: [<Record id=1 name='Alice'>]

        # Выполнение параметризованного запроса на выборку данных
        user_name = "Alice"
        user = await conn.fetchrow("SELECT * FROM users WHERE name = $1", user_name)
        print(user) # Вывод: <Record id=1 name='Alice'>

        # Транзакции
        async with conn.transaction():
            await conn.execute("UPDATE users SET name = $1 WHERE id = $2", "Bob", 1)


        # Обработка ошибок
        try:
            await conn.execute("SELECT * FROM non_existent_table")  # Несуществующая таблица
        except asyncpg.exceptions.UndefinedTableError as e:
            print(f"Ошибка: {e}")



    finally:
        await conn.close()


if __name__ == "__main__":
    asyncio.run(run())

# неформатированный код
def very_important_function(template: str, *variables, engine: str = "jinja2"):
    """Applies `variables` to the `template` using the `engine`."""
    if engine == "jinja2":
        return template.render(*variables)
    elif engine == 'f-strings':
        return eval(f"f'{template}'")
    return template.format(*variables)

# установка black: pip install black
# запуск black: black имя_файла.py

# отформатированный код после Black
def very_important_function(
    template: str, *variables, engine: str = "jinja2"
):
    """Applies `variables` to the `template` using the `engine`."""
    if engine == "jinja2":
        return template.render(*variables)
    elif engine == "f-strings":
        return eval(f"f'{template}'")
    return template.format(*variables)

print(bool(-1))  # Результат: True