📱Threaded Map-Reduce.

Threaded Map-Reduce — это библиотека, реализующая паттерн Map-Reduce с настоящей многопоточностью, без ограничений GIL, благодаря экспериментальной версии Python 3.13+ с поддержкой free-threading.

❓ Зачем это нужно?

При работе с CPU-нагруженными задачами (например, в биоинформатике или обработке больших данных) использование потоков в стандартном Python не даёт прироста из-за GIL. Но с free-threaded Python 3.13+ можно задействовать все ядра процессора на полную мощность.

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

from threaded_map_reduce import map_reduce
from operator import add

def square(x): return x * x

result = map_reduce(
    map_fn=square,
    reduce_fn=add,
    iterable=range(1, 1001),
    num_computing_threads=4,
    num_items_per_chunk=100
)
print(f"Сумма квадратов: {result}")

📊Производительность:

🔘Тесты на Intel i7-1260P показали ускорение в разы.

🔘Итераторы в Python не потокобезопасны, поэтому используется безопасная разбивка на чанки.

🔘Очереди тоже тестировались, но оказались чуть менее эффективны.

❗️Важно:

🔘Работает только с Python 3.13+ (с ключом -Xno-gil или uv run).

🔘reduce_fn должна быть ассоциативной.

🔘Некоторые библиотеки (например, pandas или gzip) реактивируют GIL при импорте, что может сломать многопоточность.

#Python313 #FreeThreading #MapReduce #Multithreading #NoGIL #CPUIntensive #Python #OpenSource #Биоинформатика #ПараллельныеВычисления #Разработка #GIL #PythonPerformance #MapReducePython #ThreadedPython

📱Ссылка на репозиторий:
https://github.com/JoseBlanca/threaded-map-reduce

📱Wove.

Wove — это новая библиотека, делающая асинхронный Python красивым и понятным.
Она позволяет писать асинхронный код линейно, без множества вложенных async/await и колбэков.

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

🔘Читаемость: код в with weave() блоке выполняется сверху вниз, как обычный Python.

🔘Автоматическая параллельность: Wove сама строит граф зависимостей и запускает независимые задачи параллельно.

🔘Поддержка sync и async: можно смешивать def и async def без боли.

🔘Фоновая обработка: выполнение в потоке или даже отдельном процессе.

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

🔘Никаких зависимостей — чистый Python, совместим с asyncio.

🔘Совместима с Python 3.8–3.14 (включая free-threaded).

✅Wove — это asyncio без боли.
Пиши красиво, выполняй параллельно.

#Python #AsyncIO #Concurrency #DevTools #OpenSource #Wove #Multithreading #AsyncProgramming

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

📱Bocpy.

Bocpy — это библиотека для Python, реализующая принципиально новую парадигму параллельного программирования — поведенческо-ориентированную конкурентность (Behavior-Oriented Concurrency, BOC).

В параллельном коде на Python часто возникают состояния гонки (data races), а с появлением сборки без GIL (free-threaded Python) защищать данные становится еще сложнее. bocpy решает эту проблему фундаментально: данные разделяются так, что каждый поток выполнения («поведение») получает уникальное временное владение объектом. Больше не нужно вручную управлять блокировками (lock.acquire()), а риск дедлоков исключен на уровне архитектуры.

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

🔘Фокус на потоке данных: Задача разработчика смещается с решения проблем параллельного доступа к простой организации логики. Функции оборачиваются в декораторы @when и со стороны выглядят как обычный линейный код.

🔘Настоящая многоядерность: Библиотека написана на C и использует механизм суб-интерпретаторов Python. Начиная с Python 3.12, где у каждого суб-интерпретатора свой собственный GIL (PEP 684), bocpy обеспечивает честный параллелизм и показывает практически линейное масштабирование (до 7.5× ускорения на 8 воркерах).

🔘Безопасность по умолчанию: Под капотом движок на C реализует двухфазное запирание (2PL) и MCS-очереди. Потоки изолированы друг от друга, поэтому данные обрабатываются так, будто программа работает в один поток.

🔘Поддержка тяжелых объектов (PinnedCown): Если объект не может быть передан между интерпретаторами (например, контекст GPU, файловые дескрипторы или UI-виджеты), его можно закрепить за главным потоком, не ломая параллельную работу остальных воркеров.

💻Как это выглядит в коде:

Вместо сложной синхронизации вы объявляете разделяемые ресурсы как Cown (concurrently-owned objects) и указываете, какие функции должны дождаться их готовности:

from bocpy import Cown, when, wait

# Создаем защищенные ресурсы
cheese = Cown(None)
meal = Cown(None)

# Задачи запустятся параллельно на разных ядрах
@when(cheese)
def buy_cheese(cheese):
    cheese.value = "Пармезан"

@when(meal)
def order_meal(meal):
    meal.value = "Салат"

# Этот блок выполнится автоматически, как только ОБОИ ресурсы освободятся
@when(cheese, meal)
def eat_dinner(cheese, meal):
    print(f"Ужинаем: {meal.value} и {cheese.value}!")

wait() # Ждем завершения всех задач

📈Поддержка версий Python:

🔘Python 3.10 / 3.11: Полная совместимость, но из-за общего глобального GIL задачи будут выполняться последовательно. Подходит для отладки и портативности.

🔘Python 3.12+: Идеальный вариант. Задачи распределяются по суб-интерпретаторам со своими GIL и работают на полную мощность процессора.

🔘Python 3.13t+ (Free-threaded): Полная нативная поддержка сборки без GIL.

🔧Установка:

pip install bocpy

#Python #bocpy #Concurrency #Parallelism #GIL #Multithreading #SubInterpreters #Backend #OpenSource

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

📱Mitti.

Mitti - это экспериментальный Python ASGI-фреймворк, объединяющий конкурентное и параллельное выполнение кода под капотом привычной синхронной модели программирования.

Вместо того чтобы заставлять разработчика разбираться с «цветными функциями», async/await и нюансами asyncio, Mitti оставляет код приложения обычным синхронным Python. Фреймворк сам берет на себя управление рантаймом: он распределяет вызовы конкурентно на стандартных сборках с GIL и запускает их в настоящем многопоточном параллелизме на free-threaded сборках Python (no-GIL / PEP 703).

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

🔘Синхронный код без бойлерплейта: Вы пишете стандартные синхронные функции (def), а среда Mitti берет на себя планирование и эффективное исполнение потоков.

🔘Готовность к Python 3.13+ (Free-threaded): Спроектирован с прицелом на отказ от GIL. На no-GIL интерпретаторах код масштабируется по процессорным ядрам без межпроцессного оверхеда, а на стандартном Python работает через пул потоков в режиме обратной совместимости.

🔘Стандарт ASGI 3: Приложение легко разворачивается под современными ASGI-серверами (например, Uvicorn).

🔘Современный стек: Включает роутинг, типизированные path- и query-параметры, внедрение зависимостей (Dependency Injection), базовую валидацию, middleware, обработку событий жизненного цикла (lifespan) и сериализацию в JSON.

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

from mitti import App

app = App()

# Обычная синхронная функция, готовая к параллельному исполнению
@app.get("/users/{user_id}")
def get_user(user_id: int):
    return users.get(user_id)

❗️Статус проекта: Ранняя альфа (Early alpha). Для работы требуется Python 3.13+, в идеале — в сборке без GIL (free-threaded Python).

#Python #ASGI #Mitti #NoGIL #FreeThreaded #Concurrency #Multithreading #Backend #WebDevelopment #OpenSource

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

📱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

📱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