📄 Подписываем документы с Python: HelloSign API в действии

В цифровом мире физические подписи — это как отправка писем с почты: можно, но зачем? Электронные подписи экономят время, автоматизируют бизнес-процессы и легитимны во многих странах. Сегодня разберём, как подключить HelloSign API с помощью Python и отправить документ на подпись за минуты.

Что такое HelloSign?

HelloSign — сервис электронных подписей, ныне часть Dropbox. Он позволяет отправлять документы на подпись, отслеживать статус, хранить подписанные версии и всё это через удобный API. Для разработчика это означает: не нужно городить свою инфраструктуру — просто вызывай метод.

Начнём с подготовки

Для работы понадобится:

- Аккаунт на https://app.hellosign.com (бесплатный тестовый доступ есть)
- API Key (доступен в настройках аккаунта)
- Библиотека requests (если не установлена: pip install requests)

Пример 1: Отправка документа на подпись

Давайте отправим PDF-файл на подпись одному получателю.

import requests

apikey = "YOURAPIKEY"
url = "https://api.hellosign.com/v3/signaturerequest/send"

data = {
"title": "NDA Agreement",
"subject": "Please sign this NDA",
"message": "Let me know if you have any questions.",
"signers0email_address": "john@example.com",
"signers0name": "John Doe",
"signers0role": "Client",
"testmode": "1" # 1 = тест, 0 = прод
}

files = {
"file": open("ndatemplate.pdf", "rb")
}

response = requests.post(url, data=data, files=files, auth=(apikey, ""))

print(response.json())

Если всё ок, в ответе будет ID запроса на подпись, статус и ссылка для отслеживания.

Пример 2: Встраиваем форму в веб-приложение

Можно встроить интерфейс HelloSign прямо в ваше приложение — клиент будет подписывать документ, не покидая сайт. Для этого используется embedded-подпись и фронтенд-библиотека (например, hellosign-embedded на JS), но бэкенд всё равно нужен:

url = "https://api.hellosign.com/v3/signaturerequest/createembedded"

data = {
"clientid": "YOURCLIENTID", # получаем здесь: https://app.hellosign.com/apiapp
"title": "Contract",
"subject": "Please sign this contract",
"message": "Contract for future collaboration.",
"signers[0][emailaddress]": "alice@example.com",
"signers0name": "Alice Smith",
"signers0role": "Partner",
"testmode": "1"
}

files = {
"file": open("contract.pdf", "rb")
}

response = requests.post(url, data=data, files=files, auth=(apikey, ""))
requestdata = response.json()
signatureid = requestdata["signaturerequest"]"signatures"0"signature_id"

# Получаем URL для встроенного окна подписи:
embedurl = f"https://app.hellosign.com/editor/embeddedSign?signatureid={signatureid}"

print("Embed URL:", embedurl)

Теперь передаём embedurl на фронт, и пользователь видит форму подписи прямо на нашем сайте.

Отслеживание подписей

Удобно получать статус — документ подписан, отклонён, просрочен и т.д.

statusurl = f"https://api.hellosign.com/v3/signaturerequest/{signatureid}"
status = requests.get(statusurl, auth=(apikey, ""))
print(status.json())

Для продвинутых задач можно настроить webhook — HelloSign будет сам уведомлять сервер о статусе.

Плюсы использования HelloSign API:

- Поддержка вложений, шаблонов и ролей
- Уведомления, напоминания
- Лёгкая интеграция
- Embedded-подпись — удобно для UX
- Подписи юридически валидны

Минусы:

- Бесплатный план ограничен
- Требуется осторожность с персональными данными и соблюдение законодательства

Заключение

Интеграция HelloSign в Python-проект — не только просто, но и эффективно. За несколько строк кода вы получаете надёжный инструмент электронного документооборота. Работает стабильно, официальная документация понятна, а под капотом — готовый бизнес-инструмент с юридической основой.

Современные инструменты для анализа больших данных на Python: модуль PySpark

Привет! Сегодня поговорим о настоящем монстре в мире больших данных — PySpark.

Если вы когда-либо работали с pandas, вы наверняка влюбились в удобство работы с DataFrame. Но однажды наступает момент, когда данных становится слишком много: говорим уже не о десятках тысяч строк, а о миллионах и миллиардах. Вот тут и появляется он — PySpark, Python-интерфейс к Apache Spark.

Apache Spark — это фреймворк для распределённой обработки больших данных. Он позволяет «переварить» десятки гигабайт данных на кластере из множества машин. Но не волнуйтесь: для начала достаточно даже локального режима — на одном компьютере.

Что делает PySpark особенным? Во-первых, он поддерживает ленивое вычисление: операции с данными не выполняются немедленно, а накапливаются в виде плана выполнения. Это позволяет оптимизировать расчёты и сократить ненужные шаги. Во-вторых, PySpark масштабируется — запустите тот же код на одном ноутбуке или на сотне узлов Hadoop кластера, и всё сработает.

Давайте посмотрим на реальные примеры.

Прежде всего, установка:

pip install pyspark

Теперь минимальный пример создания DataFrame и работы с ним:

from pyspark.sql import SparkSession
from pyspark.sql.functions import avg

# Инициализация Spark
spark = SparkSession.builder.appName("BigDataAnalysis").getOrCreate()

# Пример данных
data = ("Alice", 25), ("Bob", 30), ("Charlie", 35), ("David", 40)
columns = "name", "age"

df = spark.createDataFrame(data, columns)

# Простая трансформация
dffiltered = df.filter(df.age > 30)

dffiltered.show()

Результат будет такой:

+-------+---+
| name|age|
+-------+---+
|Charlie| 35|
| David| 40|
+-------+---+

Теперь посчитаем средний возраст:

dfavg = df.select(avg("age").alias("averageage"))
dfavg.show()

Вывод:

+-----------+
|averageage|
+-----------+
| 32.5|
+-----------+

А ещё можно делать группировки, соединения, агрегации — примерно так же, как в pandas, но с учётом миллиардов строк.

Особо стоит отметить PySpark SQL — возможность писать запросы прямо на SQL, обращаясь к таблицам, как к базам данных:

df.createOrReplaceTempView("people")
sqlresult = spark.sql("SELECT name FROM people WHERE age >= 30")
sqlresult.show()

Важно: всё это выполняется распределённо, если подключён кластер. Это значит, что даже при десятках гигабайт данных PySpark не утонет, в отличие от pandas.

PySpark часто используется в реальных проектах: от анализа логов и телеметрии до обработки событий в режиме реального времени. В экосистеме — поддержка Kafka, Amazon S3, Hadoop HDFS, интеграция с MLlib (машинное обучение), GraphX (работа с графами) и другими мощными инструментами.

Да, порог входа чуть выше, чем у pandas. Надо разобраться в концепциях RDD, DAG и планах выполнения, но результат того стоит. Начать можно локально, подключить ноутбук и Jupyter — и вперёд, к большим данным.

PySpark — это не просто модуль, а целая философия обработки данных. Если вы чувствуете, что обычный инструментарий Python упирается в лимит — самое время попробовать Spark.

Настройка и использование Apache Kafka для обработки событий с Python

# Настройка и использование Apache Kafka для обработки событий с Python

Привет, друзья! Сегодня у нас на очереди одна из самых интересных тем — подключение Python к Apache Kafka. Если раньше ты считал, что Kafka — это только для больших компаний и бородатых архитекторах с диаграммами в руках, то готовься: сейчас мы её приручим и начнем использовать буквально в несколько строк кода.

## Что такое Apache Kafka?

Kafka — это распределённая платформа для потоковой передачи сообщений. Грубо говоря, она позволяет одной части вашей системы быстро сообщать события другой части. Представь это как сверхбыстрый почтовый сервис для данных в реальном времени.

## Установка Kafka (локально)

Для локальной установки понадобится Java и собственно Kafka. Если у тебя установлен Docker, развернуть Kafka можно буквально в две команды:

docker network create kafka-net

docker run -d --name zookeeper --network kafka-net -e ALLOW_ANONYMOUS_LOGIN=yes bitnami/zookeeper:latest

docker run -d --name kafka --network kafka-net -e KAFKA_CFG_ZOOKEEPER_CONNECT=zookeeper:2181 -e ALLOW_ANONYMOUS_LOGIN=yes -p 9092:9092 bitnami/kafka:latest

Это поднимет Zookeeper и Kafka сервер локально на порте 9092.

## Установка Python-клиента

Kafka сама по себе не разговаривает на Python. Нам поможет библиотека kafka-python. Устанавливаем ее:

pip install kafka-python

Готово! Теперь пишем наш первый продюсер и консьюмер сообщений.

## Отправка сообщений в Kafka

Создадим продюсера, который будет отправлять события в топик test-topic:

from kafka import KafkaProducer

producer = KafkaProducer(bootstrap_servers='localhost:9092')

for i in range(5):
    message = f"Hello Kafka {i}"
    producer.send('test-topic', message.encode('utf-8'))
    print(f"Sent: {message}")

producer.flush()

Обрати внимание, Kafka ожидает отправку байтов, поэтому .encode('utf-8') обязательно.

## Получение сообщений из Kafka

А теперь консьюмер, который будет эти сообщения забирать:

from kafka import KafkaConsumer

consumer = KafkaConsumer(
    'test-topic',
    bootstrap_servers='localhost:9092',
    auto_offset_reset='earliest',  # берем всё с начала
    enable_auto_commit=True,
    group_id='test-group'
)

for message in consumer:
    print(f"Received: {message.value.decode('utf-8')}")

И вот ты уже слушаешь свой первый поток данных в реальном времени!

## Пара моментов, которые стоит знать:

- Топики и партиции — данные в Kafka не просто в одном потоке, они разбиваются на "топики", а внутри топиков — еще и на "партиции". Это даёт масштабируемость и отказоустойчивость.
- Консьюмер-группы — если несколько приложений читают данные из одного топика в одной группе, Kafka сама балансирует нагрузку между ними.
- Брокеры — один экземпляр Kafka называется брокером. Несколько брокеров можно объединить в кластер для масштабирования.
- Производитель (Producer) и Потребитель (Consumer) — фундаментальные роли в любой системе на Kafka.

## Когда стоит использовать Kafka?

- Если твои данные нужно обрабатывать в реальном времени.
- Когда у тебя много источников событий (например, клики на сайте, заказы в магазине, сенсорные данные).
- Для построения надёжных очередей сообщений между микросервисами.

## Пара советов для продвинутой работы:

- На продакшн используют более надёжные библиотеки, например confluent-kafka-python, основанную на C-библиотеке — она быстрее.
- На старте важно правильно настроить параметры продюсера (например, acks или retries), чтобы не терять сообщения.
- Kafka прекрасно скейлится горизонтально. Добавлять брокеры просто — как складывать кубики Lego.

---

На этом всё! Сегодня мы сделали серьёзный шаг в мир потоковой обработки данных. Теперь ты умеешь не только писать скрипты, но и строить настоящие события в реальном времени.

До встречи в новых статьях — дальше будет ещё интереснее!

Работа с геопространственными данными с использованием библиотеки Fiona

Привет, друзья! Сегодня у нас в блоге отличная тема: поговорим о работе с географическими данными с помощью библиотеки Fiona.

Часто, когда речь заходит о ГИС-данных (географических информационных системах), большинство вспоминает тяжеловесные инструменты вроде ArcGIS или QGIS. Но если вам нужно быстро прочитать shapefile, извлечь нужные геометрии и метаданные, преобразовать их — Python с его библиотекой Fiona делает это элегантно и без лишнего шума.

Что такое Fiona? В двух словах — это библиотека для работы с геопространственными файлами через Python в стиле "сущности-объекты". Она строится поверх библиотеки GDAL/OGR, но обёрнута в удобный, Python-овый интерфейс.

### Установка

Стандартно через pip:

pip install fiona

Важно: GDAL должен быть установлен до этого. На Windows проще всего поставить всё через Conda.

---

### Пример 1: Читаем shapefile

Допустим, у нас есть shapefile с пунктами мониторинга воздуха. Считаем его:

import fiona

with fiona.open('air_quality_stations.shp') as shp:
    for feature in shp:
        print(feature['properties'])
        print(feature['geometry'])

Что происходит?
- feature — это одна запись в файле: свойства точки (например, имя станции) и геометрия (координаты).
- Свойства хранятся в словаре properties, а форма данных (точка, линия, полигон) — в geometry.

---

### Пример 2: Создаём новый geo-файл

Хотите создать свой собственный shapefile из программы? Fiona тоже здесь пригодится.

import fiona
from shapely.geometry import mapping, Point

schema = {
    'geometry': 'Point',
    'properties': {'name': 'str'}
}

points = [
    {'name': 'Station A', 'coordinates': (102.0, 0.5)},
    {'name': 'Station B', 'coordinates': (103.0, 1.0)}
]

with fiona.open(
    'new_stations.shp', 
    mode='w',
    driver='ESRI Shapefile',
    schema=schema,
    crs='EPSG:4326'
) as shp:
    for point in points:
        geom = Point(point['coordinates'])
        shp.write({
            'geometry': mapping(geom),
            'properties': {'name': point['name']}
        })

Здесь:
- Мы задали схему файла: каждый объект — точка + одно текстовое поле name.
- Для каждой точки создаём геометрию через библиотеку Shapely (mapping превращает объект в формат GeoJSON).

---

### Пример 3: Фильтрация объектов

Иногда нужно выбрать только некоторые объекты по условиям:

import fiona

with fiona.open('air_quality_stations.shp') as shp:
    selected = [f for f in shp if f['properties']['city'] == 'Moscow']
    print(f"Found {len(selected)} stations in Moscow")

Быстро и лаконично.

---

### Чем ещё полезна Fiona?

- Поддерживает множество форматов: GeoPackage (.gpkg), GeoJSON, Shapefile и др.
- Читает данные постранично, без загрузки всего файла в память — важно для тяжёлых архивов.
- Работает в паре с другими библиотеками — например, вместе с Shapely и Rasterio делает магию геообработки.

Ключевая идея Fiona — "не ломай данные". Она напрямую передаёт вам GeoJSON-подобные объекты без преобразований, тем самым избавляя вас от сюрпризов при чтении/записи.

---

Fiona — основной инструмент, если стартовать работу с ГИС-данными через Python. Минимализм, устойчивость и логичность — вот за что её любят разработчики.

На следующем шаге рекомендую попробовать связать работу Fiona с визуализацией через Folium или обработкой пространственных запросов через GeoPandas. Но об этом как-нибудь в отдельном посте!

До скорого! 🚀

Как использовать Flask-Security для добавления безопасности в веб-приложения

Добро пожаловать в мир, где безопасность веб-приложений перестает быть кошмаром! Сегодня мы разберем, как с помощью Flask-Security можно быстро добавить регистрацию, логин, подтверждение email и управление ролями в ваше Python-приложение.

Итак, Flask сам по себе не навязывает систему аутентификации. Да, можно писать всё вручную, но это долго и рискованно. Flask-Security же объединяет несколько мощных библиотек — Flask-Login, Flask-Principal, Flask-WTF и Flask-SQLAlchemy — и оборачивает их в элегантный интерфейс.

Давайте сразу к делу.

📦 Устанавливаем всё необходимое:

pip install flask flask_sqlalchemy flask_security-too

Да, именно flask_security-too — форк оригинального Flask-Security, который жив и развивается!

🚀 Базовый пример:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_security import Security, SQLAlchemyUserDatastore, UserMixin, RoleMixin

app = Flask(__name__)
app.config['SECRET_KEY'] = 'supersecretkey'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///app.db'
app.config['SECURITY_REGISTERABLE'] = True
app.config['SECURITY_PASSWORD_SALT'] = 'salt123'

db = SQLAlchemy(app)

# Определяем модели
class Role(db.Model, RoleMixin):
    id = db.Column(db.Integer(), primary_key=True)
    name = db.Column(db.String(80), unique=True)

class User(db.Model, UserMixin):
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(255), unique=True)
    password = db.Column(db.String(255))
    active = db.Column(db.Boolean())
    roles = db.relationship('Role', secondary='roles_users')

class RolesUsers(db.Model):
    id = db.Column(db.Integer(), primary_key=True)
    user_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
    role_id = db.Column(db.Integer(), db.ForeignKey('role.id'))

# Настраиваем
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)

@app.route('/')
def home():
    return 'Welcome to the secured app!'

if __name__ == '__main__':
    db.create_all()
    app.run(debug=True)

И всё! У вас уже есть готовые маршруты для /login, /logout, /register, /reset и многое другое.

⚡ Что ещё можно сделать?

Например, ограничить доступ к маршрутам:

from flask_security import login_required, roles_required

@app.route('/profile')
@login_required
def profile():
    return 'This is your profile.'

@app.route('/admin')
@roles_required('admin')
def admin_area():
    return 'Welcome, admin!'

Теперь только авторизованные пользователи смогут видеть /profile, а доступ к /admin получат лишь те, кто имеет роль "admin".

✨ Пара крутых фишек Flask-Security:

- Встроенное подтверждение регистрации через email.
- Автоматическое управление системой восстановления пароля.
- Защита от CSRF атак "из коробки".
- Возможность кастомизации форм.

Например, чтобы валидировать пароли по-своему, надо просто переопределить форму регистрации:

from flask_security.forms import RegisterForm
from wtforms import StringField
from wtforms.validators import DataRequired

class ExtendedRegisterForm(RegisterForm):
    username = StringField('Username', [DataRequired()])

app.config['SECURITY_REGISTER_FORM'] = ExtendedRegisterForm

И теперь ваши пользователи смогут указывать дополнительное поле username при регистрации!

---

Flask-Security делает жизнь разработчика проще без ущерба безопасности. Он отлично подходит для MVP, внутренних админок и даже более серьёзных проектов, если подкрутить конфигурацию.

Хотите создать продвинутую авторизацию буквально за полчаса? Теперь вы знаете, с чего начать.

Визуализация кинематических цепей с использованием библиотеки PyPlot

Привет! Сегодня мы отправимся в мир движения — а вернее, построим визуализацию кинематической цепи при помощи Python и библиотеки PyPlot. Нет, не нужно быть инженером-механиком, чтобы понять, как «ходят» шестерёнки. Достаточно немного кода и чуточку воображения.

Кинематическая цепь — это модель системы, в которой звенья соединены подвижными сочленениями. Например, рука человека: плечо, локоть, кисть — каждая часть связана с другой и может двигаться. Аналогично, в робототехнике или анимации персонажей используется описание звеньев и их движений.

Для наглядности мы создадим простую двумерную цепь из нескольких сегментов, каждый из которых соединён с предыдущим. Наша задача — визуализировать положение каждого звена в разных конфигурациях, используя библиотеку matplotlib.pyplot.

Начнём с обязательного импорта и настроек:

import matplotlib.pyplot as plt
import numpy as np

Создадим функцию, которая на основе углов и длин звеньев будет генерировать координаты:

def generate_chain_positions(angles, lengths):
    positions = [(0, 0)]
    angle_total = 0
    for i in range(len(angles)):
        angle_total += angles[i]
        x = positions[-1][0] + lengths[i] * np.cos(angle_total)
        y = positions[-1][1] + lengths[i] * np.sin(angle_total)
        positions.append((x, y))
    return positions

В этой функции angles — список углов (в радианах), а lengths — длины каждого звена. Мы накапливаем общее смещение по углу (angle_total), чтобы правильно отрисовать концы звеньев при повороте каждого следующего.

Следующая функция займётся отображением цепи:

def draw_chain(positions):
    x_coords, y_coords = zip(*positions)
    plt.figure(figsize=(6, 6))
    plt.plot(x_coords, y_coords, marker='o', linewidth=3, markersize=8)
    plt.xlim(-10, 10)
    plt.ylim(-10, 10)
    plt.gca().set_aspect('equal')
    plt.grid(True)
    plt.title('Kinematic Chain Visualization')
    plt.show()

Теперь соберем всё вместе и поиграемся с разными положениями:

angles1 = [np.pi/6, np.pi/4, -np.pi/3]
lengths = [3, 2.5, 2]

positions1 = generate_chain_positions(angles1, lengths)
draw_chain(positions1)

Вы увидите трёхзвенную цепь, где каждый следующий сегмент под углом относительно предыдущего. Попробуйте изменить углы — например, анимировать движение:

import time

for i in range(10):
    angles = [np.pi/6 + i*0.1, np.pi/4 - i*0.05, -np.pi/6 + i*0.07]
    positions = generate_chain_positions(angles, lengths)
    draw_chain(positions)
    time.sleep(0.1)

Это приведёт к простой анимации — не самой плавной, но эффектной.

Зачем всё это? Такие визуализации важны в робототехнике, где тонко настраивается движение манипуляторов, или в разработке игр, где требуется реализовать движение конечностей персонажа. Более того, основа такой цепи может быть применена в аналитике движений (motion capture), симуляциях или обучении нейросетей захвату объектов.

PyPlot — не единственный инструмент, конечно. Но если вы только начинаете осваивать Python и хотите визуализировать свои идеи без сложной 3D-графики, он — отличная стартовая точка.

Играйтесь с углами, добавляйте больше звеньев, усложняйте модели — ведь граница только одна: ваше воображение.

Разработка приложений для тестирования пользовательского интерфейса с PyTest

Привет! Сегодня поговорим о том, как использовать PyTest для разработки приложений, связанных с тестированием пользовательского интерфейса. Да-да, PyTest – не только про юнит-тесты и проверку бизнес-логики. С его помощью можно очень удобно организовать тестирование UI, особенно если ты уже используешь Selenium или Playwright.

Когда мы говорим о UI-тестах, первое, что может прийти в голову — это длинные, медленные, хрупкие тесты. Но если подойти к процессу с умом, PyTest превращается в мощный инструмент — с поддержкой фикстур, параметризации, удобной организации кода и настроек. Главное понять, как “подружить” его с UI-инструментами.

Начнем с Selenium. Допустим, ты тестируешь веб-приложение.

Установим все:

pip install pytest selenium

Создаём базовую фикстуру для браузера:

# conftest.py
import pytest
from selenium import webdriver

@pytest.fixture
def browser():
driver = webdriver.Chrome()
yield driver
driver.quit()

Теперь пишем наш первый UI-тест:

# testlogin.py
def testloginform(browser):
browser.get("https://example.com/login")
usernameinput = browser.findelement("name", "username")
passwordinput = browser.findelement("name", "password")
loginbutton = browser.findelement("id", "login")

usernameinput.sendkeys("admin")
passwordinput.sendkeys("123456")
loginbutton.click()

assert "Dashboard" in browser.pagesource

А теперь магия: эти тесты можно запускать, как обычный PyTest-тест, с отчетами, параметрами, фильтрами — как угодно. Если добавить @pytest.mark.parametrize, можно прогнать этот тест с разными значениями логинов/паролей.

PyTest также позволяет внедрить флаг "--headless", чтобы запускать тесты без открытия окна браузера — полезно для CI/CD.

А что насчет Playwright? Это современная альтернатива Selenium, отлично подходящая для UI-тестов. Установим:

pip install pytest-playwright
playwright install

Далее почти всё также. Фреймворк автоматически предоставляет фикстуру 'page':

# testsearch.py
def testsearchfunctionality(page):
page.goto("https://example.com")
page.fill("inputname='q'", "Python")
page.click("buttontype='submit'")
assert page.url.contains("search")

С PyTest и Playwright легко запускать тесты в разных браузерах и окружениях, записывать видео, делать скриншоты при ошибках. Всё это поддерживается “из коробки”.

Ещё один плюс PyTest — структура. Можно группировать тесты по классам, использовать фикстуры для авторизации, навигации, состояния сессии. А если потренироваться, можно автоматически формировать отчёты в формате HTML.

Вывод? PyTest — это не просто способ проверить, делится ли два на два. Это настоящая тестовая платформа, в которую прекрасно вписываются UI-инструменты. С ней удобно, быстро и понятно. А ещё — командная строка для запуска, гибкая конфигурация, расширения (например, pytest-html или pytest-xdist для параллельных прогонов).

Так что, если ты хочешь не просто "тыкать по кнопкам", а делать стабильные и наглядные UI-тесты — PyTest хватает с запасом. Главное — не бояться писать код, даже если ты тестируешь мышкой.

Основы создания настольных приложений с библиотекой PyQt

Основы создания настольных приложений с библиотекой PyQt

Привет, друзья! Сегодня у нас интересная тема — создание настольных приложений с помощью библиотеки PyQt.

Если вы когда-нибудь задумывались: "А как вообще пишут программы с окнами, кнопками и выпадающими списками?" — то добро пожаловать в мир графических интерфейсов. И PyQt — один из самых мощных инструментов для этого в арсенале Python-разработчика.

PyQt — это набор привязок (bindings) к фреймворку Qt, который используют такие крупные приложения, как Dropbox и даже интерфейсы в Autodesk Maya. Он кроссплатформенный, стабильный и безумно гибкий.

Начнем с простого окна. Установка PyQt5:

pip install PyQt5

Теперь создадим базовое окно. Это наш «Hello, world!» в мире GUI:

from PyQt5.QtWidgets import QApplication, QWidget

import sys

app = QApplication(sys.argv)
window = QWidget()
window.setWindowTitle("My First App")
window.resize(300, 200)
window.show()
sys.exit(app.exec())

Здесь QApplication запускает цикл события — сердце любого GUI-приложения. QWidget — это базовый строительный блок интерфейсов. Метод show() делает наше окно видимым.

Теперь добавим кнопку и обработчик события — пусть при нажатии выводится сообщение в терминал:

from PyQt5.QtWidgets import QApplication, QWidget, QPushButton
import sys

def onbuttonclick():
print("Button clicked!")

app = QApplication(sys.argv)
window = QWidget()
window.setWindowTitle("Button Example")
window.resize(300, 200)

button = QPushButton("Click me", window)
button.move(100, 80)
button.clicked.connect(onbuttonclick)

window.show()
sys.exit(app.exec())

Метод connect позволяет связать событие (signal) кнопки с функцией-обработчиком. Все просто и элегантно.

Давайте сделаем еще шаг — добавим поле ввода и выведем текст из него:

from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QLineEdit, QLabel
import sys

def showtext():
userinput = inputfield.text()
label.setText(f"Hello, {userinput}!")

app = QApplication(sys.argv)
window = QWidget()
window.setWindowTitle("Input Example")
window.resize(300, 150)

inputfield = QLineEdit(window)
inputfield.move(20, 20)

button = QPushButton("Greet", window)
button.move(200, 20)
button.clicked.connect(showtext)

label = QLabel("", window)
label.move(20, 60)

window.show()
sys.exit(app.exec())

Теперь программа реагирует на действия пользователя, как настоящее приложение. При желании можно подключать меню, вкладки, таблицы, диалоги выбора файлов и даже рисовать на холсте. Именно так создаются полноценные графические программы.

Если хочется упорядочить расположение элементов — используйте layout-менеджеры: QVBoxLayout, QHBoxLayout и др. Это избавит от ручного указания координат.

PyQt поддерживает более 100 виджетов, работу со стилями (под капотом Qt Style Sheets — аналог CSS), интеграцию с базами данных, OpenGL, WebEngine и даже анимации.

Минус один — PyQt имеет двойную лицензию, GPL и коммерческую. Если вы планируете продавать своё приложение и делать его закрытым, стоит обратить внимание на Qt for Python (бывший PySide2 или PySide6) — он полностью бесплатен для коммерции.

PyQt — отличный инструмент, чтобы перейти от скриптов к настоящим программам. Он позволяет создавать мощные интерфейсы, не покидая удобный и знакомый Python. Попробуйте — и увидите, насколько это круто.

Как использовать Chatterbot для создания чат-ботов на Python

Создание собственного чат-бота звучит как магия будущего, но в Python это может быть делом буквально нескольких десятков строк. Сегодня я расскажу тебе о библиотеке ChatterBot — простом инструменте для обучения и создания диалоговых систем. Даже начинающий программист может собрать своего виртуального собеседника за вечер. Поехали!

Что такое ChatterBot?

ChatterBot — это Python-библиотека, которая позволяет создавать самообучающиеся чат-боты. Она использует алгоритмы машинного обучения для генерации ответов, основываясь на примерах диалогов. Бот анализирует входящие сообщения и подбирает наиболее уместный ответ из своей базы знаний.

Установка

Для начала нужно установить библиотеку (лучше в отдельном виртуальном окружении):

pip install chatterbot==1.0.5
pip install chatterbotcorpus

Внимание: ChatterBot не обновлялся с 2020 года, так что он может не поддерживаться в будущих версиях Python. Точная работа гарантирована, например, на Python 3.8.

Создание простого чат-бота

Начнем с минимального примера:

from chatterbot import ChatBot
from chatterbot.trainers import ChatterBotCorpusTrainer

chatbot = ChatBot('SimpleBot')

trainer = ChatterBotCorpusTrainer(chatbot)
trainer.train('chatterbot.corpus.english')

response = chatbot.getresponse("Hello, how are you?")
print(response)

Что тут происходит:

- Создаем экземпляр ChatBot с именем 'SimpleBot'.
- Используем ChatterBotCorpusTrainer для обучения бота на встроенных английских диалогах из chatterbotcorpus.
- После тренировки бот уже может отвечать на простые приветствия и бытовые фразы.

Добавим свои реплики

Корпус англоязычных диалогов — это хорошо, но что если мы хотим научить бота специальной тематике или стилю?

from chatterbot.trainers import ListTrainer

customdialogue =
"Hi",
"Hello there!",
"What is your name?",
"My name is CodeBot.",
"What do you do?",
"I help you write Python code."


trainer = ListTrainer(chatbot)
trainer.train(customdialogue)

Теперь бот сможет отвечать в стиле, заданном нами. Это особенно полезно для создания узкоспециализированных ботов: техподдержка, FAQ, помощник для онлайн-курса.

Улучшение правдоподобия

ChatterBot использует механизм сравнения строк и выбор наиболее похожего ответа. Но чтобы бот звучал чуть умнее, его нужно «кормить» большим количеством похожих на реальную переписку диалогов.

Можно комбинировать:

- Стандартные корпуса: greetings, conversations, computers и другие из chatterbotcorpus.
- Свои цепочки реплик: списки на ListTrainer.

Также можно подключить логирование:

import logging
logging.basicConfig(level=logging.INFO)

Так ты сможешь видеть, как бот принимает решения при выборе ответа.

Ограничения

Стоит помнить, что ChatterBot — не инструмент для создания суперумных ботов уровня GPT. Он не понимает смысл текста, не использует нейросети (только локальное машинное обучение), и плохо справляется с генерализацией вне обученной логики. Но как вводная платформа — он отличен. Хочешь создать Telegram-бота с ChatterBot внутри? Пожалуйста. Нужно сделать чат-бота для сайта с базовым FAQ? Тоже не проблема.

Заключение

ChatterBot — это замечательный способ начать работать с чат-ботами на Python. Он прост, открыт, легко расширяется. Конечно, у него есть ограничения, но для знакомства с темой и несложных задач — он как находка.

Будь то ваш первый бот-помощник или просто эксперимент для новых знаний — попробуйте создать свою версию и пообщайтесь с ней. А вдруг она окажется интереснее некоторых людей?

Работа с API Twitter: Как создавать автоматизированные обновления статуса.

Ты хочешь, чтобы твой Python-скрипт сообщил всем в Twitter, что ты пьешь утренний кофе? Или, может, каждый день в 9:00 выкладывал мудрую цитату? Что ж, пора познакомиться с одним из самых интересных практических аспектов Python — работой с Twitter API.

Да, Twitter (точнее, X) предоставляет открытое API, к которому можно обращаться через HTTP-запросы. А в Python есть готовые удобные библиотеки, которые позволяют сэкономить массу времени. Наш выбор — Tweepy. Это легковесная и популярная обёртка для Twitter API.

Первым делом — регистрация приложения в консоли разработчика Twitter (https://developer.twitter.com/). После этого вы получите четыре ключевых параметра: API key, API key secret, Access token и Access token secret. Без них не получится выполнять ни одного запроса.

Устанавливаем tweepy:

pip install tweepy

Теперь — сам код. Простой скрипт, который публикует статус:

import tweepy

api_key = "YOUR_API_KEY"
api_secret = "YOUR_API_SECRET"
access_token = "YOUR_ACCESS_TOKEN"
access_secret = "YOUR_ACCESS_SECRET"

auth = tweepy.OAuth1UserHandler(api_key, api_secret, access_token, access_secret)
api = tweepy.API(auth)

status_text = "Доброе утро, Twitter! #python"
api.update_status(status=status_text)

Всё. Этот код опубликует твит от имени пользователя, чьи токены ты указал. Серьёзно, всего несколько строк — и ты уже автоматизируешь публикации.

А что насчёт автоматизации по расписанию? Тут пригодится модуль schedule:

pip install schedule

Пример: публиковать сообщение каждый день в определённое время:

import schedule
import time
import tweepy

def post_daily_status():
    status_text = "Автоматическое утро: солнце, Python и немного кофе. ☕ #GoodMorning"
    api.update_status(status=status_text)

auth = tweepy.OAuth1UserHandler(api_key, api_secret, access_token, access_secret)
api = tweepy.API(auth)

schedule.every().day.at("09:00").do(post_daily_status)

while True:
    schedule.run_pending()
    time.sleep(30)

Можно не ограничиваться текстами. С помощью Tweepy можно прикреплять изображения или даже видео — лишь бы придерживаться формата Twitter и не превышать лимитов.

Кстати, не забывайте о rate limits: Twitter не позволит вам публиковать тысячи твитов в час. Ознакомьтесь с документацией — там всё чётко расписано.

Интересный трюк: создайте JSON-файл с массивом строк, которые бот будет публиковать случайным образом. Чуть-чуть random, чуть-чуть json — и уже почти интеллектуальный твиттер-агент!

В следующем шаге можно добавить реакцию на события. Например, бот отслеживает определённый хэштег — и отвечает на твиты в реальном времени. Сам Tweepy поддерживает stream-интерфейс, что делает это вполне реализуемым даже для новичка.

Работа с Twitter API — отличный способ почувствовать себя разработчиком "боевого" кода. Это не учебные задачи, это реальная интеграция, которая живёт в сети и взаимодействует с другими людьми. Причём на языке Python, который прекрасно справляется с такими задачами: лаконично, красиво и надёжно.