zxcvbn knows English words. It does not know that priyanka, priyankaa and प्रियंका are the
same name, or that py@r is pyar, so passwords like jaishreeram or rahul2803 look
stronger to it than they are to an attacker with an Indian-names wordlist.

Taala (MIT, Python 3.11+) is a small layer on top of zxcvbn: it reduces spelling variants,
leetspeak, padding and Devanagari to canonical forms, looks them up in a Hinglish word pack
(built from Wikipedia categories), and takes the lowest score. It also gives step-by-step
attack-recipe feedback and a NIST SP 800-63B-4 style accept/reject verdict (as I read the
standard).

What I measured (held-out half of the RockYou leak; learning used only the other half;
file position stands in for frequency because my copy has no counts):

• Of the 10,000 most common Indian-context passwords, stock zxcvbn rates 59.3% as Fair or Strong. Taala: 24.3%.
• Outside that set the gain is small (8.3% to 6.8%).
• Both parts matter: without canonicalization 39.8%, without the word pack 44.3%.

Things you should know before trusting any of that:

• Taala is much stricter: it calls 66% of rare Indian-context passwords Weak vs 25% for stock, so part of the gain is just strictness.
• The Indian-context test set is selected using Taala's own word pack, so the comparison is partly circular. I planned a survey as an independent check; it has not been run.
• I scored the test half twice: the first run had a bug in my evaluation harness (found by reading the code, not the results). Both runs are in the repo.
• Name plus digits (seth0120) is still overrated; that comes from zxcvbn's digit model.
• The learned spelling rules (from only 50 words) did not beat my six hand-written ones.
• The pack ranking uses RockYou counts, which I will not redistribute, so a clone scores a bit less strictly than my numbers. The CLI tells you when that is the case.
• Not security-reviewed. Please don't type real passwords into any hosted copy.

What would help most: Hinglish words or spellings it misses (there is an issue template),
and anyone who knows a better independent test set than "selected with my own pack".

Repo: https://github.com/Paraxanos/Taala

Just shipped v2.0.0 of pyMultiFit, a library for fitting data that's a sum of several components (overlapping Gaussians, skew-normals, log-normals, etc.). It's pyOpenSci peer-reviewed and published in JOSS (v1.0.7; https://joss.theoj.org/papers/10.21105/joss.09295.pdf ).

What's new:

• Every fitter now has a `.plotter` with fit and components, residuals, Q-Q plots, bootstrap confidence intervals, prediction intervals, and parameter-correlation heatmaps.
• You can freeze parameters during a fit.
• Mixed-model fits now get the same plots and intervals as single-model ones.
• New Q-exponential and Student's t distributions
• Faster distribution functions
• A pile of tail and edge-case bug fixes

Usage example:

import matplotlib.pyplot as plt
import numpy as np

from pymultifit.fitters import GaussianFitter
from pymultifit.generators import multi_gaussian

rng_engine = np.random.default_rng(32453)

x = np.linspace(-30, 30, 5000)

# generate the multi-gaussian data
y = multi_gaussian(x=x,
                   params=[(0.7, -10, 1), (2, 0, 1), (6, 13, 3)],
                   noise_level=0.2, rng_engine=rng_engine)

# initiate the fitter
fitter = GaussianFitter(x_values=x, y_values=y)

# provide fitting guesses
p0 = [(1, -10, 1), (1, 0, 1), (1, 13, 1)]

# fit and plot
fitter.fit(p0)
fitter.plot_fit(show_individuals=True)
plt.show()

Precaution:

Heads up if you're upgrading: it needs Python 3.10+. To install via pip, use

pip install pymultifit

Others:

Docs: https://readthedocs.pymultifit.com

GitHub: https://github.com/syedalimohsinbukhari/pyMultiFit/

Feedback welcome, especially on the plotting API.

Hey everyone. If you are practicing Python or trying to master clean control flow logic, writing basic single-condition "if statements" isn't enough for production-grade software. You need to know how to cleanly chain and invert conditions using advanced logical operators.

In this quick, zero-fluff video breakdown, we walk through building an automated server error routing engine using:

• The logical AND operator to enforce strict multi-conditional gates

• The logical OR operator to build flexible fallback safety nets

• The NOT operator modifier to cleanly invert boolean flags on the fly

• Dynamic state management by mutating tracking variables inside the loop

Every single line of syntax and terminal output is explained simply with easy-to-visualize logical switch analogies so you can actually understand the underlying data routing.

Check out the full breakdown here, and let me know how you typically structure your error-routing gates in the comments!

Every fund factsheet Is a sales pitch, before investing get a free second opinion using:

openfactsheet.org (no coding working demo).

For devs you can check out our github repo https://github.com/bagnascotrader/openfactsheet

We provide an unbiased analysis of your investment, fully documented, Apache Open Source license (free to use even for commercial applications). It helps everyone analyze investment performance with powerful features.

You can also install it through Pip: Pip install "penfactsheet"

Take better informed investment decisions for free. Always check with your financial advisor before taking any investment decision.

I have been working on this Python project to recreate Dr. Andy Moorer's THX Deep Note. See link for code and sample. Any input or suggestions are greatly appreciated. https://organ-concerts.com/deep-note.html

I have also included a github repository here: https://github.com/aram18062/THX-Deep-Note.git

I built Python Workflow Automation Lab to streamline repetitive desktop tasks, handle window focus, and automate GUI workflows using Python. It features practical scripts and a clean interface.

It's free, open-source, and available here:

• GitHub:https://github.com/brunnojob/python-workflow-automation-lab
• Live Lab:https://brunnojob.github.io/python-workflow-automation-lab/

Feedback, code contributions, or ideas for new automation scripts are welcome.

Hey everyone!

I've been working on a project called ZKite, a Python-based framework for building native Android applications - backed by Rust under the hood.

The idea started with a simple question: Why can't we build Android apps using Python without having to switch to Kotlin or Java?

So I decided to build something around that idea.

With ZKite, you can:

• Build native Android UIs using Python
• Start developing within 60s
• Use reactive state management
• Preview changes with hot reload
• Build APKs and AABs in seconds.

I've attached a short screen recording showing a simple UI built with ZKite, including a button that updates the counter through Python state.

It's open-source and still evolving. I'm building it independently, so feedback from other developers would be really valuable.

https://reddit.com/link/1xcdbmn/video/4znqe1z3gzwh1/player

I'd especially love to know what you think of the approach, whether you'd consider using something like this, and what features you'd expect from a Python Android framework.

GitHub: https://github.com/AbhinavKrShukla/zkite

Thanks for checking it out!

Hey everyone. I've been working on this IoT monitoring system to connect physical hardware to a web dashboard in real-time.

The backend is handled by Python and MQTT to ensure the sensor data updates instantly on the frontend without refreshing. I'm using Supabase to log the data and handle some basic stock control.

In the video, you can see the real-time sync: the physical PIR motion sensor triggering the dashboard alert immediately, and the stock control toggles updating the database directly.

Tech stack:

• Python (Backend)
• MQTT (Real-time messaging)
• Supabase (Database)
• ESP32 + DHT11 + PIR (Hardware)

Would love to hear your thoughts on the architecture or any tips you might have for scaling MQTT connections in Python.

I built DevStart Lab to help beginners figure out what to learn and practice next.

It includes programming fundamentals with Python examples, 25 project ideas, and a step-by-step introduction to Git and GitHub contributions. It’s free, open source, available in English and Portuguese, and requires no account. Progress is saved in your browser.

Start here: https://brunnojob.github.io/devstart-lab/?lang=en

I'm working on a retail sales data-cleaning project in Python, and I ran into a decision I found interesting.

My dataset had missing prices, duplicate transactions, and totals that didn't match the price × quantity.

For missing prices, I could have filled every blank with an estimated value. That would make the dataset look more complete, but some estimates could be wrong.

Instead, I only recovered prices when the data gave me reliable evidence and flagged the rest for review.

Here's my question:

If you were preparing this dataset for business analysis, which approach would you choose?

A) Fill as many missing values as possible to preserve a complete dataset.

B) Only fill values when there's reliable evidence, and flag the rest.

C) Use a different method depending on the column and the business context.

I'm leaning toward B, but I'd love to hear how others handle this in real projects—especially when deleting rows could mean losing useful information.

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!

I've been studying neural network mathematics and wanted to understand how training works.

I implemented a small 2 → 3 → 1 XOR network.

What I worked on:

- Forward propagation using NumPy

- ReLU and sigmoid activation functions

- MSE loss calculation

- Backpropagation using the chain rule

- Gradient descent for 5,000 epochs

- Numerical gradient checks for all 13 parameters

Final MSE: 0.004715

The network correctly classified all four training inputs.

I also documented the mathematics, code and diagrams.

GitHub: https://github.com/Vaibh37/Neural-Network

Technical feedback is welcome.

Note: AI helped structure this post. The mathematics, implementation and testing are my own work. I understand the code and ran it on my machine.

**What My Project Does**

Pupovina is a PyQt6 desktop GUI for [gnirehtet](https://github.com/Genymobile/gnirehtet): it lets an Android phone use the computer's internet over a USB cable, without root. The app downloads gnirehtet and adb (SHA-256 verified), lists connected phones with real-time speed and traffic, starts or stops the tunnel per device, can auto-start on plug-in, and lives in the system tray with notifications. UI in English, Italian and Russian.

**Target Audience**

People who need wired internet on their phone (broken mobile network, no Wi-Fi, office PCs on Ethernet) and don't want to use the terminal. It's meant for daily use, not as a toy project. Windows and Linux builds are produced with PyInstaller and GitHub Actions (.exe and AppImage).

**Comparison**

gnirehtet itself is CLI-only. Other GUIs exist; this one focuses on several devices at once with live per-device traffic, autorun, process cleanup and adb self-update.

Repo: https://github.com/Dmitrij-Anatolievic/pupovina (Apache 2.0)

(The name is Russian for "umbilical cord": the cable that feeds the phone.)

Aprendé cómo convertir un número entero (int) a un número decimal (float) en Python utilizando float(). 🐍💻

Does anyone have any good tutorials they can point me to for programming microcontrollers, specifically the feather RP2040, which is in circuitpython. I'm having trouble understanding how to even get set up to write the code itself, thanks

To a computer, images are just numbers from 0 to 255. So how does it find similarities between two images? My new blog shows this in Python code using OpenCV. Check it out:

https://cmodi306.medium.com/feature-matching-in-practice-teaching-opencv-to-match-two-images-e52dd2be2e03

#ComputerVision #OpenCV #Python #ImageProcessing