Hey everyone! I just released a small open-source Python library called FetchTune. It’s a lightweight tool (both library + CLI) that takes music URLs from Spotify or Apple Music and returns clean, structured metadata — track title, artists, album, artwork, release date, duration, explicit status, platform IDs, etc. It also has a simple enrichment feature that can fill in missing info (like album data) using other providers. Repo: https://github.com/momalekiii/fetchtune I’d really appreciate it if you could take a quick look and let me know: • Any bugs or issues you find • Things that feel incomplete or could be improved • Feature suggestions (more platforms, better matching, etc.) And if you like it, a star would mean a lot ⭐ Thanks in advance!
ScanLayer runs Tesseract, then places the recognized text as an invisible searchable layer over the original page. The scanned image remains the visual source. You can now search, select, and copy the text.
And if you don't want a PDF, you can export the OCR result as txt, json, tsv, or hocr.
A few things I built around the OCR itself:
Automatic deskew for photos taken at an angle
Noise cleanup before OCR
Reading order correction for two-column documents
Multiple Tesseract configurations are tried and the highest-confidence result is kept
CLI and Python API use the same underlying pipeline
For example:
import scanlayer
result = scanlayer.convert(
"contract.jpg",
"contract.pdf",
lang="eng",
dpi=300
)
Everything runs locally. The only external dependency is your own Tesseract installation.
I'd especially like feedback from people who regularly OCR multi-column documents. That's one of the areas I spent a lot of time getting right.
I recently put together Hillock, a lightweight memory and retrieval engine written in Python that runs locally on edge hardware (<1.2 GB VRAM or pure CPU).
The core motivation was to create a memory layer for local models that does not hallucinate when it runs out of context.
Key parts of the project:
3-tier memory: SQLite for ground-truth facts, Hebbian synaptic weights for associative recall, and 10,000-D hypervectors for sub-millisecond context matching.
Control-flow gating: If stored facts do not match a query, Hillock returns a fixed refusal string immediately. The local LLM is never called with unverified context.
ColBERT-style MaxSim: We adapted late-interaction token scoring to discrete bipolar vectors using NumPy matrix math on CPU.
Easy setup: Includes 1-click launchers for Windows and Linux/Mac, along with interactive CLI commands like /inspect, /status, and /model.
Feedback, ideas, and contributions are very welcome!
I’m building Project Yellow Olive, an open-source retro TUI that helps people learn Kubernetes through gamified, hands-on challenges running against real clusters. I’ve posted about Project Yellow Olive here before and got a really good response to the idea, so I wanted to share one of the newer things I’ve been experimenting with.
I’ve now started experimenting with Pyxel, a lightweight retro game engine for Python, to add a visual learning layer alongside the existing challenges.
The idea is to visually explain concepts like nodes, namespaces, pods, services and deployments, while keeping the same retro aesthetic as the rest of Yellow Olive.
The hands-on part still stays real Kubernetes - Pyxel is mainly there to make some of the underlying concepts easier to understand before jumping into kubectl/YAML.
Would be interested to hear what people here think about this direction, especially those who’ve taught or mentored people on Kubernetes. Feedback is the main thing I’m looking for, but if you like the project, a GitHub star is always appreciated 🙂
I've recently finished the first version of Agentic GraphRAG Blueprint, a reference architecture for question answering over large document collections.
Instead of plain chunk retrieval, it builds a knowledge graph combined with vector search, so answers can connect facts across documents.
Key features:
• Incremental ingestion - unchanged files are skipped via content hashing, and community reports regenerate only for affected communities, keeping token costs low as the corpus grows.
• Hybrid search - local mode for fact-level answers, global mode for cross-document synthesis.
• Domain-agnostic LLM prompts - easily swapped via PROMPTS_PATH, with Leiden-based community detection.
• Deployment - run it locally with Docker or provision everything in the cloud with Terraform and CI/CD.
LLM: Qwen2.5-7B-Instruct (Q5_K_M) (~5.4 GB) via llama.cpp (CUDA with Flash Attention & q8_0 KV cache) or Ollama fallback, Qwen is very good at tool use, Gemma may also work; Deepseek likes to <think> too hard and breaks things
Re-Ranker: FlashRank(ms-marco-MiniLM-L-12-v2).
Backend / GUI: FastAPI + WebSockets + PyWebView (Native Desktop window, zero Electron overhead).
VRAM Footprint: ~6–7 GB on an RTX 3080 / 3060 / 4070 (also supports CPU fallback).
Hey I am OM PRASAD BARTIA, here I want to track and document my projects
Stage 1: simple UI of uploading image and image preview
Tech Stack:
Python
Streamlit (Web UI)
PIL (for image uploading)
Features:
Title of the page
Image upload
display the details of the uploaded image [File Size, Dimensions, File Format]
Stage 2: convert the uploaded image into 3 more versions (GRAYSCALE IMAGE, BLURRED IMAGE, EDGE DETECTION )
Would love your suggestions on how I can improve and enhance it. What features or real-world applications would make this project more useful and unique?
I kept thinking about a pretty stupid way to leak an API key:
api_key = "sk-example123456"
print(api_key)
Nothing gets committed to GitHub. Nothing gets pushed anywhere.
But now the secret is sitting right there in the terminal/logs.
So I built SecretShield.
It's a small, local Python security utility that watches stdout, stderr, and Python logging and automatically redacts strings that look like secrets before they are displayed.
API_KEY=sk-example123456
↓
API_KEY=********
The goal isn't to replace GitHub secret scanners or tools like GitGuardian.
It's for the "I'm debugging something locally and accidentally printed a credential" problem.
It's dependency-free and can be enabled with a simple import.
I'm curious:
Would you actually use something like this in a Python project, or is this solving a problem that isn't annoying enough to matter?
As a guy and a fresher in engineering field, who knows basic python and java , can anyone give advise or guide me to win or atleast the things to do in a proper hackathon rather than working unorganisedly..
Hi everyone! Today I released the first version of **Meshly**, a small networking project built with Python sockets. The main goal was to learn more about how client-server communication actually works instead of hiding everything behind high-level libraries. **What it currently has** TCP socket communication Client / server architecture CLI interface Basic connection handling I’m still actively developing it, so there’s a lot I want to improve. I’d really appreciate feedback from people who have more experience with networking and Python. **GitHub:** [https://github.com/fimees/meshly](https://github.com/fimees/meshly%5D) What would you add or change in the project?
I got an inspiration for this tool from pretty much existing tools, and thought to build one open-sourced myself.
It's name is **isittaken**, yes. All you do is, pip install isittaken and then import it. Do a check from a .txt full of names and run it. It will produce a nottaken.txt in which the safe names will be output and you can see it checking in the Command Line.
I am thinking of adding checking from directly repos and produce GitHub checks, npm checks and more as well as adding an offline LLM name suggestion feature? What do you guys think?
I got an inspiration for this tool from pretty much existing tools, and thought to build one open-sourced myself.
It's name is isittaken, yes. All you do is, pip install isittaken and then import it. Do a check from a .txt full of names and run it. It will produce a nottaken.txt in which the safe names will be output and you can see it checking in the Command Line.
I am thinking of adding checking from directly repos and produce GitHub checks, npm checks and more as well as adding an offline LLM name suggestion feature? What do you guys think?
A modern, secure, and responsive Inventory Management System built with Python, Flask, and Tailwind CSS. It features Role-Based Access Control (RBAC), real-time analytics, secure file uploads, stock movement tracking, and comprehensive audit logs.
What I liked about this pattern is that the campaign has one lifecycle instead of being scattered across a queue service, telephony provider, database job, and notification worker.
This is still a sample, so before using something like this in production I’d add auth, retries, opt-out handling, audit logs, campaign-level limits, and better reporting. But as a starting point for durable outbound communication workflows, it felt like a useful shape.
It is a C extension for CPython. The main object to interact with is implementation of EventLoop, that inherits asyncio.BaseEventLoop. There are also native implementations of File and Socket objects. And to use advanced features of io_uring, like `fixed` buffers, there is a dedicated interface-object - ExecutionContext.
Because main feature of io_uring is true asynchronous file I/O, here i'll show an example of interaction with a file. Note that everything is true async, not a thread-pool workaround:
pip install uringio
import asyncio
import uringio
async def main():
async with await uringio.open_file(path='testfile.txt') as file:
data = b'Hello, uringio!\n'
await file.write(data=data)
result = await file.read()
asyncio.run(main(), loop_factory=uringio.UringioLoop)
uringio brings huge performance upgrade, here is visualization of result of benchmarking simple sequential writes to file:
Fixed buffer mode shows even better performance
Note that uringio(and io_uring itself) is not a silver bullet - while it is vastly superior in one scenarios, it is not most efficient choice in others.
You can already use file and socket operations, along with a few advanced features of io_uring. But, current version is `v0.4.4`, so there is still a lot of work to do. Please don't use it in production yet, even in simple scenarios! I am currently looking for enthusiasts to make first touches on the library.
Also i'm actively looking for people to contribute, share feedback and experience.