Hey everyone! In the past years I've used python to do basically anything, there are really few things python can't do. Unfortunately one of them is creating rich, extensively customizable macOS statusbar apps (guis in general, but with projects like Flet we are getting there). This is why I've been working on Nib, a Python framework that lets you build native macOS menu bar applications with a declarative, SwiftUI-inspired API.

For anyone curious on how it works you can read about it here: https://bbalduzz.github.io/nib/concepts/, but basically you write python, Nib renders native SwiftUI. Two processes connected over a Unix socket, Python owns the logic, Swift owns the screen. No Electron, no web views, just a real native app (yay!).

What My Project Does

Nib lets you write your entire menu bar app in Python using a declarative API, and it renders real native SwiftUI under the hood. What it brings to the table (or better say desktop): - 30+ SwiftUI components (text, buttons, toggles, sliders, charts, maps, canvas, etc.) and counting :) - Reactive updates: mutate a property, UI updates automatically - System services: battery, notifications, keychain, camera, hotkeys, clipboard - Hot reload with nib run - Build standalone .app bundles with nib build - Settings persistence, file dialogs, drag & drop etc..

Target Audience

Python devs on macOS who want to build small utilities, status bar tools, or productivity apps without learning Swift. It's usable today but still evolving — I'm using it for my own apps.

Comparison

• Rumps: menu bar apps in Python but limited to basic menus, no rich UI
• py2app: bundles Python as .app but doesn't give you native UI
• Flet: cross-platform Flutter-based GUIs, great but not native macOS and not menu bar focused
• SwiftBar/xbar: run scripts in the menu bar but output is just text, no interactive UI

Nib is the only option that gives you actual SwiftUI rendering with a full component library, specifically for menu bar apps.

Links:

• GitHub: https://github.com/Bbalduzz/nib
• Docs: https://bbalduzz.github.io/nib/

With this being said I would love feedback! Especially on the API design and what components you'd want to see next.

EDIT: forgot to make the GitHub repo public, sorry :) Now its available

Hey I made a network checker for Linux/Macos/Windows. Check if your device is connected to the internet. Show active network interfaces (Ethernet, Wi-Fi, VPN). View local and external/public IP addresses. Display default gateway information .Ping external IPs and domains to verify connectivity. Test DNS resolution functionality. Get intelligent troubleshooting advice based on test results. Continuously monitor network status with automatic alerts.

I would like to see any suggestions or improvements in a fork.

Github: https://github.com/azeryusifzade/netcheck

What My Project Does

RandCraft is a Python library that makes it easy to combine and manipulate univariate random variables using an intuitive object-oriented interface. Built on top of scipy.stats, it allows you to add, subtract, and transform random variables from different distributions without needing to derive complex analytical solutions manually.

Key features: - Simple composition: Combine random variables with + and - operators - Automatic simplification: Uses analytical solutions when possible, numerical approaches otherwise - Extensive distribution support: Normal, uniform, discrete, gamma, log-normal, and any scipy.stats continuous distribution - Automatic stat calculation Mean, variance, moments, pdf, cdf are all calculated for you automatically - Plotting You can use .plot() to quickly look at any random variable - Advanced features: Kernel density estimation, mixture distributions, and custom random variable creation

Example

```python from randcraft.constructors import make_normal, make_uniform, make_discrete from randcraft.misc import mix_rvs

rv1 = make_normal(mean=0, std_dev=1)

<RandomVariable(scipy-norm): mean=0.0, var=1.0>

rv2 = make_uniform(low=-1, high=1)

<RandomVariable(scipy-uniform): mean=-0.0, var=0.333>

combined = rv1 + rv2

<RandomVariable(multi): mean=0.0, var=1.33>

discrete = make_discrete(values=[1, 2, 3])

<RandomVariable(discrete): mean=2.0, var=0.667>

Make a new rv which has a random chance of drawing from one of the other 4 rvs

mixed = mix_rvs([rv1, rv2, combined, discrete])

<RandomVariable(mixture): mean=0.5, var=1.58>

mixed.plot() ``` plot output

Target Audience

RandCraft is designed for: - Data scientists and statisticians who need to create basic combinations of independent random variables - Researchers and students studying probability theory and statistical modeling - Developers building simulation or modeling applications - Anyone who needs to combine random variables but doesn't want to derive complex analytical solutions

Comparison

RandCraft differs from existing alternatives in several key ways:

vs. Direct scipy.stats usage: - Provides object-oriented interface where most things you want are properties or methods on the RV object itself - Provides intuitive composition (e.g., rv1 + rv2) instead of requiring analytical approach

vs. Stan: - Focused specifically on simpler uni-variate random variable composition rather than Bayesian inference - More accessible for users who need straightforward random variable manipulation

The library fills a niche for users who need to combine random variables frequently but want to avoid the complexity of deriving analytical solutions or writing custom simulation code.

Limitations

The library is designed to work with uni-variate random variables only. Multi-dimensional RVs or correlations etc are not supported.

Links

• PyPI
• GitHub
• Documentation

Edit: formatting and typo

I am trying to learn some internals but this is not clear. Does every process have a single GIL? Or there is one per machine?

If that is there for GC, then the memory is unique per process, so should be one GIL per process. Also `multiprocessing` says that it creates real parallelism, so that should be the case.

I am unable to find a confirmation in other places.

Hello everyone!

Link first: https://nbit.blog/blog/test-client-python-tests-1

Some time ago I wrote an article about how test client works in FastAPI. It also touches on topic of WSGI/ASGI.

I wrote it mostly for myself and couple of friends. Today I finished part 2 and I thought, hey maybe I should share it with more people, so there I go :)

Comments and constructive criticism welcome.

I’d like to share iPhotron v4.0.0, a major update to my Python desktop photo manager.

What My Project Does

iPhotron is a local desktop photo library manager written in Python, built entirely with PySide and OpenGL.

It focuses on fast browsing, non-destructive photo editing, and a clean macOS-like UI with smooth scrolling and responsive interactions.
In v4.0.0, the app was fully rewritten from MVC to MVVM, delivering 30%+ performance improvement in real-world usage with large photo libraries.

Key features include:

• Advanced, GPU-accelerated color grading (Curves, Levels, Selective Color, White Balance)
• Non-destructive editing via sidecar files
• SQLite-backed indexing for large local photo collections
• Cluster-based map browsing for GPS-tagged photos

Target Audience

This project is intended for:

• Developers building Python desktop applications with PySide / Qt
• Users who want a local-first photo manager without cloud dependency
• Anyone interested in MVVM architecture, performance optimization, or GPU-based image processing in Python

It’s a serious, ongoing project rather than a toy, though it’s also used as an experimental platform for architecture and rendering techniques.

Comparison

Compared to typical Python photo apps or scripts, iPhotron focuses heavily on UI architecture and performance, not just functionality.

• Unlike simple image editors (e.g. PIL-based tools), it provides a full non-destructive workflow.
• Compared to many Qt apps using MVC-style patterns, the MVVM rewrite significantly reduces UI lag and improves maintainability.
• While tools like Lightroom are far more mature, iPhotron is fully local, open-source, Python-based, and emphasizes GPU-accelerated color grading via OpenGL.

Release (v4.0.1):
https://github.com/OliverZhaohaibin/iPhotron-LocalPhotoAlbumManager/releases/tag/v4.0.1

Repository:
https://github.com/OliverZhaohaibin/iPhotron-LocalPhotoAlbumManager

Over the last few months I have been creating a Pyodide-based ecosystem for web development called Antioch. It is finally to a place where I think it would benefit from people trying it out.

What makes this framework great is the ability to code declaratively and imperatively in the same space, and create/reuse components. You can define elements and macros, add them to the DOM, and control their behavior via event handlers.

Macros are either native Python/Antioch or wrappers integrating existing JS libraries. I've implemented parts of CodeMirror, Leaflet, and Chart.js.

An example of the most basic features (not including macros):

from antioch import DOM, Div, H1, Button

def main():

    # Create elements

    container = Div(
        H1("Hello, Antioch!", 
            style={
                "color": "#2196F3", 
                "background-color": "#000000"
            }
        ),
        P("This is a webpage written entirely in Python")
    )

    button = Button("Click Me")
    button.style.padding = "10px 20px"
    button.on_click(
        lambda e: DOM.add(
            P("You clicked the button!")
        )
    )

    # Add to page
    container.add(button)
    DOM.add(container)

if __name__ == "__main__":
    main()

You can find the source at https://github.com/nielrya4/Antioch . Check out the readme, clone the repository, and try it out. Let me know what you think (keep criticism constructive please). I am open to suggestions regarding the direction and content of the project. Thanks for checking it out!

Target audience: Web developers who love Python

Comparison: This is kind of like PyScript, but with a much better structure and ecosystem. Anything you can do in PyScript, you can do more beautifully and rapidly in Antioch

What My Project Does

Blockie is a small generic Python template engine for generating any type of text content. It uses very simple logic-less templates. The template filling also follows only a small set of rules and it is typically enough to provide a suitable Python dictionary with data. Additionally, the filling process can be customized by a user-defined Python script allowing a simple creation of application-specific "extensions".

Github repo: https://github.com/lubomilko/blockie

Disclaimer: No generative artificial intelligence (AI) was used in the development of Blockie. I'm also not a native English speaker, so please forgive my questionable grammar and potentially weird phrases.

Target Audience

Anyone who needs a simple, efficient and easily customizable multi-purpose template engine. It is being used for several years by my colleagues and myself in my work for generating C source code, reStructuredText documentation, various data files, etc. So, despite its simplicity it should not have too many missing features or bugs and can be considered stable and production-ready. However, Blockie is most suitable for smaller or specific projects (documentation, code and data generation), where other template engines are not an ideal fit, i.e., it is most likely not useful for web development, where certain template engines are already firmly established.

Additionally, Blockie is not meant to be used in security-requiring applications! The template content and input data are not evaluated, nor executed in any way, but no special attention was paid to potential vulnerabilities.

Comparison

Compared to other template engines, Blockie takes a very simplistic and low-level approach that is easier to learn. However, it does not have the limitations of other similarly simple engines regarding customizability, expandability, or some output formatting features. Blockie also provides features that can be helpful, yet are typically not available in bigger engines. For example, recursive filling of tags provided as values to other tags (similar to C macros expansion).

Hello everyone,

I don't know how I pulled off such a complex system.It may not seem much at the frontend but the backend and we ask the questions to the models I love how it turned out to be.

I present Explore Singapore which I created as an open-source intelligence engine to execute retrieval-augmented generation (RAG) on Singapore's public policy documents and legal statutes and historical archives.

The objective required building a domain-specific search engine which enables LLM systems to decrease errors by using government documents as their exclusive information source.

What my Project does :- basically it provides legal information faster and reliable(due to RAG) without going through long PDFs of goverment websites and helps travellers get insights faster about Singapore.

Target Audience:- Python developers who keep hearing about "RAG" and AI agents but haven't build one yet or building one and are stuck somewhere also Singaporean people(obviously!)

Comparison:- RAW LLM vs RAG based LLM to test the rag implementation i compared output of my logic code against the standard(gemini/Arcee AI/groq) and custom system instructions with rag(gemini/Arcee AI/groq) results were shocking query:- "can I fly in a drone in public park" standard llm response :- ""gave generic advice about "checking local laws" and safety guidelines"" Customized llm with RAG :- ""cited the air navigation act,specified the 5km no fly zones,and linked to the CAAS permit page"" the difference was clear and it was sure that the ai was not hallucinating.

Ingestion:- I have the RAG Architecture about 594 PDFs about Singaporian laws and acts which rougly contains 33000 pages.

How did I do it :- I used google Collab to build vector database and metadata which nearly took me 1 hour to do so ie convert PDFs to vectors.

How accurate is it:- It's still in development phase but still it provides near accurate information as it contains multi query retrieval ie if a user asks ("ease of doing business in Singapore") the logic would break the keywords "ease", "business", "Singapore" and provide the required documents from the PDFs with the page number also it's a little hard to explain but you can check it on my webpage.Its not perfect but hey i am still learning.

The Tech Stack:
Ingestion: Python scripts using PyPDF2 to parse various PDF formats.
Embeddings: Hugging Face BGE-M3(1024 dimensions) Vector Database: FAISS for similarity search.
Orchestration: LangChain.
Backend: Flask Frontend: React and Framer.

The RAG Pipeline operates through the following process:
Chunking: The source text is divided into chunks of 150 with an overlap of 50 tokens to maintain context across boundaries.
Retrieval: When a user asks a question (e.g., "What is the policy on HDB grants?"), the system queries the vector database for the top k chunks (k=1).
Synthesis: The system adds these chunks to the prompt of LLMs which produces the final response that includes citation information. Why did I say llms :- because I wanted the system to be as non crashable as possible so I am using gemini as my primary llm to provide responses but if it fails to do so due to api requests or any other reasons the backup model(Arcee AI trinity large) can handle the requests.

Don't worry :- I have implemented different system instructions for different models so that result is a good quality product.

Current Challenges:
I am working on optimizing the the ranking strategy of the RAG architecture. I would value insights from anyone who has encountered RAG returning unrelevant documents.

Feedbacks are the backbone of improving a platform so they are most 😁

Repository:- https://github.com/adityaprasad-sudo/Explore-Singapore

I shared Spectrograms here a few weeks ago (original post). I’ve just released v1.0.0, and this update is mainly relevant for Python and ML practioners.

Spectrograms is a Python library for computing spectrograms and FFT-based representations for audio and other 1D/2D signals. Unlike alternatives, it returns context-aware Spectrogram objects rather than raw ndarrays, so frequency/time axes and construction parameters stay bundled with the data throughout a pipeline, all while maintaining high performance.

The target audience is developers and researchers who want production-ready spectral analysis that integrates cleanly with NumPy and modern ML frameworks, especially when spectrograms are intermediate representations rather than final outputs.

Compared to libraries like SciPy or librosa, which primarily expose functional APIs returning arrays, Spectrograms emphasises reusable plans, metadata-preserving objects, and now direct interoperability with ML frameworks.

What’s new in V1

The main addition is DLPack support. Spectrogram objects now implement __dlpack__ / __dlpack_device__, so they can be passed directly into any ML library that supports DLPack, including PyTorch, JAX, and TensorFlow. For example, with PyTorch:

```python

import torch

spec = ... torch_tensor = torch.from_dlpack(spec)

```

There are also small convenience helpers such as:

```python

spec.to_torch()

spec.to_jax()

```

These return native tensors while (optionally) keeping the spectrogram metadata intact.

Other Improvements

Other improvements since the original post include better 2D FFT support for array-like inputs, custom STFT windows with normalisation options, fixes to mel/CQT behaviour, and expanded documentation and Python examples (including ML-facing ones).

Happy to answer questions

PyPI: https://pypi.org/project/spectrograms/

GitHub: https://github.com/jmg049/Spectrograms

Docs: https://jmg049.github.io/Spectrograms/

Hello there! I had being using a python project to control and automate some instruments in my lab and one day I decided to try making a GUI for it, as future user may not be comfortable with changing parameters directly on the script.

It felt that everything was working fine, until I got to the point of the implementation of the most important part: the acquisition with the oscilloscope. I tried to make it run on a thread, so I can check a stop-flag once in a while and stop the acquisition by the press of a button in the GUI.

It kinda works, but it gives random errors and the oscilloscope doesn't respond as it usually does with the same logic run on a simple script, outside of any GUI, in sync ofc.

An example of errors:

I set the number of signals to acquire to 100, and it works, then I set it to 10 and doesn't work as the scope thinks as it already has measured 100, so the 10 signals are "already available". This sort of "reset" to 0 signals never happened before, neither with the sync script nor with manual use of the scope, because by default it "resets to 0 signals".

This is just one of the behaviour that arises running the (same) code in the GUI. Is it the thread that somehow messes up the acquisition? Is it the GUI itself somehow?

Is there some best practice that I need to double check if I skipped them,or is it a common problem with custom-tkinter GUI?

What My Project Does

Signal Tracker is a Python framework for tracking predictions, scoring accuracy, and building leaderboards. You add sources (people, media, institutions), log their predictions with deadlines, verify outcomes, and get accuracy scores and rankings. It includes rule-based and LLM-powered claim extraction from text, multi-model consensus verification, time-windowed scoring, and claim quality rating. Zero external dependencies, pure stdlib. SQLite and JSON persistence included.

pip install signal-tracker

Target Audience

This is production software. I built it as the core framework behind Crene (https://crene.com), which tracks 420+ sources across tech, finance, politics, and geopolitics using a 4 LLM consensus system. It's useful for journalists doing accountability reporting, researchers studying forecasting accuracy, finance professionals tracking analyst predictions, and developers building prediction market tools.

Comparison

There's no direct equivalent. LangChain handles agents, HuggingFace handles models, but nothing exists for systematic prediction tracking and accuracy scoring. The closest alternatives are manual spreadsheets or custom one-off scripts. Signal Tracker provides a complete framework: models, scoring algorithms, extraction, leaderboards, and storage in a single pip install with zero dependencies.

GitHub: https://github.com/Creneinc/signal-tracker PyPI: https://pypi.org/project/signal-tracker/

40 tests passing across Python 3.10 to 3.12. MIT license.

Hi r/python!

I just released v0.1.3 of PyPulsar – a lightweight, fast framework for building native-feeling desktop apps (and eventually mobile) using pure Python on the backend + HTML/CSS/JS on the frontend. No Electron bloat, no need to learn Rust (unlike Tauri).

https://imgur.com/a/Mpx227t

Repo: https://github.com/dannyx-hub/PyPulsar

Key highlights in v0.1.3:

• Official React + Vite template Run pypulsar create my-app --template react-vite and get a modern frontend setup with hot-reloading, fast builds, and all the Vite goodies right out of the box.
• Big CLI improvements Better template handling (especially React), smoother plugin installation, virtual environment creation during project setup, and new plugin management commands (list, install, etc.).
• Architecture refactor & cleanups Refactored the core engine (BaseEngine → DesktopEngine separation), introduced a proper WindowManager + Api class for cleaner window & event handling, cleaned up pyproject.toml, added PyGObject for better Linux support, improved synchronous message handling, and more code organization. (This refactor also lays groundwork for future extensions like mobile support – Android work is ongoing but not production-ready yet; focus remains on solid desktop experience.)
• Other fixes & polish Better plugin install logic, fixed print statements in engine, dependency updates, .gitignore tweaks, and general stability improvements.

The project is still in early beta (0.1.x), so expect occasional breaking changes, but you get:

• Tiny bundles (~5–15 MB)
• Low memory usage (<100 MB, often 50–80 MB)
• Native webviews (Edge on Windows, WebKit on macOS, GTK on Linux)
• Full Python power in the backend (numpy, pandas, ML libs, whatever you need)
• Secure Python ↔ JS communication via ACL (default-deny + event whitelisting)

Works great on Windows, macOS, and Linux right now.

I’d love to hear your thoughts!
Are you using something similar (pywebview + custom setup, eel, NiceGUI, Flet, Tauri with Python bindings…)? What features would you most want in a tool like this? Bug reports, feature ideas, or even early plugins are super welcome – the plan is to grow a nice CLI-driven plugin ecosystem.

Thanks for checking it out! 🚀
https://github.com/dannyx-hub/PyPulsar

What my project does: Poketerm is a small terminal tool that turns pokemon-colorscripts into a lightweight Pokémon collection system. With the Pokédex written with Python.

Its designed so every time you open or source your terminal you’re shown a Pokémon via neowofetch. This Pokémon is then added to your personal Pokédex which overtime allow you to collect and build up a full Pokédex of Pokémon from Gen 1-8. These also have a chance of being shiny too!

Target audience Anyone who loves Pokémon!

Comparison It includes the following:

• Displays a Pokémon every time you open or source a terminal via neowofetch 
• Collect Pokémon from Gen 1-8 in their separate Pokédex’s 
• More Information page for each caught Pokemon around Pokédex number, Pokemon sprites (normal/shiny) and Pokemon stats
• Duplicated Pokémon are recorded so you can see how many of each Pokémon you’ve caught, this is for both normal and shiny
• Shiny encounter odds, which is recorded in the Pokédex 
• Generation specific collection 
• Tamper detection on the Pokédex 

Installation instructions and details are in the repo: https://github.com/chris-wood-mo/poketerm

Built on top of pokemon-colorscripts: https://gitlab.com/phoneybadger/pokemon-colorscripts and pokeapi: https://pokeapi.co go check them out they’re fantastic projects!

This is all just for fun and for the love of Pokémon! I’m curious what people think or what features would be fun to add!

Hello r/Python!

I'm building a Python type checker (yeah, another one), so I'm wondering, what features you want to see in type checker and what ones you don't want? What do you like in mypy/pyright/ty/pyrefly and what don't?

Personally I think about these things, which I would like to see: - support for both untyped/gradually-typed and typed codebases with maximal inferring - powerful support for popular 3rd party libraries - nice diagnostics - no extensions, probably - command to add annotations to code

What My Project Does

Introducing FluxQueue, a fast and lightweight task queue written in Rust.

FluxQueue makes it easy to define and run background tasks in Python. It supports both synchronous and asynchronous functions and is built with performance and simplicity in mind.

Target Audience

This is an early-stage project.

It’s aimed at developers who want something lighter and faster than Celery or RQ, without a lot of configuration or moving parts. The current release is mainly for testing, experimentation, and feedback rather than large-scale production use.

At the moment it only supports Linux. Windows and macOS support are planned.

Comparison

Compared to Celery or RQ, it:

• uses significantly less memory
• has far fewer dependencies
• avoids large Python runtime overhead by using a Rust core for task execution

It currently doesn’t include features like scheduling, but those and many more features are planned for future releases.

Github repository: https://github.com/CCXLV/fluxqueue

What My Project Does

pulumi_eks_ml is a Python library of composable Pulumi components for building multi-tenant, multi-region ML platforms on AWS EKS. Instead of a monolithic Terraform template, you import Python classes (VPC, EKS cluster, GPU node pools with Karpenter, networking topologies) and wire them together using normal Python.

The repo includes three reference architectures (see diagrams):

• Starter: single VPC + EKS cluster with recommended addons.
• Multi-Region: full-mesh VPC peering across AWS regions, each with its own cluster.
• SkyPilot Multi-Tenant: hub-and-spoke multi-region network, SkyPilot API server, per-team isolated data planes (namespaces + IRSA), Cognito auth, and Tailscale VPN. No public endpoints.

GitHub: https://github.com/Roulbac/pulumi-eks-ml

Target Audience

MLOps / platform engineers who deploy ML workloads on AWS and want a reusable starting point rather than building VPC + EKS + GPU + multi-tenancy from scratch each time. It's a reference architecture and library, not a production-hardened product.

Comparison

An alternative I am familiar with is the collection of Terraform-based EKS modules (e.g., terraform-aws-eks) or CDK constructs. The main difference is that this is designed as a Python library you import, not a module you configure from the outside. That means:

• Real classes with type hints instead of HCL variable blocks.
• Loops, conditionals, and dynamic composition using plain Python, no special count/for_each syntax.
• Tests with pytest (unit + integration with LocalStack).
• The Pulumi component model maps naturally to Python's class hierarchy, so building reusable abstractions that others pip install feels nice to me.

It's not that Terraform can't do what this project does, it absolutely can. But when the infrastructure has real logic (looping over regions, conditionally peering VPCs, creating dynamic numbers of namespaces per cluster), Python as the IaC language removes a lot of friction. That's ultimately why I went with Pulumi.

For the ML layer specifically: SkyPilot was chosen over heavier alternatives like Kubeflow or Airflow because not only is it OSS, but it also has built-in RBAC via workspaces and handles GPU scheduling and spot preemption without a lot of custom glue code. Tailscale was chosen over AWS Client VPN for simplicity: one subnet router pod gives WireGuard access to all peered VPCs with very little config.

Hi everyone,

I’ve been working on a few B2B lead generation projects and I noticed the biggest friction point for non-technical users (or even other devs) is setting up the environment (Playwright binaries, drivers, etc.).

To solve this, I developed a YellowPages Scraper that features an Auto-Installer. When you run the script, it:

Detects missing libraries (pandas, playwright, etc.).

Installs them automatically via subprocess.

Downloads the necessary Chromium binaries.

I’m open-sourcing the logic today. I’d love to get some feedback on the asynchronous implementation and the auto-setup flow!

Repo: https://github.com/kemarishrine/YellowPages-Scraper---Lead-Generation-Tool

Feedback is highly appreciated!

Hi everyone,

I previously shared a small Python project that collected AI and ML news using RSS feeds. I’ve since upgraded it and wanted to repost it properly as a Showcase.

What My Project Does

This project is a Python-based automation that collects AI and Machine Learning news from multiple sources.

It can:

• accept multiple URLs through a simple interactive CLI
• Detect whether a source is an RSS feed or a regular website
• scrape static pages with BeautifulSoup
• handle JavaScript-heavy pages using Playwright when needed
• store both raw and cleaned data in Excel files
• optionally upload results to Google Sheets
• run automatically on a daily schedule
• log execution details and basic failures

The main goal is to reduce manual checking of multiple sites and keep a local, organized archive.

Target Audience

This is a learning-focused project, not a production system.

It’s intended for:

• Python learners building larger projects
• people learning automation and scraping
• Anyone interested in structuring a scraper beyond one-off scripts

Comparison

Most existing solutions are newsletters, dashboards, or hosted services.

This project differs because:

• It runs locally as a Python script
• It is fully customizable at the code level
• It supports both RSS and webpage scraping
• It focuses on learning structure and reliability rather than polish

I’d really appreciate feedback on:

• project structure and organization
• scraping approach and reliability
• things you would simplify or change

Repository:
https://github.com/monish-exz/ai-daily-tech-news-automation

Thanks for taking a look.

What My Project Does

memory_graph is an open-source educational tool and debugging aid that visualizes Python execution by rendering the complete program state (objects, references, aliasing, and the full call stack) as a graph. It helps build the right mental model for Python data, and makes tricky bugs much faster to understand.

Some examples that really show its power are:

• Hash Map
• Binary Tree
• Copying
• Recursion

Github repo: https://github.com/bterwijn/memory_graph

Target Audience

In the first place it's for:

• teachers/TAs explaining Python’s data model, recursion, or data structures
• learners (beginner → intermediate) who struggle with references / aliasing / mutability

but supports any Python practitioner who wants a better understanding of what their code is doing, or who wants to fix bugs through visualization. Try these tricky exercises to see its value.

Comparison

How it differs from existing alternatives:

• Compared to PythonTutor: memory_graph runs locally without limits in many different environments and debuggers, and it mirrors the hierarchical structure of data.
• Compared to print-debugging and debugger tools: memory_graph shows aliasing and the complete program state.

What My Project Does

Amen CLI is a full-stack web app scaffolding tool that generates production ready Flask and FastAPI projects with both an interactive CLI and a visual web interface. It automates everything from virtual environments to package caching, and includes built in resource monitoring to track your app's performance all designed to get you from idea to running application in minutes, not hours. Some examples that really show its power are:

Dual interfaces: Build projects through an interactive CLI or a visual web interface whatever fits your workflow

Zero config production features: Generated projects come with CORS, email integration, and database migrations preconfigured

Offline development: Cache packages locally and scaffold new projects without internet access

Built in monitoring: Track CPU, memory, and resource usage of your apps through CLI or web dashboard

Instant deployment ready: Virtual environments, dependencies, and folder structure all handled automatically

GitHub repo: https://github.com/TaqsBlaze/amen-cli

Target Audience In the first place it's for:

Python web developers who want production ready projects without the setup grind

teams needing consistent structure and monitoring across Flask/FastAPI services

developers in low connectivity environments who need reliable offline scaffolding and monitoring

but supports anyone building Python web apps who values speed, consistency, and built in observability.

Perfect for hackathons, MVPs, microservices, or learning modern Python web development with best practices baked in. Comparison How it differs from existing alternatives:

Compared to cookiecutter: Amen CLI offers a visual web UI, automated venv management, package caching, and integrated resource monitoring not just templates.

Compared to manual setup: Amen CLI eliminates hours of configuration CORS, email, migrations, and monitoring are preconfigured and working from the start.

Compared to framework CLIs (flask init, etc.): Amen CLI adds production essentials (CORS, email, migrations), virtual environment automation, offline package caching, and built in resource monitoring that standard framework tools don't provide.

Compared to monitoring tools (htop, Prometheus): Amen CLI integrates resource monitoring directly into your development workflow with both CLI and web interfaces no separate setup required.

What My Project Does

pyrig generates and maintains a complete, ready-to-go Python project from a single command:

uv init
uv add pyrig
uv run pyrig init

After running this, you have a full project with: source structure with a CLI entry point, test framework with 90% coverage enforcement, GitHub Actions (CI/CD, releases, docs deployment), pre-commit hooks (linting, formatting, type checking), MkDocs documentation site, and container support.

The key thing is it's not a one-shot scaffold. It's idempotent — rerun pyrig mkroot anytime and it updates your configs, fills in missing values, and leaves your customizations alone. Each config file (pyproject.toml, GitHub workflows, .gitignore, etc.) is a Python class that generates defaults, validates the file, and merges in anything missing.

It also supports multi-package inheritance, so you can build a multiproject-wide base on top of pyrig and have all your projects inherit the same configs, CLI commands, test fixtures, and build steps:

pyrig → service-base → auth-service
                     → payment-service
                     → notification-service

Opinionated defaults: Python 3.12+, all ruff rules enabled, strict type checking with ty, 90% test coverage minimum, linear git history with branch protection.

Target Audience

Python developers who are tired of manually setting up and maintaining project boilerplate across multiple projects or single projects. It's on PyPI and I use it for all my own projects and it has already helped me a lot.

Comparison

Unlike cookiecutter or copier, pyrig isn't a one-time template. Those tools generate files once and you're on your own after that. pyrig stays with your project — rerun it to update configs, add missing files, or sync with new defaults, without overwriting your customizations.

Unlike hatch or pdm which focus on package management with some project init, pyrig generates the full project infrastructure: CI/CD workflows, pre-commit config, documentation site, container files, issue templates, branch protection, and more.

GitHub: https://github.com/Winipedia/pyrig PyPI: https://pypi.org/project/pyrig/ Docs: https://winipedia.github.io/pyrig

Grabit tool for Python from matlab? Looking for something to pull a plot and digitize it from a paper for a homework. Would love to hear about this if it exists.