Как создать симулятор физических процессов с использованием 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

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

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

Иногда программы требуют больше, чем просто «считать файл» или «отправить e-mail». Представим ситуацию: у вас есть Python-приложение, сервис на REST API, очередь сообщений RabbitMQ и какой-нибудь FTP-сервер. Все эти элементы нужно интегрировать в единый рабочий поток. Здесь на сцену выходит Apache Camel — не самый известный герой в мире Python, но крайне мощный, если знать, как с ним работать.

Что такое Apache Camel?
Это интеграционный фреймворк на Java, который позволяет соединять разные системы по принципу "роутеров". Основная идея: определить маршрут (route), по которому сообщение будет двигаться от источника к получателю, проходя через возможные трансформации и фильтры. Camel — это своего рода логист при передаче данных между сервисами.

Какой же тут Python?
Прямой интеграции нет — но Camel поддерживает REST, WebSocket, JMS, Kafka, FTP и десятки других компонентов. А на стороне Python — всё, что угодно (Flask, aiohttp, pika, requests, pandas). Нам достаточно определить логичный интерфейс взаимодействия. Обычно — это REST API или очередь сообщений.

Рассмотрим простой сценарий: вы пишете Python-скрипт, который анализирует погоду и отправляет предупреждение в Telegram, но при этом получение данных с погодного сервиса и рассылку сообщений вы хотите делегировать Camel.

🧩 Интеграция:

- Camel забирает данные с внешнего OpenWeather API (через HTTP).
- Camel отправляет POST-запрос на Python REST-сервис для анализа.
- Camel получает ответ и публикует сообщение в Telegram через HTTP.

🎯 Пример маршрутного файла Apache Camel (route.xml):

<routes xmlns="http://camel.apache.org/schema/spring">
  <route id="weather-to-telegram">
    <from uri="timer://weatherTimer?fixedRate=true&period=60000"/>
    <setHeader headerName="CamelHttpMethod">
      <constant>GET</constant>
    </setHeader>
    <to uri="https://api.openweathermap.org/data/2.5/weather?q=London&amp;appid=YOUR_API_KEY"/>
    <to uri="http4://localhost:5000/analyze_weather"/>
    <to uri="https://api.telegram.org/botYOUR_BOT_TOKEN/sendMessage?chat_id=YOUR_CHAT_ID"/>
  </route>
</routes>

Здесь три простой цепочки: таймер (каждую минуту), вызов погоды, отправка на Python, результат — в Telegram.

🧠 Python Flask-приложение, которое анализирует погоду:

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/analyze_weather', methods=['POST'])
def analyze_weather():
    data = request.get_json()
    temp = data.get('main', {}).get('temp', 0)
    message = ""
    if temp < 273:
        message = "❄️ Холодно! Одевайтесь теплее."
    elif temp > 298:
        message = "🔥 Жарковато! Не забудьте воду."
    else:
        message = "🌤️ Погода норм, можно гулять."
    return jsonify({'text': message})

if __name__ == '__main__':
    app.run(port=5000)

Camel сам отправит в наш сервис JSON с погодой. Наш Python-анализатор вернёт сообщение, и Camel сразу бросит его в Telegram.

⚙️ Почему такой подход удобен?

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

🧪 Альтернатива — писать всё в Python вручную. Но тогда мы получим связку requests, sched, threading, json, urllib, time, и это быстро обернётся технодолгом.

🛠 Заключение

Apache Camel + Python — отличная связка для микросервисной интеграции. Camel решает задачу маршрутизации и оркестрации данных, Python — реализует «ум» бизнес-логики. Пускай Camel и из мира Java, но он отлично дрессируется даже под сценарии с Flask, FastAPI, Celery и другими Python-инструментами. Главное — понимать, где проходят границы ответственности.

Работа с облачными хранилищами данных и аналитикой с помощью Python.

Если вы не живёте в пещере, то наверняка сталкивались с "облаками": Google Drive, Dropbox, Amazon S3 и другие — это то место, куда современные приложения сбрасывают гигигабайты данных, чтобы потом что-то с ними делать. Сегодня мы поговорим, как Python помогает не только достучаться до облака, но и прокачать аналитические навыки при помощи этих данных.

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

Начнем с самого популярного хранилища — Amazon S3. Библиотека boto3 позволяет удобно и быстро взаимодействовать с ним:

import boto3

s3 = boto3.client('s3')
s3.download_file('my-bucket', 'sales/q1_report.csv', 'q1_report.csv')

После скачивания данных — аналитика. Pandas и Matplotlib — наши верные помощники:

import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv('q1_report.csv')
summary = df.groupby('region')['sales'].sum()

summary.plot(kind='bar')
plt.title('Sales by Region - Q1')
plt.tight_layout()
plt.savefig('q1_summary.png')

Теперь результат — обратно в облако:

s3.upload_file('q1_summary.png', 'my-bucket', 'reports/q1_summary.png')

Если вы работаете с Google Drive — удобней всего использовать библиотеку pydrive или Google API. С Dropbox — dropbox SDK. Вот пример, как загрузить файл в Dropbox:

import dropbox

dbx = dropbox.Dropbox('YOUR_ACCESS_TOKEN')
with open('q1_summary.png', 'rb') as f:
    dbx.files_upload(f.read(), '/reports/q1_summary.png', mode=dropbox.files.WriteMode.overwrite)

И да, облака — это не только про хранение. Google BigQuery и Amazon Redshift позволяют выполнять SQL-запросы к огромным объемам данных. Попробуем подключиться к BigQuery через pandas-gbq:

from pandas_gbq import read_gbq

query = """
SELECT region, SUM(sales) as total_sales
FROM `project.dataset.sales_data`
GROUP BY region
"""
df = read_gbq(query, project_id='your-project-id')
print(df.head())

Секунды — и у вас на руках сводка за год по всем регионам. Всё это без скачивания гигабайт данных.

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

Так что если в вашем проекте используются облака — самое время подружить их с Python. Возможности открываются действительно космические.

Разработка навыков для голосовых ассистентов на Python.

Разработка навыков для голосовых ассистентов на Python.

Разработка навыков для голосовых ассистентов на Python
———————————————————————

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

🧠 Что такое "навык"?
Навык (skill) — это модуль, который расширяет функциональность голосового ассистента. Например, навык "напомни покормить кота" или "включи успокаивающую музыку" — это код, который получает запрос от пользователя, обрабатывает его и отдает результат в естественном языке.

🎯 Где применимо?
Самые популярные платформы — это Amazon Alexa, Google Assistant и Mycroft AI. Первые две требуют сторонних SDK и облачных сервисов, а вот Mycroft — open-source и идеален для хобби-проектов. Именно на нем и сосредоточимся.

🔧 Установка Mycroft и разработка навыка
Mycroft — это система на Python, легко разворачивается на Linux, Raspberry Pi или в Docker. Навыки для него пишутся с использованием Mycroft Skill SDK.

Проще всего начать с шаблона. Установи SDK:

git clone https://github.com/MycroftAI/mycroft-skills-kit
cd mycroft-skills-kit
./msk create

Тебя проведут по созданию скелета навыка. После этого появится директория с Python-файлом, который выглядит примерно так:

from mycroft import MycroftSkill, intent_file_handler

class CatFeederSkill(MycroftSkill):
    def __init__(self):
        super().__init__()

    @intent_file_handler('feed.cat.intent')
    def handle_feed_cat(self, message):
        self.speak('Don\'t forget to feed the cat!')

📝 Что здесь происходит?
- Мы унаследовали класс MycroftSkill, переопределили инициализацию
- Через декоратор @intent_file_handler мы связали фразу "feed the cat" с функцией
- self.speak() — это то, что прозвучит в ответ

Чтобы навык заработал, нужно отдельно указать список ключевых фраз, запускающих его. В файле vocab/en-us/feed.cat.intent пишем, например:

feed the cat
remind me to feed the cat

💥 Расширяем: подключаем API
Допустим, мы хотим, чтобы навык узнавал, какое сейчас время кормления, из Google Calendar. Используем библиотеку google-api-python-client.

Установим:

pip install --upgrade google-api-python-client google-auth-httplib2 google-auth-oauthlib

(Подразумевается, что вы уже получили доступ к календарю через OAuth 2.0).

Пример запроса к API:

from googleapiclient.discovery import build

def get_next_feeding_event():
    service = build('calendar', 'v3', credentials=creds)
    now = datetime.utcnow().isoformat() + 'Z'
    events_result = service.events().list(calendarId='primary', timeMin=now,
                                          maxResults=1, singleEvents=True,
                                          orderBy='startTime').execute()
    events = events_result.get('items', [])
    if events:
        return events[0]['start'].get('dateTime', 'No dateTime')
    return 'No upcoming events'

Интегрируешь это в навык — и голосовой ассистент будет знать расписание кормления кота лучше тебя.

🧪 Тестирование
Тестировать можно через терминал или же загрузить навык на устройство с Mycroft. Есть поддержка логирования и горячей перезагрузки.

🚀 Заключение
Создание голосовых навыков — это не только шаг в мир ИИ, но и реальная возможность автоматизировать повседневность. Python делает это просто: минимум кода, максимум смысла. Хотите умного помощника? Начните с одной команды — а закончите персональным ИИ-дворецким.

Как использовать библиотеки для автоматического тестирования веб-приложений.

🔥 Как использовать библиотеки для автоматического тестирования веб-приложений

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

Да, автоматизация тестирования — это не только для корпораций с огромным QA-отделом. Даже если ты пишешь свой первый сайт на Flask — запускать тесты «по кнопке» и быть уверенным, что ничего не сломано после очередного коммита — бесценно.

Давайте рассмотрим две популярные библиотеки: Selenium и pytest, плюс кратко затронем requests и BeautifulSoup для API и контентных проверок.

🎯 Selenium — когда надо кликать мышкой и вводить текст

Selenium позволяет имитировать поведение пользователя в браузере: запустить сайт, заполнить поля, нажать кнопки и проверить, как всё работает. Вот простой пример с использованием Chrome WebDriver:

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys

driver = webdriver.Chrome()
driver.get("https://example.com/login")

username_input = driver.find_element(By.NAME, "username")
password_input = driver.find_element(By.NAME, "password")

username_input.send_keys("test_user")
password_input.send_keys("secure_pass")
password_input.send_keys(Keys.RETURN)

assert "Dashboard" in driver.title
driver.quit()

Этот код удобно запускать в рамках pytest или unittest. Selenium особенно полезен, когда нужно протестировать интерфейс, JavaScript и формы.

🤖 Pytest — быстрые и читаемые тесты

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

Пример интеграции с requests для проверки REST API:

import requests

def test_api_status():
    response = requests.get("https://api.example.com/status")
    assert response.status_code == 200

def test_login_api():
    data = {"username": "test_user", "password": "secure_pass"}
    response = requests.post("https://api.example.com/login", json=data)
    assert response.json().get("token") is not None

Иногда этого достаточно — особенно если ты делаешь SPA с разделённым backend.

🍜 Bonus: BeautifulSoup для проверки содержимого

Допустим, приходит HTML, и хочется убедиться, что нужный блок отрисовался:

from bs4 import BeautifulSoup

html = "<html><body><div id='welcome'>Hello, test_user!</div></body></html>"
soup = BeautifulSoup(html, "html.parser")
welcome_div = soup.find("div", id="welcome")
assert welcome_div.text == "Hello, test_user!"

Не затыкай нос — HTML можно парсить, не страдая.

📦 Как собрать вместе?

Обычно автоматика выглядит так: ты пишешь тесты на pytest, которые используют библиотеки вроде requests для API и selenium для UI. Запуск происходит через команду:

pytest tests/

Или, если хочется сборку в CI/CD — используется GitHub Actions или GitLab CI. Всё по-взрослому.

⚡ Итог

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

Тестируй умно — пиши код с уверенностью.