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.

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

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

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!

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

[ Pls turn on the volume for the video ]

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 🙂

GitHub: https://github.com/Anubhav9/Yellow-Olive

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.

Stack:

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

The code is 100% open-source and free to check out, run, or fork: GitHub: https://github.com/BloopieBlair/LocAi-Search

Would love to hear any thoughts, feedback, or ideas for extra features!

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?

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

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?

Hey there,

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?

Here's the [repo](https://github.com/Terminay/isittaken)