if you found this project or app good please review it , also suggest for improvements and problems

https://github.com/work-Sameerbanchhor/bhilaiTV3.0

I wrote a small utility that converts tree output into an Excel file. The code is far from ideal, but it does handle Cyrillic filenames on my own test data.

To make it more robust, I need to test it on real-world data with rare encodings, varying nesting depths, special characters, long names and paths, and so on.

I'd appreciate any feedback, criticism, or advice – especially on edge cases and code structure.

Thanks!

https://github.com/Usdmal-tech/tree-to-excel

I wanted an EPUB version of *Kubernetes The Hard Way*, but I did not want to manually rebuild it whenever the upstream project changed.

I used OpenAI to help me design and build a project that handles the entire process. I provided the requirements, reviewed the results, tested the generated books, and kept refining the project when I found formatting or security problems.

The finished project tracks the current upstream default branch and checks for changes every six hours. When the source changes, it builds a new EPUB, validates it, and updates the GitHub release.

OpenAI helped with the Python builder, EPUB structure, responsive styling, GitHub Actions workflow, tests, documentation, and release automation. It was especially useful for working through EPUB details that I did not want to handle manually, such as manifests, navigation, metadata, archive layout, and light and dark mode compatibility.

I also wanted the result to have a strong security model. The generated EPUB cannot contain JavaScript, executable files, unsafe embedded content, remote resources, encrypted files, or suspicious archive structures. Every release passes a custom security scanner and official EPUBCheck validation. It also includes an SHA 256 checksum, source provenance, and a GitHub build attestation.

Calibre is not required. The EPUB is constructed directly with Python and should work with any standards compliant reader.

The project is here:

[https://github.com/terrytrent/kubernetes-the-hard-way-epub-builder\](https://github.com/terrytrent/kubernetes-the-hard-way-epub-builder)

The current EPUB is here:

[https://github.com/terrytrent/kubernetes-the-hard-way-epub-builder/releases/tag/epub-master\](https://github.com/terrytrent/kubernetes-the-hard-way-epub-builder/releases/tag/epub-master)

This was a useful example of using AI as a development partner instead of asking it for a single block of code. Most of the value came from reviewing the output, finding problems, adding requirements, testing again, and continuing until the complete workflow worked reliably.

all you do is give it a prop size, a motor and your printer's bed. It derives the duct section from the aerodynamics, splits the ring into the fewest pieces that still fit the plate, and builds the parts as SLDPRT, STEP and STL.

I built this from measurements of my own 13" ducted quad, so every default in the code is a number taken off that airframe. The design side (preview, section, layers, report) needs nothing but numpy and matplotlib and runs anywhere. The SolidWorks backend is tested on SolidWorks 2025, rev 33.4.1, on Windows only. The build123d backend runs anywhere Python does.

for more information , also looking for contributors to help if possible https://github.com/jackgibbons85/ductgen

give it a look ! ^_^

Do check out this project if you want to talk to hardware device like Arduino,ESP32,Raspberry Pi Pico (RP2040), Raspberry Pi Pico (RP2350) etc from your PC (Windows /Linux ) or Mac OS using Virtual serial port.

The Hands on Project walks you through installing relevant libraries, Opening the Serial port, Setting Baud rate, Reading and Writing into the Serial Port using Python Language.

You can Download the Source codes and other Relevant project files using the Link below.

Cross Platform serial communication using Python (PySerial) and Arduino

Learn Python by Building Real Projects

In this journey, we’ll learn Python from the basics and use it to build practical projects with powerful tools and technologies:

• 🐍 Python Programming
• 👁️ OpenCV & Computer Vision
• 🔌 APIs & First API Projects
• 🌐 Web Applications
• 🤖 AI & Machine Learning
• 📝 AI Content Summarization
• 🚀 Real-World Projects & Automation

Simple explanation → Practical coding → Real projects

A collection of self-contained Python exhibits and examples designed for learners—feedback and contributions welcome!

​

After working with Python backend development for years, I wanted to build a framework that brings the things I repeatedly need into one place.

So I built Shakti, a Python backend framework focused on building modern APIs and applications faster.

Some of the things I’m working on:

- ⚡ Async-first architecture

- 🔐 Built-in authentication & RBAC

- 🗄️ Async ORM

- 🤖 AI integration

- 📄 Document AI

- 🔄 Background jobs

- 📡 SSE / streaming

- 🛠️ CLI & code generation

- 📊 Monitoring

- 💾 Database migrations

- 💉 Dependency injection

GitHub: https://github.com/shaktihq/shakti

PyPI: https://pypi.org/project/shakti-framework/

This is still an evolving project, and I’d genuinely love feedback from Python developers.

What would you want to see in a new Python backend framework?

WebSockets? Better developer tooling? More AI features? Something else?

I’m building Shakti in public and would love to hear your thoughts. 🙌

You scan a contract, but you can't search any word in it. This is the fix.

I built ScanLayer, a Python OCR library that adds a searchable text layer to scanned documents.

You give it a scanned image:

pip install scanlayer
scanlayer contract.jpg -o contract.pdf

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.

Github
Documentation
PyPi

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!

Hey Python community!

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!

Check the comment below of how it looks like

Hi everyone,

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.

Link: https://github.com/sebastianbrzustowicz/Agentic-GraphRAG-Blueprint

I'm looking for any feedback.

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?

GitHub discussion: https://github.com/orgs/localghosters/discussions/1

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..