📱Plotex.

Plotex - это легковесная библиотека для Python, позволяющая строить графики, диаграммы и визуализировать данные прямо внутри терминала в виде цветного псевдографического текста.

Главное преимущество библиотеки — она полностью автономна: базовый функционал не требует никаких внешних зависимостей и библиотек вроде matplotlib или numpy. При этом она способна превратить обычную консоль в полноценную графическую панель.

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

🔘Широкий набор типов графиков:

✔️Базовые: линейные графики (line), точечные (scatter), стержневые (stem).

Столбчатые и статистические: гистограммы, боксплоты (box plots), накопленные (stacked) и плавающие столбчатые диаграммы.

✔️Специализированные: тепловые карты (heatmaps), матрицы ошибок (confusion matrices), полосы погрешностей (error bars) и индикаторы.

✔️Финансовые: японские свечи (candlestick) и шкалы дат/времени.

🔘Субсимвольное разрешение: Разбивает знакоместо символа на матрицу суб-точек (включая символы Брайля), позволяя отображать в 4–8 раз больше точек данных на том же экранном пространстве.

🔘Интерактивность и медиа: Поддерживает анимацию, потоковое обновление графиков в реальном времени (live stream), рендеринг картинок, GIF и даже воспроизведение видео со звуком (включая ролики с YouTube).

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

🔘Гибкая стилизация: 12 готовых тем оформления, настройка осей, меток, легенды, а также поддержка собственных цветовых палитр терминала.

🔘Готовый CLI-инструмент: Позволяет строить графики из входного потока данных прямо в командной строке без написания Python-кода.

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

import plotext as plt

# Данные для графика
y = [1, 5, 3, 8, 4, 9, 6]

# Настройка и вывод
plt.plot(y)
plt.title("График в терминале")
plt.theme("dark")
plt.show()

📦Установка:

pip install plotext

#Python #Plotext #DataVisualization #Terminal #CLI #DataScience #DevTools #OpenSource #Console #Analytics

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

📱DeployProof.

DeployProof - это инструмент командной строки (CLI) для Python, предназначенный для верификации кода (в том числе сгенерированного ИИ) с помощью молниеносного мутационного тестирования AST прямо в оперативной памяти.

Нейросети вроде Copilot или ChatGPT легко генерируют тесты со 100% покрытием строк (line coverage), которые при этом не проверяют реальную логику и граничные условия: мутационный скор у такого сьюта часто близок к нулю. DeployProof решает эту проблему прямо перед коммитом или пушем в CI.

🧬 В чем отличие от Mutmut и Cosmic Ray?

🔘Классические мутационные фреймворки перезаписывают исходные файлы на диске и заново запускают тесты для каждого мутанта на всем проекте, что занимает минуты или часы.

🔘DeployProof компилирует все мутации в единое условное AST-дерево прямо в RAM (без дискового I/O) и анализирует только измененные файлы из текущего git diff. Проверка отрабатывает за пару секунд — буквально пока вы переключаете вкладку.

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

🔘In-Memory AST Mutation: Мутирует операторы (>=, ==, and, or), константы, граничные значения строк, меняет аргументы местами и убирает await без перезаписи файлов на диске.

🔘Самоисцеление тестов (Self-Healing Tests): Флаг --heal-tests анализирует выживших мутантов и автоматически синтезирует готовые к запуску pytest-кейсы, закрывающие обнаруженные дыры в логике.

🔘Комплексные шлюзы безопасности (Security Gates):

🔘SAST: Проверка на инъекции, shell=True, небезопасную десериализацию (pickle, yaml.load) и обход путей.

🔘Поиск секретов: Анализ энтропии Шеннона в файлах и последних 50 коммитах Git (поиск API-ключей OpenAI, AWS, GitHub, Stripe).

🔘Защита от галлюцинаций ИИ: Проверяет установленные пакеты через PyPI API на предмет выдуманных нейросетью библиотек (slopsquatting) и сопоставляет с базой уязвимостей OSV (CVE).

🔘100% приватность: Код и результаты тестов не покидают вашу локальную машину (в сеть уходят только read-only запросы к PyPI и OSV).

💻Пример работы:

# Проверка изменений в git diff перед пушем
deployproof check

# Автоматическая генерация тестов под выжившие мутации
deployproof check --heal-tests

# Установка pre-push хука в один клик
deployproof init

📦Установка:

pip install deployproof
# или изолированно через pipx:
pipx install deployproof

#Python #DeployProof #MutationTesting #Testing #QA #Pytest #AICode #DevTools #OpenSource #AppSec #CICD

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

📱No AI Slop.

No AI Slop - это инструмент для очистки текста от «нейросетевых штампов» (AI slop), который вырезает более 20 заезженных паттернов ИИ-генерации, не убивая при этом ваш уникальный авторский голос.

Проблема ИИ-текстов в том, что они звучат одинаково. Даже лучшие языковые модели постоянно выдают фразы вроде:

«Это не Х. Это Y.»

«То, о чем вам никто не расскажет...»

«Будущее не грядет. Оно уже здесь.»

Когда вы просите ИИ отредактировать ваш черновик, он часто «сглаживает» лексику, ритм, юмор и те самые шероховатости, которые делают текст живым и человечным.

❓Что отлавливает и удаляет No AI Slop:

🔘Бинарные противопоставления: «Это не X. Это Y.»

🔘Пустые вступления для «прочистки горла»: «Суть в следующем», «Давайте начистоту».

🔘Псевдо-инсайты: «То, что все упускают», «То, о чем никто не говорит».

🔘Искусственную интригу: «Самое лучшее: оно учится».

🔘Драматичные обрывки фраз: «Вот и всё. Это всё, что нужно».

🔘Напыщенную важность: «знаменует поворотный момент», «является ярким свидетельством».

🔘Размытые ссылки на авторитет: «эксперты согласны», «исследования показывают».

🔘Псевдоглубокие концовки: «Будущее не наступает. Оно уже здесь».

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

⌨Как использовать команды:

🔘Редактура: /no-ai-slop (ваш текст) — убирает клише, сохраняет ваш стиль и выводит список того, что было изменено.

🔘Детектор штампов: /no-ai-slop is this slop? (текст) — находит и цитирует все ИИ-паттерны в тексте.

🔘Генератор сатиры: Попросите написать текст в стиле «AI slop», чтобы получить максимально кринжовый и клишированный результат (например, ради шутки).

📦Установка:

Инструмент работает в ChatGPT, Claude Code и Codex. Самый простой способ установки — отправить вашему ИИ-агенту следующий промпт:

Install the /no-ai-slop skill globally from [https://github.com/petergyang/no-ai-slop](https://github.com/petergyang/no-ai-slop)

Для установки через терминал (npx):

npx skills add petergyang/no-ai-slop --skill no-ai-slop --global --yes

#NoAISlop #Нейросети #Тексты #Копирайтинг #Редактура #ChatGPT #Claude #DevTools #AI

📱Ссылка на репозиторий:
https://github.com/petergyang/no-ai-slop

📱Cayu.

Cayu - это production-ready среда выполнения (agent runtime) для создания, масштабирования и надежной эксплуатации автономных ИИ-агентов на Python.

Собрать прототип агента на базе стандартных SDK сегодня несложно, но реальные проблемы в проде начинаются на стыках инфраструктуры: падение процесса прямо во время внешнего API-вызова, утечка учетных данных, переполнение контекста LLM, необходимость паузы для аппрува человеком или потеря истории расходов при ретраях. Cayu закрывает именно эти эксплуатационные вызовы, предоставляя надежные низкоуровневые примитивы без привязки к громоздким внешним оркестраторам.

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

🔘Durable Execution и контрольные точки: Сессии, события и транскрипты сохраняются в базу (SQLite локально или PostgreSQL в проде). Любой пайплайн агента можно поставить на паузу, безопасно форкнуть, прервать или возобновить (resume) после перезапуска сервиса.

🔘Human-in-the-Loop (HITL): Нативные механизмы согласований (approvals) и ручного вмешательства. Если модели требуется подтверждение опасного действия или дополнительный ввод от пользователя, выполнение встает на чекпоинт.

🔘Безопасность и виртуальный egress: Строгие политики вызова инструментов (ToolPolicy), типизированные эффекты и изоляция учетных данных. Агенты могут выполнять задачи (например, работу с Git/GitHub CLI), не получая прямого доступа к боевым токенам хоста.

🔘Изоляция окружений: Поддержка локальных воркспейсов, Docker-контейнеров, песочниц E2B и легковесных микро-ВМ (Microsandbox, AWS Lambda MicroVM).

🔘Контроль контекста и расходов: Автоматический подсчет токенов, алгоритмическое сжатие контекста (compaction), защита от переполнения окна модели и пошаговый учет стоимости каждого вызова.

🔘Встроенный Control Plane: Включает готовый сервер на FastAPI и веб-дашборд на React/TypeScript для мониторинга сессий, трейсов, артефактов и задач. Исходники дашборда можно в один клик извлечь для кастомизации (cayu dashboard eject).

🔘Мультипровайдерность: Поддержка OpenAI, Anthropic, AWS Bedrock, Google Cloud Vertex AI, OpenRouter, а также локальный режим авторизации через личную подписку ChatGPT.

💻Пример запуска агента на Python:

import asyncio
from cayu import (
    AgentSpec,
    CayuApp,
    Message,
    OpenAIProvider,
    RunRequest,
    run_to_completion,
)

async def main() -> None:
    app = CayuApp()
    # Регистрация провайдера (берет ключ из OPENAI_API_KEY)
    app.register_provider(OpenAIProvider(), default=True)
    app.register_agent(AgentSpec(name="assistant", model="gpt-4o"))

    # Надежный запуск с фиксацией событий в сессии
    outcome = await run_to_completion(
        app,
        RunRequest(
            agent_name="assistant",
            messages=[Message.text("user", "Объясни концепцию durable agent execution.")],
        ),
    )

    if outcome.ok:
        print(outcome.final_text)
    else:
        print(f"Ошибка {outcome.status}: {outcome.error}")

asyncio.run(main())

🚀Быстрый старт через CLI:

pip install cayu

# Генерация готового каркаса проекта
cayu new myagent
cd myagent

# Запуск проверок и тестов
cayu check --fail-on warning --json
pytest

✅Проект распространяется под открытой лицензией Apache 2.0.

#Python #Cayu #AIAgents #LLM #AgenticAI #DevTools #MachineLearning #OpenSource #Backend #SoftwareEngineering

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

📱Engrim.

Engrim - это универсальный открытый стандарт эпизодической памяти для ИИ-агентов и кодинг-ассистентов, позволяющий свободно переключаться между различными инструментами и моделями (Claude Code, Cursor, Codex CLI, Google Antigravity, GitHub Copilot CLI, OpenCode, Windsurf) на одной кодовой базе без потери архитектурных решений, ограничений и проектного контекста.

Главная проблема современных чат-сессий при разработке — «ловушка 200k-токенов»: повторная отправка сотен тысяч токенов сырых логов размывает внимание LLM, вызывает галлюцинации и раздувает стоимость вызовов, а очистка чата (/clear) сбрасывает контекст до нуля. Engrim решает это заменой сырой истории диалога на компактный, высокоточный пак рабочей памяти (~4000 символов, менее 1000 токенов / <1% окна контекста), который хранится локально в SQLite.

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

🔘Воркфлоу Continue-As-Clear: Когда контекстное окно забивается или модель начинает «плыть», вы просто очищаете чат командой /clear. Следующая сессия автоматически подхватывает актуальные архитектурные решения, состояние проекта и указатель [▶️ RESUME HERE].

🔘100% Local-First и приватность: Данные хранятся исключительно на вашей машине в файле ~/.engrim/memory.db (режим SQLite WAL, права доступа POSIX 0600). Никакой телеметрии, облачной синхронизации и риска утечки проприетарного кода в сторонние SaaS-сервисы.

🔘Отслеживание авторства решений (Provenance Tracking): Запоминает, какой именно агент инициировал изменение (origin_agent: claude-code, cursor, antigravity, codex и т.д.). В памяти четко видно, кто переключил базу данных на PostgreSQL или стандартизировал схемы Pydantic.

🔘Быстрый гибридный поиск (~30 мс на CPU): Комбинирует полнотекстовый лексический поиск (BM25 / FTS5) и легковесные векторные эмбеддинги (model2vec), работая полностью на процессоре без необходимости в GPU.

🔘Самоисцеление окружений (engrim doctor --fix): Проводит аудит базы данных, проверяет статус хуков жизненного цикла во всех средах и автоматически исправляет пути к бинарникам при смене каталогов или переносе конфигов между машинами.

🔘Нативный MCP-сервер: Из коробки реализует протокол Model Context Protocol с инструментами engrim_add, engrim_recall, engrim_context и engrim_review.

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

Установка:

pip install engrim

Автоматическая настройка всех сред разработки на машине:

# Сам находит установленные Claude Code, Cursor, Codex, Copilot и др. и прописывает хуки/MCP
engrim setup

# Диагностика и автоматическое исправление путей:
engrim doctor --fix

Добавление важного архитектурного решения вручную:

engrim add -t decision -s "Перешли на PostgreSQL и нормализовали схемы данных"

✅Проект распространяется под открытой лицензией MIT.

#Engrim #Python #AIAgents #ClaudeCode #Cursor #Codex #LLM #DevTools #OpenSource #SoftwareEngineering #Architecture #MCP

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

📱Hyperresearch.

Hyperresearch - это специализированная среда и фреймворк (research harness) для Claude Code, превращающий ассистента в автономного агента глубоких исследований (Deep Research Agent) с автоматической верификацией источников и защитой от галлюцинаций.

Инструмент берет один исследовательский промпт и прогоняет его через адаптивный 16-шаговый пайплайн: от декомпозиции запроса и поиска сотен источников до параллельной критики черновиков и точечного патчинга финального отчета. Все собранные материалы сохраняются в локальное постоянное хранилище, благодаря чему агент «умнеет» от сессии к сессии.

🔹Главные фичи и архитектурные решения:

🔘250+ источников за один прогон: Масштабный охват предметной области с автоматическим поиском пробелов (gap-fill) и отслеживанием цепочек цитирований (citation chasing).

🔘Аудит независимости (Independence Audit): Система группирует синонимичные копии и перепечатки — пять повторов одного пресс-релиза в разных СМИ считаются за один источник, исключая иллюзию консенсуса.

🔘Верификация цитат и проверка отзывов (Retraction Check): Встроенный скептический модуль проверяет, действительно ли источник подтверждает написанный тезис. Выдуманные цитаты или ссылки на отозванные научные статьи блокируют выпуск отчета.

🔘Враждебная критика (Adversarial by design): Четыре агента-критика параллельно атакуют готовый драфт (по диалектике, глубине, ширине охвата и соответствию задаче). Агент-патчер ограничен правами [Read, Edit] и может вносить только точечные хирургические правки — переписать отчет целиком он физически не может.

🔘Академический поиск в один запрос: Команда hpr scholar search одновременно опрашивает OpenAlex, Crossref, CORE, DOAB, ClinicalTrials.gov, SEC EDGAR и FRED, возвращая единый дедуплицированный список (статьи, монографии, клинические испытания, отчеты регуляторов).

🔘Легальный доступ к полным текстам (Open Access): При обнаружении пейволла Hyperresearch автоматически ищет легальные открытые копии через Unpaywall, Europe PMC и CORE, выгружая полный текст вместо короткого абстракта.

🔘Постоянное хранилище (Vault): Статьи и заметки сохраняются в формате Markdown + SQLite (с поддержкой FTS, PageRank-графа ссылок и векторного поиска). Хранилище доступно вне Claude Code через встроенный MCP-сервер и локальный веб-интерфейс.

🔘Защита от Prompt Injection: Весь спарсенный веб-контент изолируется в теги <untrusted-source>, гарантируя, что внедренные на страницах инструкции не перехватят управление агентом.

⏱️Режимы работы (Tiers):

🔘Light (~30–40 мин): Компактный 5-шаговый маршрут для фактологических справок и экспресс-сравнений.

🔘Full (~1.5–2.5 ч): Полный 16-шаговый цикл с глубоким анализом, оппонирующими критиками и аудитом цитирований (55–130 источников).

🔘Dissertation (экспериментальный, ~4–8 ч): Разбивка на 4–10 глав, анализ 300–450 источников и формирование объемных документов на 25 000 – 80 000 слов.

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

Установка:

cd your-project
pip install hyperresearch && hyperresearch install

Запуск исследования в интерфейсе Claude Code:

/hyperresearch Объясни состояние рынка квантовых вычислений на ионных ловушках

✅Проект написан на Python (3.11–3.14) и распространяется под открытой лицензией MIT.

#Hyperresearch #ClaudeCode #DeepResearch #AIAgents #Anthropic #Python #Research #LLM #OpenSource #DevTools #DataScience

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

📱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

🎓Claude Academy - это официальный интерактивный обучающий трек от компании Anthropic, посвященный эффективному освоению и практическому применению консольного ИИ-агента Claude Code.

Большинство инженеров привыкли к ИИ в виде чатов или расширений для автодополнения в IDE. Claude Code переносит агента прямо в терминал: он умеет самостоятельно исследовать архитектуру проекта, читать и редактировать файлы, выполнять тесты, диагностировать логи сборки и работать с Git.

Обучающая программа Claude Academy помогает перейти от поверхностного использования к продвинутым паттернам агентной разработки.

📚Чему учит курс:

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

🔘Модель разрешений и безопасность: Управление политиками выполнения команд (bash, модификация файлов, работа с Git), настройка уровней автономности и безопасная изоляция окружения.

🔘Управление контекстом и долговременная память: Тонкости работы с файлами инструкций CLAUDE.md, оптимизация расхода токенов, алгоритмическое сжатие сессий (/compact) и сброс контекста без потери ключевых архитектурных договоренностей.

🔘Расширение возможностей через MCP: Подключение внешних баз данных, поисковых систем, документаций и API через открытый протокол Model Context Protocol прямо в рабочий цикл агента.

🔘Реальные инженерные кейсы: Практика рефакторинга монолитов, расследование сложных плавающих багов, автоматизация написания тестов и подготовка PR.

💻Быстрый старт с инструментом:

# Глобальная установка Claude Code
npm install -g @anthropic-ai/claude-code

# Запуск в корне вашего репозитория
cd my-project
claude

⬇️Пройти интерактивные модули и практические руководства можно бесплатно на портале Anthropic Academy.

#ClaudeCode #Anthropic #Claude #ClaudeAcademy #AIAgents #CLI #DevTools #Programming #LLM #SoftwareEngineering #MCP

📱Kev.

Kev - это семейство открытых компактных моделей принятия решений (decision models) на базе Qwen3.5 и Qwen3.8, вдохновленное архитектурой Jev и API TypeSafe System One.

Вместо того чтобы гонять тяжелые генеративные LLM ради простых задач классификации, роутинга и скоринга, Kev выполняет быстрый направленный анализ текста и возвращает строго калиброванные вероятности по каждому вопросу. Это позволяет коду автоматически маршрутизировать уверенные кейсы и передавать пограничные ситуации операторам-людям.

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

🔘Три типа вопросов в одном запросе:

noul — бинарные вопросы (да/нет) с выдачей точной вероятности.

choice — множественный выбор из списка вариантов с распределением вероятностей и метрикой уверенности.

score — рейтинговая шкала оценки (например, уровень срочности или тональности) со средним баллом.

🔘Истинная калибровка вероятностей: В каждый чекпоинт встроена подобранная температура (temperature scaling), благодаря чему процент уверенности модели отражает реальную статистическую вероятность ошибки, а не завышенные «галлюцинации».

🔘Полная совместимость с TypeSafe / Jev: Работает как drop-in замена коммерческого API System One — вы можете направить официальный typesafe-sdk на свой локальный инстанс Kev без изменения клиентского кода.

🔘Четыре размера под любые ресурсы:

Kev-0.8B — работает на ноутбуках и Apple Silicon через нативный бэкенд MLX.

Kev-4B и Kev-9B — оптимальный баланс точности и скорости (работают на картах уровня L40S, A100, H100).

Kev-27B — флагман на базе Qwen3.8 для 80 ГБ GPU, практически не уступающий проприетарному Jev по качеству на сложных задачах.

🔘Экстремальная скорость инференса: Kev-4B обрабатывает 6 вопросов по тексту за ~18 мс на H100 (или ~40 мс на L40S). При повторных вопросах к тому же документу контекст берется из кэша.

🔘Простой дообучение (Fine-Tuning): Модель легко дообучается на собственных размеченных данных через LoRA (--init_from). Также доступен готовый агентский скилл (kev-finetune) для запуска цикла обучения и деплоя в облаке Modal.

💻Пример использования в Python (через typesafe-sdk):

from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

# Подключение к локальному серверу Kev
client = TypeSafeClient(
    api_key="local",
    base_url="http://127.0.0.1:8009",
    model="kev-latest",
)

# Анализ тикета службы поддержки
response = client.system_one(
    state="Заказ задержался на 2 недели, привезли не тот размер. Еще и списали деньги дважды!",
    questions={
        "billing": Noul(instructions="Вопрос связан с оплатой или списанием средств?"),
        "department": Choice(
            instructions="В какой отдел направить тикет?",
            criteria={
                "billing": "Счета, оплаты и возвраты денег",
                "shipping": "Статус доставки, задержки курьера",
                "returns": "Обмен и возврат бракованного товара",
            },
        ),
        "urgency": Score(
            instructions="Оцените срочность тикета",
            criteria=["может подождать", "в течение недели", "срочно сегодня"],
        ),
    },
)

# Извлечение результатов
print("Вероятность проблемы с биллингом:", response.nouls["billing"].noul)
print("Целевой отдел:", response.choices["department"].choice)
print("Срочность:", response.scores["urgency"].score)

🚀Быстрый запуск:

Локальный запуск через uv:

git clone https://github.com/jaredpalmer/kev.git && cd kev
uv sync --extra serve

# Запуск сервера (CUDA / ROCm / Apple Silicon MLX подхватятся автоматически):
uv run --extra serve python -m kev.serve --run jaredpalmer/kev-4b --port 8009

✅Проект распространяется под открытой лицензией Apache 2.0.

#Kev #MachineLearning #LLM #DecisionModels #Qwen #NLP #Classification #Python #MLX #OpenSource #DevTools

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

📱Reef.

Reef - это первая открытая инфраструктура для создания непрерывно самосовершенствующихся ИИ-агентов (continually self-improving agents), объединяющая в единый контур инференс, сбор обратной связи, дообучение и версионированную доставку обновлений.

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

🔄Как устроен 4-шаговый цикл обучения (Core Loop):

✔️Serve (Раздача): Обслуживание боевого трафика через OpenAI- и Anthropic-совместимый API. Каждому ответу присваивается уникальный идентификатор взаимодействия (x-reef-agent-record-id).

✔️Observe (Наблюдение): Сопоставление поступившей обратной связи (числовой скор, текстовые замечания или статус прохождения тестов) с записями сессий.

✔️Grow (Генерация обновлений): Обработка валидных данных по выбранному сценарию (рецепту) и запуск итерации обучения.

✔️Commit (Фиксация): Тестирование кандидатов, сохранение истории версий в Git LFS и бесшовная доставка обновлений в рантайм без перезапуска сервиса.

🧬Два пути эволюции:

🔘Обучение весов модели (Model Weight Training): Затачивает саму LLM под специфику задач с использованием RL-фреймворков (Slime, veRL, AReaL) и высокопроизводительного движка SGLang.

🔘Эволюция харнесса агента (Harness Optimization / Reefine): Если у вас нет кластера GPU, агент может оптимизировать свой «обвес» — системные инструкции, регламенты поведения и код кастомных инструментов/скиллов через обращение к внешнему API. Достаточно поставить задачу на естественном языке (например: «перед исправлением бага всегда пиши воспроизводящий падающий тест»), и агент сам внесет правки в свои правила и протестирует обновленную конфигурацию.

🔘Test-Time Training: Подходит для научных задач и сложных алгоритмических исследований с измеримым критерием корректности (успешно протестировано на задачах AIME, IMOAnswerBench и переборе математических конфигураций).

💻Пример взаимодействия и отправки фидбека:

import httpx

reef = httpx.Client(
    base_url="http://127.0.0.1:8900",
    headers={"Authorization": "Bearer reef-local", "x-reef-scenario": "customer-support"}
)

# 1. Отправляем стандартный запрос
response = reef.post(
    "/v1/chat/completions",
    json={
        "model": "Qwen/Qwen2.5-1.5B-Instruct",
        "messages": [{"role": "user", "content": "Помоги оформить возврат заказа #1234"}],
    },
)
response.raise_for_status()

# Забираем чек транзакции из заголовков
receipt_id = response.headers["x-reef-agent-record-id"]
answer = response.json()["choices"][0]["message"]["content"]

# 2. Отправляем оценку качества ответа для запуска цикла обучения
reef.post(
    "/reef/report",
    json={
        "score": 1.0,
        "feedback": "Отличный ответ: запросил детали чека и назвал корректные сроки",
        "references": [receipt_id],
    },
)

📦Установка:

# Требуется установленный git-lfs в системе
uv pip install reef-infra

Быстрый запуск сервера инференса:

uv run reef serve --inference.model-path Qwen/Qwen2.5-1.5B-Instruct

#Reef #Python #AIAgents #LLM #ReinforcementLearning #SGLang #Slime #MachineLearning #OpenSource #DevTools #PostTraining

📱Ссылка на репозиторий:
https://github.com/Human-Agent-Society/reef

📱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

📱Bashautom.

Bashautom - это легковесная Python-библиотека для управления персистентными (долгоживущими) сессиями Bash, сохраняющая контекст и состояние шелла между последовательными командами.

При использовании стандартного subprocess.run() на каждый вызов порождается абсолютно новый изолированный процесс: изменения рабочей директории (cd), экспортированные переменные (export) и активированные виртуальные окружения (source .env) моментально сбрасываются. Библиотека pexpect решает проблему персистентности, но завязана на хрупкий интерактивный парсинг шелл-промптов.

bashautom держит один живой процесс /bin/bash в фоновом режиме и возвращает чистый структурированный результат по каждой команде без необходимости писать регулярные выражения и шаблоны expect.

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

🔘Персистентность окружения: Переменные среды, активная директория (cwd) и результаты выполнения скриптов через source сохраняются между вызовами метода .execute().

🔘Структурированный CommandResult: Каждая команда возвращает подробный статус: stdout, stderr, exit_code, флаг success, флаг timed_out и точное время выполнения в секундах (duration).

🔘Безопасные таймауты: Если команда превышает заданный лимит времени (timeout=N), она принудительно прерывается, но сама bash-сессия остается живой и готовой принимать следующие команды.

🔘Потоковый вывод в реальном времени: Поддержка коллбеков (stream_callback) для чтения stdout/stderr по мере генерации (полезно для логов сборки и долгих циклов).

🔘Менеджер сессий (SessionManager): Удобное создание, координация и параллельное управление несколькими именованными bash-сессиями в разных директориях.

🔘Встроенные хелперы: Быстрый доступ к состоянию процесса через методы set_env(), get_env(), get_cwd(), проверку PID и флага alive.

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

from bashautom import Session

with Session() as s:
    # Состояние сохраняется от шага к шагу:
    s.execute("cd /opt/myproject")
    s.execute("source .env")
    s.execute("export BUILD_ID=42")
    
    # Выполнение с контролем времени
    result = s.execute("make build", timeout=120)
    
    if result.success:
        print(f"Сборка завершена за {result.duration:.2f} сек")
        print(result.stdout)
    else:
        print(f"Ошибка (код {result.exit_code}):", result.stderr)

Потоковый вывод (Streaming):

from bashautom import Session
from bashautom.session import StreamEvent

def on_output(event: StreamEvent):
    print(f"[{event.stream}] {event.data.strip()}")

with Session() as s:
    s.execute("for i in 1 2 3; do echo $i; sleep 0.5; done", stream_callback=on_output)

📦Установка:

pip install bashautom

✅Требования: Python 3.10+, поддержка Linux и macOS. Лицензия: MIT.

#Bashautom #Python #Bash #DevOps #Automation #Linux #MacOS #CLI #Scripting #OpenSource #DevTools

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

📱Ollaya.

Ollaya - это CLI-утилита и локальный демон для запуска открытых моделей принятия решений (decision models), работающий по тому же принципу и с тем же удобством, как Ollama запускает генеративные LLM.

Модели принятия решений принципиально отличаются от привычных чат-ботов: они не генерируют текст токен за токеном. Вместо этого модель принимает входящий контекст (письмо, тикет техподдержки, произвольный JSON) и список типизированных вопросов, а затем за один прямой проход (forward pass) за миллисекунды возвращает математически откалиброванные вероятности по каждому пункту.

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

🔘Экстремальная скорость без генерации: Оценка параметров происходит в разы быстрее классических LLM. Легковесные энкодеры вроде laya:en (на базе ModernBERT) отвечают на 5 вопросов за 8–10 мс на RTX 4090 и доли секунды на обычном CPU.

🔘Три типа вопросов:

choice — множественный выбор категории с распределением вероятностей;

noul — бинарные вопросы (да/нет);

score — оценка по шкале (уровень злости клиента, срочность и т.д.).

🔘Совместимость с TypeSafe / Jev: Демон полностью воспроизводит протокол /v1/systemone. Код, написанный под SDK TypeSafe, переключается на локальный инстанс простой установкой переменной TYPESAFE_BASE_URL=http://localhost:11435.

🔘Знакомый интерфейс в стиле Ollama: Единый бинарный файл с привычными командами управления: ollaya run, ollaya pull, ollaya list, ollaya ps, ollaya rm.

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

🔘Готовность к работе с ИИ-агентами: Встроенная поддержка протокола Model Context Protocol (ollaya mcp) позволяет в одну команду подключить локальные классификаторы к Claude Code, Cursor или Claude Desktop.

🔘Поддержка кастомных Modelfile: Можно упаковать фиксированный набор вопросов в собственную модель:

Dockerfile:

FROM laya
QUESTIONS ./triage.json
PARAMETER precision fp32

🧢Каталог моделей:

✔️winnow:e4b — рекомендуемая флагманская модель (файнтьюн Gemma 4 в формате GGUF через llama.cpp). Точность 0.722, время ответа ~89 мс на RTX 4090.

✔️laya / laya:en / laya:multilingual — быстрый роутер и энкодеры для мгновенной классификации на 100+ языках даже на слабом процессоре.

✔️kev (kev:4b, kev:9b) — открытые откалиброванные модели принятия решений на базе архитектуры Qwen3.5.

✔️qwen3guard — специализированная модель фильтрации контента и безопасности (safe / controversial / unsafe).

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

# Мгновенная классификация тикета саппорта
ollaya run winnow:e4b --preset triage "Уже третий раз за год списываете деньги дважды! Верните платеж сегодня же или я ухожу к конкурентам."

Вывод модели:

intent            refund                                ███████████████░ 0.91
is_urgent         yes                                   ███████████████░ 0.92
frustration       2.89 / 3  very angry or using stron…  ██████████████░░ 0.86
refund_requested  yes                                   ████████████████ 0.99
churn_risk        yes                                   ████████████████ 0.99

🚀Установка:

Linux / macOS (Apple Silicon):

curl -fsSL https://ollaya.dev/install.sh | sh

Windows (PowerShell):

irm https://ollaya.dev/install.ps1 | iex

✅Также доступны Docker-образы с поддержкой CUDA и официальное десктопное приложение для управления моделями из системного трея.

#Ollaya #MachineLearning #DecisionModels #Ollama #Classification #NLP #AI #DevTools #OpenSource #LocalAI #LLM

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

📱Taste-Bench.

Taste-Bench - это бенчмарк для языковых моделей и ИИ-агентов, оценивающий их инженерную интуицию и «вкус» (taste) — способность выбирать верное направление на ключевых развилках при решении сложных долгосрочных задач (long-horizon tasks).

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

🧩Как устроен датасет:

Модели на вход подается описание задачи, накопленный контекст работы агента до развилки (до 64k токенов) и два альтернативных варианта следующего действия (A и B). Задача — выбрать шаг, который в скрытом продолжении реальной траектории привел к успеху.

Все 502 вопроса бенчмарка добыты напрямую из логов реальных запусков без ручной разметки экспертами:
✔️
• 🔀 Параллельные развилки (Parallel forks): Независимые попытки решить одну задачу, разошедшиеся в определенной точке с противоположным итоговым результатом (одна прошла тесты, вторая упала).

🔘Развилки с откатом (Detour forks): Ситуации, где агент выбрал ложный путь, столкнулся с ошибкой, откатился и нашел рабочее решение. Сравнивается тупиковое действие и правильный корректирующий шаг.

🔘Строгая фильтрация: Исключены тривиальные развилки (где очевиден выбор без контекста) и спорные случаи (где судьи-модели не сошлись в оценке). 390 вопросов взяты из SWE-bench и SWE-bench Pro (software engineering), а 112 — из METR MALT / RE-Bench / HCAST (ML-исследования).

⚖️Бескомпромиссный протокол тестирования:

Оценка проводится по протоколу paired_order_v1: каждый вопрос задается дважды с перестановкой вариантов (A/B и B/A). Балл засчитывается только при верном выборе в обоих случаях.
• Случайное угадывание дает всего 25%.
• Стратегия «всегда выбирать A» дает 0%.

🏆Результаты лидерборда (Frontier Models):
Даже ведущие модели с трудом преодолевают планку в 50–60% точности:

✔️GPT-5.6 Sol — 59.7%

✔️GPT-5.5 — 59.5%

✔️Claude Opus 5 — 55.5%

✔️Grok 4.5 — 54.6%

✔️GLM-5.2 — 53.9%

✔️Claude Sonnet 5 — 51.6%

✔️DeepSeek V4 Flash — 43.3%

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

git clone https://github.com/wbopan/tastebench && cd tastebench
uv sync

# Загрузка датасета (требуется доступ на Hugging Face)
uv run tb download

# Запуск оценки модели через OpenAI-совместимый эндпоинт
export TASTEBENCH_API_KEY="your-key"
uv run tb run --model gpt-5.5 --api https://api.openai.com/v1/chat/completions

# Подсчет итогового скора
uv run tb score runs/gpt-5.5/<date>

Датасет доступен в библиотеке datasets:

from datasets import load_dataset
rows = load_dataset("wenbopan/taste-bench", "engineering", split="test", revision="v1.0")

✅Код бенчмарка распространяется под лицензией MIT, данные — под CC BY 4.0.

#TasteBench #Benchmark #AIAgents #LLM #MachineLearning #SWEbench #SoftwareEngineering #DataScience #OpenSource #DevTools #Eval

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

📱Jeff.

Jeff - это сверхлегкая (0.8B параметров) открытая модель «Системы 1» (System 1), спроектированная для быстрого принятия решений и многоклассовой классификации в любых предметных областях за миллисекунды.

Вместо того чтобы тратить секунды и десятки гигабайт видеопамяти тяжелых генеративных LLM на выбор из нескольких вариантов, роутинг или валидацию, Jeff делает выбор за один прямой проход (forward pass) без генерации лишнего текста и возвращает строго откалиброванные вероятности.

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

🔘Тандем «Быстрый + Умный» (System 1 перед System 2): Jeff ставится как легковесный шлюз перед большой моделью (например, Qwen 3.8-27B). В подавляющем большинстве случаев Jeff принимает решение сам всего за 20–70 мс (в 28–35 раз быстрее!). К тяжелой 27B-модели система обращается только тогда, когда уверенность Jeff падает ниже пороговой. На тестах такая связка показала среднюю точность 95.0% против 86.6% у одиночной 27B-модели.

🔘Модульные адаптеры (v1.3): Базовая модель весит всего ~1.7 ГБ VRAM и поддерживает горячее переключение 15 компактных LoRA-адаптеров под узкие задачи:

✔️guard — защита от промпт-инъекций и джейлбрейков (точность 98.2%);

✔️tools — выбор вызываемого инструмента для агентов (97.2%);

✔️ground — проверка обоснованности ответа источниками (анти-галлюцинации);

✔️triage и support-intents — маршрутизация тикетов и определение намерений клиентов;

✔️legal-clauses, aml, sanctions, soc — доменные проверки для финтеха, комплаенса и ИБ.

🔘Jeff-Code для кодинг-агентов: В связке с Qwen 3.8-27B берет на себя рутинные подготовительные шаги (чтение файлов, grep, запуск тестов) и решает, когда большой модели действительно нужно включать режим глубокого рассуждения (thinking). Задачи выполняются на 47% быстрее при сохранении аналогичного Pass Rate (~62.4%).

🔘Аппаратная всеядность и GGUF: Работает через нативный бэкенд MLX на Apple Silicon, через PyTorch/CUDA на видеокартах NVIDIA, а также через llama.cpp с поддержкой квантованных GGUF-сборок (Q8_0 и Q4_K_M).

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

from jeff import Client
from jeff.client import choice_question, yes_no_question

# Подключение к локальному инстансу с нужным адаптером
jeff = Client("http://localhost:8765", model="triage")

# Мгновенная классификация тикета
answers = jeff.ask(
    "Посылка пришла разбитой, требую немедленный возврат денег.",
    {
        "team": choice_question(
            {
                "refunds": "Возвраты и финансовые вопросы",
                "parcels": "Поврежденные или утерянные посылки",
                "login": "Проблемы со входом и учетной записью",
            },
            instructions="Какая команда должна обработать тикет?",
        ),
        "angry": yes_no_question("Клиент выражает злость?"),
    },
)

# Получаем категорию с откалиброванной вероятностью
print(answers.choice("team").key)         # parcels
print(answers.choice("team").confidence)  # 0.94

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

git clone https://github.com/firelex/jeff && cd jeff
uv sync --no-default-groups --extra lora

# Скачивание базы и адаптеров
uv run hf download mstrasser/jeff-base --revision v1.3 --local-dir jeff-base-v1.3
uv run hf download mstrasser/jeff-adapter-triage --revision v1.3 --local-dir adapters/triage

# Запуск сервера
JEFF_CHECKPOINT=jeff-base-v1.3 JEFF_ADAPTERS=adapters PORT=8765 uv run --extra lora jeff-serve

✅Код проекта распространяется под лицензией MIT, веса моделей — Apache 2.0.

#Jeff #MachineLearning #LLM #DecisionModels #System1 #Qwen #Classification #AI #DevTools #OpenSource #LocalAI #AgenticAI

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

📱RightWayUp.

RightWayUp - это открытая модель компьютерного зрения (Computer Vision) от команды ORTUS AI, предназначенная для определения угла поворота (roll) изображений в полном диапазоне 360° с шагом в 1° и механизмом калиброванного воздержания от ответа (calibrated abstention).

Большинство классических решений либо классифицируют поворот только с шагом 90° (0°, 90°, 180°, 270°), либо «считывают» ориентацию не по смыслу сцены, а по артефактам повернутой 8×8 сетки блоков JPEG. Кроме того, обычные модели пытаются повернуть даже те кадры, где верха и низа объективно не существует.

RightWayUp решает эти проблемы: модель возвращает точный угол по часовой стрелке (angle_cw), скор уверенности (confidence), флаг воздержания (abstain) и умеет автоматически сохранять исправленный снимок.

🔹Ключевые особенности и архитектура:

🔘Полный круг 360° с точностью до 1°: Непрерывная оценка угла поворота кадра на основе архитектуры DINOv2 (ViT) с 360-биновой классификационной головой и circular-Gaussian soft target loss.

🔘Калиброванное воздержание (Calibrated Abstention): Если на снимке нет выраженного «верха» (текстуры, сплошная стена, чистое небо, съемка поверхности строго сверху вниз), модель активирует флаг abstain, исключая ложные срабатывания в автоматических пайплайнах.

🔘Защита от читерства на JPEG-сетке (The Grid Fix): Архитектура обучена на «чистых» данных без утечки сетки сжатия (lossless cue-free rendering), благодаря чему модель анализирует реальную физику и геометрию сцены, а не артефакты ресемплинга.

🔘Результаты выше человека и мультимодальных LLM: На бенчмарке RotBench старшие версии модели показывают 100% точности при поворотах на 0/90/180/270°, опережая как живых асессоров (97–99%), так и современные мультимодальные модели вроде GPT-5 и Gemini 2.5 Pro (40–80%).

🔘Устойчивость к помехам: Изначально создавалась для систем мониторинга камер видеонаблюдения (CCTV/CHEQIT) — отлично справляется с размытием, ночной съемкой, низким разрешением и даже тепловизионными кадрами.

🔧Линейка моделей (Tiers):

🔘Pico / Nano (23M параметров): Экстремально быстрые модели (0.55 мс на GPU, 3–7 мс на CPU). Pico оптимизирована для запуска прямо в браузере через WebAssembly/ONNX Runtime Web.

🔘Fast (23M параметров, 224 px): Дистиллированная из Max версия для edge-устройств и парков камер (0.68 мс на GPU).

🔘Balanced / Pro (Каскады Fast → Max): Большинство простых кадров обрабатываются быстрой сетью Fast, а пограничные и сложные передаются тяжелой модели Max.

🔘Max (306M параметров, ViT-L/14, 280 px): Флагманская модель для максимальной точности на сложных ракурсах и датасетах.

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

Установка:

pip install rightwayup

Использование через CLI:

# Определение угла поворота
rightwayup predict frame.jpg

# Автоматическое выравнивание с привязкой к 90° (пропускает кадры с abstain)
rightwayup fix photo.jpg --snap 90 --out upright/

Использование в Python:

from PIL import Image
from rightwayup import Orienter

# Инициализация модели (pico, nano, fast, balanced, pro, max)
orienter = Orienter(tier="balanced")

# Предсказание угла
result = orienter.predict("frame.jpg")
print(f"Поворот: {result.angle_cw}°, Уверенность: {result.confidence}, Воздержание: {result.abstain}")

# Коррекция положения
corrected_img = orienter.correct(Image.open("photo.jpg"), snap=90)

Модели доступны в форматах ONNX (FP32, FP16, INT8), Core ML (для Apple Silicon / Neural Engine) и TensorRT.

✅Лицензия: Apache 2.0 (разрешено коммерческое использование).

#RightWayUp #ComputerVision #MachineLearning #DINOv2 #AI #Python #ONNX #CoreML #ImageProcessing #DevTools #OpenSource

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

📱Flowfile.

Flowfile - это инструмент для визуального построения ETL-пайплайнов, который компилируется в высокопроизводительный код на Polars.

Главная идея проекта — стереть грань между визуальным no-code/low-code и классической разработкой: визуальный холст (canvas) с нодами и Python-код являются двумя синхронными представлениями одного и того же графа вычислений.

Flowfile работает без тяжелых кластеров (вроде Apache Spark): все преобразования выполняются in-process на базе Polars, утилизируя ресурсы одной машины на максимум.

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

🔘Холст + Код (Dual-Mode):

✔️49 готовых типов узлов: джойны, нечеткое сопоставление (fuzzy matching), сводные таблицы (pivot), оконные функции, агрегации, древовидное разворачивание (bill-of-materials explosion) и ветвление.

✔️Редактор формул с 95 встроенными функциями.

✔️Узел произвольного Polars-кода для специфической логики, не покрытой стандартными блоками.

✔️Живое интерактивное превью данных (Live Data Preview) на каждом этапе пайплайна.

🔤Генерация чистого Python-кода: Вы можете быстро спроектировать логику визуально, а затем экспортировать её в лаконичный независимый скрипт на чистом Polars (import polars as pl) без необходимости тащить Flowfile на прод. Графы сохраняются в человекочитаемом YAML для версионирования в Git.

🔤Встроенный AI-ассистент: Позволяет генерировать и модифицировать структуру пайплайна прямо на холсте по текстовому описанию задачи (поддерживаются ключи OpenAI, Anthropic, Google, Groq, OpenRouter или локальная Ollama).

🔤Каталог данных на Delta Lake и SQL: Встроенный каталог таблиц с поддержкой версионирования, Time Travel и предикатного пушдауна (pushdown) в виртуальных таблицах. Для исследовательской работы есть встроенный SQL-редактор (Polars SQLContext) и модуль визуализации графиков Graphic Walker (аналог Tableau).

🔤Источники и коннекторы: Локальные файлы (CSV, Parquet, Excel, JSON), СУБД (PostgreSQL, DuckDB, MySQL, SQLite, SQL Server), облачные хранилища (S3, GCS, ADLS с поддержкой Delta Lake и Iceberg на чтение), Kafka (consumer) и внешние REST API.

🔤Запуск в любом окружении:

✔️В браузере: мгновенная работа через WebAssembly / Pyodide на demo.flowfile.org без установки и сервера;

✔️Локально на ноутбуке: установка в одну команду через pip или готовые десктопные приложения (Tauri);

✔️В команде: развертывание через Docker Compose с авторизацией, ролями пользователей, общим каталогом, планировщиком задач (scheduler) и изолированными Jupyter-подобными Python-кернелами.

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

Вы можете описать пайплайн кодом через API в стиле Polars и в один вызов открыть его в визуальном редакторе:

import flowfile as ff
from flowfile import col, open_graph_in_editor

# Загрузка и трансформация данных
df = ff.from_dict({
    "category": ["A", "B", "A", "C", "B"],
    "value": [100, 200, 150, 300, 250]
})

result = (
    df.filter(col("value") > 150)
      .with_columns((col("value") * 2).alias("double_value"))
      .group_by("category")
      .agg(col("value").sum().alias("total"))
)

# Открытие собранного графа в визуальном интерфейсе
open_graph_in_editor(result.flow_graph)

🚀Быстрый запуск:

Установка и запуск UI на локальной машине (Python 3.10–3.13):

pip install Flowfile
flowfile run ui

Командный запуск в Docker Compose:

git clone https://github.com/edwardvaneechoud/Flowfile.git
cd Flowfile
docker compose up -d
# Веб-интерфейс будет доступен по адресу http://localhost:8080

✅Проект распространяется под свободной лицензией MIT.

#Flowfile #Python #Polars #ETL #DataEngineering #DataScience #SQL #DeltaLake #DuckDB #OpenSource #DevTools #DataPipelines

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

📱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