Our goal is much bigger: we want to keep adding powerful features, build a community of contributors, and eventually make ColorIDE a serious alternative. Its still early, currently supports macOS Apple Silicon, and we would love your feedback :). It's made 35.5% with python.

Github: https://github.com/Color-IDE/coloride

🚀 ZEROAGENT X v1.0.0 — Open-Source Developer Automation

A local-first Python developer automation platform featuring CLI + Textual TUI, policy-controlled agent execution, request-specific approvals, OpenCode integration, and inspectable execution evidence.

Built to give developers more visibility and control over their automation workflows.

Open source • Apache-2.0 • Python 3.11+

🔗 GitHub: https://github.com/harisazharir-boop/zeroagent-x

Feedback and contributions are welcome!

Following the discontinuation of Roche's software, this open-source Python project utilizes the ISO/IEEE 11073-20601 standard via USB in read-only mode to extract and analyze glucose data locally, generating AGP reports and clinical metrics while maintaining complete user privacy.

Repo: [https://github.com/serajbaltu/accu-check-active-platform\](https://github.com/serajbaltu/accu-check-active-platform)

Hi everyone! 👋

I've been building DoveORM, a small, synchronous ORM for Python. It brings models, validation, chainable queries, relationships, and migrations together in one package with a short learning curve.

It's currently at version 0.8.0 on PyPI, licensed under MIT, and I'd love to get feedback from the Python community and welcome contributors.

🔗 Links

• GitHub: https://github.com/imaradesk/doveorm
• Installation: pip install doveorm
• Optional database drivers: pip install "doveorm[mysql]" or pip install "doveorm[postgres]"

What does DoveORM do?

Here's a small example:

from doveorm import Model, configure, CharField, IntegerField

configure(DATABASE_PATH="app.db")

class User(Model):
    name = CharField(max_length=100, nullable=False)
    age = IntegerField(default=0)

User.create_table()

user = User.create(name="Ada", age=36)

adults = User.where(age__gte=18).order_by("name").get()

The goal is to make everyday database operations straightforward without requiring a large amount of configuration.

Key features

• Models and validation: A table() decorator or class Meta, 31 field types, and a clean() validation hook.
• Chainable queries: Lazy QuerySets, field__lookup filters, Q objects for combining conditions, slicing, and eager loading.
• Dynamic finders: Methods such as findByEmail(), findAllByActive(), countBy...(), and existsBy...().
• Relationships: HasMany, HasOne, BelongsTo, and ManyToMany.
• Transactions: Nested transactions using SAVEPOINTs and a db.run_in_transaction(fn) helper with retries for deadlocks and lock timeouts.
• Built-in migrations: Automatic change detection, reversible migrations, squashing, and a CLI for generating, applying, reverting, and verifying migrations.
• Security-conscious defaults: Bound SQL parameters, identifier validation, protection against accidental unfiltered bulk updates and deletes, mass-assignment protection, and redaction of sensitive fields.
• Connection safety: Thread-safe and fork-safe connections.
• Minimal setup: SQLite works without installing an additional database driver.

Who is it for?

DoveORM is intended for small to medium-sized applications, services, background workers, and scripts that primarily perform CRUD operations.

It supports SQLite, MySQL/MariaDB, and PostgreSQL and can be used with Flask, FastAPI, django or plain Python applications.

How does it compare with other ORMs?

I know Python already has excellent ORM options, so I'm not trying to claim DoveORM replaces them all.

• SQLAlchemy: A much more comprehensive toolkit with extensive database support, Core, ORM, and asynchronous capabilities. DoveORM takes a smaller, more opinionated approach with migrations built in.
• Peewee: Probably the closest in spirit. DoveORM aims for a similarly lightweight experience while offering model-driven migration generation and a CLI for managing migrations.
• Django ORM: Provides a great ORM and migration workflow within Django. DoveORM is designed to offer a similar model-and-migration workflow across different Python frameworks and standalone scripts.

What are its limitations?

DoveORM is still a young project, and there are some deliberate limitations:

• It is synchronous; there is no async API.
• It supports three database families: SQLite, MySQL/MariaDB, and PostgreSQL.
• Advanced SQL features, such as window functions and CTEs, may require raw SQL through db.execute(...).
• As a 0.x project, its API may still evolve. Pin the version if using it in production.

For applications that need advanced database features, extensive integrations, or a mature ecosystem, SQLAlchemy or Django ORM may be the better choice.

I'd love your feedback!

I'm sharing DoveORM because I've been using it in my own projects and want to see how it holds up to different use cases.

I'd particularly appreciate feedback on:

• The API design and developer experience.
• What feels missing or unnecessarily complicated.
• Database driver compatibility and edge cases.
• Documentation and examples.
• Potential contributions or areas worth improving.

If you were evaluating a new Python ORM, what would you need to see before considering it for a project?

Honest criticism is welcome. I'd rather hear about the problems early and make the project better.

GitHub: https://github.com/imaradesk/doveorm

working on a large codebase can get confusing pretty quickly. you end up jumping between files, tracing dependencies, figuring out how things connect, and trying to understand what might break when you change something.

so i built context forge, a local-first python cli that helps developers understand and navigate python codebases.

it analyzes your repository and stores information about its structure, symbols, and dependencies in sqlite, so you can reuse that information instead of starting from scratch every time.

some of its main features include:

• repository analysis — explore files, symbols, dependencies, and code relationships.
• context and memory — persist repository information and retrieve relevant context when working on a task.
• architecture analysis — understand how different parts of a project connect and identify structural issues.
• change impact analysis — investigate what could be affected before modifying code.
• pre/post-change verification — inspect the project before making changes and check the results afterward.

i wanted the tool to be deterministic and local-first rather than depending on an llm to figure everything out. getting caching, persistence, and analysis reliability right took quite a bit of work, and the project went through several iterations before reaching its current release.

this started as my project for stardance, a ysws event by hack club. building it taught me a lot about python, software architecture, testing, and the difference between adding features and making them reliable.

it's now open source, and i'd like to get it into the hands of developers who might actually find it useful.

github: https://github.com/vxyzln/context_forge

pypi: https://pypi.org/project/context-forge-local/1.0.1/

to try it, install it with:

uv tool install context-forge-local

then run cf --help to explore the commands.

i'd appreciate a star if you find it interesting, but i'm especially interested in honest feedback. if you've worked on larger python projects, what would you want a tool like this to do better? IF u like this , Please upvote it.

This was made as a Part of a YSWS event Stardance by Hack Club. Stardance Project

Introducing WordSmithX — a Python-based text variation engine designed for efficient string generation, rule-based transformations, and automated deduplication.

🔗 GitHub: https://github.com/securitygeek15/WordSmithX

\#Python #OpenSource #Automation #SoftwareEngineering

PatchSmith translates a video game's text inside the game folder itself, like an official localization: no overlay, no OCR. You pick the game folder; it detects the engine, finds the text, translates it and writes it back, with a backup of every file it touches. One click restores the originals byte for byte.

I made it because lots of indie games never get an Italian translation. Italian is what I tested most, features many languages.

What it does, engine by engine (each one tested on real games):

- Unity (Mono): installs and configures BepInEx + XUnity.AutoTranslator, which do the in-game work

- Unity with Unity Localization (also IL2CPP): rewrites the string tables inside the asset bundles

- Unreal Engine 4 (unencrypted paks): translated `.locres` files in a new patch pak, the game's own paks are untouched

- GameMaker: external localization files (line files, JSON, CSV)

- XNA / FNA / MonoGame: translated satellite assemblies

- Godot 4: translation tables through `override.cfg` and a small script, without touching the game's files

- Electron / NW.js / HTML5: JSON data and menus; some encrypted web games are translated while you play through their `preload.js`

- Detected but not supported yet: Unreal 5 / IoStore, Unity IL2CPP without Unity Localization, Godot 3, Ren'Py, KiriKiri, Wolf (RPG Maker MV/MZ is experimental)

Translators: by default a local one, Ollama with Google's TranslateGemma (4B or 12B): no account, no limits, works offline (best with an NVIDIA GPU). DeepL (free API key), MyMemory and the unofficial free Google endpoint are there too.

After you play it checks what happened (crashes, files restored by a game update, letters the game's font can't draw) and fixes what it can safely: missing letters are replaced with the closest ones, and labels that don't fit get a shorter translation from the local model.

Tech: Python standard library only (Tkinter GUI + CLI), C# for the Unity plugins and the launcher, JavaScript for the web injectors. The release zip ships a portable Python and is built by GitHub Actions with a build provenance attestation. 32 tests run against fake games and fake translators.

Limits, honestly: Windows only. It's machine translation, so expect machine-translation quality (a "Fix translations…" window lets you correct lines). Not for online games with anti-cheat. The exe isn't code-signed, so SmartScreen may warn the first time.

About AI: I built it with Claude Code. I designed it, chose what to support and tested it on real games; the agent wrote most of the code.

MIT licensed. If you try it on a game where it doesn't work, an issue with the zip from Create report helps a lot.

I keep losing the thread when I work. I start a task, open the docs for one thing, and twenty minutes later I’m on YouTube. I’m also done with to-do apps that bolt on timers and bloated features, and especially the monthly subscriptions.

So I made Breadcrumbs, a terminal focus timer that tracks your attention and gives you a clean pomodoro-style timer. You write an intention, start a timer, and pick what counts as in scope: an app, a domain, an exact page, or a Claude Code or Codex CLI session. While the block runs, anything outside that scope shows up in the trail as a branch, a bit like a git graph. If a detour turned out to be useful, you mark it Supporting and it stops counting against you. When the block ends, you write down what you actually got done.

Everything lives in a local SQLite database in ~/.breadcrumbs. It needs no account or subscription and doesn’t use any AI service. Tracking is off unless you turn it on, and it only runs while a focus block is running. The optional Chrome/Edge extension sends domains and URL hashes, never full paths or queries.

Install it with pipx (Python 3.11+):

pipx install breadcrumbst

Then run breadcrumbs.

The timer and the browser extension work on Windows, Linux and macOS. Native foreground app capture only works on Windows and Linux/X11 right now. macOS and Wayland capture aren’t written yet, and both are open issues if anyone wants to take one.

It’s MIT licensed: https://github.com/SaroashDS/Breadcrumbs

This started as a small problem I wanted to fix for myself, maybe just a quirk of mine. If you think it’s worth building on, I’d like ideas for features that would actually help, and a few issues are labelled good first issue if you want to poke at the code. I’d also like to hear what’s confusing or breaks on a first run.

Hey everyone!

I recently built and published Prepix, a lightweight Python library using pandas to simplify common data quality checks and exploratory data analysis.

It includes missing-value reports, duplicate analysis, column and numerical summaries, unique-value analysis, and schema validation.

📦 Install: "pip install prepix"

🔗 PyPI: https://pypi.org/project/prepix/ 💻 GitHub: https://github.com/manishparihar3618/prepix

This is my first published Python library, and I'm hoping to improve it based on real-world feedback.

If you work with pandas, I'd love to hear what features you'd find useful or what could be improved. Bug reports and contributions are welcome!

A payment tracking app used to match and track payments made by account holders and keep track of the balances.

I recently took over management of a caravan park in southern Victoria Australia. Previously the manager would have to spend a few hours every month hand sorting and writing down any payments made into the account, and track the fees owed by different site holders and van owners. It could sometimes take half an hour to just find who made a particular payment, due to lacking information in the description, and with up to 4 payments a month from dozens of site holders, it was draining.

Payments were often missed or calculated incorrectly. Accounts not making regular payments flew under the radar until they racked up huge amounts of debt. Or the index cards the balances were tracked on went missing and we would have to spend multiple hours reconstructing them by going back through bank statements from 5 years ago.

So I built a program to match, track, and display payment information and account balances. It's my first useful application, and while I've found it very useful I mainly did it as a learning exercise. It's only a CLI tool at the moment, with plans to eventually add a GUI.

It can be found on GitHub here https://github.com/mtepaske/ParkBanking

As I mentioned, it's my first proper program. So if anyone has any suggestions or feedback, please feel free to DM me!

Every fund factsheet Is a sales pitch, before investing get a free second opinion using:

openfactsheet.org (no coding working demo).

For devs you can check out our github repo https://github.com/bagnascotrader/openfactsheet

We provide an unbiased analysis of your investment, fully documented, Apache Open Source license (free to use even for commercial applications). It helps everyone analyze investment performance with powerful features.

You can also install it through Pip: Pip install "penfactsheet"

Take better informed investment decisions for free. Always check with your financial advisor before taking any investment decision.

BlockGuard is a small circuit breaker for rate limits imposed by the server you're calling. When an API answers 429 (or blocks you silently), you call breaker.trip("some_api"). Until a cooldown passes, breaker.in_cooldown("some_api") returns True, so you can skip the request instead of hitting a server that already said no. Each new block doubles the cooldown (60s, 120s, 240s...) up to a ceiling, and keys are tracked independently, so one blocked endpoint doesn't stop the others.

It also ships a pytest plugin that resets breaker state between tests. Without it, a test that simulates a 429 leaves a real cooldown behind that silently breaks the next test.

Source: https://github.com/pdrleite/blockguard

Install: pip install blockguard

TARGET AUDIENCE

People who scrape or integrate with APIs that have undocumented, IP-scoped or time-varying limits, and people building AI agents whose tools call external APIs. Agents retry failed tool calls fast and repeatedly, which is exactly what extends a block. The README has a section and a runnable example for that case.

I built it after a hobby tool against the Steam Community Market got blocked: retrying during an active block kept extending it, and a block that should have lasted minutes ran for hours. It's v0.1: in-memory, single process, MIT, no dependencies, 14 tests. Not production-hardened for multi-worker setups yet.

COMPARISON

Libraries like ratelimit or django-ratelimit throttle how fast you call out (e.g. max 10 calls/second). tenacity and backoff retry a failing call with a delay. BlockGuard does neither: it remembers that a block is active across calls and tells you not to send the request at all until the cooldown ends. You can use it alongside them.

AI disclosure: built with Claude Code. The design came from a real rate-limit incident in my own project, and I reviewed and tested it.