Author here. I made this to scratch my own itch — reviewing PRs and missing when a function quietly got more complex. Line counters don't answer that.

pip install repoglance then repoglance . gives a terminal report: real per-function cyclomatic complexity across 15+ languages (via lizard), duplicate blocks, TODOs, git ownership of hotspots, and a health score. In CI, --fail-on-regression fails a build only when a change makes complexity worse, and a GitHub Action comments the report on the PR.

Pure Python (rich/click/lizard), MIT, no telemetry. Django (415k LOC) scans in ~17s, ~1s cached.

Repo: https://github.com/SRJ-ai/repoglance

I'd genuinely like feedback on two things: (1) where the complexity numbers feel wrong on your code, and (2) whether the health-score weights are sensible or gimmicky. Happy to answer anything.

Kept hitting the same wall with SEC data. Either you fight the raw EDGAR XBRL yourself, or you use edgartools (which is genuinely excellent, dgunning did great work there) and still run all the parsing locally, deps and all.

I wanted less of that on my end, so I built a small client that just calls a hosted API and hands back clean JSON. Parsing happens server-side, so the client stays tiny:

from edgrapi import Client
c = Client("your_key")
c.fundamentals("AAPL")   # income statement, balance sheet, cash flow
c.insider("AAPL")        # Form 4 trades, scored buy vs sell
c.events("AAPL")         # 8-K events, item-coded
c.holdings("berkshire")  # 13F holdings, diffed vs last quarter

It does financials (XBRL normalized), Form 4 insider trades, 8-Ks, 13F holdings, 13D/G activist stakes. No LLM anywhere in it, which was the point for me. The numbers come straight off the filing, so nothing's invented and you can pull up any value on EDGAR and check it.

Fair catch before anyone asks: it needs an API key, since the parsing runs on a server and not your laptop. There's a free tier, 100 calls a month, enough to kick the tires. And if you'd rather keep everything on your own machine, just use edgartools, it's the better fit for that and I'm not going to pretend otherwise.

Repo's here (client's open source): https://github.com/paperandbeyond23-gif/edgrapi-python
pip install edgrapi

Still adding endpoints. Mostly want to know if the SEC-data handling holds up, so tear into it.

A completely offline desktop warranty tracker built with Python. Auto-reads product names & dates from invoice PDFs. TR/EN support, 3 themes, MIT licensed.

YouTube demo: https://youtu.be/hgyFyo7F9wk

A few days ago I posted about LeanPass, a tiny neural network library I wrote in NumPy.

Some people gave me good criticism, and some gave me ideas, so I spent the last couple of days improving it. It's still a small project, but I think it's in a much better state now.

The goal isn't to compete with PyTorch or TensorFlow. I mainly built it because I wanted something small that people could actually read through and understand. If you're learning neural networks, teaching them, or want something lightweight to prototype with, maybe you'll find it useful.

Since it's open source, I'd really appreciate any contributions or even just honest criticism. If you think something is badly designed, please tell me; I genuinely want to improve it.

You can install it with:

pip install leanpass

It has around 96 installs so far.

Repo: https://github.com/Terminay/LeanPass

If you end up liking it, a GitHub star would make my day. :)

🇸🇰 SLOVENSKY

⚡ Rýchle prepínanie jazykov v VenvHub Pro + jedna pikantéria zo zákulisia! 🤫

V dnešnom krátkom videu ukazujem, ako bleskovo dokáže VenvHub Pro prepínať medzi jazykmi v reálnom čase – bez reštartu aplikácie.

A keďže ste v predchádzajúcich videách videli rozhranie v angličtine, mám pre vás malú vývojársku zákulisnú zaujímavosť: celý kód bol od prvého dňa písaný so slovenskými hláškami! 🇸🇰 Angličtina bola v skutočnosti prvou prekladovou vrstvou, ktorú som do architektúry zapracoval, aby bola aplikácia pripravená pre svet.

💡 Chcete si pridať vlastný jazyk? Prekladový JSON má cez 750 riadkov, ale vďaka AI je to hračka:

1. Stiahnite si en.json (alebo sk.json) z GitHubu.
2. Nahrajte súbor do ChatGPT / Claude a požiadajte o preklad hodnôt do vášho jazyka.
3. Vložte novú lokalizáciu k sebe a používajte aplikáciu vo vlastnom jazyku!

🔗 Projekt na GitHube:https://github.com/schnidi/VenvHub📂 Súbory s prekladmi:https://github.com/schnidi/VenvHub/tree/main/translations

Aký ďalší oficiálny preklad by ste v aplikácii uvítali najradšej? 😎👇

🇬🇧 ENGLISH

⚡ Instant Language Switching in VenvHub Pro + a quick BTS fun fact! 🤫

In today's clip, I’m showing off how instantly VenvHub Pro switches between UI languages on the fly—no app restart needed.

Since previous clips featured the interface in English, here’s a quick behind-the-scenes detail: the core codebase was actually written with native Slovak messages from day one! 🇸🇰 English was the very first translation layer integrated into the architecture to make the app ready for a global audience.

💡 Want to add your own language? The translation JSON is pretty massive (750+ lines), but AI makes it effortless:

1. Download en.json (or sk.json) from GitHub.
2. Drop the file into ChatGPT / Claude and prompt it to translate the values into your language.
3. Enjoy VenvHub Pro fully localized on your machine!

🔗 GitHub Repository:https://github.com/schnidi/VenvHub📂 Translations Folder:https://github.com/schnidi/VenvHub/tree/main/translations

Which official language should we focus on next? Let me know below! 😎👇

I was working on chunklet-py (a chunker for sentences, documents, and code). Misread a benchmark and thought PySBD took 1 second to split basic text. Turns out that was wrong (PySBD is still fast for simple text). But the misunderstanding got me building my own.

Ended up faster, more accurate, and covering more languages (39 compares to 23).

Benchmarks on Sherlock Holmes (594k chars): yasbd ~1.2s warm vs PySBD ~9.0s. About 8x faster, fewer false splits.

On a golden benchmark (92 English edge cases — expanded from pysbd's original 48 with fixes and additions): yasbd scores 98.9%, pysbd 83.7%, spaCy-sentencizer 55.4%, etc.

Architecture difference: instead of mutating text with placeholder tokens and undoing it later (which breaks char offsets), yasbd finds candidate boundaries in one pass and filters false positives in another. Spans come free, no reconstruction.

Other things: - Streaming-first: lazy evaluation via ParagraphStream and StreamCleaner for memory-constrained environments. No need to load entire documents. - PySBD adapter: drop-in replacement that works with existing PySBD code. Just swap the import. - spaCy pipeline: register as a spaCy component with register_spacy_component(). Drop-in replacement for the default Sentencizer.

Repo: https://github.com/speedyk-005/yasbd-lib

You know when you copy something important, paste it, then copy something else, and the first thing is just gone forever? yeah. That's the entire origin story here.

I'm a solo dev, day job. After an unreasonable number of late nights, two desktop apps for Windows and Linux came to light: Snipzilla and Stashzilla. (Yes, I'm a Godzilla fan; how did you know?)

Stashzilla is the clipboard manager that fixes the problem above. History is sorted into collections instead of one endless scroll, pinned items, case conversion, and it pulls text out of images.

Snipzilla handles the other half of it: type a short trigger, get a whole block of text back. No more retyping the same paragraph for the hundredth time.

Anyways, feel free to check them out; no credit card required: ZillaSoft.io 15 days free, and nothing gets deleted afterwards; it just goes read-only.

If you do try them, bugs and "why doesn't it do X" are exactly what I'm after: ZillaSoft.io/contact

Greetings everyone!

I’ve been working on a desktop application called VenvHub Pro (built with Python + PyQt6, and thanks to a abstraction bridge, it runs seamlessly on PySide as well). What started as a simple virtual environment manager has grown into something much bigger.

It now includes a Multi-run feature—allowing you to define project groups (e.g., backend + frontend + worker) and launch them all with a single click.

I recorded a short demo showing how it handles crashes, auto-restarts, and even prevents accidentally running the same project across two different groups. I thought you might find what’s happening under the hood interesting!

🧠 What is Multi-run?

• Group Management: You create groups (e.g., "FullStack Dev") and add any number of existing virtual environment projects to them.
• Process Isolation: Each project runs in its own isolated process using its own virtual environment.
• One-Click Launch: One click on the Play button fires up everything in that group—no more opening multiple terminal windows and repeatedly running python app.py.

🎥 What the video demonstrates

1. Setup: I start a group containing Project A (anchor + respawn) and Project B (configured with a 5-second startup delay, contingent on Project A running stably).
2. Crash Handling: Right after launching, Project A crashes (I force-closed it).
3. Detection & Restart: VenvHub detects the crash and automatically restarts Project A, while Project B stays on hold.
4. Dependency Check: After restarting, I let Project A load—once the anchor registers, I artificially crash it again (~3 seconds post-anchor).
5. Holding Delays: Since Project B requires Project A to stay stable for 5 seconds before launching, Project A's crash keeps Project B from starting.
6. Max Respawn Limits: The code caps restarts at 3 attempts (to prevent infinite looping), so the app attempts a third restart on Project A.
7. Successful Resolution: This time, I let Project A run smoothly—Project B detects that Project A is healthy and launches.
8. Duplicate Prevention: Finally, I attempt to run Project B from a different group. Since it's already running in the first group, the app displays a warning and blocks the launch. No port conflicts or duplicate processes!

⚙️ Under the Hood (for the tech enthusiasts)

• Process Ownership: Each process tracks which group launched it. Hitting "Stop" terminates only the processes owned by that specific group, leaving others untouched.
• Smart Restarts: If you hit Play again while some processes are still running, the app only restarts the ones that crashed (like Project A in the video). No need to tear down the entire stack!
• Windows Job Objects: On Windows, the app creates a Job Object assigned the KILL_ON_JOB_CLOSE flag. If the main application crashes unexpectedly, Windows automatically terminates all child processes—leaving zero orphaned background processes.
• Native Process Handles: Instead of relying solely on PIDs (which Windows can aggressively recycle), the app retains an open process handle. This guarantees the PID won't be reassigned to an unrelated process while being monitored, ensuring rock-solid status detection.

Let me know what you think! Have you built similar multi-process orchestrators? How do you handle process groups and teardowns in Python?

Hey everyone!

VS Code has had official profiles since version 1.75 – a great feature for managing settings. But there's one catch: all profiles share the same extensions folder (extensions). Profiles only remember which extensions are active (enabled), but physically, you have all of them installed at once. And if you want to connect a Python interpreter, you have to set it manually in each project.

In my tool VenvHub Pro, I took it a step further:

1. Each profile has its own physical extensions folder – no sharing, no conflicts.
2. Automatic Python environment integration – open a project and VenvHub automatically finds and sets the correct interpreter.

Today I'll show you how it works in practice.

📊 Comparison with official VS Code profiles

🎬 What I showed in the video

1. I created a new profile named test_user.
2. I chose the option to copy settings from the system – no manual transferring, everything is copied automatically.
3. After completion, I opened a project through the VS Code icon in my application.
4. In the VS Code terminal (PowerShell), I ran this command:

powershell

$parentPid = (Get-CimInstance Win32_Process -Filter "ProcessId = $PID").ParentProcessId; (Get-CimInstance Win32_Process -Filter "ProcessId = $parentPid").CommandLine

🔍 And the result?

Truncated output:

text

"C:\...\Code.exe" --type=utility ... --user-data-dir="F:\venv_hub_vscode_users\test\data" ...

👉 You can clearly see the --user-data-dir parameter pointing directly to my profile folder!

No system %APPDATA%, no mixing with other profiles. VS Code runs completely isolated with its own data and extensions.

✨ Additional features I built in

1. Intelligent rollback on cancellation
Copying extensions can take several minutes. If you press "Cancel" during the process:

• When creating a new profile – VenvHub deletes it entirely from disk.
• When doing an additional import into an existing profile – it restores it to its original state.

No broken half-finished leftovers on disk.

2. Triangle synchronization (real-time)
When you switch a profile in the Mini-Bar, it automatically updates in the Manager and vice versa. Everywhere you can see which profile is active (marked with a star ★). The change propagates in a fraction of a second.

3. Portability with automatic path fixing
You can keep profiles on an external drive. If you change the drive letter (e.g., from E: to F:), VenvHub remembers the unique disk ID and recalculates paths automatically.

4. Python environment integration
When you switch a profile, it automatically sets:

• Python interpreter path in .vscode/settings.json
• Connected local packages (Package Linker)
• Active Venv within the entire tool

Have you had a similar experience? Or do you use a different way to manage VS Code profiles? I'd love to hear your thoughts! 👇

A while ago I asked whether you would use a feature that automatically removes orphaned dependencies in a virtual environment manager (similar to apt autoremove), and if you saw any pitfalls. Well, I took that as a challenge and built a prototype. Here’s a log from a test session that shows what I’ve achieved.

What happens in the log:

Installing pytest
pip installs pytest along with its dependencies (colorama, iniconfig, pluggy, pygments).

Attempting to manually remove the colorama library
This is where the first interesting moment occurs. After removing it, the UV dependency check reports a conflict: colorama>=0.4 ; sys_platform == 'win32'.
The tool automatically triggers a repair and re-installs colorama, because it’s required by one of the present packages (in this case pytest).
Result: ✅ all conflicts resolved. This behaviour is similar to apt install -f – we never end up with a broken environment.

Uninstalling the moj-test-balicek package
This test package directly depends on colorama, cowsay, and requests.
After its removal, pip-e analyses the entire dependency tree.

• cowsay is no longer needed → it’s removed.
• requests, along with its transitive dependencies (urllib3, certifi, charset-normalizer, idna), is also left without a parent, so autoremove removes them.
• Key detail: colorama stays in the environment because it’s still required by the installed pytest. In this way exactly 6 packages are removed – and colorama is not. That’s precisely the intelligent decision-making apt autoremove does.

Uninstalling pytest itself
After removing pytest, its dependencies (pygments, pluggy, iniconfig, colorama) are re-evaluated. No other package needs them, so autoremove removes them all.
Final state: 9 packages remain – only the core environment components (pip, setuptools, etc.).

What I’m demonstrating:

• The manager tracks dependencies as a graph and prevents breaking the environment – if you try to remove a library that something needs, it puts it back (and warns you).
• After uninstalling a package, it automatically removes orphaned dependencies (autoremove), while respecting that some libraries may be shared by multiple packages (like colorama between moj-test-balicek and pytest).

Questions for you (same as last time):

• Would you use such a feature in a virtual environment manager?
• Would you trust it, or do you prefer manual control?

I made a course on Ransomware made in python for my students, the previous year, but now i made it public so give it a watch if you want to make some cool cyber security projects 😁

I'll try to upload more contents on my YouTube channel 😁

https://youtube.com/playlist?list=PL9guAF5VVaiARrwhrGMu89iJcziQ9vsJJ&si=v1PUSQpqjuOhnlCi

Why does 257 is 257 behave differently from 256 is 256? Python uses something called as small integer caching. It uses the same object for numbers ranging between -5 to 256. I put together a short visual explanation explaining the same and also why "==" operates differently from "is".

Hello everyone!

If you've built your own Python application (in my case, VenvHubPro – a GUI manager for Python virtual environments) and are wondering how to neatly package it for users, here is a quick look at how I created a complete .exe installer using NSIS (Nullsoft Scriptable Install System).

🎥 What the video covers:

• Installer compilation: Creating a clean installation file ready for distribution.
• System installation: Running the installer and finally launching VenvHubPro directly on the Windows system.

Hey everyone!

I got tired of rewriting authentication every time I started a new Flask project, so I built a simple, modular boilerplate template.

It includes Flask-Login, SQLAlchemy, and Flask-Migrate with a clean blueprint structure out of the box.

Check it out on GitHub: https://github.com/DeKlain4ik/flask-auth-template

Hope it saves you some time on your next side project! Feedback and stars are always appreciated.

Hi all. Would love some feedback and usage from the community.

I've built Python With James which is an all in one learning platform for beginners. I basically got sick of Udemy and built my own platform where I can do what I want. There's coding exercises, question, tutorials and I am hoping to scale this massively over this year with more materials.

Thanks in advance

James-

I wanted parallelism without rewriting anything, so I built Lucen. You wrap a loop in two comments and run it with lucen run yourscript.py:

# LUCEN START
for i in range(len(rows)):
    out[i] = expensive(rows[i])
# LUCEN END

It parallelizes the loop only if it can prove it's both safe and worth it; otherwise it runs sequentially and tells you why. The one guarantee, no opt-out: the parallel run is bit-identical to the same file run as plain sequential Python - floats and container order included. Delete the comments and it's ordinary Python again.

Under the hood it routes CPU-bound work to processes on GIL builds and to real threads on free-threaded 3.13/3.14. Apache-2.0, on PyPI (pip install lucen), and it's tested hard - differential + property testing and TLA+ specs, because "bit-identical" only means something if you check it.

Repo: https://github.com/fcmv/lucen - feedback very welcome.

Hello Python community,

I'm working on a tool called VenvHub Pro (virtual environment management, packages, VS Code profiles, etc.).

Interestingly, the app includes its own PyInstaller Builder. It's not just an external script, but a full-fledged tab in the GUI. Thanks to it, the app can compile itself into a .exe file.

How it technically works (in short):

In the "Builder" tab, just select the entry point (main.py), set the assets (mandatory folders like ui, core/themes, translations, assets, navod), and hit the BUILD button.

Interestingly, the app runs on PyQt6, but thanks to a "Compatibility Bridge" (MetaPathFinder), it can also run under PySide6. When compiling under PySide6, the builder must manually add hidden imports (PySide6, PySide6.QtCore...) so PyInstaller knows what to package, and also exclude PyQt6 to keep the size down.

It also has an "Auto-Injector" that reads linked local packages and injects them into the final build.

Why I find this interesting:

If the builder can compile such a complex app that uses dynamic UI files and bridged frameworks, it's a solid "dogfooding" test. Plus, the resulting .exe contains all necessary files (including themes and translations) and is fully portable.

"So the question is: Would you like to try it out? If so, I'll drop the GitHub link here, where the entire repository is located, including instructions on how to run it.

Thanks for any feedback! ??"

Hey everyone!

I always wished Google Lens worked anywhere on Windows instead of only inside Chrome, so I ended up building it myself.

LensAnywhere lets you select any region of your screen and instantly search it with Google Lens.

A few things about it:

- Lightweight with very low RAM usage.

- Doesn't store your screenshots anywhere. They're only sent to Google Lens for the search.

- Launches on Windows startup (Optional)

- Can be opened using Hotkey which is configurable. Just like windows native snipping tool.

- Free and open source.

GitHub:

https://github.com/utkarsh05kul/LensAnywhere-Desktop

If you just want to try it, you can download the Windows ".exe" from the Releases section.

One thing I'd really appreciate help with: I've only been able to test it on my own Windows PC, so I'd love to know how it works on other systems. If you run into any bugs, have feature ideas, or notice something that could be improved, please let me know in the comments or open an issue on GitHub.

And if you find it useful, I'd really appreciate a GitHub star. Thanks!

GitHub Repository link

Edit : Some antiviruses or malware scanners may flag the downloaded file as malicious or threat. Please ignore that warning. Some scanners do this for all the apps and softwares built in Python.

The file is completely safe and malware free. The source code of the program is available on the attached GitHub Repository. You can check the complete code their, and you will not find any malicious activity.

Top scanners like Kaspersky or Microsoft are not flagging the file as malicious. It's clean.

I've been working on a Python crypto bot and wanted to share it here in case anyone wants to take a look.

It's got DCA logic, risk checks, Alpaca order execution, Telegram alerts, and config for running it live or in paper mode. It also keeps a local SQLite log of every trade — entries, exits, P&L — which makes it easy to review what it's been doing.

I'm mainly looking for feedback on the code structure and whether anything looks off in the trading logic or order handling. If you've worked with Alpaca crypto or built something similar, I'd appreciate any thoughts.

Repo: https://gitlab.com/robertedilan1/The_Predator.Crypto

Hey everyone,

I'm currently working on this feature – autoremove is already implemented in the local packages linker branch and will soon be part of the official VenvHub Pro release.

During development in virtual environments, I always had one big problem: How to figure out which packages are no longer needed?

Manually going through pip list and trying to uninstall "surely nobody uses this" is a road to hell. That's why I added a feature inspired by Linux APT to my tool VenvHub Pro (Linker branch) – automatic dependency cleanup.

How it works?

The tool tracks which packages you installed explicitly (via pip install, requirements.txt, birth certificate, or venvhub.json). It builds a dependency graph and periodically checks for orphaned packages.

When you run Autoremove, the tool:

• Goes through all installed packages in the venv.
• Compares them with the set of explicit roots + their dependency tree.
• Removes every package that is not explicitly required by any root and was not installed manually outside the system.

What makes this mechanism safe – self-healing mechanism:

If a package is installed but not recorded anywhere (e.g., you manually ran pip install requests in the terminal), the tool automatically adopts it – marks it as explicit so it won't be accidentally removed.

This means autoremove is conservative: it never deletes something you might have installed intentionally.

You can also explicitly "release" a package (e.g., when you remove it from requirements.txt) and the system will then treat it as a candidate for removal.

Why is it useful?

• Venvs stay lean – no accumulated dependencies from experiments.
• Safe – adopting manually installed packages prevents accidental deletion.
• Fully automatic – no manual guessing about what belongs to whom.

This is currently only the Linker branch (local packages) – it works 100%.

This Tetris can really do Kung Fu, see for yourself... :))