📱PyTauri.

PyTauri — это способ создавать Tauri-приложения на Python, почти без Rust.

Если кратко, PyTauri — это Python-биндинги для Tauri, позволяющие писать backend-логику вашего приложения на Python, а интерфейс — на HTML/JS, как в обычном Tauri.

❓А что такое Tauri:

Tauri — это лёгкий и быстрый фреймворк для создания кроссплатформенных desktop-приложений.

🔹Он использует системный WebView, а не Chromium, поэтому приложения получаются:

🔘Очень лёгкими.

🔘Быстрыми.

🔘Безопасными.

🔘Удобными для сборки в exe/dmg/AppImage.

❓Что даёт PyTauri:

🔘Делаете десктоп-приложения, как в Electron — но Python + Tauri.

🔘Почти не нужно писать Rust-код.

🔘Полная async-поддержка (asyncio / trio / anyio).

🔘Поддержка Tauri-плагинов (например, уведомления).

🔘Генерация TypeScript-типов и клиента для IPC.

🔘Можно собирать standalone-экзешники.

🔘Есть pytauri-wheel, позволяющий обойтись вообще без Rust .

🔘Проект открыт, бесплатен и развивается сообществом.

#PyTauri #Tauri #Python #Desktop #GUI #Webview #Pyo3 #Rust #DevTools

📱Ссылка на репозиторий:
https://github.com/pytauri/pytauri

📱Bitwave.

Bitwave — это высококачественный, ориентированный на разработчиков аудиоформат, созданный для современных сценариев: пространственный звук, динамический темп и мультитрековые сетапы. Минималистичный по структуре, но мощный по возможностям: от стерео до 3D/ambisonic, VR/AR и адаптивной музыки.

🔹Ключевые фичи:

🔘Мультиканал: от стерео до 7.1+, ambisonic и полноценных 3D‑форматов.

🔘Spatial-ready: встроенные XYZ‑координаты в формате .bwx для VR/AR и иммерсивных инсталляций.

🔘Динамический темп: идеален для DJ‑сетов, генеративной музыки и интерактивных сред.

🔘Python SDK + Rust core: удобный Python‑API и высокопроизводительное ядро на Rust.

🔘Мощный CLI: конвертация (WAV/FLAC/OGG <-> Bitwave), анализ (BPM, спектр, fingerprint, ключ), эффекты, батч‑обработка, качество и метаданные.

🔘Кроссплатформенный плеер: современный UI, плейлисты, визуализация волны и spatial‑аудио (macOS/Windows).

❓Где пригодится:

Game dev, VR/AR, live‑сеты, инсталляции, стриминг, ресёрч, пост‑продакшн и продвинутая музыкальная продакшн‑цепочка.

#Bitwave #AudioDev #SpatialAudio #VR #AR #GameAudio #MusicTech #Python #Rust #AudioFormat #ImmersiveAudio #Multichannel #GenerativeMusic #DJ #DSP

📱Ссылка на репозиторий:
https://github.com/makalin/Bitwave

📱Transtractor.

Transtractor — это библиотека на Rust с Python‑API для извлечения транзакций из PDF‑выписок банка в CSV или DataFrame, без какого‑либо AI.

❓Что умеет:

🔘Парсит PDF‑выписки, вытягивая структурированные данные о транзакциях (дата, описание, суммы, баланс) в стандартный CSV‑формат или словарь для Pandas.

🔘Работает по конфигам: готовые профили для поддерживаемых банков + возможность подключать свои my_config.json, не трогая ядро парсинга.

🚀Установка и запуск:

🔘Установка из PyPI:

  pip install transtractor

🔘Базовое использование:

  from transtractor import Parser
  parser = Parser()
  parser.parse("statement.pdf").to_csv("statement.csv")

  data = parser.parse("statement.pdf").to_pandas_dict()

Далее данные можно анализировать в Pandas/Excel.

🔻Конфиги и расширение:

🔘Список поддерживаемых банков и примеры конфигов — в документации на Read the Docs и на сайте Transtractor.

🔘Свои конфиги подключаются так:

  parser.load("my_config.json")
  parser.parse("statement.pdf").to_csv("statement.csv")

#Transtractor #Rust #Python #PDF #BankStatements #FinTech #DataExtraction #Pandas #PersonalFinance #OpenSource

📱Ссылка на репозиторий:
https://github.com/transtractor/transtractor-lib

📱WebRockets.

WebRockets — это высокопроизводительный WebSocket-сервер для Python с нативной поддержкой Django. Ядро написано на Rust (PyO3 + axum + fastwebsockets) для максимальной скорости — до 10x быстрее Daphne в бенчмарках.

🔹Ключевые фичи:

🔘Производительность — Rust-ядро, 10x выше throughput на 100 соединениях (Thinkpad i7, Linux).
🔘Django-интеграция — аутентификация (Session, Token из cookie/header/query), команды runwebsockets.
🔘Pattern Matching — роутинг по дискриминатору + Pydantic-валидация JSON.
🔘Broadcasting — Redis/RabbitMQ из коробки.
🔘Async/Sync — колбэки на Python, полная async-поддержка.

🔻Быстрый старт (standalone):

from webrockets import WebsocketServer
server = WebsocketServer(host="0.0.0.0", port=8080)
echo = server.create_route("ws/echo/", "echo")

@echo.connect("before")
def on_connect(conn): print(f"Connected: {conn.path}")

@echo.receive
def on_message(conn, data): conn.send(f"You said: {data}")

server.start()

Django (websockets.py в app):

from webrockets.django import server
from webrockets.django.auth import SessionAuthentication

chat = server.create_route("ws/chat/", "chat", authentication_classes=[SessionAuthentication()])

@chat.connect("before")
def on_connect(conn): print(f"User {conn.user} joined")

@chat.receive(match=Match("type", "message"), schema=ChatMessage)
def on_message(conn, data: ChatMessage): conn.broadcast([data.room], data.content)

# Запуск: python manage.py runwebsockets

🔻Установка:
pip install webrockets[django,schema].

#WebRockets #WebSocket #Django #Rust #Python #Async #HighPerformance #WebDev #OpenSource

📱Ссылка на репозиторий:
https://github.com/ploMP4/webrockets

📱Zoocache.

Zoocache — это высокопроизводительная библиотека кеширования с ядром на Rust и обвязкой для Python, заточенная под сценарии, где важно одновременно и быстро читать, и строго соблюдать консистентность данных. В отличие от простых TTL‑кешей, она использует семантические зависимости и иерархическую инвалидацию, поэтому вы можете «убить» сразу целые группы связанных ключей (например, user:* или region:eu:*) одним вызовом.

🔹Ключевые фичи:

🔘Rust‑сердце: основная логика на Rust + PyO3 даёт низкую латентность и безопасную конкуррентность.

🔘Семантическая инвалидация: PrefixTrie позволяет мгновенно инвалидировать поддеревья ключей (invalidate("store:1") очищает всё store:1:*).

🔘Причинно‑следственная консистентность: встроенные Hybrid Logical Clocks (HLC) для согласованности в распределённых инсталляциях.

🔘Anti‑avalanch / SingleFlight: защита бэкенда от «стада бизонов» — параллельные одинаковые запросы схлопываются в один поход в базу.

🔘Умная сериализация: MsgPack + LZ4 используются прозрачно, уменьшая размер и ускоряя IO.

🔘Distributed cache: синхронизация узлов через Redis Pub/Sub, плюс защита от ошибок и «отравленных» мьютексов.

🔻Использование в коде максимально простое:

🔘Установка: pip install zoocache или uv add zoocache.

🔘Декоратор @cacheable + deps и add_deps() задают зависимости, а invalidate("user:123") гарантированно очищает все связанные кэши для этого пользователя.

🔘Для Django есть отдельные гайды: автоматическая интеграция с ORM, инвалидация по сигналам _save/_delete, учёт транзакций, авто‑зависимости по JOIN‑ам и поддержка Django REST Framework сериализаторов.

Zoocache особенно уместен там, где много сложных связей (каталоги, прайсинги, инвентарь, персонизация), высокая доля чтения и требуется строгий «сразу видно апдейт», а не «подождём, пока TTL протухнет».

#Python #Rust #Caching #Zoocache #Redis #Django #HighLoad #HLC #MsgPack #LZ4 #SingleFlight

📱Ссылка на репозиторий:
https://github.com/albertobadia/zoocache

📱Silkworm-rs.

silkworm-rs — async‑first фреймворк для веб‑скрейпинга на Python с «двигателем» на Rust: HTTP‑клиент rnet (имперсонация браузера) + быстрый HTML‑парсер scraper-rs, минимальная модель Spider/Request/Response, middlewares и pipelines без тонны бойлерплейта. Он сразу даёт конкурентный движок с backpressure (очередь по умолчанию concurrency * 10), таймаутами на запрос, дедупликацией по URL и структурированным логгированием со статистикой по RPS, памяти, количеству URL и ошибок.

🔹Ключевые возможности:

🔘HTTP‑клиент с «маскарадом» под браузер, поддержкой редиректов с защитой от циклов, мерджем query‑параметров и прокси через request.meta["proxy"].

🔘Типизированные пауки и коллбэки, которые могут возвращать как items, так и новые Request; HTMLResponse даёт удобные селекторы (select, select_first) и response.follow() для переходов.

🔘Готовые middlewares: ротация User‑Agent, прокси, ретраи с экспоненциальным бэкоффом и «sleep‑кодами», гибкие задержки (фикс/рандом/функция), SkipNonHTMLMiddleware для отбрасывания не‑HTML.

🔘Богатый набор pipelines «из коробки»: JSONL, CSV, XML, SQLite, MsgPack, Polars/Parquet, Excel, YAML, Avro, куча БД (Postgres, MySQL, Mongo, Cassandra, DynamoDB, DuckDB и др.), S3, FTP/SFTP, Elasticsearch, Google Sheets, Snowflake, вебхуки и Taskiq‑очереди.

🔘Поддержка разных event loop’ов: стандартный asyncio (run_spider), uvloop на *nix, winloop на Windows и trio‑бэкенд (run_spider_trio) — для I/O‑bound задач это даёт 2–4x прирост.

🔘JavaScript‑страницы можно рендерить через экспериментальную интеграцию с Lightpanda/Chrome по CDP (fetch_html_cdp, CDPClient и spider‑примеры).

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

pip install silkworm-rs
# или (рекомендуется)
uv pip install --prerelease=allow silkworm-rs

Дальше — наследуете Spider, реализуете async def parse(...), yield’ите словари или Request, а run_spider(...) берёт на себя конкурентный движок, middleware’ы и выгрузку данных в нужные пайплайны.

#Python #Rust #WebScraping #AsyncIO #silkworm #rnet #scraperRS #DataEngineering #ETL #uvloop

📱Ссылка на репозиторий:
https://github.com/BitingSnakes/silkworm

📱Oxyde ORM.

Oxyde ORM — асинхронный type‑safe ORM с Pydantic v2 и быстрым Rust‑ядром, сделанный в духе Django ORM, но с современным API и предсказуемым поведением.

🔹Особенности Oxyde:

🔘Django‑стиль: привычный User.objects.filter(...), аннотации полей и Meta‑класс для таблиц.

🔘Pydantic‑центричность: модели — полноценные Pydantic v2, с валидацией, тайпингом и удобной сериализацией.

🔘Rust‑производительность: генерация и выполнение SQL вынесены в Rust‑core (oxyde-core), что даёт высокий ops/sec в бенчмарках против популярных ORM.

🔘Async‑first: всё на asyncio, с поддержкой PostgreSQL, SQLite и MySQL, транзакций и nested transaction.atomic().

🔘Интеграция с FastAPI: готовый db.lifespan(...) для подключения БД на уровне приложения.

🔻Установка и быстрый старт:

pip install oxyde

from oxyde import Model, Field

class User(Model):
    id: int | None = Field(default=None, db_pk=True)
    name: str
    email: str = Field(db_unique=True)

#python #orm #asyncio #pydantic #rust #fastapi #postgresql #sqlite #mysql

📱Ссылка на репозиторий:
https://github.com/mr-fatalyst/oxyde

📱Py2many.

py2many — это Python‑транспайлер, который автоматически преобразует Python‑код в Rust, C++, Go, Zig, Julia, Kotlin, Nim, Dart и другие статически типизированные языки.

🔹Зачем транспилировать Python:

🔘Производительность: Python удобен для разработки, но медленный в рантайме — компиляция в Rust/C++/Go даёт нативную скорость.

🔘Кроссплатформенность: один Python‑код → нативные приложения для мобильных, embedded‑систем и WebAssembly.

🔘Безопасность: верифицируете логику тестами на Python, потом транспилируете в Rust для memory safety.

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

pip install py2many

# Конвертация в Rust
py2many --rust tests/cases/fib.py

# Конвертация в C++
py2many --cpp tests/cases/fib.py

# Конвертация в Go/Kotlin/Julia/Nim/Dart
py2many --go/--kotlin/--julia/--nim/--dart tests/cases/fib.py

#python #transpiler #rust #cpp #golang #performance #py2many

📱Ссылка на репозиторий:
https://github.com/py2many/py2many

📱Formualizer.

Formualizer — это spreadsheet‑движок на Rust с 320+ Excel‑функциями, который реально вычисляет формулы (не просто читает XLSX), поддерживает dependency graph и доступен из Python/Rust/WASM.

🔹Что умеет:

🔘320+ функций: PMT, XLOOKUP, FILTER, IRR и др. + dynamic arrays и spill semantics.

🔘Инкрементальная оценка: пересчитывает только изменённое, с цикло‑детекцией и параллельным режимом.

🔘SheetPort: любая таблица → типизированный API с YAML‑схемой для AI‑агентов и batch‑вычислений.

pip install formualizer

✅Идеально для fintech, AI‑агентов и data engineering — без Excel на сервере.

#python #rust #excel #spreadsheet #formualizer #fintech

📱Ссылка на репозиторий:
https://github.com/psu3d0/formualizer

📱Rsloop.

rsloop — это альтернативный event loop для asyncio, написанный на Rust через PyO3.

Каждый rsloop.Loop держит выделенный Rust‑поток для координации цикла и I/O, при этом ваши Python‑корутины продолжают выполняться в том же потоке, откуда вы вызываете run_forever() / run_until_complete() (обычно main‑поток).

🔧Установка:

pip install rsloop
# или
uv add rsloop

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

import rsloop

async def main():
    ...

rsloop.run(main())

Или вручную:

import asyncio, rsloop

loop = rsloop.new_event_loop()
asyncio.set_event_loop(loop)
try:
    loop.run_until_complete(...)
finally:
    asyncio.set_event_loop(None)
    loop.close()

🔹Основные особенности:

🔘Отдельный Rust runtime‑поток: координация цикла и I/O (на Linux — через compio с io_uring), Python‑колбэки и таски остаются на Python‑потоке.

🔘Полноценная реализация core‑поверхности asyncio: жизненный цикл лупа, задачи, future, run_in_executor, TCP/Unix сокеты, пайпы, сабпроцессы, сигналы, Windows‑пайпы и subprocess‑workflow.

🔘Fast Streams: импорт rsloop патчит asyncio.open_connection() и asyncio.start_server() для использования нативных быстрых стримов, когда запущен rsloop.Loop и не используется TLS; поведение можно отключить через RSLOOP_USE_FAST_STREAMS=0.

🔘Профилирование через Tracy: with rsloop.profile(): rsloop.run(main()) или ручное start_profiler()/stop_profiler() при сборке с фичей profiler.

🔘Производительность: в бенчмарках callbacks/tcp‑streams rsloop сопоставим или быстрее stdlib asyncio и близок к uvloop, иногда чуть медленнее по задачам, но выигрывает по p99‑латентности в реальных API‑нагрузках.

#python #asyncio #rust #rsloop #eventloop #io_uring #fastapi #uvloop #PyO3 #profiling

📱Ссылка на репозиторий:
https://github.com/RustedBytes/rsloop

📱Honker.

Honker — это SQLite-расширение, которое приносит в SQLite NOTIFY/LISTEN- логику в стиле Postgres.
Без брокера. Без polling. Без лишней инфраструктуры.

❓Что умеет:

🔘durable pub/sub
🔘очередь задач
🔘event streams
🔘retry, delayed jobs, priority
🔘scheduler по cron
🔘атомарные enqueue вместе с бизнес-транзакцией

Идея простая: если у вас SQLite — то очередь и события должны жить прямо в том же .db файле.
INSERT INTO orders ... и queue.enqueue(...) могут коммититься вместе — это очень удобно и надежно.

❗️Поддерживаются Python, Node.js, Bun, Ruby, Go, Elixir, C++, .NET/C#, JVM и Kotlin.

А для пробуждения процессов используется `PRAGMA data_version`, что дает реакцию почти как push — быстро и без ручного опроса.

#SQLite #Rust #OpenSource #PubSub #Queue #Backend #Python #NodeJS #Kotlin #DotNet #DevTools

📱Ссылка на репозиторий:
https://github.com/russellromney/honker

📱Feloxi.

Feloxi - это мощная self-hosted платформа для мониторинга очередей задач Python, в первую очередь — Celery. Инструмент предоставляет живые дашборды, поиск по истории задач и гибкую систему алертов.

Вам не нужно устанавливать никаких дополнительных агентов или менять код приложения! Feloxi просто подключается к вашему брокеру (Redis или RabbitMQ), читает стандартные события, которые и так генерирует Celery, и бережно сохраняет их в ClickHouse.

🔹Главные возможности:

🔘Продвинутый поиск: Ищите таски по ID, названию, аргументам (args/kwargs), результатам и даже по тексту ошибок. Смотрите таймлайны, ретраи и полные трейсбеки.

🔘Health-мониторинг воркеров: Следите за загрузкой CPU, памятью, размером пула, активными задачами и пропусками heartbeat.

🔘Визуализация цепочек: Сложные воркфлоу (chains, groups, chords) автоматически отрисовываются в виде интерактивных DAG (направленных ациклических графов). Если пайплайн упадет, вы сразу увидите, на каком именно шаге это произошло.

🔘Контроль периодических задач (Celery Beat): Вы всегда будете знать расписание задач, время последнего запуска и не пропустили ли они свой "бит".

🔘Умные алерты: Доступно 10 типов условий (например, падение скорости обработки, медленные таски, оффлайн воркер, аномалии в глубине очереди). Уведомления можно отправлять в Slack, PagerDuty, на email или через Webhook.

🔘Prometheus из коробки: Метрики доступны по эндпоинту GET /metrics для легкой интеграции с вашей инфраструктурой мониторинга.

❓Как подключить (нужно всего 3 шага):

Добавьте в celeryconfig.py:

worker_send_task_events = True
task_send_sent_event = True
task_track_started = True

Перезапустите воркеры с флагом --events.

Зайдите в UI Feloxi, нажмите Add Broker и введите URL вашего Redis/RabbitMQ. Всё!

🚀Быстрый старт (через Docker Compose):

git clone https://github.com/thesaadmirza/feloxi.git
cd feloxi
cp .env.example .env
docker compose up -d

Стек: Rust (Axum), Next.js 15, PostgreSQL, ClickHouse и Redis. Поддерживается установка в Kubernetes через Helm-чарты.

#Python #Celery #DevOps #Monitoring #RabbitMQ #Redis #Rust #NextJS #OpenSource #Backend

📱Ссылка на репозиторий:
https://github.com/thesaadmirza/feloxi

📱Lifeguard.

Lifeguard — это быстрый инструмент статического анализа, созданный для безопасного внедрения «ленивых» импортов (Lazy Imports) в Python-проектах.

❓Зачем нужны ленивые импорты (PEP 810).

Обычно в Python каждый import выполняется моментально при чтении файла. Ленивые импорты откладывают реальную загрузку модуля до момента первого обращения к импортированному имени. Это радикально снижает потребление памяти и ускоряет запуск приложений, особенно в огромных кодовых базах с глубоким деревом зависимостей.

🔻В чем подвох?

Перевести старый код на ленивые импорты вслепую не выйдет — часть логики обязательно сломается. Например, проблемы возникнут, если:

🔘У модуля есть сайд-эффекты при загрузке (он меняет глобальное состояние).

🔘Используется паттерн «Реестр» (Registry), где модуль регистрирует себя в глобальном словаре в момент импорта.

🔘Код манипулирует sys.modules, ожидая, что предыдущие импорты уже выполнились.

🔘Используются сложные метаклассы или __init_subclass__.

Найти все такие места в большом проекте вручную практически невозможно.

🔧Как помогает Lifeguard:

Инструмент (написанный на Rust) параллельно анализирует AST-дерево ваших исходников и выявляет все несовместимые паттерны. Lifeguard максимально консервативен: если он не может программно доказать, что модуль безопасен для ленивого импорта, он помечает его как небезопасный. Стабильность продакшена здесь ставится выше микрооптимизаций.

🔹 Два главных сценария использования:

🔘Как классический линтер: Запуск в подробном режиме (verbose) покажет конкретные строки в файлах, которые мешают отложенной загрузке. Вы можете постепенно исправлять их в коде.

🔘Как генератор конфига: Lifeguard выдает JSON-файл с двумя списками: LAZY_ELIGIBLE (полностью безопасные модули) и LOAD_IMPORTS_EAGERLY (модули-исключения). В будущем (в Python 3.15) этот JSON можно будет использовать в качестве фильтра для функции importlib.util.lazy_import, чтобы управлять импортами автоматически.

❗️Статус проекта:

Находится в стадии беты и готовится к выходу Python 3.15 (уже протестирован на версиях 3.12 и 3.14). Сейчас для работы требуется Rust (nightly) и запуск через cargo run, но разработчики уже готовят пакет для PyPI и готовые GitHub Actions.

#Python #Rust #LazyImports #PEP810 #StaticAnalysis #DevTools #Backend #Оптимизация

📱Ссылка на репозиторий:
https://github.com/facebook/Lifeguard

📱Python UUID Utils.

Python UUID Utils — это сверхбыстрая замена стандартного модуля uuid в Python, написанная на Rust. Инструмент разработан как полноценная альтернатива (drop-in replacement): вы можете кратно ускорить генерацию уникальных идентификаторов в вашем приложении без кардинального переписывания кодовой базы.

🔹Доступные версии UUID:

🔘uuid1 / uuid6 — на основе временной метки и монотонного счетчика.

🔘uuid3 / uuid5 — на основе хэшей MD5 и SHA-1 от переданных данных.

🔘uuid4 — классический UUID на базе случайных данных.

🔘uuid7 — современный стандарт на основе Unix-времени, идеально подходящий для первичных ключей в базах данных благодаря сортировке по времени создания.

🔘uuid8 — кастомные UUID на основе пользовательских данных.

🚀Потрясающая производительность (Бенчмарки):

Согласно официальным тестам на Python 3.14, ускорение получается просто космическим:

🔘uuid4(): Стандартная библиотека — 1189 нс | uuid_utils — всего 61 нс (быстрее почти в 20 раз!).

🔘uuid7(): Стандартная библиотека — 1336 нс | uuid_utils — 84 нс (быстрее в 15 раз!).

🔘Парсинг идентификатора из строк (hex) или байтов работает быстрее в 4–5 раз.

🔧Совместимость с Django и другими фреймворками:

Некоторые крупные фреймворки строго требуют, чтобы объекты UUID были именно инстансами стандартного класса uuid.UUID из встроенной библиотеки Python, а не сторонними сабклассами. Разработчики это учли! Для таких случаев есть специальный модуль совместимости:

import uuid_utils.compat as uuid

# Возвращает родной объект stdlib uuid.UUID,
# но генерирует его в 4-5 раз быстрее стандартного модуля!
my_id = uuid.uuid4() 

📦Установка:

pip install uuid-utils
# или через conda
conda install -c conda-forge uuid-utils

#Python #Rust #Performance #UUID #Backend #Django #DevTools #Programming #OpenSource #Оптимизация

📱Ссылка на репозиторий:
https://github.com/aminalaee/uuid-utils

📱Symbolica.

Symbolica - это высокопроизводительная библиотека компьютерной алгебры для Python и Rust. Она спроектирована специально для работы с огромными математическими выражениями, символьных преобразований (symbolic rewrites), точной полиномиальной арифметики и оптимизированных численных вычислений.

Этому инструменту доверяют ученые из CERN, а также ведущие исследовательские группы из ETH Zurich, Университета Цюриха, Университета Берна и Технологического института Карлсруэ.

❓Почему Symbolica:

🔘Единое ядро: Нативные API для Python и Rust, работающие на одном и том же сверхбыстром символьном движке.

🔘Максимальное ускорение: Оптимизированные численные вычислители с генерацией кода на лету (JIT), поддержкой C++, SIMD, ASM и вычислений на GPU через CUDA.

🔘Работа с Big Data в математике: Встроенные инструменты потоковой передачи данных (streaming) для выражений, которые слишком велики, чтобы целиком поместиться в оперативной памяти.

🔘Гибкая логика: Сопоставление с образцом (pattern matching) и перезапись для адаптации алгебры под конкретные доменные задачи.

🔘Смешанные вычисления: Поддержка комбинации точных и численных расчетов с автоматическим отслеживанием погрешности.

🔻Пример использования (калибровка маятника):

Библиотека позволяет изящно совмещать символьные манипуляции, разложение в ряды и финальный численный расчет:

from symbolica import *

θ, κ = S("θ", "κ")
V = κ * (1 - θ.cos())
τ = -V.derivative(θ)  # Символьное дифференцирование: −κ*sin(θ)

# Разложение крутящего момента в ряд для модели малых углов
# Результат: −κθ + 1/6*κθ³ + O(θ⁴)
τ_small = τ.series(θ, 0, 3)  

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

📦Установка:

pip install symbolica

#Symbolica #Python #Rust #Math #ComputerAlgebra #CERN #DataScience #Physics #CUDA #DevTools #OpenSource

📱Ссылка на репозиторий:
https://github.com/symbolica-dev/symbolica

📱Centaur.

Centaur - это self-hosted платформа для командной работы с ИИ-агентами прямо через интерфейс Slack или REST API.

Вместо того чтобы каждый инженер настраивал персональных ботов и локальные скрипты на своей машине, Centaur предоставляет единого общего ассистента: вы тегаете @centaur в треде Slack, бот выделяет изолированную среду, запускает задачи, использует внутренние инструменты компании и возвращает готовый ответ в переписку.

🔹Ключевые возможности:

🔘Интеграция со Slack «из коробки»: Общение происходит прямо в тредах — бот публикует промежуточный прогресс выполнения и финальный результат.

🔘Изолированные песочницы Kubernetes: Каждая сессия запускается в отдельном контейнере (для локальной работы достаточно легковесного k3s) с доступом к терминалу, Git, Python, Node.js, Bun и рабочему пространству.

🔘Поддержка любых агентских CLI (BYOH): Внутри песочницы можно запускать такие среды и агентские движки, как Claude Code, Codex, Amp или собственные скрипты.

🔘Безопасная работа с секретами: Благодаря специальному сервису iron-proxy, агент никогда не получает «сырые» API-ключи в переменные окружения. Внутри песочницы используются токены-заглушки, а реальные учетные данные из 1Password подставляются на лету только при исходящих запросах к доверенным адресам.

🔘Общие инструменты команды: Достаточно один раз оформить скрипт на Python в виде плагина, и он станет доступен агенту во всех задачах через локальный CLI-мост (centaur-tools).

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

🛠Сценарии использования:

🔘Быстрый поиск причин падения тестов и сбоев в CI/CD.

🔘Ответы на вопросы команды с использованием внутренних баз данных и закрытых сервисов.

🔘Формирование регулярных дайджестов и выжимок из длинных переписок.

🔘Автоматизация рутинных многошаговых операций и дежурств (On-Call).

⚙️Стек и архитектура:

Панель управления и API платформы написаны на Rust (Axum) с сохранением состояний в PostgreSQL, интерфейс взаимодействия со Slack реализован отдельным микросервисом, а задачи оркестрируются в среде Kubernetes.

#Centaur #AIAgents #Slack #Kubernetes #Rust #DevOps #DevTools #OpenSource #Automation #Security

📱Ссылка на репозиторий:
https://github.com/paradigmxyz/centaur

📱Arid.

Arid - это сверхбыстрый инструмент для поиска дублирующегося кода в Python-проектах, написанный на Rust.

Проект создан как узкоспециализированная замена анализатору дубликатов из Pylint (правило R0801 / утилита symilar). Arid не пытается быть еще одним универсальным линтером, а идеально дополняет Ruff: пока Ruff форматирует и линтит код, Arid берет на себя строгий контроль принципа DRY (Don't Repeat Yourself).

🔹Главные фичи и преимущества:

🔘Производительность Rust: В бенчмарках на реальных кодовых базах (Requests, Pydantic, Polaris) отрабатывает в 190–250 раз быстрее, чем анализатор Pylint.

🔘Понимание синтаксиса Python: В отличие от универсальных текстовых утилит вроде jscpd, Arid парсит синтаксис языка и поддерживает умную нормализацию. При поиске дубликатов можно исключать комментарии, докстринги, блоки импортов и сигнатуры функций.

🔘Baselines: Позволяет зафиксировать текущий техдолг в легаси-проектах (--write-baseline arid-baseline.json). В CI проверяются только новые дубликаты, не ломая сборки на старом коде.

🔘Suppression audit: Намеренные дубликаты можно изолировать директивами # arid: disable / # arid: enable. Опция --suppression-status --fail-on-stale отслеживает и требует удалять комментарии подавления, если код вокруг изменился и дубликата больше нет.

🔘Машиночитаемые отчеты: Поддерживает вывод в Text, JSON, Markdown и стандартный формат SARIF (для бесшовной интеграции с GitHub Code Scanning).

🔘Готовая экосистема: Официальный GitHub Action, хук для pre-commit (анализирует весь проект целиком, а не только staged-файлы) и конфигурация через секцию [tool.arid] в pyproject.toml.

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

Установка:

# Через uv (изолированно):
uv tool install arid

# Или через pip:
pip install arid

Использование в связке с Ruff:

ruff check .
arid .

Пример конфигурации в pyproject.toml:

Ini, TOML

[tool.arid]
min-lines = 5
ignore-comments = true
ignore-docstrings = true
ignore-imports = true
ignore-signatures = true
exclude = ["generated/**", "vendor/**"]

#Python #Rust #Arid #Ruff #Pylint #DRY #CodeQuality #CleanCode #DevTools #OpenSource #CICD

📱Ссылка на репозиторий:
https://github.com/sponge-b0b/arid

📱TonIO.

TonIO - это многопоточный асинхронный рантайм для free-threaded Python (сборки без GIL), написанный на Rust поверх крейта mio и вдохновленный архитектурой Tokio, Trio и TinyIO.

В отличие от стандартного asyncio, чей цикл событий (event loop) жестко привязан к одному системному потоку, TonIO спроектирован под реалии современного многопоточного Python 3.13+ (PEP 703): рантайм автоматически распределяет и исполняет корутины параллельно на нескольких ядрах процессора.

🔹Ключевые особенности:

🐱Два стиля синтаксиса (Coloring vs Uncolored):

🔘Модуль tonio.colored предоставляет привычный синтаксис async / await.

🔘Базовый модуль tonio позволяет писать асинхронный код через обычные генераторы и yield, полностью избавляя от проблемы «цветных функций».

✔️Rust-ядро на mio: Высокопроизводительный неблокирующий системный I/O (epoll, kqueue, IOCP) и планировщик задач прямо под капотом Python.

✔️Структурная конкурентность (Structured Concurrency):

🔘tonio.scope() гарантирует корректную отмену и сбор всех дочерних корутин при выходе из контекста или возникновении исключений.

🔘tonio.select() для конкурентных гонок задач (отменяет оставшиеся корутины при первом завершении).

✔️Синхронизация и MPMC-каналы:

🔘События Event и комбинируемые ожидатели Waiter через операторы пересечения и объединения (w1 & w2, w1 | w2).

🔘Lock, Semaphore, Barrier и каналы передачи сообщений (bounded и unbounded) с неблокирующими методами send_nowait / receive_nowait.

✔️Сетевой стек и системные примитивы:

🔘Высокоуровневые стримы для TCP, Unix Domain Sockets и TLS (open_tcp_stream, serve_tcp).

🔘Низкоуровневый модуль tonio.io для подключения любых файловых дескрипторов ОС к системному поллеру.

🔘Асинхронная файловая система tonio.fs и управление подпроцессами (run_process, open_process).

✔️Интеграция с Pytest: Поставляется с готовым плагином, маркером @pytest.mark.tonio и авто-режимом для тестирования асинхронного кода.

💻Пример использования:

С классическим синтаксисом async / await:

import tonio.colored as tonio

async def fetch_data(task_id: int):
    await tonio.sleep(0.5)
    return f"Результат {task_id}"

@tonio.main
async def main():
    # Параллельный запуск задач в пуле потоков рантайма
    parallel = tonio.spawn(
        fetch_data(1),
        fetch_data(2)
    )
    
    extra = await fetch_data(3)
    res1, res2 = await parallel
    
    print([res1, res2, extra])

main()

С синтаксисом на чистом yield (без async/await):

import tonio

def fetch_data(task_id: int):
    yield tonio.sleep(0.5)
    return f"Результат {task_id}"

@tonio.main
def main():
    parallel = tonio.spawn(fetch_data(1), fetch_data(2))
    extra = yield fetch_data(3)
    res1, res2 = yield parallel
    print([res1, res2, extra])

main()

⚠️ Важно: Проект находится в активной разработке (WIP), не совместим напрямую с объектами asyncio (для интеграций доступен проект-патчер TonIO-Monkey) и рассчитан исключительно на free-threaded Python без GIL.

✅Лицензия: BSD 3-Clause.

#Python #Rust #TonIO #Async #NoGIL #FreeThreaded #Tokio #Concurrency #Multithreading #Performance #DevTools #OpenSource

📱Ссылка на репозиторий:
https://github.com/gi0baro/tonio

📱Fastlogging-rs.

Fastlogging-rs - это сверхбыстрый и универсальный кросс-язычный фреймворк для логирования, написанный на Rust и предоставляющий унифицированный API для Python, Rust, C/C++, Go, Java и C#.

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

fastlogging-rs решает это архитектурно: вызовы логов абсолютно неблокирующие (non-blocking) и потокобезопасные, а сброс данных во внешние приемники происходит в фоновых потоках. В бенчмарках на запись в файл с ротацией он оказывается быстрее стандартного Python-логгера более чем в 100 раз (0.17 с против 35.2 с).

🔹Ключевые возможности:

🔘Экстремальная производительность: Запись сообщений не тормозит основной поток приложения, пока не переполнится внутренняя очередь.

🔘Полноценная кросс-язычность: Единый согласованный API для Rust, Python (>=3.10 через PyO3), C / C++ (FFI/CXX), Go, Java (через FFM и JNI) и C#.

🔘Автоматический сбор из подпроцессов: Автоматически перенаправляет логи из дочерних процессов (multiprocessing / child processes) в основной процесс с поддержкой глубоких уровней вложенности.

🔘Богатый выбор приемников (Sinks / Writers):

✔️Консоль с поддержкой цветов;

✔️Файлы с автоматической ротацией и сжатием;

✔️TCP-клиент с аутентификацией и AES-шифрованием сетевых логов;

✔️Системные журналы: Syslog (Linux) и EventLog (Windows);

✔️Пользовательские функции обратного вызова (Callbacks).

🔘Гибкая конфигурация: Настраивается как программно через API, так и декларативно через файлы конфигурации (JSON, XML, YAML).

💻Пример использования:

from fastlogging import Logging

# Инициализация и логирование
log = Logging()
log.info("Привет из fastlogging!")

# Корректное завершение фоновых потоков
log.shutdown(False)

#Fastlogging #Rust #Python #Logging #Performance #Backend #DevTools #Cpp #Golang #Java #OpenSource

📱Ссылка на репозиторий:
https://github.com/brmmm3/fastlogging-rs

📱TurboPython.

TurboPython - это опережающий (AOT) компилятор, транслирующий статически типизированный Python через современный C++23 напрямую в автономный нативный бинарник без интерпретатора, сборщика мусора и GIL.

В отличие от Cython, mypyc или Nuitka, сгенерированный код вообще не опирается на рантайм CPython и подсчет ссылок, а в отличие от Codon и Shed Skin — не использует сторонний сборщик мусора (GC). Памятью управляет строгая модель владения (Ownership) в стиле Rust, проверяемая прямо во время компиляции. При этом исходные файлы остаются синтаксически валидным кодом на Python, понятным привычным линтерам, IDE и кодинг-агентам.

🔹Главные особенности:

🔘Никакого CPython, GC и GIL: На выходе получается чистый нативный C++23-бинарник. Нет оверхеда на виртуальную машину, трассирующий сборщик мусора или Reference Counting, а для критических участков доступна директива @noalloc.

🔘Модель владения (Ownership Model): Каждое значение имеет ровно одного владельца (стековый фрейм, поле класса или контейнер). Передача владения оформляется явно через Own[T], а неявные копирования данных подсвечиваются компилятором еще до запуска программы.

🔘Настоящий параллелизм с проверкой типов: Многопоточный запуск (spawn) нативных потоков ОС без ограничений GIL. Компилятор на этапе сборки статически проверяет контракты Send и Sync, предотвращая состояние гонки (data races). Доступ к разделяемым ресурсам идет через знакомые примитивы: Arc[Mutex[T]], RwLock, атомики и каналы.

🔘Фиксированные типы и контроль переполнений: Введены нативные целочисленные типы (например, int32), литералы и функция len() по умолчанию 32-битные с проверкой переполнения на аппаратном уровне (ошибка вместо тихого заворачивания значения). Стандартный int остается длинной арифметикой произвольной точности.

🔘Полная интеграция с экосистемой C/C++: Легко линкуется с внешними C/C++ библиотеками (@native, @export(binding="C")), генерирует чистый C++ код с готовыми CMakeLists.txt и умеет компилироваться как в автономные бинарники, так и в нативные модули расширения для стандартного CPython.

💻Пример кода:

from dataclasses import dataclass
from tpy import Own, int32

@dataclass
class Stats:
    count: int32
    total: int32
    longest: int32

# Функция передает владение объектом Stats вызывающей стороне
def measure(words: list[str]) -> Own[Stats]:
    total, longest = 0, 0
    for w in words:
        total += len(w)
        longest = max(longest, len(w))
    return Stats(len(words), total, longest)

s = measure("the quick brown fox jumps over the lazy dog".split())
print(s.count, s.total, s.longest)

🚀Сборка и запуск:

Установка компилятора (требуется Python 3.12+ и Clang 19+ / GCC 13+):

# Установка с бандлом компилятора Zig
pip install "tpy-lang[bundled]"

Компиляция и запуск:

# Запуск через JIT-подобный вызов или REPL
tpy stats.py

# Сборка в автономный нативный бинарный файл
tpyc -b stats.py
./__tpyc__/stats.d/release/stats

# Просмотр сгенерированного чистого C++ кода
tpy --dump-code stats.py

📌Статус проекта: Ранняя разработка (pre-1.0). Поддерживаются Linux и macOS (для Windows рекомендуется WSL). Лицензия — Apache 2.0 with LLVM Exceptions (позволяет распространять собранные бинарники без лицензионных ограничений).

#TurboPython #Python #Cpp #Compiler #AOT #Performance #Rust #NoGIL #Multithreading #DevTools #OpenSource #SoftwareEngineering

📱Ссылка на репозиторий:
https://github.com/trozen/tpy-lang