Многоязычие в Django: как заставить ваше приложение "говорить" по-английски, по-русски и не только

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

🔹 Шаг 1: Включим поддержку перевода

В settings.py активируем интернационализацию:

USE_I18N = True
USE_L10N = True

LANGUAGE_CODE = 'en'

LANGUAGES = [
    ('en', 'English'),
    ('ru', 'Russian'),
]

LOCALE_PATHS = [
    BASE_DIR / 'locale',
]

Параметр LANGUAGES важен — это список поддерживаемых языков. Именно здесь вы определяете, на какие языки будет переведён ваш интерфейс.

🔹 Шаг 2: Готовим строки к переводу

Все строки, которые должны быть переведены, нужно пометить специальными функциями. Django предоставляет gettext() и gettext_lazy() (чаще используется ugettext_lazy, но начиная с Django 4.0 используется просто gettext_lazy).

Пример в шаблоне:

<h1>{% trans "Welcome to my website!" %}</h1>

Пример в Python-коде:

from django.utils.translation import gettext_lazy as _

class Product(models.Model):
    name = models.CharField(max_length=100, verbose_name=_("Product Name"))

🔹 Шаг 3: Собираем переводимые строки

После пометок — соберём все строки для перевода. Выполняем команду:

django-admin makemessages -l ru

В результате появится файл locale/ru/LC_MESSAGES/django.po. Именно в нём вы вписываете переводы:

msgid "Welcome to my website!"
msgstr "Добро пожаловать на мой сайт!"

🔹 Шаг 4: Компилируем переводы

Чтобы Django мог использовать переведённые строки, необходимо скомпилировать .po в .mo:

django-admin compilemessages

Теперь переводы готовы к использованию.

🔹 Шаг 5: Автоматическое определение языка

Добавьте LocaleMiddleware в MIDDLEWARE:

MIDDLEWARE = [
    # ...
    'django.middleware.locale.LocaleMiddleware',
    # ...
]

Этот middleware анализирует заголовки браузера или куки и подставляет нужный язык.

Хотите переключать язык вручную? Создайте URL:

from django.conf.urls.i18n import i18n_patterns

urlpatterns = i18n_patterns(
    path('admin/', admin.site.urls),
    path('products/', include('products.urls')),
)

Теперь URL-адрес будет содержать префикс языка (/ru/products/), а Django подстроится под локаль.

🔹 Шаг 6: Динамическое переключение языка

Можно переключать язык прямо во время выполнения, например, через форму или селектор:

from django.utils import translation

def set_language_view(request):
    user_language = 'ru'
    translation.activate(user_language)
    response = HttpResponse("Привет!")
    response.set_cookie(settings.LANGUAGE_COOKIE_NAME, user_language)
    return response

🎉 Готово!

Теперь ваше Django-приложение умеет "разговаривать" на нескольких языках. Это открывает дорогу к глобальному рынку и делает интерфейс дружелюбнее к пользователю.

Локализация в Django — это не просто nice-to-have. Это must-have, если вы хотите выйти за пределы одного языка. Делая ваш сайт многоязычным, вы делаете его доступным. А значит — полезным.

Обзор архитектуры микросервисов и их реализация на Python.

🚀 Микросервисы на Python: как всё устроено?

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

🔧 Что такое микросервисы?

Если коротко — микросервисная архитектура подразумевает разделение приложения на отдельные, автономные сервисы. Каждый из них выполняет небольшую, четко определённую задачу и взаимодействует с остальными через API, обычно по HTTP или через очередь сообщений. В отличие от монолита, где всё связано, микросервисы «разведены» по своим зонам ответственности, что позволяет им развиваться независимо.

🎯 Почему Python?

Python отлично подходит для микросервисов благодаря своей лаконичности, огромному количеству библиотек и фреймворков, а также простоте интеграции с современными DevOps-инструментами и брокерами сообщений.

🔥 Основные инструменты

Рассмотрим три популярных подхода к созданию микросервисов на Python.

1. Flask/FastAPI — REST API сервисы

Для простых REST-сервисов FastAPI — просто бомба. Он быстрый (благодаря ASGI), прост в использовании и умеет сам генерировать документацию (Swagger, ReDoc).

Пример простого микросервиса:

from fastapi import FastAPI

app = FastAPI()

@app.get("/ping")
def ping():
    return {"message": "pong"}

Такой сервис легко развернуть, протестировать или масштабировать.

2. Celery + Redis/RabbitMQ — асинхронные задачи

Если ты хочешь, чтобы один микросервис "бросал задание", а другой — "его делал", без ожидания, пригодится Celery. Пример с использованием Redis:

worker.py

from celery import Celery

app = Celery('tasks', broker='redis://localhost:6379/0')

@app.task
def add_numbers(a, b):
    return a + b

caller.py

from worker import add_numbers

result = add_numbers.delay(3, 5)
print(result.get())

Celery превращает Python-функции в асинхронные задачи, которые можно распределять между машинами и масштабировать.

3. gRPC — бинарный, быстрый, строгий

Для микросервисов с высоким трафиком, строгими контрактами и необходимостью работать быстро — gRPC отличное решение. Он использует Protocol Buffers вместо JSON и позволяет создавать строго типизированные API.

Пример на базе библиотек grpcio и protobuf выходит чуть длиннее, но даёт большой выигрыш в производительности и безопасности.

👀 Взаимодействие микросервисов

Варианты связки сервисов:

- HTTP-запросы (Flask/FastAPI)
- Очереди сообщений (RabbitMQ, Kafka, Redis Streams)
- gRPC
- GraphQL gateway

Для оркестрации и развертывания чаще всего используют Docker и Kubernetes.

🧩 Где подводные камни?

- Сложность: микросервисы — это дополнительная логика: деплой, мониторинг, логирование, безопасность.
- Сетевые накладные расходы.
- Управление версиями API.

Тем не менее, если архитектура продумана и под задачи системы микросервисы подходят — Python обеспечит тебе мощный и гибкий стек.

📦 Заключение

Python и микросервисы — отличная пара. Благодаря таким фреймворкам, как FastAPI, Celery и gRPC, ты можешь легко строить масштабируемые и надёжные системы. Вопрос только в задачах и грамотном проектировании — всё остальное уже есть в твоем распоряжении.

Следующий шаг — выбирать инструменты под конкретную задачу и не забывать про тестирование и наблюдаемость (observability). Удачного микросервисинга! 💡

Первичные шаги в создании персонализированных чат-ботов с NLP.

Привет, друзья! Сегодня мы с вами заглянем под капот одного из самых интересных применений Python – создание собственных чат-ботов с помощью Natural Language Processing (NLP). Да, тех самых "ботиков", которые понимают речь, здороваются, отвечают на вопросы и даже могут разрядить неловкую паузу в чате.

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

Итак, для начала нам понадобятся следующие инструменты:

- библиотека nltk — для базовой обработки человеческой речи;
- библиотека random — чтобы бот не казался шаблонным;
- немного Python-мозгов — оно у вас точно есть ;)

Установка нужных библиотек:

pip install nltk

Импортируем всё, что нужно, и подгрузим ресурсы:

import nltk
import random
from nltk.chat.util import Chat, reflections

nltk.download('punkt')

Теперь разберёмся с основой: Chat в nltk работает по принципу паттерн-ответ. То есть, когда бот видит "привет", он ищет подходящий шаблон и отвечает заготовленной фразой.

Создадим набор диалогов:

pairs = [
    [
        r"привет|здравствуй|хай",
        ["Привет!", "Здравствуйте!", "Хаюшки :)"]
    ],
    [
        r"как дела\??",
        ["Всё отлично, а у тебя?", "Лучше не бывает!", "Пишу код, как обычно!"]
    ],
    [
        r"что ты умеешь\??",
        ["Я умею болтать и поддерживать диалог, как любой вежливый бот.", 
         "Моя задача — делать твоё общение с компьютером чуть приятнее."]
    ],
    [
        r"пока|до свидания",
        ["Пока-пока!", "До встречи!", "Счастливо!"]
    ],
    [
        r"(.*)",
        ["Извини, я пока не знаю, как на это ответить.", 
         "Попробуй переформулировать вопрос.", 
         "Интересно… но не совсем понятно :)"]
    ]
]

Если вы заметили, шаблоны — это регулярные выражения. Они ловят фразы, похожие на заданный паттерн. Это просто, но мощно! Последний шаблон r"(.*)" — запасной план, "уловка на всё", если бот не понял, что вы сказали.

Теперь создаём и запускаем нашего чат-бота:

def run_bot():
    print("Привет! Я — твой простой NLP-бот. Напиши что-нибудь, чтобы начать (или 'пока' для выхода).")
    chat = Chat(pairs, reflections)
    chat.converse()

run_bot()

Кстати, переменная reflections — это словарь с заменами типа "я" -> "ты", "мой" -> "твой", что делает диалог чуть-чуть более персонализированным. Хотите больше — можно под себя переписать.

Что можно улучшить?

1. Добавить понимание эмоций: анализировать тональность текста, например, с помощью TextBlob.
2. Интегрировать с Telegram, Discord или веб-интерфейсом.
3. Хранить историю диалога, "тренировать" бота под вашу специфику.

Создание собственного NLP-бота — это как завести ручного интеллекта: вы растите его сами, программируя каждую реакцию. Это отличный способ прокачать свои навыки Python, регулярных выражений и понимания языка.

Впереди ещё много интересного: препроцессинг текста, машинное обучение, векторизации фраз — но об этом в следующих постах. А пока — вперед, создать своего первого "говоруна"! 🧠🤖

Как создавать графические интерфейсы с библиотекой PySimpleGUI.

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

Если вас пугают слова вроде "Qt", "Tkinter" или "canvas", вы не одиноки. Многие считают, что GUI на Python — это сложно, громоздко и требует много времени. Но PySimpleGUI с этим не согласен. Его девиз — «сделай быстро и просто». Он оборачивает популярные GUI-библиотеки (Tkinter, Qt, WxPython, Remi) в простой, читаемый интерфейс. Это буквально Python-код, который читается как псевдоязык.

Давайте не терять время и перейдём к практике.

Установка

Для начала установим библиотеку:

pip install PySimpleGUI

Пример 1. Первое окно "Hello, world!"

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

import PySimpleGUI as sg

layout = [
    [sg.Text("Hello, world!")],
    [sg.Button("OK")]
]

window = sg.Window("My First Window", layout)

while True:
    event, values = window.read()
    if event == sg.WINDOW_CLOSED or event == "OK":
        break

window.close()

Здесь layout — это список, описывающий содержимое окна построчно. Всё элементарно: текстовая метка и кнопка.

Пример 2. Простая форма ввода

Теперь создадим мини-приложение, которое спрашивает имя пользователя и приветствует его:

import PySimpleGUI as sg

layout = [
    [sg.Text("What's your name?")],
    [sg.Input(key="name")],
    [sg.Button("Submit")],
    [sg.Text("", size=(30, 1), key="output")]
]

window = sg.Window("Name App", layout)

while True:
    event, values = window.read()
    if event == sg.WINDOW_CLOSED:
        break
    if event == "Submit":
        name = values["name"]
        window["output"].update(f"Hello, {name}!")

window.close()

Обратите внимание: каждое поле можно идентифицировать по ключу (key), а затем обновлять или извлекать значение через values.

Пример 3. Сохранение файла

А теперь добавим диалог сохранения файла, который можно встроить в любое приложение:

import PySimpleGUI as sg

layout = [
    [sg.Text("Save your file:")],
    [sg.InputText(key="filepath"), sg.FileSaveAs()],
    [sg.Button("Save"), sg.Button("Exit")]
]

window = sg.Window("File Saver", layout)

while True:
    event, values = window.read()
    if event in (sg.WINDOW_CLOSED, "Exit"):
        break
    if event == "Save" and values["filepath"]:
        with open(values["filepath"], "w") as f:
            f.write("Some example content.")

window.close()

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

Что мне особенно нравится — вы можете быстро собрать интерфейс, протестировать логику, и на лету вносить изменения. У PySimpleGUI отличный встроенный отладочный вывод — вы всегда видите, что возвращает read() и какие события происходят.

Заключение

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

Если вы только начинаете знакомство с GUI-разработкой — PySimpleGUI даст вам мягкий старт и хороший фундамент.

Введение в генеративные модели с использованием отличившихся нейронных сетей и Python.

# Введение в генеративные модели с использованием нейронных сетей и Python

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

В этом посте я покажу, как с помощью Python и фреймворка PyTorch можно построить базовую генеративную модель — автокодировщик (Autoencoder). Это не GAN и не Diffusion модель, но отличная стартовая точка для понимания принципов генерации.

## Что делает автокодировщик?

Автокодировщик состоит из двух частей:
1. Encoder — ужимает входные данные в компактное представление (вектор скрытого пространства).
2. Decoder — восстанавливает оригинальные данные из этого "сжатого" представления.

По сути, он учится восстанавливать вход с минимальными потерями — и, научившись этому, может "фантазировать" похожие данные в этом же пространстве.

## Простой пример: генерация изображений цифр MNIST

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

pip install torch torchvision matplotlib

Импортируем нужное:

import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt

Определим архитектуру:

class Autoencoder(nn.Module):
    def __init__(self):
        super(Autoencoder, self).__init__()
        self.encoder = nn.Sequential(
            nn.Flatten(),
            nn.Linear(28 * 28, 128),
            nn.ReLU(),
            nn.Linear(128, 32),
        )
        self.decoder = nn.Sequential(
            nn.Linear(32, 128),
            nn.ReLU(),
            nn.Linear(128, 28 * 28),
            nn.Sigmoid(),
            nn.Unflatten(1, (1, 28, 28))
        )

    def forward(self, x):
        encoded = self.encoder(x)
        decoded = self.decoder(encoded)
        return decoded

Подготовим данные MNIST:

transform = transforms.ToTensor()
dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
loader = DataLoader(dataset, batch_size=64, shuffle=True)

Обучим модель:

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = Autoencoder().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
criterion = nn.MSELoss()

for epoch in range(5):
    for batch in loader:
        imgs, _ = batch
        imgs = imgs.to(device)
        outputs = model(imgs)
        loss = criterion(outputs, imgs)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")

Сгенерируем несколько новых изображений:

with torch.no_grad():
    latent_vectors = torch.randn(16, 32).to(device)
    generated_imgs = model.decoder(latent_vectors)
    grid = torchvision.utils.make_grid(generated_imgs.cpu(), nrow=4)
    plt.imshow(grid.permute(1, 2, 0))
    plt.axis('off')
    plt.show()

## Что дальше?

Автокодировщики — это только первая ступень в мире генеративных моделей. На их базе строятся Variational Autoencoders (VAE), GANs и даже новейшие Diffusion Models, которые уже рисуют как DALL·E и пишут как ChatGPT.

Понимание принципов автокодировщиков дает хорошую основу для освоения более сложных, но невероятно мощных моделей.

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

Как создать симулятор физических процессов с использованием Python и PhysX

Когда Python встречает физику: симулятор с помощью NVIDIA PhysX

Что объединяет гоночные симуляторы, реалистичную анимацию разрушений и эффектное поведение объектов на сцене? Конечно, физика. А если быть конкретнее — движок PhysX, изначально разработанный Ageia, а позже поглощённый NVIDIA. Он лежит в основе механики многих игр и симуляторов. Но что, если мы хотим использовать его вместе с Python?

Благодаря проекту physx-python от NVIDIA, теперь это возможно. Интуитивный интерфейс Python позволяет собирать полноценные трёхмерные сцены с телами, гравитацией и столкновениями — и всё это с минимальной настройкой.

Что потребуется?

- Установленный Python 3.8+
- Установленный модуль physx (доступен через PyPI или GitHub)
- Знание базовых концепций физики (масса, силы, импульсы)

Установка:

pip install physx

Сборка первой сцены

Создадим простую сцену: куб падает на плоскость под действием гравитации.

from physx import PxPhysics, PxSceneDesc, PxDefaultErrorCallback, PxDefaultAllocator, PxSimulationEventCallback
from physx import PxRigidStatic, PxRigidDynamic, PxShape, PxBoxGeometry, PxMaterial, PxTransform, PxVec3

physics = PxPhysics()
material = physics.create_material(0.5, 0.5, 0.6)

scene_desc = PxSceneDesc(gravity=PxVec3(0, -9.81, 0))
scene = physics.create_scene(scene_desc)

# Создаем землю (плоскость)
ground_shape = physics.create_shape(PxBoxGeometry(50, 1, 50), material)
ground_body = physics.create_rigid_static(transform=PxTransform(p=PxVec3(0, -1, 0)))
ground_body.attach_shape(ground_shape)
scene.add_actor(ground_body)

# Создаем динамический куб
box_shape = physics.create_shape(PxBoxGeometry(1, 1, 1), material)
box_body = physics.create_rigid_dynamic(transform=PxTransform(p=PxVec3(0, 5, 0)))
box_body.attach_shape(box_shape)
scene.add_actor(box_body)

Теперь запустим симуляцию:

time_step = 1.0 / 60.0  # 60 FPS
for step in range(120):
    scene.simulate(time_step)
    scene.fetch_results()
    pos = box_body.get_global_pose().p
    print(f"Step {step}: Box Y={pos.y:.2f}")

На выходе мы получим по кадрам, как куб падает и отскакивает — PhysX учитывает инерцию, массу, трение и отскок автоматически.

Почему PhysX и не, скажем, Pymunk или Box2D?

- PhysX — это полноценная 3D-физика. Большинство Python-движков оперируют 2D.
- Оптимизация. PhysX используется в AAA-проектах и оптимизирован под реальные нагрузки.
- Расширяемость. С PhysX можно моделировать не только твердые тела, но и жидкости, ткани, разрушения (через расширения).

Советы:

- Обрабатывайте столкновения через колбэки (наследуйте PxSimulationEventCallback)
- Используйте инерцию и силы, а не вручную перемещайте тела
- Не забывайте освобождать ресурсы (release())

PhysX с Python — это серьезный инструмент для тех, кто хочет симулировать реальные процессы: от гравитации и столкновений до сложного взаимодействия объектов. Создавайте симуляторы роботов, физические головоломки или тестируйте алгоритмы управления — теперь это возможно без написания ни строчки C++.

Следующий шаг? Визуализация. А значит, впереди ждёт интеграция с OpenGL, Pyglet или Panda3D. Физика оживает, а Python снова доказывает, что с ним возможны настоящие чудеса.

Разработка IoT решений с помощью платформы ThingsBoard и Python

Разработка IoT решений с помощью платформы ThingsBoard и Python

Интернет вещей (IoT) — уже не фантастика, а реальность, которую легко начать осваивать, имея под рукой Python и платформу ThingsBoard. Если вы хотите собирать телеметрию с датчиков, управлять устройствами удалённо и строить красивые дашборды — добро пожаловать в мир ThingsBoard.

Что такое ThingsBoard?

ThingsBoard — это Open-source IoT-платформа, которая позволяет собирать, обрабатывать, визуализировать данные и управлять устройствами через MQTT, HTTP или CoAP. Платформа поддерживает модульность, масштабируемость и отлично работает как на обычном сервере, так и в облаке.

Как Python здесь помогает?

Python хорош тем, что позволяет быстро прототипировать. Нас интересует взаимодействие с ThingsBoard через MQTT, и здесь библиотека paho-mqtt — наш лучший друг.

Подключение устройства к ThingsBoard

Допустим, у вас есть датчик температуры подключенный к Raspberry Pi. Для начала опубликуем данные об измерениях в ThingsBoard. У каждого устройства в ThingsBoard есть access token. Всё, что нужно — отправить JSON с телеметрией на сервер.

Установка зависимостей:

pip install paho-mqtt

Пример кода отправки данных:

import time
import json
import random
import paho.mqtt.client as mqtt

BROKER = "demo.thingsboard.io"
PORT = 1883
ACCESS_TOKEN = "YOUR_DEVICE_ACCESS_TOKEN"

client = mqtt.Client()
client.username_pw_set(ACCESS_TOKEN)
client.connect(BROKER, PORT, 60)

while True:
    temperature = round(random.uniform(20.0, 30.0), 2)
    humidity = round(random.uniform(40.0, 60.0), 2)

    payload = json.dumps({"temperature": temperature, "humidity": humidity})
    client.publish("v1/devices/me/telemetry", payload)

    print(f"Sent: {payload}")
    time.sleep(10)

Теперь, заходя в веб-интерфейс ThingsBoard, вы будете видеть температуру и влажность в режиме реального времени.

Чтение команд от сервера

Но IoT — это не только датчики, но и управление в обратную сторону. ThingsBoard умеет отправлять RPC-команды (например, включить тумблер или лампу на устройстве).

Добавим обработку RPC-запросов:

def on_connect(client, userdata, flags, rc):
    client.subscribe("v1/devices/me/rpc/request/+")
    
def on_message(client, userdata, msg):
    payload = json.loads(msg.payload)
    method = payload.get("method")
    params = payload.get("params")

    if method == "toggle_led":
        state = params.get("enabled")
        print(f"Turning LED {'ON' if state else 'OFF'}")

client.on_connect = on_connect
client.on_message = on_message
client.loop_start()

Теперь если вы отправите RPC-команду из интерфейса ThingsBoard, Python-скрипт обработает её.

ThingsBoard + Python = мощное решение для реальных задач

С помощью всего пары десятков строк кода вы создаёте устройство, связанное с облаком, способное сообщать телеметрию и выполнять команды. Это отличная основа для "умного дома", производственных мониторингов, сельскохозяйственных систем и десятков других сценариев.

Бонус: симуляция устройства

Даже если у вас под рукой нет Raspberry Pi — вы можете использовать обычный Python-скрипт как симулятор устройства. Тестируйте логику на стадии прототипа без лишнего оборудования.

В следующий раз мы подробнее разберём построение дашбордов и создание алертов в ThingsBoard. А пока — запускайте скрипт и наблюдайте, как в облаке "живёт" ваше первое IoT-устройство.

Работа с распределенными системами: основы использования Zookeeper с Python

📌 Работа с распределёнными системами: основы использования Zookeeper с Python

Если вы когда-нибудь задумывались, как крупные системы вроде Kafka, Hadoop или Cassandra координируют свои миллионы узлов по всему миру — скорее всего, там где-то завелся Apache Zookeeper. Сегодня разберемся, как Python может взаимодействовать с этим повелителем распределённого хаоса.

🧠 Немного теории

Apache Zookeeper — это централизованный сервис для поддержания конфигурации, управления кластером и обнаружения сервисов. Он основан на простой, но мощной модели: дерево узлов данных (так называемые znode), очень похожее на файловую систему.

Zookeeper гарантирует:

- Последовательность операций между узлами
- Обнаружение сбоев
- Хранение конфигураций и состояний
- Лёгкую синхронизацию при помощи блокировок и очередей

🎮 Подключаемся к Zookeeper из Python

Для общения с Zookeeper в Python стоит использовать библиотеку kazoo. Она предоставляет высокоуровневый, асинхронный API. Устанавливаем:

pip install kazoo

🚀 Пример 1: Подключение и создание узла

from kazoo.client import KazooClient

zk = KazooClient(hosts='127.0.0.1:2181')
zk.start()

# Создадим узел /app с данными "ready"
if not zk.exists("/app"):
    zk.create("/app", b"ready")

data, stat = zk.get("/app")
print("Node data:", data.decode())

zk.stop()

Мы подключились к локальному экземпляру Zookeeper, создали узел /app и записали туда строку. Zookeeper по умолчанию работает с байтами, имейте это в виду.

🧪 Пример 2: Вотчеры (наблюдатели)

Вотчеры позволяют следить за изменениями в узлах. Когда данные меняются — вызывается обратный вызов.

from kazoo.client import KazooClient

zk = KazooClient(hosts='127.0.0.1:2181')
zk.start()

def on_change(event):
    print(f"Watched event type: {event.type}, path: {event.path}")

zk.DataWatch('/app', on_change)

zk.set('/app', b'updated')

zk.stop()

Это основа реактивного взаимодействия между сервисами. Один узел может изменить состояние, другой сразу это подхватит.

🔐 Пример 3: Примитив блокировки

Zookeeper часто используют для реализации распределённых блокировок. Kazoo предоставляет удобный API:

from kazoo.client import KazooClient
from kazoo.recipe.lock import Lock

zk = KazooClient(hosts='127.0.0.1:2181')
zk.start()

lock = Lock(zk, "/lockpath")

with lock:
    print("Lock acquired, doing critical section")

zk.stop()

Это особенно полезно, если несколько пользователей или сервисов должны иметь эксклюзивный доступ к ресурсу, например — к файлу или порту.

🎯 Когда стоит использовать Zookeeper?

- Управление состояниями микросервисов
- Выбор лидера в кластере
- Распределённые блокировки
- Централизованная конфигурация
- Обнаружение доступных сервисов

Однако учтите: Zookeeper не масштабируется горизонтально как message queue — это не база данных, а регистр состояний. Он не любит большие объёмы данных, и требует внимания к отказоустойчивости.

📎 Заключение

Zookeeper — инструмент, стоящий на стыке простоты и мощности. С помощью всего пары десятков строк кода на Python можно внедрить базовую координацию в распределённую систему. Kazoo делает это приятным и вполне Python-образным. Так что если ваш проект растёт вширь и нуждается в синхронизации множества сервисов, взгляните на Zookeeper!

Создание приложений для черепичной сшивки изображений с OpenCV

Привет! Сегодня поговорим о том, как с помощью Python и библиотеки OpenCV сделать собственное приложение для черепичной сшивки изображений (image tiling & stitching). Эта задача особенно актуальна в сфере обработки спутниковых снимков, работы с изображениями высокой чёткости или при создании панорам.

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

—

Что такое черепичная сшивка?

Представьте, что у вас есть несколько перекрывающихся фрагментов одной и той же большой сцены, но снятых по частям. Ваша задача — склеить эти плитки (tiles) в одно большое изображение. Чтобы это сделать, нужно:

1. Найти ключевые точки (keypoints) в каждом изображении.
2. Сопоставить соответствующие точки между изображениями.
3. Посчитать матрицу преобразования (гомографию).
4. Трансформировать изображения и сшить в финальную панораму.

Теперь перейдем к коду.

Первым делом, необходимые модули:

import cv2
import numpy as np

Теперь загрузим два изображения:

image_1 = cv2.imread("tile_left.jpg")
image_2 = cv2.imread("tile_right.jpg")

Далее — извлечение ключевых точек и дескрипторов с помощью ORB:

orb = cv2.ORB_create(nfeatures=2000)

kp1, des1 = orb.detectAndCompute(image_1, None)
kp2, des2 = orb.detectAndCompute(image_2, None)

Для поиска совпадений используем BFMatcher:

bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
matches = bf.match(des1, des2)
matches = sorted(matches, key=lambda x: x.distance)

Отфильтруем и найдем гомографию:

src_pts = np.float32([kp1[m.queryIdx].pt for m in matches[:50]]).reshape(-1,1,2)
dst_pts = np.float32([kp2[m.trainIdx].pt for m in matches[:50]]).reshape(-1,1,2)

H, mask = cv2.findHomography(dst_pts, src_pts, cv2.RANSAC, 5.0)

И наконец — применим гомографию и объединим изображения:

height, width = image_1.shape[:2]
image_2_warped = cv2.warpPerspective(image_2, H, (width * 2, height))
image_2_warped[0:height, 0:width] = image_1

cv2.imwrite("stitched_output.jpg", image_2_warped)

—

Приложение, построенное на этом пайплайне, способно объединить десятки изображений в одну панораму. Конечно, для большого количества тайлов придётся реализовать логику автоматического выбора пар изображений, контроля перекрытия и конечной обрезки границ. Но фундамент уже есть.

Можно также использовать SIFT или AKAZE вместо ORB, повысить количество фич, настроить лучшее сопоставление по расстоянию — и ваша сшивка будет максимально качественной.

Бонус: если изображения GRID-подобные (например, каждая плитка — квадрат одной мозаики), можно автоматизировать позиции сшивки заранее, что даст прирост скорости. А если вы работаете с гигабайтными изображениями — добавьте Pillow или Dask для потоковой обработки.

С OpenCV и всего сотней строк кода на Python вы можете превратить десятки скучных фрагментов в полноценную мозаику мира.

Введение в web scraping с использованием библиотек Scrapy и Selenium

Введение в web scraping с использованием библиотек Scrapy и Selenium

🏗 Введение в web scraping с использованием Scrapy и Selenium

Собирать данные с сайтов — это почти как добывать золото: кто вовремя начал, тот и нашёл сокровища. Web scraping позволяет автоматизировать сбор информации с сайтов, и в Python для этого есть мощные инструменты. Сегодня мы взглянем на два самых популярных — Scrapy и Selenium.

📌 Scrapy: паук, который знает, куда ползти

Если вам нужно быстро и масштабируемо собирать структурированные данные, Scrapy — идеальный выбор. Это асинхронный фреймворк, созданный специально для парсинга.

Установка:

pip install scrapy

Как выглядит простейший Scrapy-паук:

import scrapy

class QuotesSpider(scrapy.Spider):
    name = "quotes"
    start_urls = ["http://quotes.toscrape.com/"]

    def parse(self, response):
        for quote in response.css("div.quote"):
            yield {
                "text": quote.css("span.text::text").get(),
                "author": quote.css("small.author::text").get(),
            }

Запуск:

scrapy runspider quotes_spider.py -o quotes.json

Scrapy быстро, удобно и экономно вытянет нужные данные из HTML — пока сайт не вставляет всё содержимое с помощью JavaScript. Тогда на сцену выходит Selenium.

🚘 Selenium: браузерный пилот-робот

Иногда сайты упрямо не отдают нужные данные, пока JavaScript не "догрузит" контент. Тогда у нас один выход — автоматизировать действия настоящего браузера.

Установка:

pip install selenium

Пример: как с помощью Selenium вытащить цитаты со страницы с динамическим контентом:

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
import time

options = Options()
options.add_argument("--headless")
driver = webdriver.Chrome(options=options)

driver.get("http://quotes.toscrape.com/js/")
time.sleep(2)  # подождём, пока JS подгрузит контент

quotes = driver.find_elements(By.CLASS_NAME, "quote")
for q in quotes:
    text = q.find_element(By.CLASS_NAME, "text").text
    author = q.find_element(By.CLASS_NAME, "author").text
    print({"text": text, "author": author})

driver.quit()

🔥 Scrapy против Selenium

| Характеристика | Scrapy | Selenium |
|----------------------|-------------------------------|-------------------------|
| Скорость | Высокая (асинхронная) | Низкая (имитирует браузер) |
| Поддержка JS | Нет | Да |
| Использование памяти | Экономное | Тяжёлое |
| Удобство отладки | Лучше для парсинга | Лучше для автотестов и сложной логики |

🧩 Идеальный сценарий — совмещать: использовать Selenium для получения HTML со сложных JS-страниц, а дальнейший парсинг делать с помощью Scrapy или BeautifulSoup.

Если вы собираетесь парсить десятки тысяч страниц, стоит идти через Scrapy. Если же цель — парсинг интерактивных компонентов одной-двух страниц, Selenium подойдёт лучше. А иногда — сочетайте.

Следите за "золотыми правилами" scraping-а: соблюдайте robots.txt, не перегружайте сервер запросами, и, конечно, уважайте условия использования сайта.

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

Как соединять различные веб-сервисы с помощью Apache Camel и Python