DEV Community: Codes Me

4 Tiny Mistakes That Secretly Destroy App Performance

Codes Me — Tue, 19 May 2026 10:32:09 +0000

Introduction

You've optimized your database queries, you're using async where you can, and your code looks clean — yet your app still feels sluggish under load. The culprit is almost never where you expect. In this post, I'll walk through 4 tiny, easy-to-miss mistakes that quietly kill your app's performance, and exactly how to fix them with Python examples.

The Problem

Most performance bottlenecks don't come from big architectural flaws. They hide in small habits: blocking calls in async functions, unnecessary object creation in tight loops, unclosed resources, and ignoring caching for repeated computations. These compound silently and become critical at scale.

The Solution

Let's go through each mistake with a concrete Python example and the fix.

Mistake 1: Blocking I/O inside async functions
Using time.sleep() or synchronous requests inside an async function blocks the entire event loop.

Mistake 2: Creating objects inside tight loops
Reusing objects instead of recreating them on every iteration saves significant memory and CPU.

Mistake 3: Not closing resources properly
Unclosed file handles, DB connections, or HTTP sessions accumulate and exhaust system resources.

Mistake 4: Recomputing the same result repeatedly
If a function returns the same result for the same inputs, cache it — don't recompute.

import asyncio
import httpx
from functools import lru_cache
from contextlib import asynccontextmanager

# ❌ MISTAKE 1: blocking call inside async — kills event loop
async def bad_fetch():
    import time
    time.sleep(2)  # blocks everything!
    ...

# ✅ FIX 1: use await with async-compatible sleep / HTTP client
async def good_fetch(url: str):
    async with httpx.AsyncClient() as client:
        response = await client.get(url)
        return response.json()


# ❌ MISTAKE 2: object creation inside a tight loop
def bad_loop(data: list):
    results = []
    for item in data:
        prefix = "user_"  # recreated 10,000x
        results.append(prefix + str(item))
    return results

# ✅ FIX 2: hoist static objects outside the loop
def good_loop(data: list):
    prefix = "user_"  # created once
    return [prefix + str(item) for item in data]


# ❌ MISTAKE 3: resource leak — session never closed
def bad_session():
    import requests
    session = requests.Session()
    r = session.get("https://api.example.com/data")
    return r.json()
    # session is never closed — leak!

# ✅ FIX 3: always use context managers
def good_session():
    import requests
    with requests.Session() as session:
        r = session.get("https://api.example.com/data")
        return r.json()


# ❌ MISTAKE 4: recomputing the same expensive result
def bad_compute(n: int):
    total = 0
    for i in range(n):  # called 1000x with same n = same result
        total += i
    return total

# ✅ FIX 4: cache with lru_cache
@lru_cache(maxsize=128)
def good_compute(n: int):
    total = 0
    for i in range(n):
        total += i
    return total


# Demo
if __name__ == "__main__":
    # Test loop optimization
    data = list(range(10_000))
    print(good_loop(data[:5]))  # ['user_0', 'user_1', ...]

    # Test caching
    import time
    start = time.perf_counter()
    for _ in range(1000):
        good_compute(100_000)
    end = time.perf_counter()
    print(f"Cached compute x1000: {end - start:.4f}s")

    # Test async fetch
    async def main():
        result = await good_fetch("https://jsonplaceholder.typicode.com/todos/1")
        print("Fetched:", result)

    asyncio.run(main())

Result

By applying these 4 fixes you'll typically see:

2–10x faster async throughput by eliminating event loop blocking
Lower memory usage in loops processing large datasets
No more connection pool exhaustion thanks to proper resource cleanup
Near-instant repeated computation with lru_cache

Small changes, massive impact at scale.

Want more Python performance tips and automation projects? Check out codes-me.com — new content every week. Drop a comment with the mistake you've hit the most in production 👇

Enjoyed this article? Feel free to check out my profile for more Python tutorials, automation tips, and open-source projects.

Join the Gemma 4 Challenge: Build a Heatwave Alert Bot with Gemma 4 — $3,000 Prize Pool for TEN Winners!

Codes Me — Wed, 13 May 2026 19:19:42 +0000

Introduction

It's getting hot out there — literally. With heatwaves hitting record temperatures across the globe, I thought: why not build something useful with Gemma 4? This is my submission concept for the Gemma 4 Challenge: a heatwave alert system that uses the OpenWeatherMap API to fetch real-time temperatures and Gemma 4 to generate natural-language heat safety advice — then emails it to you automatically.

The Problem

Most weather apps just show you numbers. But what if you could get a personalized, AI-generated safety message when temperatures go dangerously high? And what if it ran silently in the background, checking every hour and alerting you only when needed? That's exactly what we're building today — and it's a great showcase for Gemma 4's text generation power in a real-world automation context.

The Solution

Here's the plan:

Fetch real-time temperature data from OpenWeatherMap API
If temp exceeds a threshold (e.g. 38°C), call Gemma 4 via the Google AI SDK to generate a heat safety message
Send the message by email using Python's built-in smtplib

This runs on a scheduler (APScheduler) so it checks automatically every hour. Clean, practical, and genuinely useful during summer.

import requests
import smtplib
import schedule
import time
from email.mime.text import MIMEText
from google import genai

# --- CONFIG ---
OWM_API_KEY = "your_openweathermap_api_key"
CITY = "Paris"
HEAT_THRESHOLD = 38  # Celsius
GEMINI_API_KEY = "your_google_ai_api_key"
EMAIL_SENDER = "your_email@gmail.com"
EMAIL_PASSWORD = "your_app_password"
EMAIL_RECEIVER = "recipient@example.com"

# --- FETCH TEMPERATURE ---
def get_temperature(city: str) -> float:
    url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={OWM_API_KEY}&units=metric"
    response = requests.get(url)
    response.raise_for_status()
    data = response.json()
    temp = data["main"]["temp"]
    print(f"[Weather] {city}: {temp}°C")
    return temp

# --- GENERATE SAFETY ADVICE WITH GEMMA 4 ---
def generate_heat_advice(city: str

Result

When the temperature in your chosen city crosses 38°C, you get an email like this:

🔴 Heatwave Alert in Paris — 41.2°C

⚠️ HEATWAVE ALERT ⚠️

Current temperature in Paris: 41.2°C

--- AI Safety Advice (powered by Gemma 4) ---
It's dangerously hot outside today! Make sure to drink at least 2 liters of water
throughout the day, avoid direct sun between 11am and 4pm, and wear light-colored,
loose clothing. Don't forget to check on elderly neighbors or family members who may
need help staying cool. Your health comes first! 💧

Stay safe,
Your Weather Bot 🤖

The bot runs silently in the background, checks every hour, and only fires when it truly matters. Gemma 4 adds real value here — the advice isn't generic, it's contextual and readable.

This is just the starting point. You could extend this to:

Monitor multiple cities at once
Add SMS alerts via Twilio
Store temperature history in a SQLite database
Deploy it on a Raspberry Pi or a free cloud VM

If you're entering the Gemma 4 Challenge, this project shows real-world utility, clean Python automation, and meaningful AI integration — exactly what the judges are looking for.

👉 Want more Python automation projects like this? Check out codes-me.com — I post tutorials, scripts, and challenges every week.

Drop your questions or ideas in the comments — I read everything! 🔥

Enjoyed this article? Feel free to check out my profile for more Python tutorials, automation tips, and open-source projects.

Join the Gemma 4 Challenge: Build a Heatwave Alert Bot with Gemma 4 — $3,000 Prize Pool for TEN Winners!

Codes Me — Wed, 13 May 2026 19:10:56 +0000

Introduction

The Problem

The Solution

Here's the plan:

Fetch real-time temperature data from OpenWeatherMap API
If temp exceeds a threshold (e.g. 38°C), call Gemma 4 via the Google AI SDK to generate a heat safety message
Send the message by email using Python's built-in smtplib

This runs on a scheduler (APScheduler) so it checks automatically every hour. Clean, practical, and genuinely useful during summer.

import requests
import smtplib
import schedule
import time
from email.mime.text import MIMEText
from google import genai

# --- CONFIG ---
OWM_API_KEY = "your_openweathermap_api_key"
CITY = "Paris"
HEAT_THRESHOLD = 38  # Celsius
GEMINI_API_KEY = "your_google_ai_api_key"
EMAIL_SENDER = "your_email@gmail.com"
EMAIL_PASSWORD = "your_app_password"
EMAIL_RECEIVER = "recipient@example.com"

# --- FETCH TEMPERATURE ---
def get_temperature(city: str) -> float:
    url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={OWM_API_KEY}&units=metric"
    response = requests.get(url)
    response.raise_for_status()
    data = response.json()
    temp = data["main"]["temp"]
    print(f"[Weather] {city}: {temp}°C")
    return temp

# --- GENERATE SAFETY ADVICE WITH GEMMA 4 ---
def generate_heat_advice(city: str

Result

When the temperature in your chosen city crosses 38°C, you get an email like this:

🔴 Heatwave Alert in Paris — 41.2°C

⚠️ HEATWAVE ALERT ⚠️

Current temperature in Paris: 41.2°C

--- AI Safety Advice (powered by Gemma 4) ---
It's dangerously hot outside today! Make sure to drink at least 2 liters of water
throughout the day, avoid direct sun between 11am and 4pm, and wear light-colored,
loose clothing. Don't forget to check on elderly neighbors or family members who may
need help staying cool. Your health comes first! 💧

Stay safe,
Your Weather Bot 🤖

The bot runs silently in the background, checks every hour, and only fires when it truly matters. Gemma 4 adds real value here — the advice isn't generic, it's contextual and readable.

This is just the starting point. You could extend this to:

Monitor multiple cities at once
Add SMS alerts via Twilio
Store temperature history in a SQLite database
Deploy it on a Raspberry Pi or a free cloud VM

If you're entering the Gemma 4 Challenge, this project shows real-world utility, clean Python automation, and meaningful AI integration — exactly what the judges are looking for.

👉 Want more Python automation projects like this? Check out codes-me.com — I post tutorials, scripts, and challenges every week.

Drop your questions or ideas in the comments — I read everything! 🔥

Enjoyed this article? Feel free to check out my profile for more Python tutorials, automation tips, and open-source projects.

Join the Gemma 4 Challenge: Can Python Detect a Ponzi Scheme? 🧠💸

Codes Me — Mon, 11 May 2026 18:15:00 +0000

Introduction

The word 'Ponzi' is trending — and for good reason. These fraudulent schemes collapse entire communities. But what if we could use Python + Gemma 4 to detect the patterns before the damage is done? In this post, I'll show you how to combine graph analysis with Google's Gemma 4 model to flag suspicious financial networks — and how this ties into the $3,000 Gemma Challenge.

The Problem

Ponzi schemes share a common structural fingerprint: a central node funnels money from many 'investors' while early participants are paid using new money. This creates a very specific graph topology. Detecting it manually is impossible at scale — but Python makes it tractable.

The Solution

We'll use NetworkX to model a financial transaction graph, then compute centrality metrics that expose Ponzi-like structures. We then pass a summary to Gemma 4 via the Google AI SDK to get an AI-powered risk verdict. Here's the full working pipeline:

import networkx as nx
import google.generativeai as genai
import random

# --- Configure Gemma 4 ---
genai.configure(api_key="YOUR_GOOGLE_AI_API_KEY")
model = genai.GenerativeModel("gemma-2-9b-it")  # Gemma 4 when available

# --- Build a fake transaction graph ---
def build_transaction_graph(n_nodes=20, ponzi_center=True):
    G = nx.DiGraph()
    nodes = [f"wallet_{i}" for i in range(n_nodes)]
    G.add_nodes_from(nodes)

    if ponzi_center:
        # Hub-and-spoke: all wallets send to wallet_0
        for node in nodes[1:]:
            G.add_edge(node, "wallet_0", amount=random.randint(100, 500))
        # wallet_0 redistributes to a few early adopters
        for node in nodes[1:4]:
            G.add_edge("wallet_0", node, amount=random.randint(50, 150))
    else:
        # Random normal transactions
        for _ in range(n_nodes * 2):
            src, dst = random.sample(nodes, 2)
            G.add_edge(src, dst, amount=random.randint(10, 300))

    return G

# --- Compute suspicion metrics ---
def analyze_graph(G):
    in_centrality = nx.in_degree_centrality(G)
    out_centrality = nx.out_degree_centrality(G)
    top_node = max(in_centrality, key=in_centrality.get)

    report = {\n        \"top_receiver\": top_node,\n        \"in_degree_score\": round(in_centrality[top_node], 3),\n        \"out_degree_score\": round(out_centrality[top_node], 3),\n        \"total_nodes\": G.number_of_nodes(),\n        \"total_edges\": G.number_of_edges(),\n    }\n    return report\n\n# --- Ask Gemma 4 for a verdict ---\ndef get_ai_verdict(report):\n    prompt = f\"\"\"\n    You are a financial fraud detection AI.\n    Analyze this transaction network report and decide if it looks like a Ponzi scheme.\n    \n    Report:\n    - Top receiver wallet: {report['top_receiver']}\n    - In-degree centrality score: {report['in_degree_score']} (1.0 = receives from everyone)\n    - Out-degree centrality score: {report['out_degree_score']}\n    - Network size: {report['total_nodes']} wallets, {report['total_edges']} transactions\n    \n    Respond with: RISK LEVEL (LOW/MEDIUM/HIGH), and one sentence of explanation.\n    \"\"\"\n    response = model.generate_content(prompt)\n    return response.text.strip()\n\n# --- Run the pipeline ---\nprint(\"=== Building suspicious graph ===\")\nG_ponzi = build_transaction_graph(ponzi_center=True)\nreport = analyze_graph(G_ponzi)\nprint(f\"Top node: {report['top_receiver']} | In-degree: {report['in_degree_score']}\")\n\nverdict = get_ai_verdict(report)\nprint(f\"\\n🤖 Gemma 4 Verdict:\\n{verdict}\")\n\nprint(\"\\n=== Building normal graph ===\")\nG_normal = build_transaction_graph(ponzi_center=False)\nreport2 = analyze_graph(G_normal)\nprint(f\"Top node: {report2['top_receiver']} | In-degree: {report2['in_degree_score']}\")\n\nverdict2 = get_ai_verdict(report2)\nprint(f\"\\n🤖 Gemma 4 Verdict:\\n{verdict2}\")",
    "resultat": "Running this script produces something like:\n\n```

\n=== Building suspicious graph ===\nTop node: wallet_0 | In-degree: 1.0\n\n🤖 Gemma 4 Verdict:\nRISK LEVEL: HIGH — The central wallet receives funds from every node in the network, a hallmark pattern of Ponzi and pyramid schemes.\n\n=== Building normal graph ===\nTop node: wallet_7 | In-degree: 0.15\n\n🤖 Gemma 4 Verdict:\nRISK LEVEL: LOW — Transaction flow appears distributed with no dominant central aggregator.\n

```\n\nThe combination of NetworkX's graph metrics + Gemma 4's reasoning gives you a powerful, explainable fraud detection pipeline in under 60 lines.",
    "cta": "This is my submission concept for the **Gemma 4 Challenge** ($3,000 prize pool, 10 winners!). The idea: use Gemma 4 not just as a chatbot, but as a reasoning layer on top of structured data analysis.\n\nWant to go further? Ideas to extend this:\n- Connect to real blockchain APIs (Etherscan, BSCScan)\n- Add time-series analysis of transaction velocity\n- Build a Streamlit dashboard to visualize the graph\n\n👉 More Python automation tutorials at **codes-me.com** — join the community and build cool things with me.",
    "tags": ["devchallenge", "gemmachallenge", "discuss", "gemma"]
  }

Result

Enjoyed this article? Feel free to check out my profile for more Python tutorials, automation tips, and open-source projects.

Cracking the Gemma 4 Challenge: A Python Dev's Guide to Text Preprocessing

Codes Me — Sun, 10 May 2026 16:34:43 +0000

Introduction

The Gemma 4 Challenge is here with a $3,000 prize pool! Are you ready to dive into AI? As Python developers, we have a unique advantage. This post will help you get started by mastering a crucial first step for any AI text-based project: effective text preprocessing.

The Problem

Many AI challenges, especially those involving large language models like Gemma, require clean, well-structured text data. Without proper preprocessing, your models can suffer from noise and inconsistencies, leading to suboptimal performance.

The Solution

Python offers powerful libraries to tackle text preprocessing. We'll explore a simple yet effective way to clean text, removing unwanted characters, normalizing case, and tokenizing words—essential steps before feeding data into any sophisticated AI model. This foundational skill is key to success in challenges like Gemma 4.

import re
from collections import Counter

def preprocess_text(text):
    # Convert to lowercase
    text = text.lower()
    # Remove special characters and numbers
    text = re.sub(r'[^a-z\s]', '', text)
    # Tokenize (split into words)
    words = text.split()
    return words

def analyze_word_frequency(words):
    return Counter(words)

sample_text = "Hello World! This is a test for the Gemma 4 Challenge, let's preprocess some text. Python is amazing!"
processed_words = preprocess_text(sample_text)
word_counts = analyze_word_frequency(processed_words)

print(f"Original text: {sample_text}")
print(f"Processed words: {processed_words}")
print(f"Word frequencies: {word_counts}")

# Example of a more complex text for the challenge
challenge_text = "The Gemma 4 AI Challenge offers a $3,000 prize for innovative solutions. Participants should focus on data quality and model efficiency. Join now!"
challenge_words = preprocess_text(challenge_text)
challenge_freq = analyze_word_frequency(challenge_words)
print(f"\nChallenge text processed: {challenge_words}")
print(f"Challenge word frequencies: {challenge_freq}")

Result

This Python script provides a solid starting point for text preprocessing. By cleaning and tokenizing your data, you prepare it for more advanced AI tasks, increasing your chances of success in challenges like the Gemma 4. Get your data ready, build robust models, and compete for those prizes!

Ready to sharpen your AI skills? Explore more Python tips and tricks for data science and AI at codes-me.com.

Enjoyed this article? Feel free to check out my profile for more Python tutorials, automation tips, and open-source projects.

I Love Tailwind. Sorry Not Sorry – How Python Can Help Your Workflow

Codes Me — Thu, 07 May 2026 18:13:32 +0000

Introduction

Tailwind CSS has become a game-changer for many web developers, myself included. Its utility-first approach drastically speeds up development and keeps your CSS lean. But even with the best tools, we can always find ways to optimize our workflow. Today, I want to show you how a little Python script can assist in understanding and managing your Tailwind CSS usage, bridging the gap between design and data.

The Problem

When working on large projects, or inheriting an existing codebase, it can sometimes be challenging to get a quick overview of the Tailwind classes being used. You might want to quickly identify common patterns, count unique classes, or even just get a sense of the CSS utility diversity. Manually sifting through HTML files is tedious and error-prone.

The Solution

Python, with its powerful string manipulation and regex capabilities, is perfect for this kind of task. We can write a simple script to parse HTML content, extract all class attributes, and then identify and count the unique Tailwind utility classes. This isn't a full CSS parser, but a practical utility to gain insights into your project's styling footprint. Below is a function that takes HTML content and returns the count of potential Tailwind classes, along with a list of those classes.

import re

def count_tailwind_classes(html_content):
    """
    Parses HTML content to find and count potential Tailwind CSS classes.
    This is a simplified approach, focusing on common Tailwind patterns.
    """
    tailwind_classes = set()
    # Find all class attributes
    class_attributes = re.findall(r'class=["\']([^"\']*)["\']', html_content)

    for classes_str in class_attributes:
        for cls in classes_str.split():
            # A heuristic to identify Tailwind classes:
            # - Contains a hyphen (e.g., 'text-xl', 'bg-blue-500', 'p-4')
            # - Is a common single-word utility (e.g., 'flex', 'block', 'hidden')
            if '-' in cls or cls in ['flex', 'block', 'hidden', 'relative', 'absolute', 'fixed']:
                tailwind_classes.add(cls)
    return len(tailwind_classes), sorted(list(tailwind_classes))

sample_html = """
<div class="flex items-center justify-between p-4 bg-gray-800 text-white">
    <h1 class="text-xl font-bold">My Awesome App</h1>
    <nav>
        <a href="#" class="text-blue-400 hover:text-blue-600 mx-2">Home</a>
        <a href="#" class="text-blue-400 hover:text-blue-600 mx-2">About</a>
    </nav>
</div>
<p class="mt-4 text-gray-700">This is some content without specific tailwind classes.</p>
<button class="btn-primary">Click Me</button> <!-- Not a tailwind class by default -->
"""

num_classes, unique_classes = count_tailwind_classes(sample_html)
print(f"Found {num_classes} potential Tailwind classes in the sample HTML.")
print(f"Unique classes: {', '.join(unique_classes)}")

Result

Running this script on our sample_html will output the number of distinct Tailwind-like classes detected and list them. This gives you an immediate snapshot of your project's CSS vocabulary. While simple, this script can be a foundation for more complex analysis, such as identifying unused classes (though that requires more advanced tooling) or creating a custom style guide based on your actual usage. It demonstrates how Python can be a versatile companion in your front-end development toolkit, even for tasks seemingly unrelated to its core strengths.

Want to build more insightful tools for your web development? Explore Python automation and web scraping techniques at codes-me.com.

🌐 Find me across the web

🌐 Website: https://codes-me.com/
💻 Dev.to: https://dev.to/codes_me_734c93c2eb65de65
🔗 Hashnode: https://hashnode.com/@codes-me
💼 LinkedIn: https://www.linkedin.com/in/alexandre-thiebaut-828133377/
🐦 X: https://x.com/CodesMe344929
🐙 GitHub: https://github.com/codesme34
📺 YouTube: https://www.youtube.com/@CodesMe
👥 Facebook: https://www.facebook.com/Codesme34
🤝 Reddit: https://www.reddit.com/user/codes_me/

How I Built a Real-Time Euro 2026 Score Tracker with Python Automation

Codes Me — Wed, 06 May 2026 18:28:17 +0000

Introduction

The Euro 2026 is heating up, with France in the semi-finals! As a football fan and a Python enthusiast, I wanted a way to stay updated on scores and critical match events without constantly checking my phone. So, I built a simple yet powerful Python bot to do just that. In this article, I'll walk you through the process, from data fetching to real-time notifications.

The Problem

Missing crucial updates during live football matches, or having to manually refresh websites for scores and events. The goal was to create an automated system that provides instant alerts for goals, red cards, or match status changes for the ongoing Euro 2026.

The Solution

I decided to use Python for its versatility in web scraping and automation. The core idea involves periodically scraping a reliable sports data website (like a specific sports news site or a public API if available) for match data, parsing it, and then sending notifications via a platform like Telegram or a custom email. We'll leverage requests and BeautifulSoup for web scraping, and a simple time.sleep for polling intervals. For demonstration, let's assume we're scraping a hypothetical euro2026-scores.com.

import requests
from bs4 import BeautifulSoup
import time

def get_euro_scores():
    url = "https://www.example.com/euro2026-scores" # Replace with actual URL
    headers = {'User-Agent': 'Mozilla/5.0'}
    try:
        response = requests.get(url, headers=headers)
        response.raise_for_status() # Raise an exception for HTTP errors
        soup = BeautifulSoup(response.text, 'html.parser')

        # --- Simplified example for demonstration ---
        # Assume scores are in a div with class 'match-score'
        score_elements = soup.find_all('div', class_='match-score')
        scores = []
        for element in score_elements:
            match_info = element.get_text(strip=True)
            scores.append(match_info)
        return scores
    except requests.exceptions.RequestException as e:
        print(f"Error fetching data: {e}")
        return []

def send_notification(message):
    # Placeholder for actual notification logic (e.g., Telegram bot, email, push service)
    print(f"NOTIFICATION: {message}")

if __name__ == "__main__":
    last_scores = []
    print("Starting Euro 2026 Bot...")
    while True:
        current_scores = get_euro_scores()
        if current_scores and current_scores != last_scores:
            print("New scores detected!")
            for score in current_scores:
                if score not in last_scores: # Only notify for new/changed scores
                    send_notification(f"Euro 2026 Update: {score}")
            last_scores = current_scores
        else:
            print("No new updates.")
        time.sleep(60) # Check every 60 seconds

Result

With this Python script, I now receive real-time updates on Euro 2026 matches directly to my preferred notification channel. No more missing crucial moments or constantly checking multiple sources. This bot efficiently fetches, processes, and alerts, making sure I'm always in the loop.

This simple project demonstrates the power of Python for real-time data monitoring. If you're looking to automate data extraction, monitoring, or any other manual tasks for your business, visit codes-me.com. We offer custom Web Scraping, Automation, and Alert Bots services. Don't forget to check out our free Email Scraper and IP Geolocator tools on codes-me.com for other useful utilities!

7 Python Scripts to Automate Your Daily Tasks in 2026

Codes Me — Tue, 05 May 2026 10:59:02 +0000

Automating repetitive tasks is one of the highest-ROI things you can do as a developer in 2026. Here are 7 ready-to-use Python scripts that will save you hours every week.

1. Bulk Rename Files in One Second

from pathlib import Path

folder = Path("./my_files")
for i, file in enumerate(folder.iterdir()):
    new_name = f"document_{i+1}{file.suffix}"
    file.rename(folder / new_name)
    print(f"Renamed: {new_name}")

Use cases: client photos, CSV exports, monthly reports.

2. Send Automated Emails with Attachments

import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email.mime.text import MIMEText
from email import encoders

def send_email(to, subject, body, attachment=None):
    msg = MIMEMultipart()
    msg["From"] = "you@gmail.com"
    msg["To"] = to
    msg["Subject"] = subject
    msg.attach(MIMEText(body, "plain"))

    if attachment:
        with open(attachment, "rb") as f:
            part = MIMEBase("application", "octet-stream")
            part.set_payload(f.read())
            encoders.encode_base64(part)
            part.add_header("Content-Disposition", f"attachment; filename={attachment}")
            msg.attach(part)

    with smtplib.SMTP_SSL("smtp.gmail.com", 465) as server:
        server.login("you@gmail.com", "your_app_password")
        server.send_message(msg)
        print(f"Email sent to {to}")

send_email("client@example.com", "Your Weekly Report", "Hi, please find the report attached.", "report.pdf")

3. Scrape E-Commerce Prices

import requests
from bs4 import BeautifulSoup

def scrape_price(url):
    headers = {"User-Agent": "Mozilla/5.0"}
    response = requests.get(url, headers=headers)
    soup = BeautifulSoup(response.text, "html.parser")
    title = soup.find("h1").text.strip()
    price = soup.find(class_="price").text.strip()
    print(f"Product : {title}")
    print(f"Price   : {price}")
    return {"title": title, "price": price}

Use cases: competitive monitoring, price alerts.

4. Auto-Generate a PDF Report

from fpdf import FPDF
from datetime import datetime

def generate_report(data: list[dict], filename="report.pdf"):
    pdf = FPDF()
    pdf.add_page()
    pdf.set_font("Arial", "B", 16)
    pdf.cell(0, 10, f"Report — {datetime.now().strftime('%Y-%m-%d')}", ln=True)
    pdf.set_font("Arial", size=12)
    for row in data:
        pdf.cell(0, 8, f"- {row['label']}: {row['value']}", ln=True)
    pdf.output(filename)

generate_report([
    {"label": "Revenue", "value": "$12,340"},
    {"label": "New clients", "value": "47"},
])

5. Monitor a Website and Get Alerts

import requests, time

def monitor(url, interval=60):
    while True:
        try:
            r = requests.get(url, timeout=10)
            status = "Online" if r.status_code == 200 else f"Error {r.status_code}"
        except requests.ConnectionError:
            status = "Offline"
        print(f"[{time.strftime('%H:%M:%S')}] {url} — {status}")
        time.sleep(interval)

monitor("https://codes-me.com")

6. Clean and Deduplicate a CSV File

import pandas as pd

df = pd.read_csv("contacts.csv")
before = len(df)
df = df.drop_duplicates(subset=["email"]).dropna(subset=["email", "name"])
df["email"] = df["email"].str.lower().str.strip()
df.to_csv("contacts_clean.csv", index=False)
print(f"{before - len(df)} rows removed. {len(df)} contacts kept.")

7. Batch Download Files from the Web

import requests
from pathlib import Path

def download_files(urls: list[str], folder="./downloads"):
    Path(folder).mkdir(exist_ok=True)
    for url in urls:
        name = url.split("/")[-1]
        r = requests.get(url, stream=True)
        with open(f"{folder}/{name}", "wb") as f:
            for chunk in r.iter_content(chunk_size=8192):
                f.write(chunk)
        print(f"Downloaded: {name}")

Conclusion

These 7 scripts cover the most common automation use cases. With just a few lines of Python, you can eliminate hours of manual work every week.

Need something more advanced — scraping pipelines, API integrations, real-time dashboards? Check out codes-me.com — we build custom automation tools tailored to your needs.

Which script would save you the most time? Drop it in the comments!

I built a set of free tools !!!

Codes Me — Fri, 01 May 2026 16:48:50 +0000

Here's what's available right now:

1. 📧 Email & Phone Scraper

Paste a list of website URLs, get back emails, phone numbers, and Facebook links — automatically.

What it does:

Scrapes the homepage and the contact page of each URL
Decodes CloudFlare-protected emails (data-cfemail)
Bypasses basic bot protection (curl_cffi Chrome impersonation)
Returns a clean table you can export

Why I built it:
Most scrapers break on Wix/Squarespace sites or miss +33 formatted phone numbers. This one handles split spans, JSON-LD structured data, and obfuscated mailto links.

Free limit: 10 URLs/day — more than enough for prospecting.

2. 🌍 IP Geolocation Tool

Enter any IP address and get detailed info: country, city, ISP, ASN, timezone, VPN/proxy detection.

What it does:

Detects your own IP automatically
Shows an interactive map pinpointing the location
Identifies VPNs, Tor exit nodes, and datacenter IPs
Copy/export results in one click

Useful for debugging regional issues, verifying CDN routing, or checking if a user is behind a proxy.

3. 📊 JSON / CSV → Excel Converter

Upload a JSON or CSV file, get a formatted .xlsx back instantly — in the browser, no server upload.

What it does:

Handles nested JSON (flattens it automatically)
Preserves column types (numbers stay numbers)
Works entirely client-side — your data never leaves your machine

Great for quick data prep before sending to a non-technical client.

4. 📱 QR Code Generator

Generates QR codes for URLs, plain text, emails, phone numbers, WiFi credentials, and vCards.

What it does:

Custom colors and background
Adjustable size and error correction level
Download as PNG instantly

Stack

Backend: Python / Flask, deployed on o2switch (French hosting)
Frontend: React + Tailwind CSS
Scraper engine: curl_cffi for anti-bot bypass + lxml for HTML parsing
Geolocation: ip-api.com
QR: qrcode JS library, runs 100% client-side

Try it

👉 codes-me.com/outils-gratuits

All tools are free, no account required. If you need something custom (higher limits, API access, bulk processing), there's a contact form on the site.

Built by a small digital agency in France. Feedback welcome in the comments.

Stop Getting Blocked: Recon Your Target Website Before Scraping It

Codes Me — Thu, 30 Apr 2026 16:01:46 +0000

The problem

You spend hours writing a scraper, run it, and immediately get a 403.
Or you build it with requests, only to realize the site needs JavaScript to render.

I got tired of this loop, so I built scrapalyser — a Python library that scans
any website before you write a single line of scraper code.

Install

pip install scrapalyser

Usage

import scrapalyser

report = scrapalyser.scan(
url="https://example.com",
output="txt",
lang="en",
)

What it detects

Anti-bot: Cloudflare, DataDome, PerimeterX, Akamai, Kasada, reCAPTCHA, hCaptcha
Tech stack: React, Vue, Angular, Next.js, Nuxt, WordPress, Shopify...
JS required: so you know if requests is enough or if you need Playwright
API endpoints: via CSP headers, inline scripts, or XHR interception (Playwright mode)
robots.txt & sitemap
Login wall: form, redirect, button, OAuth

Two engines

curl_cffi (default): fast, no browser, one HTTP request.

playwright: full browser with XHR interception and screenshot.

report = scrapalyser.scan(
url="https://example.com",
engine="playwright",
headless=False,
screenshot="capture.png",
)

If you get blocked

If the site returns a 403 or a captcha page, the report immediately tells you
which antibot blocked you — all other fields return "blocked by antibot".
No guessing.

DEV Community: Codes Me

4 Tiny Mistakes That Secretly Destroy App Performance

Introduction

The Problem

The Solution

Result

Join the Gemma 4 Challenge: Build a Heatwave Alert Bot with Gemma 4 — $3,000 Prize Pool for TEN Winners!

Introduction

The Problem

The Solution

Result

Join the Gemma 4 Challenge: Build a Heatwave Alert Bot with Gemma 4 — $3,000 Prize Pool for TEN Winners!

Introduction

The Problem

The Solution

Result

Join the Gemma 4 Challenge: Can Python Detect a Ponzi Scheme? 🧠💸

Introduction

The Problem

The Solution

Result

Cracking the Gemma 4 Challenge: A Python Dev's Guide to Text Preprocessing

Introduction

The Problem

The Solution

Result

I Love Tailwind. Sorry Not Sorry – How Python Can Help Your Workflow

Introduction

The Problem

The Solution

Result

🌐 Find me across the web

How I Built a Real-Time Euro 2026 Score Tracker with Python Automation

Introduction

The Problem

The Solution

Result

7 Python Scripts to Automate Your Daily Tasks in 2026

1. Bulk Rename Files in One Second

2. Send Automated Emails with Attachments

3. Scrape E-Commerce Prices

4. Auto-Generate a PDF Report

5. Monitor a Website and Get Alerts

6. Clean and Deduplicate a CSV File

7. Batch Download Files from the Web

Conclusion

I built a set of free tools !!!

1. 📧 Email & Phone Scraper

2. 🌍 IP Geolocation Tool

3. 📊 JSON / CSV → Excel Converter

4. 📱 QR Code Generator

Stack

Try it

Stop Getting Blocked: Recon Your Target Website Before Scraping It

The problem

Install

Usage

What it detects

Two engines

If you get blocked

Links