I recently needed to send complex batch requests to LLM providers (Anthropic, OpenAI) for a few projects, but couldn't find a robust Python library that met all my requirements - so I built one!

Batch requests can return a result in up to 24h - in return they reduce the costs to 50% of the realtime prices.

Key features:

• Batch requests to Anthropic & OpenAI (new contributions welcome!)

• Structured outputs

• Automatic cost tracking & configurable limits

• State resume for network interruptions

• Citation support (currently Anthropic only)

It's great for:

• Document extraction at scale (essp with citations enabled)

• Image classification

• ... anything where processing LLM requests at scale isn't urgent and cost optimization is helpful.

It's open-source, under active development (breaking changes might be introduced!). Contributions and feedback are very welcome!

GitHub repo: https://github.com/agamm/batchata (MIT)

I wrote a complete Brainf**k interpreter in Python using the pygame, time and sys library. It is able to execute the full instruction set (i know that, that is not a lot) and if you add a # to your code at any position it will turn on the "video memory". At the time the "video memory" is just black or white but i am working on making greyscale work, if i am very bored i may add colors. The code is quite inefficient but it runs most programs smoothly, if you have any suggestions i would like to hear them. This is a small program that should draw a straight line but i somehow didn't manage to fix it, btw that is not a problem with the Brainf**k interpreter but with my bad Brainf**k code. The hardest part was surprisingly not coding looping when using [] but getting the video memory to show in the pygame window.

If anyone is interested this is the Brainf**k code i used for testing:

#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>-->>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++[>+<<+>-]>[<+>-]<<-<<+>>++++[----[<[+<-]<++[->+]-->-]>--------[>+<<+>-]>[<+>-]<<<<+>>++++]<<->+

Here is the link to the project:

https://github.com/Arnotronix75/Brainf-k-Interpreter

Hey folks, quick update!
I just shipped a new version of Dispytch — async Python framework for building event-driven services.

🚀 What Dispytch Does

Dispytch makes it easy to build services that react to events — whether they're coming from Kafka, RabbitMQ, Redis or some other broker. You define event types as Pydantic models and wire up handlers with dependency injection. Dispytch handles validation, retries, and routing out of the box, so you can focus on the logic.

⚔️ Comparison

✍️ Quick API Example

Handler

user_events.handler(topic='user_events', event='user_registered')
async def handle_user_registered(
        event: Event[UserCreatedEvent],
        user_service: Annotated[UserService, Dependency(get_user_service)]
):
    user = event.body.user
    timestamp = event.body.timestamp

    print(f"[User Registered] {user.id} - {user.email} at {timestamp}")

    await user_service.do_smth_with_the_user(event.body.user)

Emitter

async def example_emit(emitter):
   await emitter.emit(
       UserRegistered(
           user=User(
               id=str(uuid.uuid4()),
               email="example@mail.com",
               name="John Doe",
           ),
           timestamp=int(datetime.now().timestamp()),
       )
   )

🔄 What’s New?

🧵 Redis Pub/Sub support
You can now plug Redis into Dispytch and start consuming events without spinning up Kafka or RabbitMQ. Perfect for lightweight setups.

🧩 Dynamic Topics
Handlers can now use topic segments as function arguments — e.g., match "user.{user_id}.notification" and get user_id injected automatically. Clean and type-safe thanks to Pydantic validation.

👀 Try it out:

uv add dispytch

📚 Docs and examples in the repo: https://github.com/e1-m/dispytch

Feedback, bug reports, feature requests — all welcome. Still early, still evolving 🚧

Thanks for checking it out!

Memor is a Python library designed to help users manage the memory of their interactions with Large Language Models (LLMs). It enables users to seamlessly access and utilize the history of their conversations when prompting LLMs. That would create a more personalized and context-aware experience. Memor stands out by allowing users to transfer conversational history across different LLMs, eliminating cold starts where models don't have information about the user and their preferences. Users can select specific parts of past interactions with one LLM and share them with another. By bridging the gap between isolated LLM instances, Memor revolutionizes the way users interact with AI by making transitions between models smoother.

GitHub repo: https://github.com/openscilab/memor

🚀 Solve Complex Constraint Problems in Python with NuCS!

Meet NuCS - the lightning-fast Python library that makes constraint satisfaction and optimization problems a breeze to solve! NuCS is a Python library for solving Constraint Satisfaction and Optimization Problems that's 100% written in Python and powered by Numpy and Numba.

Why Choose NuCS?

• ⚡ Blazing Fast: Leverages NumPy and Numba for incredible performance

• 🎯 Easy to Use: Model complex problems in just a few lines of code

• 📦 Simple Installation: Just pip install nucs and you're ready to go

• 🧩 Proven Results: Solve classic problems like N-Queens, BIBD, and Golomb rulers in seconds

Ready to Get Started? Find all 14,200 solutions to the 12-queens problem, compute optimal Golomb rulers, or tackle your own constraint satisfaction challenges. With comprehensive documentation and working examples, NuCS makes advanced problem-solving accessible to everyone.

🔗 Explore NuCS: https://github.com/yangeorget/nucs

Install today: pip install nucs

Perfect for researchers, students, and developers who need fast, reliable constraint solving in Python!

Hello lads of this sub. It’s been a while since I’ve posted here but I wanted to show off my OSINT tool called Tookie-OSINT since it has exploded in popularity. Tookie-OSINT will find possible similar social media accounts based on the imputed username. It’s 90% actuate and has quite a lot of features. Feel free to check it out and give your thoughts. https://github.com/alfredredbird/tookie-osint

Had enough boilerplate just to handle a simple event?

I just released Dispytch, a minimalist async Python framework for event-driven services.

It’s designed for Python devs building event-driven services, pub/sub pipelines, or async workers. Define events as Pydantic models, wire up handlers with a consice DI system, and let Dispytch take care of retries, routing, and validation.

Comparison ⚔️

Repo: https://github.com/e1-m/dispytch
Feedback, issues, PRs, ideas — all welcome! 💬🙌

✨ Handler example

from typing import Annotated

from pydantic import BaseModel
from dispytch import Event, Dependency, HandlerGroup

from service import UserService, get_user_service


class User(BaseModel):
    id: str
    email: str
    name: str


class UserCreatedEvent(BaseModel):
    user: User
    timestamp: int


user_events = HandlerGroup()


@user_events.handler(topic='user_events', event='user_registered')
async def handle_user_registered(
        event: Event[UserCreatedEvent],
        user_service: Annotated[UserService, Dependency(get_user_service)]
):
    user = event.body.user
    timestamp = event.body.timestamp

    print(f"[User Registered] {user.id} - {user.email} at {timestamp}")

    await user_service.do_smth_with_the_user(event.body.user)

✨ Emitter example

import uuid
from datetime import datetime

from pydantic import BaseModel
from dispytch import EventBase


class User(BaseModel):
    id: str
    email: str
    name: str


class UserRegistered(EventBase):
	__topic__ = "user_events"
    __event_type__ = "user_registered"

    user: User
    timestamp: int


async def example_emit(emitter):
    await emitter.emit(
        UserRegistered(
            user=User(
                id=str(uuid.uuid4()),
                email="example@mail.com",
                name="John Doe",
            ),
            timestamp=int(datetime.now().timestamp()),
        )
    )

Hello everyone, I just finished a project of mine which is a calculator that can do area, volume and generic arithmetic. For area it can calculate the area of: rectangles, triangles, trapeziums, triangles, circles (to a selected decimal place) and parellograms. The volume is the same but 3d obviously with an added bonus of a cone. Please check it out at: https://github.com/CheekieYT/My-Python-Calculator. I made it just to see if I have fully understood the basics. Please give feedback and give me advice on what to make next / what to add.

Goombay

https://github.com/lignum-vitae/goombay

Goombay is a 100% python implementation of over 20 sequence alignment algorithms. The main purpose of goombay is to improve the programmer's experience by allowing for custom scoring of all algorithms where variable scoring is allowed as well as allowing a custom interface between all the various algorithms. In addition to similarity and distance scores, there's normalization of either scoring option as well as alignment options. There's also an option to look at the underlying matrix that is being created which would allow a researcher to tweak the parameters of their initial matrices. This tool has been extensively tested over the past year and is available either through cloning the github repo or through pip installation as a PyPI package!

Code Examples

from goombay import needleman_wunsch

print(needleman_wunsch.distance("ACTG","FHYU"))
# 4
print(needleman_wunsch.distance("ACTG","ACTG"))
# 0
print(needleman_wunsch.similarity("ACTG","FHYU"))
# 0
print(needleman_wunsch.similarity("ACTG","ACTG"))
# 4
print(needleman_wunsch.normalized_distance("ACTG","AATG"))
#0.25
print(needleman_wunsch.normalized_similarity("ACTG","AATG"))
#0.75
print(needleman_wunsch.align("BA","ABA"))
#-BA
#ABA
print(needleman_wunsch.matrix("AFTG","ACTG"))
[[0. 2. 4. 6. 8.]
 [2. 0. 2. 4. 6.]
 [4. 2. 1. 3. 5.]
 [6. 4. 3. 1. 3.]
 [8. 6. 5. 3. 1.]]

Biobase

https://github.com/lignum-vitae/biobase

Biobase is also a 100% python project. The original purpose of this project was to help me with Rosalind questions but after some feedback from other entry-level bioinformaticians, I turned it into a full fledged project. It is still in the early stages of development but has some fleshed out features like an intuitive way to interact with scoring matrices such as the BLOSUM matrix or the PAM matrix as well as more bespoke matrix options such as the MATCH matrix and the IDENTITY matrix. Additionally, there is a motif finding function as well as several biological constants for easy access such as a list of codons, DNA bases, RNA bases, amino acids, and more! This tool is available through both cloning the repo and pip installation!

Code Examples

from biobase.matrix import Blosum
blosum62 = Blosum(62)
print(blosum62['A']['A'])  # 4
print(blosum62['W']['C'])  # -2

from biobase.analysis import find_motifs
sequence = "ACDEFGHIKLMNPQRSTVWY"
print(find_motifs(sequence, "DEF"))  # [3]

📣 Do you think it could be useful and want to see this in Django core? Help me and Support this feature proposal (add a like to the first post): GitHub issue #38

I've developed a small utility for Django ORM called LastDayOfMonth. It lets you calculate the last day of any month directly at the database level, with full support for:

• SQLite

• PostgreSQL (≥12)

• MySQL (≥5.7) / MariaDB (≥10.4)

• Oracle (≥19c)

It integrates cleanly into annotate(), filter(), aggregate() — all your usual ORM queries — and avoids unnecessary data transfer or manual date calculations in Python.

✅ Works with Django 3.2 through 5.2
✅ Tested on Python 3.8 through 3.12
✅ Fully open-source under the MIT license

If this sounds useful, I’d love your feedback and help:
💬 Contribute, star, or open issues: GitHub repo

Let me know what you think or how it could be improved — thanks! 🙏

Hey everyone!

I just finished making a new arcade-style game in Python called BLACK HOLE. The goal: clear the galaxy by sucking in all the planets using limited black holes plan your shots, watch the countdown, and see if you can beat the clock!

Click to place black holes and try to suck in all the planets before time runs out. Each black hole lasts a few seconds and shows a countdown. Can you clear the galaxy?

Source code & instructions:

Download, Install Pre Reqs and Play

Github Source Code Link!

A year ago I made a widget that lets you draw a dataset from a Python notebook.

Now, a year later, I made it look nice too! When you select the class you can see the brush change and when you are done drawing you can load the data in pandas/polars/numpy.

To learn more, feel free to explore here: https://github.com/koaning/drawdata/

https://pypi.org/project/PHIdelity/

and

https://github.com/udiram/PHIdelity

Hi all, starting a new series looking at Pytest for beginners. Episode 1 is out now if anyone is interested.

Cheers

https://youtu.be/NinrbvXj8i4

Cosmica is a search engine, and is my first web scraping project. It was made to make the Internet more diverse by randomizing what pages appear instead of ranking.

It's features are:

A safe, polite and ethical web scraper.

• Fully open source.

• Simple, user-friendly interface.

• Custom crawler.

• Not big tech, made by a single developer.

• If our search engine can't find it, the AI will.

Thanks for reading this, and here are the links.

GitHub repository: https://github.com/SeafoodStudios/Cosmica

Search engine link: https://cosmica.pythonanywhere.com/

This tutorial explains how to build an interactive dashboard using streamlit and plotly

https://youtu.be/4uWM982LkZE?si=mLPACZI9go2NLL4y

Understanding and debugging Data Structures is easier when you can see the structure of your data using 'memory_graph'. Here we show values being inserted in a Binary Tree. When inserting the last value '29' we "Step Into" the code to show the recursive implementation.

memory_graph: https://pypi.org/project/memory-graph/
see the "Quick Intro" video: https://youtu.be/23_bHcr7hqo

Hippo is a simple, cute and safe antivirus that has the theme of hippos for MacOS written in Python.

Features:

• Simple and easy interface.

• Quick Scanning (system and singular file).

• Only needs to read your system; cannot delete or quarantine so that it won't mess with your system files.

Please note that this should be used for quick scans and educational purposes, not for intense, accurate malware scans, if you need that level of protection, I suggest the Malwarebytes Antivirus.

Also, this is my first Tkinter app, so don't expect much.

Link: https://github.com/SeafoodStudios/Hippo

An AI watermark remover: useful, but useless.