Coder Legion - Recent posts tagged python3

py_cpp_pair

Tue, 12 May 2026 05:28:32 +0000

py_cpp_pair

Write C++ directly inside Python strings, auto-generate pybind11 bindings, compile on-demand, dynamically load the extension, and inject exported symbols into your Python globals.

Version: 1.0.0

Badges

PyPI: py_cpp_pair 1.0.0 (import name: py_cpp)
Python: 3.10–3.13
Platforms: Windows / Linux / macOS
CI: GitHub Actions

Install

pip install py-cpp-pair

Import name stays:

import py_cpp as pcp

Quickstart

import py_cpp as pcp

pcp.cpp("""
int add(int a, int b) {
    return a + b;
}
""")

print(add(5, 7))  # 12

Class support

import py_cpp as pcp

pcp.cpp(r"""
class Robot {
public:
    int power = 100;
    Robot() {}
    int attack() { return power * 2; }
};
""")

r = Robot()
print(r.attack())  # 200

Public API

Only these are intended as public:

pcp.cpp(code: str) -> module
pcp.install(package: str) -> bool
pcp.clear_cache() -> None
pcp.version() -> str

Cross-platform support

OS	Compiler used	Notes
Windows	MinGW-w64 `g++` (preferred)	Requires `g++` on `PATH`.
Linux	`g++`	Requires build tools installed.
macOS	`clang++`	Requires Xcode Command Line Tools.

Override the compiler via:

# Windows (PowerShell)
$env:PY_CPP_CXX = "g++"

# Windows (cmd.exe)
set PY_CPP_CXX=g++

# Linux/macOS (bash/zsh)
export PY_CPP_CXX=clang++

Optional best-effort auto-install (opt-in):

# Enable by setting an environment variable in your shell.
# The installer logic is OS-aware (Linux/macOS/Windows) and picks the best available path.

# Windows (PowerShell)
$env:PY_CPP_AUTO_INSTALL_COMPILER = "1"

# Windows (cmd.exe)
set PY_CPP_AUTO_INSTALL_COMPILER=1

# Linux/macOS (bash/zsh)
export PY_CPP_AUTO_INSTALL_COMPILER=1

One-shot (only for a single command):

# Windows (PowerShell)
$env:PY_CPP_AUTO_INSTALL_COMPILER="1"; python -c "import py_cpp.toolchain as t; t.ensure_compiler_available(); print('compiler ok')"

# Linux/macOS (bash/zsh)
PY_CPP_AUTO_INSTALL_COMPILER=1 python -c "import py_cpp.toolchain as t; t.ensure_compiler_available(); print('compiler ok')"

Note: after an installer runs, you may need to open a new terminal so PATH updates are visible.

vcpkg package management

Install a C++ library with:

import py_cpp as pcp
pcp.install("fmt")

If the port does not exist:

Sorry, library not found.

py_cpp_pair detects vcpkg via VCPKG_ROOT or PATH. If missing, it can auto-bootstrap by cloning vcpkg (requires Git).

Caching and build layout

py_cpp_pair caches builds by SHA256 hash of the C++ source. Reusing identical code reuses the compiled extension.

Per-user state is stored under PY_CPP_HOME if set, otherwise the OS-default data directory:

Windows: %LOCALAPPDATA%\\py_cpp
macOS: ~/Library/Application Support/py_cpp
Linux: $XDG_DATA_HOME/py_cpp or ~/.local/share/py_cpp

Subfolders:

builds/: compiled extensions per hash
cache/: toolchain artifacts (Windows Python import libs)
logs/: optional logs (enable with PY_CPP_LOG_FILE=1)

Troubleshooting

ImportError: DLL load failed (Windows): ensure MinGW runtime DLLs are visible. py_cpp_pair adds common DLL dirs automatically, but the compiler bin directory must be on PATH.
No compiler found: install g++/clang++ and ensure it is on PATH.
vcpkg bootstrap fails: install Git and retry, or set VCPKG_ROOT to an existing vcpkg checkout.

Performance notes

Compilation is cached by source hash; repeated calls are fast after the first build.
For larger projects, prefer fewer, bigger cpp() calls (each call creates a module).

Documentation

See docs/:

docs/installation.md
docs/architecture.md
docs/api.md
docs/package_manager.md
docs/troubleshooting.md
docs/examples.md

Roadmap

Better symbol detection (still regex-based by design)
Multiple translation units / headers
Better vcpkg library auto-linking
Optional clang-based parsing for richer bindings

Contributing

See CONTRIBUTING.md.

Building an Expectation-Based AI Governance Model (EBAGM) in Python

Tue, 31 Mar 2026 12:02:37 +0000

Building an Expectation-Based AI Governance Model (EBAGM) in Python

What if AI governance wasn’t just about accuracy—but about aligning with human expectations?

Introduction

Most AI systems today are evaluated using metrics like accuracy, precision, and recall. But in real-world scenarios, that’s not enough.

A model can be technically correct and still feel unfair, biased, or unethical to humans.

This is where a new idea comes in:

Expectation-Based AI Governance Model (EBAGM)

Instead of only focusing on data and outputs, EBAGM introduces:

Human expectations
Perceived intent
Ethical alignment

In this blog, I’ll walk you through building a working prototype in Python.

⚙️ What is EBAGM?

EBAGM is a governance framework with 5 layers:

Expectation Layer (E) → What humans expect (fairness, privacy, etc.)
Data Governance (D → D') → Modify data based on expectations
Model (M) → AI decision-making
Perceived Intent (P) → Does AI feel fair?
Feedback Loop → Adjust system if misaligned

Step 1: Creating a Biased Dataset

We simulate a loan approval system with built-in bias.

import pandas as pd
import numpy as np

np.random.seed(42)

data = pd.DataFrame({
    "income": np.random.randint(20000, 100000, 100),
    "credit_score": np.random.randint(300, 850, 100),
    "gender": np.random.choice([0, 1], 100)
})

data["approved"] = (
    (data["income"] > 50000) &
    (data["credit_score"] > 600)
).astype(int)

# Bias toward males
data.loc[data["gender"] == 1, "approved"] |= (np.random.rand(100) > 0.7)

Step 2: Defining Expectations

This is the core of EBAGM.

expectations = {
    "fairness": 0.9,
    "accuracy": 0.8,
    "privacy": 0.7
}

Here, fairness is prioritized.

⚖️ Step 3: Data Governance

If fairness is high, we remove sensitive attributes.

def apply_governance(data, expectations):
    data = data.copy()
    
    if expectations["fairness"] > 0.8:
        data = data.drop(columns=["gender"])
    
    return data

governed_data = apply_governance(data, expectations)

Step 4: Train the Model

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

X = governed_data.drop(columns=["approved"])
y = governed_data["approved"]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

model = LogisticRegression()
model.fit(X_train, y_train)

predictions = model.predict(X_test)

Step 5: Perceived Intent Score (PIS)

This is the key innovation.

Instead of just checking accuracy, we measure:

Does the model appear fair?

def perceived_intent_score(original_data, X_test, predictions, expectations):
    df = original_data.loc[X_test.index].copy()
    df["pred"] = predictions
    
    male_rate = df[df["gender"] == 1]["pred"].mean()
    female_rate = df[df["gender"] == 0]["pred"].mean()
    
    bias = abs(male_rate - female_rate)
    
    pis = 1 - (bias * expectations["fairness"])
    
    return round(pis, 3), round(bias, 3)

pis, bias = perceived_intent_score(data, X_test, predictions, expectations)

Step 6: Governance Feedback

def governance_feedback(pis, threshold=0.75):
    if pis < threshold:
        return "⚠️ Misalignment detected"
    else:
        return "✅ System aligned"

print(governance_feedback(pis))

Sample Output

Perceived Intent Score (PIS): 0.955
Bias: 0.05

✅ System aligned with expectations

Key Insight

Even though the model doesn’t explicitly optimize fairness, governance decisions (like removing gender) improved ethical alignment.

⚠️ Experiment: Lower Fairness

Change:

"fairness": 0.2

Now:

Gender is NOT removed
Bias increases
PIS drops

You may see:

⚠️ Misalignment detected

Why This Matters

Traditional AI governance focuses on:

Data quality
Model performance

EBAGM adds something new:

Human expectation alignment

This leads to three new concepts:

1. Expectation Misalignment

When AI is correct but feels wrong

2. Perceived Consciousness Risk

When humans think AI has intent

3. Utility vs Ethics Conflict

When optimization clashes with fairness

Final Thoughts

EBAGM is a simple but powerful idea:

AI systems shouldn’t just be correct—they should be aligned with human expectations.

This prototype shows how we can:

Embed ethics into pipelines
Quantify perceived fairness
Build adaptive governance systems

What’s Next?

You can extend this by:

Adding fairness metrics (demographic parity, equal opportunity)
Using real datasets (Kaggle)
Adding explainability (SHAP, LIME)
Running multi-scenario experiments

Closing Idea

“The future of AI governance is not just about controlling systems, but about aligning them with how humans expect them to behave.”

If you’re exploring AI ethics, data governance, or philosophy of AI—this is a space worth building in.

Let me know if you want the research paper version or a GitHub-ready project

Three Ways to Read from a Dict in Python

Fri, 23 Jan 2026 12:08:24 +0000

Reading values from a dictionary looks trivial in Python.

But depending on how you do it, you may introduce silent bugs, unexpected KeyErrors, or logic errors that only appear in production.

In this short tutorial, we’ll compare:

Direct indexing
dict.get()
dict.setdefault()

And see when each one is correct — and when it’s dangerous.

1. Direct indexing

config = {"timeout": 10}

timeout = config["timeout"]      # OK
retries = config["retries"]      # KeyError

When to use it

Use direct indexing only when the key must exist.

2. dict.get(): Safe Reads

timeout = config.get("timeout", 5)
retries = config.get("retries", 3)

When to use it

To avoid KeyErrors, when key doesn't exist
When key doesn't exist, want to return a default value

3. dict.setdefault(): Read + Initialize

counts = {}

counts.setdefault("apple", 0)
counts["apple"] += 1

When to use it

Whe a key doesn't exist, you want to create it.

Final rule of thumb

Use d[key] when the key must exist
Use get() when missing keys are normal
Use setdefault() only when initializing structures

Building a Production-Ready Ecommerce Backend with FastAPI

Sun, 18 Jan 2026 08:03:04 +0000

When learning backend development, most projects stop at CRUD APIs.
I wanted to go a step further and build a realistic ecommerce backend—one that follows industry practices, not shortcuts.

This blog walks through what I built, why I built it that way, and the key backend concepts involved.

Project Goal

To design a secure, scalable ecommerce backend that handles:

Authentication
Cart management
Checkout flow
Orders
Payments
Stock consistency
Password recovery
All while following real-world backend design principles.

Tech Stack

FastAPI – high-performance Python API framework
SQLAlchemy – ORM for database modeling
PostgreSQL – relational database
Alembic – database migrations
JWT – authentication
bcrypt – password hashing

Authentication & Security

Passwords are never stored in plain text.
Passwords are hashed using bcrypt
JWT is used for authentication
Password recovery is handled via secure, time-bound reset tokens
No password is ever decrypted or sent back to users
Password recovery is implemented by resetting, not revealing passwords.

Cart Design (Temporary State)

The cart is designed as a mutable, temporary state:

Users can add, update, or remove items
Only one active cart per user
Prices are snapshotted at the time of adding to cart
This prevents price mismatch issues during checkout.

Checkout (State Transition)

Checkout is a critical boundary:

Converts a cart into an immutable order
Validates stock
Calculates final price
Creates a PENDING order
Cart represents intent.
Checkout represents commitment.

Orders (Immutable Records)

Orders are treated as financial records:

Created only via checkout
Read-only for users
Status-based lifecycle: PENDING → PAID → CANCELLED
This ensures auditability and consistency.

Payments (Asynchronous & Safe)

Payments are handled separately from checkout:

Payment intents are created for orders
Payments are confirmed asynchronously
Stock is reduced only after payment success

This avoids overselling and handles real payment gateway behavior.

Stock Management

Stock updates are protected using row-level locking to avoid race conditions during concurrent purchases.

Stock is reduced only after confirmed payment—not during checkout.

API Documentation

Swagger (OpenAPI) is fully integrated:

Cleanly grouped APIs
Request & response schemas
JWT authorization support
Ready for frontend or third-party integration

Database Migrations

All schema changes are managed via Alembic migrations
No manual DB edits
Reproducible environments
Safe schema evolution

What I Learned

Why carts and orders must be separate
Why payments must be asynchronous
Why passwords must be irreversible
How ORM relationships fail if not symmetric
How real-world ecommerce systems prevent overselling

Source Code

The complete project is available on GitHub:
https://github.com/sanjay-dot/Ecommerce

Final Thoughts

This project helped me move from API writing to system thinking.

If you’re learning backend development, I highly recommend building projects that:

model real workflows
enforce correct state transitions
prioritize security from day one