Разработка навыков для голосовых ассистентов на 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. Начни с простого, а потом постепенно автоматизируй всё, что можно.

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

Быстрая обработка гигантских наборов данных с использованием библиотеки Vaex.

🚀 Быстрая обработка гигантских наборов данных с использованием библиотеки Vaex

Обработка миллионов строк данных за секунды — звучит как фантастика? Для pandas — возможно, но не факт. А вот для Vaex — это его стихия. В этом посте я расскажу о том, как справляться с большими объёмами данных с помощью библиотеки Vaex — легковесного и ультрабыстрого инструмента для анализа данных на Python.

🧠 Что такое Vaex?

Vaex — это библиотека для обработки больших табличных данных, созданная с фокусом на производительность. В отличие от pandas, она использует ленивые вычисления (lazy evaluation), memory-mapping и мультиядерные вычисления для обработки данных в десятки раз быстрее. Миллионы строк? Подумаешь. Даже миллиард — не предел.

Вот ключевые фишки Vaex:
- Обработка данных, которые не помещаются в оперативную память.
- Поддержка ленивых операций (т.е. ничего не считается до тех пор, пока не попросишь).
- Использование zero-copy memory access — данные читаются прямо с диска без загрузки в RAM.
- Интеграция с файловыми форматами Arrow, HDF5 и Parquet.

📦 Установка

Устанавливаем библиотеку:

pip install vaex

🚀 Быстрый старт

Допустим, у нас есть CSV-файл с 50 миллионами строк. Попробуем прочитать его и посмотреть средние значения по колонке:

import vaex

# Быстрая загрузка большого файла
df = vaex.from_csv('big_data.csv', convert=True, chunk_size=5_000_000)

# Просмотр первых строк, как в pandas
print(df.head())

# Вычисление средней температуры, к примеру
mean_temp = df['temperature'].mean()
print(f"Mean temperature: {mean_temp}")

Метод from_csv с параметром convert=True один раз конвертирует CSV в более быстрый бинарный формат Arrow/HDF5, чтобы в будущем грузиться мгновенно.

🧪 Где быстрее, чем в pandas?

Vaex особенно хорош для агрегаций и фильтраций. Сравним простую агрегацию:

# Средняя цена по категориям
df.groupby('category', agg={'avg_price': vaex.agg.mean('price')})

Огромный набор категорий и десятки миллионов цен — Vaex справляется без напряжения.

🎯 Фильтрация на лету

Vaex не гонит весь датафрейм через фильтры. Он выполняет их лениво, максимально эффективно:

# Отфильтруем дорогие продукты
df_filtered = df[df.price > 1000]

# Считаем средний рейтинг у дорогих товаров
print(df_filtered['rating'].mean())

🔥 Визуализация огромных данных

Vaex умеет делать биннинг (разбиение по диапазонам), что особенно полезно при визуализации плотных scatter-плотов:

df.plot(df.x, df.y, f='log1p', shape=512)

Да, прямо так. Интерактивное, быстрое, работает на миллионах точек.

📁 Разделение и экспорт

Вы можете экспортировать уже отфильтрованные или агрегированные данные обратно в Parquet или CSV:

df_filtered.export_parquet('filtered_data.parquet')

🧩 Vaex против pandas

Время выполнения задачи агрегации в pandas: десятки секунд или даже минуты (и возможный MemoryError). В Vaex — доли секунды. И не нужно думать, достаточно ли у тебя оперативки.

📌 Используй тогда, когда:

- Твои данные занимают десятки или сотни ГБ
- pandas падает с ошибками памяти
- Требуется быстрая агрегация, фильтрация, группировка
- Нужно делать всё это без громоздких кластеров Spark/Dask

✨ Вывод

Vaex — отличный инструмент, когда речь идёт о больших объемах данных и важна скорость. Он не заменяет pandas как основной инструмент работы с данными, но для heavy-duty аналитики — просто must-have. Попробуй использовать его в своём следующем дата-проекте — и удивишься, насколько это быстро.

Как выстраивать непрерывную интеграцию и доставку (CI/CD) для Python проектов.

🚀 Как выстраивать непрерывную интеграцию и доставку (CI/CD) для Python-проектов

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

Что такое CI/CD?

- Continuous Integration (CI) — это процесс автоматической сборки и проверки кода при каждом коммите.
- Continuous Delivery (CD) — автоматическая доставка протестированного кода в staging или даже production.

Вместе они превращают “внезапный релиз” в “предсказуемое событие”.

Платформы: GitHub Actions, GitLab CI, CircleCI и др. Мы разберем GitHub Actions — мощный и удобный инструмент, прямо внутри GitHub.

📦 Структура Python-проекта

Типовая структура проекта:

my_project/
├── app/
│   └── main.py
├── tests/
│   └── test_main.py
├── requirements.txt
└── .github/
    └── workflows/
        └── ci.yml

Файл ci.yml — сердце нашего процесса CI.

🔧 Простой CI pipeline (GitHub Actions)

name: Python CI

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v3

    - name: Set up Python
      uses: actions/setup-python@v4
      with:
        python-version: '3.10'

    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt

    - name: Run tests
      run: |
        pytest tests/

Что происходит:
- Workflow запускается на push или pull request в ветку main.
- На виртуальной машине ставится Python.
- Устанавливаются зависимости.
- Запускаются тесты с помощью pytest.

🛠️ Добавляем Code Quality: linters

Проверка стиля важна не меньше тестов.

    - name: Run linter
      run: |
        pip install flake8
        flake8 app/

Ошибка форматирования — fail pipeline. Чистота — залог стабильности.

🚢 Непрерывная доставка: CD

Допустим, у нас есть staging-сервер и GitHub уже подключен к нему через секреты (например, SSH-ключ, API token и т.д.). Ниже пример, как можно деплоить через SCP:

  deploy:
    needs: test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'

    steps:
    - name: Checkout code
      uses: actions/checkout@v3
      
    - name: Deploy via SCP
      run: scp -r ./app user@staging-host:/app-folder
      env:
        SSH_PRIVATE_KEY: ${{ secrets.SSH_PRIVATE_KEY }}

Реализация зависит от вашего хостинга. Можно использовать Docker, Heroku, DigitalOcean, AWS — что угодно.

🔥 Бонус: кэш зависимостей

Чтобы ускорить pipeline:

    - name: Cache pip
      uses: actions/cache@v3
      with:
        path: ~/.cache/pip
        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
        restore-keys: |
          ${{ runner.os }}-pip-

При повторном запуске зависимости не будут скачиваться заново — экономим минуты и нервы.

🎯 Вывод

CI/CD превращает ваш Python-проект из “хаоса” в “машину”, где каждый коммит — шаг вперед, а не на грабли. Даже простая автоматизация сборки и тестов — огромный шаг к качеству и стабильности. Начните с малого, добавляйте шаг за шагом. Пусть ваш код работает, пока вы спите!

Использование библиотеки dash для создания интерактивных веб-приложений.

Если вы когда-нибудь задумывались, как превратить скрипт на Python в красивое и интерактивное веб-приложение, не вникая в HTML, CSS и JavaScript, то библиотека Dash — это то, что вам нужно. Она позволяет собирать интерактивные сайты с панелями управления (dashboards), графиками и формами буквально из нескольких строчек кода. Всё, что нужно — знание Python и немного фантазии.

Dash создана разработчиками Plotly, и в её основе — Flask, React.js и Plotly.js. Однако всё это скрыто за удобным API, который говорит с вами исключительно на Python.

Начнём с простого примера:

📦 Установка:

pip install dash

📈 Минимальное приложение:

import dash
from dash import html

app = dash.Dash(__name__)

app.layout = html.Div([
    html.H1("Hello, Dash!"),
    html.P("Build interactive web apps with pure Python.")
])

if __name__ == '__main__':
    app.run_server(debug=True)

После запуска откройте в браузере http://127.0.0.1:8050 — и увидите вашу первую HTML-страницу, сгенерированную Python-кодом.

Но Dash действительно раскрывает свой потенциал, когда вы интегрируете графику и взаимодействие.

🎯 Добавим графики с Plotly:

import dash
from dash import dcc, html
import plotly.express as px
import pandas as pd

df = px.data.iris()

fig = px.scatter(df, x="sepal_width", y="sepal_length", color="species")

app = dash.Dash(__name__)

app.layout = html.Div(children=[
    html.H1("Iris Data Visualization"),
    dcc.Graph(
        id='iris-graph',
        figure=fig
    )
])

if __name__ == '__main__':
    app.run_server(debug=True)

Всё, что вы знали о графиках в Jupyter Notebook, теперь работает и в вебе. Идём дальше — добавим интерактивность.

🕹️ Используем callbacks:

from dash.dependencies import Input, Output

app.layout = html.Div([
    dcc.Input(id='user-input', type='text', value='Dash', debounce=True),
    html.H2(id='output')
])

@app.callback(
    Output('output', 'children'),
    Input('user-input', 'value')
)
def update_output(value):
    return f'Hello, {value}!'

Теперь всё живое. Меняете текст — и приложение реагирует. Без JS и без боли. Это может быть input-поле, выпадающий список, слайдер и многое другое.

👨‍💻 Dash особенно полезен для аналитиков данных и инженеров, которым надо собрать визуальную панель или форму для управления расчётами, не отвлекаясь на фронтенд.

Бонус: всё, что вы делаете в Dash, может быть развёрнуто на любой платформе: от Heroku до Docker-контейнера.

📚 Полезно знать:

- dash.html — набор базовых HTML-компонентов
- dash.dcc — продвинутые компоненты: графики, слайдеры, dropdown
- @app.callback — магия, связывающая данные и визуал

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

Эффективная обработка JSON-LD данных с использованием библиотеки RDFLib.

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

🎯 Немного теории: JSON-LD (JSON for Linking Data) — это способ сериализации Linked Data в формате JSON. Используется для представления семантической информации: описания сущностей, связей между ними и контекста. Обычно это можно встретить в open data от правительств, научных институтов, Википедии (через Wikidata) и в структурированных данных на сайтах.

А теперь самое интересное — практика.

📦 RDFLib — это мощная Python-библиотека для работы с RDF-графами. Она поддерживает различные форматы (Turtle, XML, JSON-LD и другие), позволяет парсить, сериализовать RDF и выполнять запросы SPARQL.

Установим библиотеку:

pip install rdflib

🛠️ Представим, что у нас есть следующий JSON-LD документ:

{
  "@context": {
    "name": "http://schema.org/name",
    "homepage": { "@id": "http://schema.org/url", "@type": "@id" }
  },
  "@id": "http://example.org/person#me",
  "name": "Ivan Petrov",
  "homepage": "http://example.org/"
}

Давайте загрузим и обработаем его с помощью RDFLib:

from rdflib import Graph

jsonld_data = '''
{
  "@context": {
    "name": "http://schema.org/name",
    "homepage": { "@id": "http://schema.org/url", "@type": "@id" }
  },
  "@id": "http://example.org/person#me",
  "name": "Ivan Petrov",
  "homepage": "http://example.org/"
}
'''

g = Graph()
g.parse(data=jsonld_data, format='json-ld')

for subj, pred, obj in g:
    print(f"{subj} -- {pred} --> {obj}")

Вывод будет примерно такой:

http://example.org/person#me -- http://schema.org/url --> http://example.org/
http://example.org/person#me -- http://schema.org/name --> Ivan Petrov

🎯 Что здесь важно? RDFLib превращает JSON-LD в RDF-граф, с которым ты можешь работать с той же легкостью, что и с обычным Python-объектом.

🔍 Запросы к данным? Легко, с помощью SPARQL:

from rdflib.namespace import Namespace

SCHEMA = Namespace("http://schema.org/")

query = """
SELECT ?name
WHERE {
  ?person <http://schema.org/name> ?name .
}
"""

qres = g.query(query)

for row in qres:
    print(row.name)

Вывод:

Ivan Petrov

Да, это похоже на SQL, только графовый стиль. Такой подход особенно хорошо себя проявляет, когда ты работаешь с большими онтологиями или данными из Wikidata.

💡 Совет: RDFLib поддерживает сериализацию обратно в JSON-LD, Turtle и другие форматы. То есть можно использовать её как конвертер:

print(g.serialize(format="json-ld", indent=2))

📌 Такой фреймворк делает Python удобной средой для работы с современными структурированными данными, где важны не только значения, но и связи между ними.

Надеюсь, теперь JSON-LD и RDFLib звучат не как абстрактные академические термины, а как инструменты, которые реально можно и нужно использовать. Experiment, explore, и пусть граф знаний будет с тобой!

Как настраивать и использовать OAuth аутентификацию в Python-приложениях.

Если вы когда-либо хотели дать своим пользователям доступ к сервисам вроде Google, GitHub или Facebook, не заставляя их вбивать пароли — добро пожаловать в мир OAuth.

OAuth (Open Authorization) — это стандарт авторизации, который позволяет получать ограниченный доступ к защищённым ресурсам без передачи логина и пароля. Звучит круто? Ещё бы. И сегодня мы посмотрим, как реализовать OAuth-аутентификацию на Python, используя библиотеку Authlib — одна из самых простых и эффективных для этой задачи.

📦 Установка библиотек:

pip install Authlib Flask

Мы будем строить небольшой Flask-сервер, через который пользователь сможет авторизоваться через, например, GitHub.

⚙️ Базовая настройка Flask и OAuth-клиента

from flask import Flask, redirect, url_for, session
from authlib.integrations.flask_client import OAuth

app = Flask(__name__)
app.secret_key = 'your-secret-key'
oauth = OAuth(app)

github = oauth.register(
    name='github',
    client_id='GITHUB_CLIENT_ID',
    client_secret='GITHUB_CLIENT_SECRET',
    access_token_url='https://github.com/login/oauth/access_token',
    authorize_url='https://github.com/login/oauth/authorize',
    api_base_url='https://api.github.com/',
    client_kwargs={'scope': 'user:email'},
)

Вам нужно будет взять значения client_id и client_secret в настройках своего GitHub OAuth-приложения.

🌐 Маршруты Flask:

@app.route('/')
def homepage():
    return '<a href="/login">Login with GitHub</a>'

@app.route('/login')
def login():
    redirect_uri = url_for('authorize', _external=True)
    return github.authorize_redirect(redirect_uri)

@app.route('/authorize')
def authorize():
    token = github.authorize_access_token()
    resp = github.get('user', token=token)
    user_info = resp.json()
    session['user'] = user_info
    return f"Hello, {user_info['login']}!"

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

1. Пользователь заходит на /login.
2. Перебрасывается на страницу авторизации GitHub.
3. После логина возвращается на /authorize.
4. Приложение получает access token и может запрашивать данные.

Теперь, не зная паролей пользователей, мы получаем информацию о них. Максимально безопасно. А если access token протухнет — можно запросить новый, не беспокоя пользователя.

🧠 Полезный совет:

Храните client_id и client_secret не в коде, а в переменных окружения:

import os

client_id = os.getenv('GITHUB_CLIENT_ID')
client_secret = os.getenv('GITHUB_CLIENT_SECRET')

🔄 А если нужен другой провайдер? Просто поменяйте ссылки и scopes. Authlib поддерживает Google, Facebook, Twitter и даже кастомные OAuth-провайдеры.

В целом, настройка OAuth через Authlib не такая уж и страшная, как может показаться на первый взгляд. Зато какой уровень удобства и безопасности! Если ваше приложение хоть как-то связано с пользователями — OAuth точно стоит освоить.

Простейшие графические редакторы с использованием библиотеки tkinter.

🎨 Простейшие графические редакторы с использованием библиотеки tkinter

Каждому программисту когда-то хочется превратить консольную рутину во что-то более… зрелищное. Если вы только начинаете осваивать Python – отличной отправной точкой может стать создание собственного графического редактора с помощью tkinter, стандартной библиотеки GUI в Python.

Да-да, самый настоящий Paint в несколько десятков строк!

tkinter поставляется в комплекте с Python, так что ничего дополнительно устанавливать не нужно. Запускаем редактор – и рисуем прямо мышкой. Прекрасная демонстрация того, как события и интерактивность работают в Python.

Разберем базовую версию редактора — с возможностью рисования линий мышкой.

Вот простой пример:

import tkinter as tk

class SimplePaint:
    def __init__(self, root):
        self.root = root
        self.root.title("Mini Paint")
        self.canvas = tk.Canvas(root, bg="white", width=600, height=400)
        self.canvas.pack(fill=tk.BOTH, expand=True)
        
        self.last_x, self.last_y = None, None

        self.canvas.bind("<Button-1>", self.start_draw)
        self.canvas.bind("<B1-Motion>", self.draw_line)

    def start_draw(self, event):
        self.last_x, self.last_y = event.x, event.y

    def draw_line(self, event):
        x, y = event.x, event.y
        self.canvas.create_line(self.last_x, self.last_y, x, y, fill="black", width=2)
        self.last_x, self.last_y = x, y

root = tk.Tk()
app = SimplePaint(root)
root.mainloop()

Что здесь происходит:

- Мы создаем окно и холст (canvas), на котором можно рисовать.
- Событие <Button-1> (нажатие левой кнопки мыши) отслеживает начало рисования.
- <B1-Motion> ловит перемещения мыши при нажатой кнопке и соединяет координаты линиями.

Теперь добавим выбор цвета — немного разнообразия:

from tkinter.colorchooser import askcolor

def choose_color():
    color = askcolor()[1]
    if color:
        app.current_color = color

color_btn = tk.Button(root, text="Color", command=choose_color)
color_btn.pack()

Добавим в класс:

self.current_color = "black"
...
self.canvas.create_line(self.last_x, self.last_y, x, y, fill=self.current_color, width=2)

Хотите очистить холст? Пожалуйста:

def clear_canvas():
    app.canvas.delete("all")

clear_btn = tk.Button(root, text="Clear", command=clear_canvas)
clear_btn.pack()

В результате — у нас простенький редактор с выбором цвета и кнопкой очистки. Интересно? На основе такой базы можно реализовать:

- выбор толщины линии;
- сохранение в PNG (с помощью PIL);
- разные инструменты (овал, прямоугольник, ластик — да, просто белая линия!);
- undo/redo с помощью хранения команд;
- и даже распознавание фигур, если вы фанат ML.

tkinter — отличный способ перейти из мира print('Hello') в более наглядный и живой Python. Начните с мини-графредактора, а дальше — рамки только в вашем воображении.

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

🎨 Создание собственных графических эффектов для веб-приложений с помощью Python

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

Начнём с основ: Pillow — это форк знаменитой библиотеки PIL (Python Imaging Library). Она позволяет создавать и редактировать изображения прямо на сервере. Например, вы можете генерировать карточки товаров, баннеры, визуальные паттерны, аватары или фоновые текстуры прямо в момент запроса.

Установка:

pip install pillow

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

from PIL import Image, ImageDraw
import random

width, height = 800, 400
image = Image.new("RGB", (width, height))
draw = ImageDraw.Draw(image)

for y in range(height):
    color = (int(255 * (y / height)), 100, 200)
    draw.line([(0, y), (width, y)], fill=color)

for _ in range(10000):
    x = random.randint(0, width - 1)
    y = random.randint(0, height - 1)
    noise_color = (random.randint(200, 255), random.randint(200, 255), random.randint(200, 255))
    image.putpixel((x, y), noise_color)

image.save("gradient_noise.png")

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

Теперь представим, что вы хотите добавить эффект текста с тенью:

from PIL import ImageFont

font = ImageFont.truetype("arial.ttf", 48)
text = "Hello, Web!"

draw.text((52, 152), text, font=font, fill=(0,0,0))  # Shadow
draw.text((50, 150), text, font=font, fill=(255,255,255))  # Main text

Вы можете встроить это изображение прямо в ваше веб-приложение на Flask:

from flask import Flask, send_file
import io

app = Flask(__name__)

@app.route("/banner")
def banner():
    img = Image.new("RGB", (600, 200), color=(30, 30, 30))
    draw = ImageDraw.Draw(img)
    draw.text((50, 80), "Welcome!", fill=(255, 255, 255))
    buf = io.BytesIO()
    img.save(buf, format="PNG")
    buf.seek(0)
    return send_file(buf, mimetype='image/png')

Этот эндпоинт отдаёт сгенерированное изображение при каждом запросе. Можно играться с параметрами URL (например, передавать текст или цвет) и получать кастомизированные баннеры под каждого пользователя. Даже SVG или фильтры постобработки можно внедрять — хотя они больше подойдут для frontend'а, но и на сервере через библиотеки Cairo или Wand (обёртка ImageMagick) можно зажечь любую искру фантазии.

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

Такой подход идеально подойдёт для тех, кто хочет поднять визуальный уровень своего веб-приложения без тяжёлой артиллерии вроде Photoshop или Canvas API. А ведь это только начало.

Автоматизация ETL процессов с использованием Apache Nifi и Python.

Если вы работаете с данными, то, скорее всего, не раз сталкивались с необходимостью обрабатывать большие объемы информации: забирать файлы из хранилищ, преобразовывать их, фильтровать, грузить в базу данных. Весь этот процесс называется ETL — Extract, Transform, Load. И если делать его вручную — это скучно, ошибкоопасно и просто не масштабируется. А вот автоматизация… вот здесь всё действительно интересно.

Сегодня расскажу, как совместить мощную визуальную платформу Apache Nifi и Python-скрипты, чтобы создать эффективный, гибкий и надёжный ETL-пайплайн. Да, можно обойтись одним Python, но Nifi значительно упрощает потоковую обработку данных, а Python добавляет нужной гибкости.

🔧 Что такое Apache Nifi?

Это open-source инструмент от Apache для автоматической передачи и обработки данных в режиме реального времени. Работает через веб-интерфейс: «нажал, соединил, запустил». Поддерживает более 300 встроенных процессоров (загрузка FTP, HTTP, базы данных, фильтрация, устранение дубликатов и т.д.)

Теперь представьте: у вас есть CSV-файлы с данными, ежедневно падающие на удалённый сервер, и вам нужно:

- Скачивать их
- Преобразовывать
- Загружать в PostgreSQL

Разберём, как это сделать с помощью Apache Nifi и Python.

🛠 Пример пайплайна с Python-скриптом в Nifi

1. Используем процессор GetFile или ListFTP + FetchFile, чтобы забирать CSV.
2. Далее применим ExecuteScript — здесь встроим Python-обработчик CSV.
3. Последний шаг — PutDatabaseRecord для загрузки данных в базу.

💡 Пример Python-обработки CSV в ExecuteScript:

# Используется Jython (Python 2.7), встроенный в Nifi
import csv
import io
from org.apache.commons.io import IOUtils
from java.nio.charset import StandardCharsets

flow_file = session.get()
if flow_file is not None:
    try:
        content = IOUtils.toString(session.read(flow_file), StandardCharsets.UTF_8)
        reader = csv.DictReader(io.StringIO(content))

        transformed = []
        for row in reader:
            row['full_name'] = f"{row['first_name']} {row['last_name']}"
            row['age'] = int(row['age'])
            transformed.append(row)

        output = io.StringIO()
        writer = csv.DictWriter(output, fieldnames=transformed[0].keys())
        writer.writeheader()
        writer.writerows(transformed)

        flow_file = session.write(flow_file, lambda out: out.write(output.getvalue().encode('utf-8')))
        session.transfer(flow_file, REL_SUCCESS)
    except Exception as e:
        session.transfer(flow_file, REL_FAILURE)

⚠️ Важно: ExecuteScript использует Jython, где модулей вроде pandas нет, но для базовых трансформаций его хватает. Для более сложных случаев можно использовать ExecuteStreamCommand, передав управление вашему внешнему Python 3 скрипту.

🎯 Заключение

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

Как интегрировать Machine Learning модели в мобильные приложения с Python.