Привет, друзья! Сегодня мы нырнём в удивительно простой, но мощный модуль стандартной библиотеки Python — http.server. С его помощью можно всего в несколько строк кода поднять настоящий HTTP-сервер. Без сторонних зависимостей, фреймворков или танцев с бубном.

Зачем это нужно? Например, для локальной отладки веб-приложений, быстрой раздачи файлов с вашей машины, тестирования API или даже написания простейшего backend'а. Итак, приступим!

Минимальный HTTP-сервер за 10 секунд

Внимание, магия! Вот базовый пример:

from http.server import SimpleHTTPRequestHandler, HTTPServer

server_address = ('', 8000)
httpd = HTTPServer(server_address, SimpleHTTPRequestHandler)
print("Server running on http://localhost:8000")
httpd.serve_forever()

Сохрани файл как simpleserver.py, запусти, и зайди в браузере на http://localhost:8000. Ты увидишь содержимое текущей директории — по сути, это файловый сервер “из коробки”.

Обратите внимание:

- Пустая строка в serveraddress означает, что сервер слушает все IP адреса.
- Port 8000 — дефолтный, можно выбрать любой другой.

А что если захотим свой ответ, а не просто отдавать файлы?

Создадим собственный обработчик:

from http.server import BaseHTTPRequestHandler, HTTPServer

class MyHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.send_header('Content-Type', 'text/html')
        self.end_headers()
        message = "<h1>Hello, Python HTTP Server!</h1>"
        self.wfile.write(message.encode('utf-8'))

server_address = ('', 8080)
httpd = HTTPServer(server_address, MyHandler)
print("Custom server running on http://localhost:8080")
httpd.serve_forever()

Теперь при любом GET-запросе сервер вернёт простую HTML-страничку. Всё управляется методом doGET. Можно переопределить и другие: doPOST, doPUT, doDELETE.

Парсим путь и параметры

Допустим, мы хотим разные ответы в зависимости от URL. Используем модуль urllib:

from http.server import BaseHTTPRequestHandler, HTTPServer
from urllib.parse import urlparse, parse_qs

class MyHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        parsed_url = urlparse(self.path)
        path = parsed_url.path
        query = parse_qs(parsed_url.query)

        self.send_response(200)
        self.send_header('Content-Type', 'text/plain')
        self.end_headers()

        if path == '/hello':
            name = query.get('name', ['stranger'])[0]
            response = f"Hello, {name}!"
        else:
            response = "Unknown path."

        self.wfile.write(response.encode('utf-8'))

server_address = ('', 9000)
httpd = HTTPServer(server_address, MyHandler)
print("Query-enabled server running on http://localhost:9000")
httpd.serve_forever()

Попробуйте перейти на http://localhost:9000/hello?name=Alice — сервер ответит: Hello, Alice!

Нюансы и ограничения

- http.server идеально подходит для простых задач, но не заменит полноценный фреймворк вроде Flask или FastAPI.
- Он однопоточный — один запрос за раз. Не подходит для продакшена.
- Без HTTPS — только HTTP.

Зато:

- Не требует установки — есть в любом Python.
- Отличен для отладки, обучения и мини-экспериментов.

Вывод

http.server — как швейцарский нож для любого Python-разработчика. Минимум кода — максимум пользы. Иногда лучшая магия — это простота.

До встречи в следующем посте!

Работа с генетическими алгоритмами в Python: библиотека DEAP

Привет! Сегодня поговорим о теме, которая звучит так, будто была взята из научной фантастики, но на деле имеет массу практического применения — генетические алгоритмы. Если ты когда-нибудь задумывался, как можно применять принципы естественного отбора для решения задач оптимизации — читай дальше. Мы познакомимся с удивительной библиотекой DEAP (Distributed Evolutionary Algorithms in Python), которая делает работу с эволюционными алгоритмами на Python простой и вдохновляющей.

Зачем вообще нужны генетические алгоритмы? Представь, что тебе нужно найти оптимальное решение в огромном пространстве возможных вариантов — классический перебор займёт вечность. Генетические алгоритмы работают по-другому: они "эволюционируют" популяцию решений, отбирая лучших "индивидов", скрещивая их и мутируя. Этот подход широко используется в инженерии, дизайне нейросетей, игровой индустрии и даже в экономике.

Теперь к практике. Устанавливаем DEAP:

pip install deap

Допустим, мы хотим найти максимум функции:

f(x) = x sin(x), где x от 0 до 10

Вот пример минимального рабочего кода на DEAP:

from deap import base, creator, tools, algorithms
import random
import math

# Создаем типы для нашей задачи
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)

toolbox = base.Toolbox()

# Гене — это просто одно число
toolbox.register("attr_float", random.uniform, 0, 10)
toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_float, 1)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)

# Целевая функция
def evaluate(individual):
x = individual[0]
return x math.sin(x),

toolbox.register("evaluate", evaluate)
toolbox.register("mate", tools.cxBlend, alpha=0.5)
toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.2)
toolbox.register("select", tools.selTournament, tournsize=3)

# Запуск эволюции
def run():
population = toolbox.population(n=50)
stats = tools.Statistics(lambda ind: ind.fitness.values)
stats.register("max", max)
stats.register("avg", lambda x: sum(x)/len(x))

population, log = algorithms.eaSimple(population, toolbox, cxpb=0.5, mutpb=0.2, ngen=40, stats=stats, verbose=False)

best = tools.selBest(population, 1)0
print(f"Best individual: x = {best0:.3f}, f(x) = {evaluate(best)0:.3f}")

run()

Что здесь происходит:
- Мы создаем индивидуумов — списки, содержащие одно число (значение x).
- Определяем функцию приспособленности evaluate.
- Используем стандартные операторы скрещивания (cxBlend) и мутации (mutGaussian).
- Запускаем эволюцию и находим наилучшее решение после 40 поколений.

Важно, что DEAP очень гибкий: ты можешь легко подставить свои структуры данных, изменить стратегию отбора, размеры популяции, тип мутации и кроссовера. Хочешь решать задачи с множеством параметров? Просто увеличь длину списка в individual.

Несмотря на "биологический" антураж, DEAP — это мощный инструмент, который реально решает впечатляющий спектр задач. Если тебе понадобилось выйти за пределы классических методов оптимизации — самое время попробовать эволюционный подход.

До встречи в следующем посте!

Как создавать среду для скрининга на вирусы с Python и ClamAV

Заголовок: Защищаем файлы Python'ом: антивирусная среда с ClamAV

Привет! Сегодня мы рассмотрим, как создать простую, но эффективную среду на Python для скрининга файлов на вирусы — руками программиста, используя бесплатный антивирус ClamAV.

Зачем это нужно? Представим: ты разрабатываешь веб-приложение с загрузкой файлов от пользователей. Кто-то может попытаться загрузить вредоносный .exe или .zip-сюрприз. Чтобы не запускать бомбу в своей системе — нужно проверять эти файлы заранее.

Здесь на помощь приходит ClamAV — легкий, кроссплатформенный антивирус с поддержкой командной строки. А Python позволяет автоматизировать и вшить проверку в любое приложение.

🔧 Установка ClamAV

На большинстве Linux-систем установка простая:

sudo apt update
sudo apt install clamav clamav-daemon

Для обновления вирусных баз:

sudo freshclam

Если ты на Windows — скачай инсталлятор с сайта проекта (https://www.clamav.net/) и добавь путь до clamscan в системные переменные.

🐍 Работаем из Python

Чтобы взаимодействовать с ClamAV из Python, можно использовать модуль subprocess для запуска процесса сканирования через clamscan, а также библиотеку pyclamd, если хочешь использовать daemon-режим.

Рассмотрим сначала с subprocess:

import subprocess

def scanfile(filepath):
result = subprocess.run("clamscan", file_path, stdout=subprocess.PIPE, text=True)
output = result.stdout
if "OK" in output:
return "Clean"
elif "FOUND" in output:
return "Infected"
else:
return "Unknown"

print(scanfile("sample.zip"))

Этот код запускает сканирование и парсит результат. Если в выводе встречается “FOUND” — пора бить тревогу.

Теперь подход с pyclamd — более быстрый, если у тебя запущен демон ClamAV (clamd):

pip install pyclamd

import pyclamd

def scanwithdaemon(filepath):
cd = pyclamd.ClamdUnixSocket()
if not cd.ping():
raise ConnectionError("ClamAV daemon is not running.")
result = cd.scanfile(filepath)
if result is None:
return "Clean"
else:
return "Infected"

print(scanwithdaemon("test.pdf"))

🚀 Как использовать

Ты можешь встроить этот сканер в Django или Flask-приложение, настроить папку мониторинга (например, сканируем все, что появляется в uploads/) или устроить cron-задачу по расписанию.

🗂 Нюансы

- ClamAV не проверяет содержимое архивов “глубоко”, если не установлен параметр --recursive или в clamd.conf не включён ScanArchive.
- Производительность: clamd быстрее clamscan, потому что один раз загружает сигнатуры.
- Без обновлений баз смысла нет — freshclam должен запускаться регулярно.

📦 Бонус: сканирование всей директории

def scandirectory(path):
result = subprocess.run(["clamscan", "-r", path], stdout=subprocess.PIPE, text=True)
infections = [line for line in result.stdout.split("\n") if "FOUND" in line]
return infections

infections = scandirectory("/home/user/uploads")
for item in infections:
print(item)

🔐 Итого:

- ClamAV + Python — это реальный способ добавить сканирование на вирусы.
- Можно быстро защитить backend загрузки файлов.
- Используем subprocess или pyclamd, в зависимости от потребностей.

Превратить Python-приложение в антивирусную мини-систему — проще, чем кажется. Рекомендую попробовать на практике — лучше один раз построить, чем сто раз удалить троян.

https://t.me/info_sol

У админа этого канала есть личный блог, в котором он пишет про саморазвитие, нейросети, постит картинки и созданную в нейросетях музыку. Подписывайтесь )

Реализация базовых шифров с библиотекой Cryptography

🔐 Реализация базовых шифров с библиотекой Cryptography в Python

Шифрование — одна из тех тем, которые звучат как нечто мистическое для новичков. Но на деле, благодаря библиотеке cryptography, реализовать базовые методы шифрования в Python проще, чем испечь бутерброд. Сегодня разберём два практических варианта: симметричное и асимметричное шифрование.

Начнём с установки:

pip install cryptography

Готово? Погружаемся.

🔥 Симметричное шифрование с Fernet

Симметричное шифрование — это когда один ключ используется для шифрования и для расшифровки. Как передать ключ другому человеку — другой вопрос. Но именно этот подход используется в большинстве локальных шифровок (например, защищённые файлы на вашем диске).

Модуль Fernet из cryptography делает весь процесс элементарным:

from cryptography.fernet import Fernet

# Генерация ключа
key = Fernet.generatekey()
cipher = Fernet(key)

# Шифруем текст
originaltext = b'This is a secret message.'
encryptedtext = cipher.encrypt(originaltext)

# Дешифруем
decryptedtext = cipher.decrypt(encryptedtext)

print('Encrypted:', encryptedtext)
print('Decrypted:', decryptedtext.decode())

Жутко просто, не правда ли? Ключ здесь — это случайная строка байтов (44 символа в base64), и если потеряете — расшифровать будет уже нельзя. Ровно как и задумано.

🔐 Асимметричное шифрование с RSA

Симметрия хороша, когда ты работаешь с данными локально. Но что делать, если надо передать зашифрованное сообщение другому человеку? Тут на помощь приходит асимметричное шифрование: два ключа — один публичный, другой приватный.

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

from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import serialization, hashes

# Генерация пары ключей
privatekey = rsa.generateprivatekey(publicexponent=65537, keysize=2048)
publickey = privatekey.publickey()

# Шифруем с помощью публичного ключа
message = b'RSA encryption example.'
encrypted = publickey.encrypt(
message,
padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(), label=None)
)

# Расшифровываем с помощью приватного ключа
decrypted = privatekey.decrypt(
encrypted,
padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(), label=None)
)

print('Encrypted (RSA):', encrypted)
print('Decrypted (RSA):', decrypted.decode())

Обрати внимание: здесь используется безопасная схема OAEP, которая делает RSA устойчивым к множеству атак.

💡 Важные моменты

- Библиотека cryptography использует низкоуровневые привязки OpenSSL, поэтому она не только удобна, но и достаточно надёжна.
- RSA шифрует только короткие сообщения. Для реальной передачи больших данных обычно шифруют симметричным ключом, а его уже шифруют RSA.
- Ни Fernet, ни RSA не гарантируют анонимность или защиту от всех атак — это всего лишь строительные блоки.

📦 Вывод

Хотя на первый взгляд шифрование может показаться чем-то пугающим, с cryptography ты получаешь мощный инструмент, который легко применять даже на ранней стадии изучения Python. И пусть это только основа, зато какая прочная!

Чтение и обработка CSV-файлов с помощью модуля csv: примеры и лучшие практики

Привет! Сегодня мы поговорим о настоящей рабочей лошадке в мире обработки данных — модуле csv из стандартной библиотеки Python. Если вы только начинаете погружаться в программирование, то CSV — это один из первых форматов, с которым вы обязательно столкнётесь. Банка Excel? Массивы данных с температурой за 20 лет? Цены акций? Всё это часто лежит в формате CSV. И Python умеет с этим работать очень изящно.

🚀 Что такое CSV?
CSV (Comma-Separated Values) — это простой текстовый формат, в котором каждая строка — это запись, а поля разделены запятыми (или другим символом-разделителем). Удобно, читается любым текстовым редактором, легко обрабатывается.

И вот тут приходит модуль csv — он умеет читать, записывать и аккуратно работать с данными из CSV-файлов. Причём делает это проще, чем кажется!

📥 Пример 1: базовое чтение CSV

Допустим, у нас есть файл data.csv с таким содержимым:

name,age,city
Alice,30,London
Bob,25,New York

Читаем этот файл в Python:

import csv

with open('data.csv', newline='', encoding='utf-8') as file:
reader = csv.reader(file)
for row in reader:
print(row)

Вывод:
'name', 'age', 'city'
'Alice', '30', 'London'
'Bob', '25', 'New York'

Важно: параметр newline='' нужен для корректной обработки переноса строк, особенно на Windows. encoding='utf-8' — чтобы не ругался на юникод.

📌 Лучшие практики:
- Обязательно используйте with для открытия файлов — так файл закроется автоматически, даже если что-то пойдёт не так.
- Никогда не полагайтесь на то, что разделитель всегда запятая. Лучше явно указать delimiter, если файл нестандартного формата.

📥 Пример 2: чтение с использованием словарей (идентификаторы — это красиво!)

import csv

with open('data.csv', newline='', encoding='utf-8') as file:
reader = csv.DictReader(file)
for row in reader:
print(row'name', 'lives in', row'city')

Вывод:
Alice lives in London
Bob lives in New York

DictReader — это просто магия: он превращает строки в словари, где ключи — это названия столбцов. Удобно и читаемо.

🛠 Пример 3: запись в CSV

newdata = [
{'name': 'Charlie', 'age': 28, 'city': 'Berlin'},
{'name': 'Diana', 'age': 32, 'city': 'Paris'}
]

with open('output.csv', mode='w', newline='', encoding='utf-8') as file:
fieldnames = ['name', 'age', 'city']
writer = csv.DictWriter(file, fieldnames=fieldnames)
writer.writeheader()
writer.writerows(newdata)

Этот код создаст новый файл output.csv с указанными строками. DictWriter — ещё одна удобная обёртка, позволяющая красиво и структурированно экспортировать данные.

✅ Несколько полезных советов:

- Если данные разделяются не запятыми, указывайте параметр delimiter, например: csv.reader(file, delimiter=';').
- Пустые строки? Передавайте параметр skipinitialspace=True, чтобы не было проблем с лишними пробелами.
- Часто приходится работать с числовыми значениями — не забудьте конвертировать строку: int(row'age') или float(...).

📎 И напоследок: CSV — это просто. С ним справится даже начинающий программист, и это отличная практика для понимания работы с файлами, структурами данных и базовой автоматизации. Используйте модуль csv на полную: он даже в 2024 году не теряет своей актуальности.

До встречи в следующем посте!

Создание фреймворков на Python: основные подходы и техники

Название статьи: Как создать свой фреймворк на Python и не сойти с ума

Создание собственного фреймворка на Python звучит внушительно — будто ты пишешь новое Django или Flask. Но если отбросить пафос, то это просто: ты создаёшь набор правил, структур и удобных инструментов, которые другие (или ты сам) смогут использовать для быстрой и понятной разработки. В этом посте разберёмся, как вообще подступиться к этой задаче, и какие техники стоит взять на вооружение.

Главная цель фреймворка — абстрагировать рутину. Ты не хочешь каждый раз писать одну и ту же обработку запроса или логирование. Вместо этого ты хочешь сказать: “вот точка входа, вот контроллер, вот обработчик данных” — и всё заработало. Красиво? Красиво. Начинаем.

🔧 Архитектура: как кирпичи в доме

Первый шаг — определить архитектурный скелет. MVC (Model-View-Controller), MVT (как у Django), функциональный стиль — неважно. Главное, чтобы ты чётко знал: где логика, где данные, где интерфейс.

Минимальный фреймворк может выглядеть так:

- точка входа: парсинг запроса, вызов контроллера;
- роутер: определение, какая функция отвечает за запрос;
- контроллер: логика обработки запроса;
- шаблон или функция ответа.

Пример:

# simpleframework.py

import re

routes = {}

def route(path):
def decorator(func):
routes[path] = func
return func
return decorator

def application(env):
path = env.get("PATH", "/")
for pattern, handler in routes.items():
if re.fullmatch(pattern, path):
return handler()
return "404 Not Found"

@route(r"/")
def index():
return "Hello, World!"

@route(r"/about")
def about():
return "This is a demo framework."

Здесь всё просто: у тебя есть декоратор @route, словарь маршрутов и функция application, которая решает, что выдать пользователю.

⚙️ Инверсия контроля: пусть фреймворк командует

Одна из ключевых идей фреймворков — Inversion of Control. Это когда разработчик не вызывает функции фреймворка, а фреймворк сам вызывает код разработчика в нужное время.

Ты предоставляешь “крючки” — функции, которые будут вызваны: обработчики маршрутов, middlewares, хуки при старте и завершении приложения.

Когда ты пишешь:

@route("/hello")
def hello():
return "Hi!"

ты лишь определяешь, что "фреймворк, если вдруг тебе попадается '/hello', вызови вот эту функцию". Это и есть инверсия управления.

🧪 Модули: используем stdlib по максимуму

Хороший фреймворк использует стандартную библиотеку как фундамент. Вот пара модулей, которые сильно помогут:

- inspect — позволяет анализировать аргументы функций, подсказывает, как их вызывать;
- functools — особенно полезен for partial и wraps в декораторах;
- collections — для гибких структур данных;
- asyncio — если ты хочешь сделать асинхронный фреймворк.

Например, добавим поддержку middleware-функций:

middlewares = []

def use(middlewarefunc):
middlewares.append(middlewarefunc)

def application(env):
path = env.get("PATH", "/")
response = None
for pattern, handler in routes.items():
if re.fullmatch(pattern, path):
response = handler()
break
else:
response = "404 Not Found"

for middleware in reversed(middlewares):
response = middleware(response)

return response

@use
def uppercasemiddleware(resp):
return resp.upper()

Теперь любой ответ автоматически становится заглавным. Примитив? Зато гибкость и возможность масштабирования налицо.

📦 Упаковка: превращаем в установочный пакет

Когда фреймворк готов, его стоит опубликовать. Используй setup.py, pyproject.toml и размещай проект на PyPI. Обрати внимание на структуру:

myframework/
init.py
core.py
router.py
...

docs/
tests/

Это не просто красота — это читаемость и поддерживаемость. Ни один разработчик не захочет копаться в мешанине файлов, даже если ты всё написал на гениальном Python.

🧠 Итого

Создание фреймворка — это не магия, а аккуратная выжимка опыта.

Как создать своего голосового помощника с использованием Python и SpeechRecognition

🎙️ Как создать своего голосового помощника с использованием Python и SpeechRecognition

Привет! Сегодня мы разберём, как создать простого голосового помощника на Python, который сможет воспринимать вашу речь и выполнять команды. И хотя до уровня Jarvis из «Железного человека» нам далеко, уже базовая реализация покажет вам, как работает распознавание речи, и даст в руки инструменты для дальнейших экспериментов.

⛏ Что понадобится:

Из модулей нам понадобится:

- speechrecognition — модуль для преобразования аудио в текст
- pyaudio — для захвата звука с микрофона
- pyttsx3 — чтобы помощник мог говорить в ответ
- optionally: webbrowser или os для выполнения простых команд

Установка (терминал):

pip install SpeechRecognition pyaudio pyttsx3

(если с pyaudio будут проблемы — скачайте колесо с https://www.lfd.uci.edu/~gohlke/pythonlibs/)

🚀 Первый голос:

Начнём с простого — распознаем сказанную фразу и ответим на неё голосом.

Пример кода:

import speech_recognition as sr
import pyttsx3

def speak(text):
    engine = pyttsx3.init()
    engine.say(text)
    engine.runAndWait()

def listen():
    recognizer = sr.Recognizer()
    with sr.Microphone() as source:
        print("I'm listening...")
        audio = recognizer.listen(source)
    try:
        return recognizer.recognize_google(audio)
    except sr.UnknownValueError:
        return "Sorry, I didn't catch that"
    except sr.RequestError:
        return "Service unavailable"

command = listen()
print("You said:", command)
speak("You said: " + command)

📌 Что тут происходит:
- Микрофон слушает вас.
- Речь преобразуется в текст через Google Speech API.
- Программа озвучивает распознанную фразу.

🛠 Реакция на команды

Теперь добавим простую обработку команд, чтобы наш голосовой помощник мог не только слушать, но и отвечать делом.

import webbrowser
import os

def handle_command(text):
    text = text.lower()
    if "open google" in text:
        webbrowser.open("https://www.google.com")
        return "Opening Google"
    elif "play music" in text:
        os.startfile("C:\\Users\\Public\\Music\\Sample Music\\song.mp3")
        return "Playing music"
    else:
        return "Command not recognized"

Слышим → Понимаем → Действуем:

command = listen()
response = handle_command(command)
speak(response)

🎯 Советы:
- Используйте .lower() для обработки текста в нижнем регистре.
- Можно подключить словари действий.
- Расширьте помощника: пусть открывает почту, погоду, включает напоминания.

⚠ Важно:
- Убедитесь, что микрофон работает.
- Речь распознаётся через интернет (если используется Google API).
- Для офлайн-распознавания обратите внимание на pocketsphinx (но качество будет хуже).

💡 Идеи на развитие:
- Поддержка нескольких языков
- Контекстный диалог
- Интеграция с Telegram, Discord, голосовыми ассистентами
- Связка с AI-моделями (например, ChatGPT через API)

🧠 Итог:
С помощью всего пары библиотек мы создали основу для голосового помощника, способного понимать речь, реагировать на неё и выполнять действия. Настоящий ИИ начинается с простых шагов — а дальше всё ограничено только воображением и строчками кода.

До встречи в следующем посте — скоро будем обучать ИИ распознавать эмоции по голосу! 🚀

Использование HelloSign API для обработки электронных подписей

📄 Подписываем документы с 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.

---

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

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