I made this Python Matplotlib Plotting tutorial for beginners.

Source codes can be downloaded from the link below

• Complete Matplotlib Library Graphing Tutorial using Python in under 1 Hour

The tutorial is designed for beginners who want to learn Matplotlib for building Data Acquisition and Data Logging applications using Arduino, Raspberry Pi, and other embedded systems. Learn how to create a Line Graph using Python and Matplotlib for visualizing data coming from an Arduino, Raspberry Pi, or other Embedded Systems.

Things Covered in This Video

• Installing Matplotlib
• Understanding the main concepts like Figure,Axes behind Matplotlib
• Creating a simple Line Chart using Matplotlib
• Understanding and using the subplots() method
• Using the .plot() method to plot graphs
• Changing graph line thickness and line style
• Controlling marker shape and marker size
• Naming the plot and creating a Legend
• Setting the names of the X and Y axis
• Setting Gridline color and visibility
• Changing the properties of a single Gridline
• Controlling Ticks in Matplotlib
• Understanding how Matplotlib chooses Ticks
• Working with Major and Minor Ticks

By the end of this tutorial, you will have a better understanding of how Matplotlib works and how its different components can be used to create customized line graphs.

Hi everyone,

I'm pretty new to programming, and this is the biggest thing I've built so far, so I wanted to share it and hopefully learn from your feedback.

**What it does**

Log Guard is a command-line tool that scans log files (and .xlsx spreadsheets) and masks emails, phone numbers, API keys, IP addresses, and credit card numbers before you share them with someone. It runs completely locally and never touches the network. I built it because the online "paste your log here to clean it" tools kind of defeat the purpose when you're uploading the sensitive stuff to someone else's server.

pip install logguard-cli

log-guard server.log

That writes a server.masked.log next to the original. There's also a --check mode that exits with code 1 if it finds anything, so it can be used as a pre-commit hook or in CI.

GitHub: https://github.com/apurvaraj9/log-guard

**What I learned along the way**

I'd used git on a handful of smaller projects before, but this is the first one I took all the way from "script on my laptop" to something other people can install. Along the way, I learned:

- writing tests with pytest (67 of them now) and running them automatically on GitHub Actions across Python 3.9 to 3.12

- packaging and publishing to PyPI. The name log-guard was already taken, and so were about ten other names I tried, so it ended up as logguard-cli

- doing a practice release on TestPyPI first, because PyPI never lets you re-upload the same version number

- adding Excel support in v0.2.0, which turned out to be a lot more than adding "xlsx" to a list, since .xlsx files are actually zip files full of XML

**Being upfront**

I used an AI assistant (Claude) while building this. It wrote some of the code, and I worked through every step myself: running it, testing it, debugging when things didn't match what I expected, and learning what each part does. I'm sharing it because I'd like real people to look at it and tell me what's wrong.

**Where I'd love feedback**

- the detection is regex-based, so if you can spot false positives or things it misses, please tell me

- the code is all in one file. Is that bad at this size?

- anything about the tests, packaging, or README that looks off

Since this is my first project at this scale, I'm sure I've made mistakes. Please point them out. I'm genuinely happy to understand what I got wrong and make it better.

Thanks for reading!

• Complete Matplotlib Library Graphing Tutorial using Python in under 1 Hour

The tutorial is designed for beginners who want to learn Matplotlib for building Data Acquisition and Data Logging applications using Arduino, Raspberry Pi, and other embedded systems. Learn how to create a Line Graph using Python and Matplotlib for visualizing data coming from an Arduino, Raspberry Pi, or other Embedded Systems.

Things Covered in This Video

• Installing Matplotlib
• Understanding the main concepts like Figure,Axes behind Matplotlib
• Creating a simple Line Chart using Matplotlib
• Understanding and using the subplots() method
• Using the .plot() method to plot graphs
• Changing graph line thickness and line style
• Controlling marker shape and marker size
• Naming the plot and creating a Legend
• Setting the names of the X and Y axis
• Setting Gridline color and visibility
• Changing the properties of a single Gridline
• Controlling Ticks in Matplotlib
• Understanding how Matplotlib chooses Ticks
• Working with Major and Minor Ticks

By the end of this tutorial, you will have a better understanding of how Matplotlib works and how its different components can be used to create customized line graphs.

here is my self-made python module. for all the pocket option users.

I made an online python interpreter that can run your python code online without downloading anything.

Features:

\- supports matplotlib (pyodide engine)

\- material design (cuz i like it)

\- supports exporting your files

\- has layouts for mobile and desktop

\- Code highlighting

\---

I built it mainly focused on mobile since python is kinda messed up in phones and other web apps have weird ui.

Site link: https://pypad-bay.vercel.app

(I used AI to build js and work with material design, the idea and implementation was mine. I test every change before publishing)

GitHub repo: https://github.com/chomuloll69-oss/pypad

hey everyone! recently built a terminal tool that turns github issues into timed coding quests with rpg progression.

it can detect and automatically open your ide. currently supports vs code and cursor.

written in python and uses a github repo scoped token and a gemini api key. it follows a byok approach and i'm planning to add support for more models.

docs: https://runedocs.vercel.app

would appreciate it if you checked it out. feedback and suggestions are welcome!

I kept hitting my Claude limit with no warning, so I built a small mascot that sits on the Windows taskbar and shows my 5-hour and weekly usage in a speech bubble. It turns yellow, then red, as I get close.

It slowly turned into a pet. It walks around, naps, fishes, wears a Santa hat in December, and gets dragged around and thrown (it screams and opens a parachute). When Claude Code is working it puts on a wizard hat and casts a spell for whatever tool is running.

It's free and open source (MIT), written in plain Python with no dependencies, and I built it with Claude Code. You double-click a .bat file to start it.

Windows only for now, and it needs Claude Code signed in. Unofficial, not affiliated with Anthropic.

GitHub: https://github.com/have-you-tried-restarting/claude-usage-pet

What would you add to it? And if you've read this far, a ⭐ on GitHub would make my day. Thank you!

I maintain a Python teaching lab inside a free fintech data-engineering roadmap. The demo ingests synthetic payment events into SQLite, replays the same batch, checks balanced entries, compares payouts with settlement data, and produces a JSON report.

From the cloned repository root, with Python 3.12+ installed:

python -m fintech_lab --out work/reddit-demo

On a fresh output directory, the first batch accepts six events; replay adds no new events and identifies six duplicates. The report also shows a payout discrepancy and how a late-arriving event changes a point-in-time feature. The directory contains warehouse.db and report.json, so learners can inspect the underlying rows.

The accompanying local grader has 40 foundation exercises and 8 scenario labs with starters, hints, and reference solutions. One scenario has learners restore a real SQLite backup and test replay and checkpoint behavior after a simulated failure. Another asks them to fix SQL join fan-out rather than just read about it.

https://github.com/antony502189-max/fintech-data-engineering-roadmap

The core practice uses Python and SQLite without a paid cloud account. Everything is in English and MIT-licensed. These are synthetic teaching examples, not a production financial system.

Disclosure: the first edition and this introduction were prepared with AI assistance using Codex. Provenance is documented in the repository. Feedback on the demo output and failure messages would help improve the learning experience.

Like most developers who try to build desktop tools in Python, I thought building a clean GUI wrapper around yt-dlp would take a weekend. It ended up taking 40+ hours of debugging threading freezes, memory leaks, and Windows packaging hell.

I wanted to build an alternative to bloated adware tools that is 100% standalone, clean, and fast. The project is called **BABAji Ka Astra (BKA)** — built with CustomTkinter, yt-dlp, Pillow, and PyInstaller.

Here are the 4 biggest architectural headaches I ran into and how I solved them:

**1. The Tkinter Mainthread Trap:**

Calling `extract_info` or running download loops directly inside Tkinter callbacks instantly freezes the UI and triggers the Windows "Not Responding" white-screen. Decoupling the UI with a dedicated `ThreadPoolExecutor` and wrapping every single UI mutation in `app.after(0, ...)` was the only way to keep smooth animations during 4K DASH downloads.

**2. The Standalone FFmpeg Bundling Nightmare:**

YouTube serves separate video and audio DASH streams for anything above 720p. If a user doesn't have FFmpeg installed on their system PATH, downloads silently fail. I bundled stripped `ffmpeg.exe` and `ffprobe.exe` binaries directly into the PyInstaller build and hooked them dynamically at runtime via `os.environ["PATH"]`. The installer jumped to 145MB, but it now runs out of the box on any clean Windows machine.

**3. Process-Safe Cancellation:**

When a user clicks "Cancel" mid-download, `taskkill /F /IM ffmpeg.exe` is dangerous because it kills unrelated processes on the user's machine. I implemented isolated PID tracking to gracefully terminate only the child worker trees spawned by BKA without leaving zombie processes.

**4. Mathematical Bitrate Fallbacks:**

When analyzing certain fragmented HLS feeds, yt-dlp's API returns `None` for file size. I built a fallback engine calculating estimated file sizes from `duration * (video_tbr + audio_tbr)` so the UI never displays broken zero-byte estimates.

The codebase is decomposed into a modular package (`bka/config.py`, `bka/engine.py`, `bka/utils.py`) with full PyInstaller `.spec` and Inno Setup `.iss` compiler scripts included.

Would love feedback from other Python desktop developers — especially anyone who's dealt with CustomTkinter threading or PyInstaller bundling on Windows!

Hi, i made my own programming language.

....And it is transpiler to python

I named it Cintra.

It is dynamic-typized language

It supports:

1.variables

1. I/O

2. If/else

3. whiles

4. lambdas/functions

5. structs/classes

--------

if you are interested, you can visit: https://github.com/MerzlikinDev/Cintra-Programming-language-

please, write your opinion in the comments

If you want to progress in Minesweeper pattern recognition and to view on your screen where mines certainly are (based on what's visible) then look no further than using this side-project I came up with.

It's written in Python and you'd need Python to run it and it's only running on Windows for now.

What it does, and what it does not

The helper reads visible board pixels, uses logical constraints to identify forced mines and safe squares, and draws hints in a separate click-through overlay. It does not read game memory, play moves for you, or label a probabilistic guess as certain. Your flags are recognised, but are not assumed to prove a mine.

Every deduction depends on a correctly recognised, complete board. Check the preview before enabling the overlay. An ambiguous board can legitimately have no hints; bounded search can also miss deductions. Unreadable cells and detected contradictions stop hints rather than forcing a label.

The repo is here, if anyone wants to have a go: https://github.com/SweeperOfTheMines/sweeperhelper

What My Project Does: It reads clips from SteelSeries GG's SQLite library and from folders made by NVIDIA, AMD, Xbox Game Bar and OBS, works out the game and date from each recorder's file names, and serves a browser UI from a small local web server (http.server). ffmpeg handles thumbnails, audio tracks and exports. The "Up next" prediction is a small logistic regression fitted with Newton's method in pure Python, checked on the user's own past weeks. GitHub Actions builds the Windows .exe with PyInstaller.

Target Audience: PC gamers with a pile of clips from one or more recorders. It's a hobby project, vibe-coded with Claude Code, and I'd love code feedback.

Comparison: Each recorder's own gallery only shows its own clips. Medal and Allstar upload to the cloud and need an account. Cliptrove merges every recorder locally, with no account, and never changes your files.

Website: https://th30utcast.github.io/Cliptrove/
GitHub: https://github.com/Th30utcast/Cliptrove

I've been working on an open-source scientific computing library built around NumPy, SciPy, pandas, and Matplotlib.

One problem I wanted to address was reproducibility. A model fit can look fine today, but what happens when someone reruns it months later with different dependency versions?

I added a guided-fit workflow that lets you fit models to CSV data, choose how missing values and outliers are handled, and generate reports.

It also records the input hash, random seed, dependency versions, and fitting settings. You can then rerun the saved analysis and inspect changes in parameters, confidence intervals, and the software environment.

There's a documented example where an archived fit was rerun with different NumPy and SciPy versions. The environment changes were detected, while the numerical differences stayed below the declared material-change threshold.

The library also includes linear algebra, optimization, statistics, ODE/PDE solvers, signal processing, Monte Carlo methods, and other numerical tools.

Install:
pip install scientific-computing-system-2.0

PyPI: https://pypi.org/project/scientific-computing-system-2.0/

npm (optional Node launcher; requires the Python package): https://www.npmjs.com/package/scientific-computing-system-2.0

Source code (MIT): https://github.com/Furox-Art/scientific-computing-system-2.0

I'd be interested in how other Python developers handle reproducibility when dependencies change between runs. Feedback on the approach is welcome.

Just want to share this https://github.com/Onehand-Coding/ani-py of mine inspired by the original bash only implementation "ani-cli", its stable for now and im just sharing here to find like minded bros.

Hi everyone! 👋

I've been developing a personal project and wanted to share it with the community. It's called **BRAIN**, a modular, 100% local, and private personal assistant for Windows designed to organize daily life from a single dashboard.

It is not just home automation: it's a complete personal core running on a local AI (Ollama) that relies solely on the Python standard library (zero external pip dependencies).

**What does BRAIN handle?**

- 🧠 **Memory & Context:** Remembers preferences, tasks, schedule, and context across sessions.

- 🥗 **Health & Nutrition:** Tracks weight history, analyzes body composition via AI vision from scale photos, manages pantry/shopping lists, and suggests smart recipes based on available ingredients.

- ⚡ **Energy & Home:** Diagnostics and optimization for solar consumption/production, appliance control, and Home Assistant integration.

- 📄 **Local Documents (RAG):** Local search and reading of notes, files, and manuals without sending anything to the cloud.

- 🔔 **Notices & Automations:** Proactive daily morning summaries, reminders, audio alerts, and natural language automations.

Everything is managed through a local web panel with tabs, dark mode, and local voice transcription.

👉 **GitHub:** https://github.com/CafeConFenix/BRAIN

⚠️ **Note:** *The project code, interface, and documentation are currently written in **Spanish**.*

Any feedback, ideas, or constructive criticism to keep improving are very welcome. Cheers!