DEV Community: qing

How to Use OpenAI API to Build Profitable Apps

qing — Wed, 26 Aug 2026 20:00:54 +0000

How to Use OpenAI API to Build Profitable Apps

tags: python, mobile, kivy, money

How to Build Profitable Mobile Apps as a Python Dev

You’ve spent years mastering Python for data science, backend APIs, and automation, but the mobile world feels like a foreign country dominated by Swift and Kotlin. The good news? You don’t need to abandon your favorite language to build a mobile app that generates real revenue. While Python isn’t natively compiled for mobile like JavaScript (via React Native) or Dart (via Flutter), frameworks like Kivy and BeeWare let you write cross-platform mobile apps entirely in Python. The secret to profitability isn’t just writing code—it’s leveraging Python’s unique strengths in AI, data processing, and rapid backend development to solve problems other devs can’t.

Here is your actionable roadmap to building, launching, and monetizing a profitable mobile app using Python, without ever touching a line of Swift.

Choose the Right Framework for Your Business Model

The first mistake many Python devs make is picking a framework based on hype rather than business goals. Your choice dictates how easily you can monetize, scale, and update your app.

Kivy: The UI Powerhouse

Kivy is ideal for apps that need complex, custom interfaces or heavy offline functionality. It uses a .kv file system for layouts, separating UI from logic, which makes maintenance easier as your app grows.

Best for: Data-heavy apps, games, and tools requiring custom UI widgets.
Monetization: Excellent support for native ads and in-app purchases via plugins like pyjnius (Android) and pyobjus (iOS).
Packaging: Use Buildozer to generate APKs for Android and PyInstaller for iOS (though iOS requires Xcode).

BeeWare (Briefcase): The Native Look

If your goal is to look like a standard native app on both iOS and Android without a custom UI overhaul, BeeWare is your winner. It uses native widget sets, meaning your app feels like it was built with Swift or Kotlin, but you wrote it in Python.

Best for: Business tools, productivity apps, and simple utilities where "native feel" drives user trust.
Monetization: Seamless integration with platform-specific payment APIs because it uses native widgets.
Packaging: Use the briefcase command to build platform-specific binaries effortlessly.

Build an AI-Driven Backend That Sells

Your frontend might be Python, but your profit engine will likely be your Python backend. Mobile users pay for value, and Python is the undisputed king of AI and data. Instead of building a simple CRUD app, build an app that solves a complex problem using machine learning.

Start by defining the core business problem your app solves. Is it a fitness app that uses object detection to count reps? A finance app that predicts market trends? Or a language app that uses speech recognition?

Design a scalable architecture where the mobile frontend (Kivy/BeeWare) communicates with a FastAPI or Django backend. FastAPI is particularly powerful for AI-heavy apps due to its async capabilities and automatic documentation.

A Working Python Code Example: The Monetizable AI Feature

Here is a practical example of a backend API using FastAPI that processes user-uploaded images to detect objects—a feature you can easily monetize as a "Pro" subscription.

from fastapi import FastAPI, UploadFile, File
from PIL import Image
import io

app = FastAPI()

# Mock function for AI detection (replace with real TensorFlow/PyTorch model)
def detect_objects(image: Image.Image) -> list:
    # In a real app, load your model and run inference here
    return ["dog", "ball", "grass"]

@app.post("/analyze-image/")
async def analyze_image(file: UploadFile = File()):
    """
    Analyzes an uploaded image and returns detected objects.
    Monetize this endpoint by limiting free users to 1 scan/day.
    """
    contents = await file.read()
    image = Image.open(io.BytesIO(contents))

    detected = detect_objects(image)

    return {
        "status": "success",
        "objects_detected": detected,
        "confidence_score": 0.95
    }

This code snippet is the core of your value proposition. You can wrap this API in a subscription model using Stripe or RevenueCat. Free users get one scan; premium users get unlimited scans and detailed analytics.

Monetization Strategies That Actually Work for Python Apps

Once you have a working app, how do you turn it into revenue? Don’t rely on a single method. Successful Python mobile apps often combine several strategies.

1. The "Freemium" AI Model

This is the most effective strategy for Python devs. Offer basic functionality for free (e.g., standard text analysis) and charge for AI-powered features (e.g., predictive analytics, image recognition, or natural language generation). Since Python handles ML libraries like TensorFlow, NumPy, and Pandas effortlessly, you can build features that competitors using only JavaScript might struggle to implement efficiently.

2. In-App Subscriptions via RevenueCat

For iOS and Android, RevenueCat is the gold standard for managing subscriptions. It handles the complex logic of receipt validation and server-side notifications. You can integrate it with your Python backend to unlock premium features.

3. Niche B2B Solutions

Don’t just build another generic game. Build a tool for a specific industry. Python is perfect for data visualization and automation. Consider building a logistics tracker for small delivery companies or a medical data analyzer for private clinics. These B2B apps often command higher prices and have lower churn rates than consumer apps.

From Code to Cash: Deployment and Testing

Writing the code is only half the battle. To be profitable, your app must be stable, fast, and compliant with store guidelines.

Rigorous Testing on Real Devices

Emulators are great, but they miss memory issues and layout quirks that happen on real hardware. Use Android Studio emulators for Android and TestFlight for iOS. Test your app on older devices too; optimizing Python modules to avoid sluggish performance on legacy hardware is critical for user retention.

Packaging for the Stores

For Android: Use Buildozer with Kivy to generate your APK. Ensure you’ve configured the AndroidManifest.xml correctly for permissions (camera, storage, network).
For iOS: Use Briefcase with BeeWare. You must have Xcode installed and a valid Apple Developer account. The build process can take 30+ minutes, so plan accordingly.

CI/CD for Profit

Don’t let a broken update kill your revenue. Set up CI/CD pipelines (using GitHub Actions or GitLab CI) to automatically test and build your app. This ensures that future updates don’t break what’s already working, keeping your user base happy and your subscription revenue steady.

Launch and Iterate: The Profit Loop

Your first launch isn’t the finish line; it’s the starting point. Prepare your store listings with high-quality screenshots and concise descriptions that highlight your AI features. Comply with Google and Apple’s review guidelines early to avoid rejection delays.

Once live, monitor your analytics. Use libraries to track user behavior and identify where users drop off. If your "Pro" feature isn’t converting, tweak the pricing or the onboarding flow.

Start Building Your First Profitable App Today

You don’t need to be a Swift expert to build a mobile business. Your Python skills are your unfair advantage. By combining Kivy or BeeWare for the frontend with a powerful FastAPI backend for AI, you can create apps that solve real problems and generate revenue.

Your Action Plan for Today:

Pick a niche: Identify a problem you can solve with AI or data.
Install the tool: Run pip install kivy or briefcase new to start your project.
Build the core: Write the API endpoint that solves the problem (use the code example above as a template).
Package it: Generate your first APK or IPA.

The mobile market is hungry for smart, data-driven apps. Stop waiting for the "perfect" idea and start building the one you can monetize today. Your next paycheck might just come from a Python script running on someone’s phone.

If you found this helpful, consider buying me a coffee ☕ — it keeps these articles coming!

Also check out my AI tools collection: AI 次元世界 — free AI tools for developers.

Build a Slack Bot That Automates Your Workflow

qing — Wed, 26 Aug 2026 20:00:49 +0000

Build a Slack Bot That Automates Your Workflow

tags: python, slack, bot, automation

Imagine your team is drowning in repetitive tasks: manually copying data from emails to spreadsheets, scheduling recurring meetings, or chasing people for status updates. You’re not lazy—you’re just wasting precious brainpower on things a bot could handle in seconds. The good news? You don’t need a engineering degree or a months-long project to fix this. With a few lines of Python and Slack’s powerful API, you can build a custom Slack bot that automates your workflow today.

Let’s get practical. This isn’t about theory—it’s about shipping a working bot that saves you time immediately.

Why Build a Slack Bot Instead of Using Built-in Tools?

Slack offers Workflow Builder, a no-code tool for automations [3][4]. It’s great for simple triggers like “send a reminder every Monday” or “post a new GitHub issue to a channel.” But Workflow Builder has limits: it can’t fetch dynamic data from external APIs, process complex logic, or integrate with services Slack doesn’t natively support.

A custom Python bot, on the other hand, gives you full control. You can:

Query your database, CRM, or analytics tools
Parse JSON responses and format them into Slack messages
Handle errors, retries, and conditional logic
Scale to hundreds of users without hitting no-code platform limits

If you need real automation—not just reminders—a bot is your best bet.

Step 1: Create Your Slack App and Bot User

Before writing code, you need a Slack app with bot permissions. Here’s how:

Go to Slack API and click Your Apps > Create New App.
Name your app (e.g., WorkflowBot) and select your workspace.
In the Features section, enable Bot Token Scopes. Add these essential scopes:
- chat:write (to post messages)
- commands (to handle slash commands)
- im:write (to send direct messages)
Under OAuth & Permissions, click Install App to Workspace.
Copy the Bot User OAuth Token (starts with xoxb-). You’ll need this to authenticate your bot.

⚠️ Never share this token. Store it in an environment variable, not in your code.

Step 2: Set Up Your Python Environment

You’ll need Python 3.7+ and the slack-bolt library, which simplifies handling Slack events and commands.

pip install slack-bolt python-dotenv

Create a .env file in your project folder:

SLACK_BOT_TOKEN=xoxb-your-bot-token-here
SLACK_SIGNING_SECRET=your-signing-secret-here

Grab the Signing Secret from your Slack app page under Basic Information.

Step 3: Write Your First Automating Bot

Here’s a complete, working example that listens for a /status slash command, fetches data from an external API (we’ll use a mock endpoint), and posts a formatted summary to Slack.

from slack_bolt import Bolt
from slack_bolt.adapter.lambda_handler import handle_request
import os
import requests
from dotenv import load_dotenv

load_dotenv()

app = Bolt(
    token=os.environ["SLACK_BOT_TOKEN"],
    signing_secret=os.environ["SLACK_SIGNING_SECRET"]
)

@app.command("/status")
def handle_status_command(ack, command, client):
    ack()  # Acknowledge the command immediately

    # Fetch data from external API (replace with your real endpoint)
    try:
        response = requests.get("https://api.example.com/status", timeout=5)
        data = response.json()
    except Exception as e:
        data = {"error": str(e)}

    # Format the message
    if "error" in data:
        message = f"❌ Failed to fetch status: {data['error']}"
    else:
        status = data.get("status", "unknown")
        uptime = data.get("uptime", "N/A")
        message = f"✅ **System Status**: {status}\n⏱️ **Uptime**: {uptime} hours"

    # Post to the channel where the command was used
    client.chat_postMessage(
        channel=command["channel_id"],
        text=message,
        reply_broadcast=False
    )

if __name__ == "__main__":
    app.start(port=3000)

How It Works

When a user types /status in Slack, the bot triggers handle_status_command.
It calls an external API (swap https://api.example.com/status with your real endpoint).
It formats the response into a clean Slack message with emojis and bold text.
The message is posted back to the same channel.

Run this locally with:

python bot.py

For production, deploy it to AWS Lambda, Google Cloud Functions, or any server that can handle HTTP requests.

Step 4: Automate Real Workflows Today

Now that your bot is running, here are three actionable automations you can implement immediately:

1. Daily Digest of Sales Metrics

Set a time-based trigger (using a cron job or cloud scheduler) to call your bot’s internal endpoint. The bot fetches your sales dashboard API, summarizes the data, and posts it to a Slack channel every morning.

2. Auto-Remind Team Members Before Deadlines

Use Slack’s im:write scope to send direct messages. When a Jira or Asana task is updated, your bot checks the due date and sends a reminder 24 hours before if it’s overdue.

3. Interactive Onboarding Checklist

Create a slash command /onboard that posts a checklist with buttons (“Task 1”, “Task 2”). When a user clicks a button, the bot updates the message to mark it complete and logs the progress in your database.

Bonus: No-Code Alternative for Quick Wins

If Python feels too heavy right now, Slack’s Workflow Builder is a great starting point for simple automations [3][6]. You can:

Create workflows from templates (e.g., “New Employee Onboarding”)
Trigger actions based on keywords, forms, or time
Post messages, assign tasks, or tag team members

But remember: once you hit the limits of no-code logic, a custom bot is your next step.

Your Next Move

Don’t wait for “the perfect time.” Build this bot today:

Create your Slack app and get your token.
Install slack-bolt and write the code above.
Test it with /status in your Slack channel.
Replace the mock API with your real data source.

In under an hour, you’ll have a bot that automates a real part of your workflow. And once you see how much time you save, you’ll start building more.

What’s the first task you’ll automate? Share your bot idea in the comments—or drop a link if you’ve already built one. Let’s automate the boring stuff together.

If you found this helpful, consider buying me a coffee ☕ — it keeps these articles coming!

Also check out my AI tools collection: AI 次元世界 — free AI tools for developers.

Python Context Managers: The Complete Guide

qing — Wed, 26 Aug 2026 20:00:08 +0000

Python Context Managers: The Complete Guide

tags: python, programming, tutorial, advanced

You’ve probably written code like this before:

f = open("data.txt")
try:
    content = f.read()
finally:
    f.close()

It works, but it’s tedious, fragile, and easy to forget. What if you could replace that entire block with two lines that automatically handle opening, reading, and closing—even if an exception crashes your program? That’s exactly what Python context managers do, and once you master them, you’ll write cleaner, safer, and more professional code.

What Is a Context Manager?

A context manager is an object that defines how to set up and clean up a block of code. It implements the context management protocol: two methods, __enter__() and __exit__(). When you use the with statement, Python calls __enter__() at the start and __exit__() at the end, regardless of whether the block succeeded or raised an error [1][9].

This pattern factors out standard uses of try/finally, making resource handling reliable and boilerplate-free [7].

Common uses include:

Files and sockets
Database connections
Locks and synchronization
Transactions
Temporary state changes
Timing and profiling [1]

Why You Should Use Them TODAY

Context managers give you three massive benefits:

Automatic cleanup: Resources are released even if exceptions occur [1].
Cleaner code: No manual try/finally blocks cluttering your logic [1].
Reliable patterns: It’s hard to forget cleanup because the syntax enforces it [1].

If you’re still manually calling .close(), .release(), or .disconnect() after every operation, you’re already losing. Context managers fix that.

How to Use the Built-in `with` Statement

Python’s built-in with statement is your gateway. Most standard objects already support it:

with open("data.txt", "r") as f:
    content = f.read()
# File is automatically closed here, even if an exception occurs

Behind the scenes, open() returns a context manager. Python calls f.__enter__() to get the file object, runs your code, then calls f.__exit__() to close it [9].

You can chain multiple resources:

with open("input.txt") as inp, open("output.txt", "w") as out:
    out.write(inp.read())

Creating Your Own Context Manager: Class-Based

When you need to manage state or handle complex setup/teardown, create a class with __enter__ and __exit__:

class DatabaseConnection:
    def __init__(self, db_path):
        self.db_path = db_path
        self.conn = None

    def __enter__(self):
        print(f"Connecting to {self.db_path}")
        self.conn = self._connect()  # hypothetical method
        return self.conn

    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.conn:
            print("Closing connection")
            self.conn.close()
        # Return False to propagate exceptions, True to suppress
        return False

# Usage
with DatabaseConnection("mydb.sqlite") as conn:
    result = conn.query("SELECT * FROM users")
# Connection is guaranteed to close

The __exit__ method receives exception details if one occurred. Returning False lets the exception propagate; True suppresses it [6].

The Easier Way: `@contextmanager` Decorator

For simple cases, the @contextmanager decorator from contextlib lets you write a context manager as a generator. This is often the nicest and easiest approach [7].

from contextlib import contextmanager

@contextmanager
def timed_block(label):
    import time
    start = time.time()
    print(f"Starting {label}")
    yield  # code inside 'with' runs here
    end = time.time()
    print(f"{label} took {end - start:.4f}s")

# Usage
with timed_block("data processing"):
    total = sum(range(10_000_000))

The yield marks where the with block executes. Everything before yield is setup; everything after is teardown [7].

This approach is perfect for:

Timing and profiling
Temporary state changes
Simple locks or transactions [1]

Managing Multiple Dynamic Resources: `ExitStack`

What if you need to open resources dynamically, like reading files from a list? ExitStack handles this elegantly:

from contextlib import ExitStack

def process_files(file_paths):
    with ExitStack() as stack:
        for path in file_paths:
            f = stack.enter_context(open(path, "r"))
            print(f.read())
        # All files closed automatically, even on exception

ExitStack lets you push context managers dynamically and ensures they’re all cleaned up in reverse order [1].

Async Context Managers: `asynccontextmanager`

When working with async code, use asynccontextmanager and async with:

from contextlib import asynccontextmanager

@asynccontextmanager
async def async_db_connection(url):
    conn = await connect(url)  # hypothetical
    try:
        yield conn
    finally:
        await conn.close()

# Usage
async with async_db_connection("postgres://localhost") as conn:
    await conn.fetch("SELECT * FROM users")

This mirrors the sync pattern but uses await and async yield [3].

Common Pitfalls and Best Practices

Don’t suppress exceptions accidentally: Only return True from __exit__ if you truly want to hide errors.
Keep __exit__ safe: It should handle cleanup even if __enter__ partially failed.
Prefer @contextmanager for simple cases; use classes for stateful or complex logic [7].
Use ExitStack when resources are dynamic or created in loops [1].

Put This Into Practice Today

Here’s your action plan:

Find one place in your code where you manually call .close(), .release(), or .disconnect().
Wrap it in a with block using a built-in context manager (like open()) or create a simple @contextmanager.
Test that it still works when an exception occurs.

You’ll immediately reduce bugs and clean up your code.

Context managers are one of Python’s most powerful yet underused tools. They turn fragile, error-prone resource handling into something elegant, automatic, and trustworthy. Once you start using them, you’ll never go back to manual cleanup.

Try it now: Pick a function in your project that opens a file or connects to a database. Wrap it in a with statement or a custom context manager. Share your before/after code on Dev.to and let the community see the difference.

If you found this helpful, consider buying me a coffee ☕ — it keeps these articles coming!

Also check out my AI tools collection: AI 次元世界 — free AI tools for developers.

How to Scrape JavaScript-Heavy Sites with Playwright

qing — Wed, 26 Aug 2026 20:00:04 +0000

How to Scrape JavaScript-Heavy Sites with Playwright

tags: python, playwright, webscraping, tutorial

How to Scrape JavaScript-Heavy Sites with Playwright

You’ve probably hit this wall: you write a clean script with requests or httpx, fire it off, and get back a blank page or a skeleton HTML with zero data. That’s because the site you’re targeting doesn’t render its content until JavaScript runs in the browser. Traditional scrapers can’t execute that JS, so they see nothing. The solution? Use a tool that actually runs a browser. Enter Playwright—a modern, fast, and reliable browser automation library that lets you scrape JavaScript-heavy sites, single-page applications (SPAs), and dynamic content with ease.

Unlike older tools like Selenium, Playwright is built for speed, supports multiple browsers (Chromium, Firefox, WebKit), and has native async support. It’s also smart about waiting: you don’t need to guess how long to wait for content to load. Playwright can wait for selectors, network events, or even specific DOM states. Let’s get you building a scraper that works today.

Why Playwright Beats Traditional Scrapers

Most HTTP-based scrapers just fetch the raw HTML response. But modern websites—especially those built with React, Vue, or Angular—load content dynamically via AJAX or WebSockets. The initial HTML might be empty, and the real data only appears after JS executes.

Playwright solves this by controlling a real browser. It launches Chromium (or another browser), navigates to the page, executes all JavaScript, and gives you the fully rendered DOM. This means:

You get the actual content users see.
You can interact with the page: click buttons, fill forms, scroll, and handle pop-ups.
You avoid many blocking issues because Playwright mimics human behavior more closely than raw HTTP requests.

According to industry guides, Playwright is “highly effective for web scraping JavaScript-heavy sites, SPAs, and any dynamic content page” [3]. It’s also a great alternative to Selenium because of its asynchronous nature and cross-browser support [5].

Setting Up Your Python Environment

Before writing code, let’s set up a clean Python environment. You’ll need:

Python 3.8+
playwright package
pandas (optional, for data handling)

Here’s how to install everything:

python -m venv playwright_scraper
source playwright_scraper/bin/activate  # On Windows: playwright_scraper\Scripts\activate
pip install playwright pandas
playwright install

The playwright install command downloads the optimized browser binaries Playwright uses [6].

Building Your First Scraper: A Real Example

Let’s scrape a simple JavaScript-heavy e-commerce sandbox that mimics real product listings. We’ll use the Oxylabs sandbox site, which is perfect for practice [6].

Our goals:

Launch a browser and navigate to the URL.
Wait for product items to load.
Extract product name, price, and URL.
Save results to a CSV.

Here’s a complete, working Python script using Playwright’s sync API (simpler for beginners):

from playwright.sync_api import sync_playwright
import csv

URL = "https://sandbox.oxylabs.io/products"
OUTPUT_FILE = "products.csv"

def scrape_products():
    products = []

    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)  # Set headless=False to see the browser
        page = browser.new_page()
        page.goto(URL)

        # Wait for product items to be rendered
        page.wait_for_selector('[data-content="product-item"]', state="attached")

        # Get all product locators
        product_items = page.locator('[data-content="product-item"]')

        for item in product_items.all():
            name = item.locator("h2 a").text_content()
            price = item.locator(".price").text_content()
            url = item.locator("h2 a").get_attribute("href")

            products.append({
                "name": name,
                "price": price,
                "url": url
            })

        browser.close()

    # Write to CSV
    with open(OUTPUT_FILE, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=["name", "price", "url"])
        writer.writeheader()
        writer.writerows(products)

    print(f"Saved {len(products)} products to {OUTPUT_FILE}")

if __name__ == "__main__":
    scrape_products()

Run this script, and you’ll get a products.csv file with real product data. No manual waits, no guesswork—just reliable scraping [6].

Handling Dynamic Content and Waiting Strategies

One of Playwright’s biggest strengths is its smart waiting. You don’t need time.sleep(5) anymore. Instead, use:

page.wait_for_selector() – waits for an element to appear.
page.wait_for_load_state("networkidle") – waits until network activity stops.
page.locator() – automatically waits and retries until the element is ready [6].

For example, if your site loads content after scrolling, you can scroll and then wait:

page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
page.wait_for_load_state("networkidle")

This ensures all AJAX-loaded products are visible before scraping [4].

Avoiding Detection and Rate Limiting

Since Playwright runs a real browser, it’s harder for sites to detect you as a bot. But you can still get blocked if you’re too aggressive. Here are pro tips:

Use headless mode in production (headless=True) to reduce overhead.
Add random delays between requests to mimic human behavior.
Implement retry logic with exponential backoff for 403 errors [2].
Block unnecessary resources (images, fonts) to speed up scraping:

def block_resources(page):
    page.route(".*", lambda route, request: 
        route.abort() if request.resource_type in ["image", "font", "stylesheet"] 
        else route.continue_()
    )

page = browser.new_page()
block_resources(page)

This technique reduces load time and bandwidth [6].

Debugging and Testing Selectors

Before writing code, inspect the page in Browser DevTools:

Right-click an element → “Inspect”.
Find a stable selector (e.g., data-content="product-item").
Copy it and drop it into page.locator().

Playwright also offers helper methods like:

get_by_role() – finds elements by accessibility role.
get_by_text() – matches visible text.
get_by_test_id() – targets elements with a test ID [6].

These make your scraper more robust against DOM changes.

When to Use Playwright vs. Other Tools

Tool	Best For	Limitations
Playwright	JS-heavy sites, SPAs, interactions	Slower than HTTP scrapers
Selenium	Legacy automation, cross-browser	Less modern, slower sync
Puppeteer	Node.js-only JS scraping	Chromium-only, no Firefox/WebKit
Requests	Static HTML, APIs	Can’t handle JS

Playwright is the best choice when you need real browser execution and interaction capabilities [2][3].

Take Action Today

You don’t need to reverse-engineer APIs or struggle with blank pages. With Playwright, you can scrape any JavaScript-heavy site by simply running a browser. Try the script above on a sandbox site, then adapt it to your target.

Your next step: Pick a real JavaScript-heavy site you’ve struggled with, install Playwright, and run the scraper. Share your results or questions in the comments—let’s build together.

Got a tricky site you’re scraping? Drop the URL and what you’re trying to extract. I’ll help you craft a selector strategy. Let’s make scraping easier, one page at a time.

If you found this helpful, consider buying me a coffee ☕ — it keeps these articles coming!

Also check out my AI tools collection: AI 次元世界 — free AI tools for developers.

Build an Email Notification System with Python

qing — Wed, 26 Aug 2026 18:00:55 +0000

Build an Email Notification System with Python

tags: python, email, automation, tutorial

Build an Email Notification System with Python

Imagine your server just crashed, a critical database backup failed, or a user reported a severe bug—but you’re asleep, at dinner, or completely offline. Without a way to alert you instantly, those minutes turn into hours of downtime, lost revenue, and frustrated customers. The good news? You can solve this today with a simple, automated email notification system built entirely in Python. No expensive third-party services, no complex infrastructure—just a few lines of code and your existing Gmail account.

In this guide, you’ll build a production-ready email notifier that sends alerts when specific events occur. We’ll cover everything from setting up secure SMTP connections to crafting reusable notification functions you can drop into any project. Let’s get coding.

Why Python Is Perfect for Email Notifications

Python comes with built-in libraries like smtplib and email.message that make sending emails straightforward. Unlike Node.js or Ruby, where you often need external packages for basic SMTP functionality, Python handles secure connections, message formatting, and authentication natively. Plus, its readability means your notification logic stays clean and maintainable—even as your system scales.

For developers who want a quicker alternative, libraries like yagmail simplify Gmail-specific workflows by handling app passwords and OAuth2 automatically [3][4]. But for maximum control and portability across mail providers (not just Gmail), we’ll stick with the standard smtplib approach.

Step 1: Set Up Your Python Environment

Before writing code, create a clean virtual environment to isolate dependencies:

python -m venv env
source env/bin/activate  # On Windows: .\env\Scripts\activate.ps1

Now install the necessary libraries. While smtplib is built-in, you’ll need secure-smtplib for modern TLS handling (though in practice, smtplib alone suffices with starttls()):

pip install smtplib secure-smtplib

Note: smtplib is part of Python’s standard library—you don’t actually need to install it with pip. The secure-smtplib package is optional; we’ll use smtplib.SMTP_SSL or starttls() directly for security [1][5].

Step 2: Configure Gmail for SMTP Access

To send emails via Gmail, you must enable SMTP access. Here’s how:

Go to your Google Account Security Settings.
Enable 2-Factor Authentication (required).
Generate an App Password:
- Under “2-Step Verification,” select “App passwords.”
- Create a new app named “Email Notifier.”
- Copy the 16-character password (you won’t see it again).

Never use your regular Gmail password. App passwords are designed for third-party apps and are revoked automatically if compromised [6].

Step 3: Write the Notification Function

Here’s a complete, reusable function that sends an email using Gmail’s SMTP server:

import smtplib
from email.message import EmailMessage
from email.utils import formataddr

SMTP_SERVER = "smtp.gmail.com"
SMTP_PORT = 465  # SSL port
SENDER_EMAIL = "your_email@gmail.com"
SENDER_PASSWORD = "your_app_password"  # Use app password, not regular password

def send_email_notification(recipient: str, subject: str, body: str) -> bool:
    """Send an email notification via Gmail SMTP."""
    msg = EmailMessage()
    msg['Subject'] = subject
    msg['From'] = formataddr((sender_name, SENDER_EMAIL))
    msg['To'] = recipient
    msg.set_content(body)

    try:
        with smtplib.SMTP_SSL(SMTP_SERVER, SMTP_PORT) as server:
            server.login(SENDER_EMAIL, SENDER_PASSWORD)
            server.send_message(msg)
        print(f"✅ Email sent successfully to {recipient}")
        return True
    except Exception as e:
        print(f"❌ Failed to send email: {e}")
        return False

# Example usage
if __name__ == "__main__":
    send_email_notification(
        recipient="friend@example.com",
        subject="🚨 Critical Alert: Server Down",
        body="Your server at 192.168.1.10 is unreachable. Please check immediately."
    )

This code uses EmailMessage for clean header handling and SMTP_SSL for encrypted connections [1][5]. It’s secure, readable, and ready to integrate into scripts, web apps, or monitoring tools.

Step 4: Automate Alerts for Real Events

Now let’s make this practical. Suppose you’re running a background job that checks if a service is alive. If it fails, send an alert:

import subprocess
import time

def check_service():
    """Returns True if service is running, False otherwise."""
    try:
        result = subprocess.run(["curl", "-f", "http://localhost:8000/health"], capture_output=True)
        return result.returncode == 0
    except:
        return False

def monitor_and_alert():
    while True:
        if not check_service():
            send_email_notification(
                recipient="admin@example.com",
                subject="🚨 Service Health Check Failed",
                body="The service at http://localhost:8000 is down. Immediate action required."
            )
            # Avoid spamming: wait 10 minutes before next check
            time.sleep(600)
        else:
            print("✅ Service is healthy")
            time.sleep(30)  # Check every 30 seconds

if __name__ == "__main__":
    monitor_and_alert()

This pattern—check → alert if failed → wait—is the backbone of most monitoring systems [7]. You can extend it to check databases, APIs, file systems, or even custom business logic.

Bonus: Add HTML and Attachments

For richer alerts, send HTML emails or attach logs:

from email.mime.base import MIMEBase
from email import encoders

def send_html_email_with_attachment(recipient, subject, html_body, filepath):
    msg = EmailMessage()
    msg['Subject'] = subject
    msg['From'] = SENDER_EMAIL
    msg['To'] = recipient
    msg.set_content(html_body, subtype='html')

    # Attach file
    with open(filepath, "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="{filepath}"')
        msg.attach(part)

    with smtplib.SMTP_SSL(SMTP_SERVER, SMTP_PORT) as server:
        server.login(SENDER_EMAIL, SENDER_PASSWORD)
        server.send_message(msg)

This lets you send formatted dashboards, error logs, or screenshots as attachments [4].

Make It Production-Ready

To deploy this safely:

Use environment variables for credentials:

  import os
  SENDER_EMAIL = os.getenv("GMAIL_USER")
  SENDER_PASSWORD = os.getenv("GMAIL_APP_PASSWORD")

Add retry logic for network failures.
Log failures to a file or monitoring system.
Rate-limit alerts to avoid spamming recipients.

For scalable systems, consider offloading notifications to background workers like Celery or using dedicated services like SendGrid or Mailtrap [5][9]. But for 90% of projects, this simple Python script is all you need.

Start Alerting Today

You now have a working, secure email notification system that can alert you about crashes, failures, or critical events—no matter where you are. The code is minimal, reusable, and ready to paste into your next project.

Your next step? Pick one thing in your workflow that should trigger an alert (a failed backup, a slow API, a login spike) and wrap it with send_email_notification(). In under 10 minutes, you’ll have real-time visibility into your system’s health.

Drop your use case in the comments below—what’s the first alert you’ll build? And if you found this helpful, share it with a teammate who’s still debugging at 3 AM instead of sleeping. 🛠️📬

If you found this helpful, consider buying me a coffee ☕ — it keeps these articles coming!

Also check out my AI tools collection: AI 次元世界 — free AI tools for developers.

Mastering Python Dataclasses: A Complete Guide

qing — Wed, 26 Aug 2026 18:00:50 +0000

Mastering Python Dataclasses: A Complete Guide

tags: python, programming, tutorial, beginners

Mastering Python Dataclasses: A Complete Guide

Remember the last time you wrote a class that was just a glorified dictionary? You spent twenty minutes typing __init__, __repr__, and __eq__ methods, only to realize you forgot to handle default values correctly. It’s tedious, repetitive, and frankly, a waste of your brilliant brainpower. Python dataclasses were introduced in version 3.7 to solve this exact problem, letting you define classes for storing data with virtually zero boilerplate [4]. If you want to write cleaner, more type-safe code today, you need to master this feature.

What Are Dataclasses and Why Use Them?

A dataclass is a class that is primarily used for storing data. While there are no strict restrictions on what a dataclass can do, its main purpose is to hold data attributes [4]. The magic happens through the @dataclass decorator, which automatically generates special methods like __init__(), __repr__(), and __eq__() for you [2].

Think of dataclasses as "records" or lightweight data-only structures containing a fixed set of named, typed fields [5]. They are the perfect alternative when you’re tempted to pass around a tuple or a dictionary but want the safety of attribute access and type checking. As a rule of thumb: if you’re considering returning or passing a group of multiple values, consider a dataclass instead of a tuple [5].

The benefits are immediate:

Reduced Boilerplate: No more writing __init__ manually.
Type Safety: Fields are defined with type annotations, making them friendly to linters and IDEs [6].
Readability: The code is shorter and expresses intent clearly.

The Basics: Defining Your First Dataclass

Let’s get practical. Here is how you define a simple dataclass to represent a user profile. Notice how we skip the __init__ method entirely.

from dataclasses import dataclass

@dataclass
class User:
    name: str
    age: int
    is_active: bool = True

# Creating an instance is intuitive
user = User(name="Alice", age=30)

# The magic methods are auto-generated
print(user)  # Output: User(name='Alice', age=30, is_active=True)
print(user == User(name="Alice", age=30))  # Output: True

In this example, the @dataclass decorator generated the initialization logic, the string representation, and the equality comparison automatically [4]. The : notation you see is using variable annotations, which is the standard way to define fields in a dataclass [4].

Advanced Features: Customizing Behavior

While the default behavior is great, real-world applications often need more control. The @dataclass decorator accepts several parameters to customize how your class behaves.

Making Objects Immutable with `frozen`

By default, dataclass attributes are mutable—you can reassign them after creation [8]. However, if you need an object that cannot change once created (like a configuration setting), you can make it immutable using the frozen parameter [5].

@dataclass(frozen=True)
class Config:
    api_key: str
    timeout: int = 30

config = Config(api_key="secret123")
# config.timeout = 60  # This will raise an error: FrozenInstanceError

When frozen=True is set, the dataclass throws an error if anyone tries to mutate the object at runtime [5]. This is a powerful pattern for preventing accidental state changes.

Customizing Fields with `field()`

Sometimes you need to set a default value that is a function call (like a list) rather than a static value. You can’t just write tags: list = [] because that would create a shared list across all instances. Instead, use the field() specifier with default_factory [4].

from dataclasses import dataclass, field

@dataclass
class Project:
    name: str
    tags: list = field(default_factory=list)

p1 = Project(name="Alpha")
p2 = Project(name="Beta")

p1.tags.append("bug")
print(p2.tags)  # Output: [] - No shared state!

The field() function supports parameters like default, default_factory, init, repr, and eq to customize individual fields [4].

Enforcing Keyword Arguments with `kw_only`

One common pain point with dataclasses is accidentally passing arguments in the wrong order. Python 3.10 introduced the kw_only flag to force all fields to be passed as keyword arguments, making your code more explicit and readable [5].

@dataclass(kw_only=True)
class Point:
    x: int
    y: int

# point = Point(1, 2)  # Error: Point takes 0 positional arguments
point = Point(x=1, y=2)  # Works perfectly

Using kw_only=True ensures every field must be explicitly set, forcing you to read the field name before setting it [5].

Dataclasses vs. Other Data Structures

It’s easy to get confused about when to use a dataclass versus a namedtuple, dict, or a regular class.

Feature	Dataclass	Namedtuple	Dict	Regular Class
Boilerplate	Low (Auto `__init__`)	None	None	High
Mutability	Mutable (default)	Immutable	Mutable	Custom
Type Hints	Native Support	Native Support	No (usually)	Native Support
Attribute Access	Yes (`obj.x`)	Yes (`obj.x`)	No (`obj['x']`)	Yes
Defaults	Easy	Harder	Easy	Custom

Dataclasses are essentially "mutable namedtuples with defaults" [8]. They offer the attribute access of a class but the simplicity of a tuple, with the added flexibility of default values. If you need a lightweight container for data, dataclasses are generally the best choice [4].

Best Practices and Gotchas

To truly master dataclasses, you need to know a few pitfalls.

Avoid Shared Defaults: As mentioned earlier, never use a mutable object (like a list or dict) as a direct default value. Always use default_factory [4].
Order Matters: Fields without default values must be defined before fields with default values, unless you use kw_only=True [5].
Slots for Performance: If you are creating thousands of instances and care about memory, you can set slots=True. This replaces the object’s __dict__ with a fixed-size array, reducing memory usage and improving lookup speed [6].
Inheritance: Dataclasses support inheritance just like regular classes. You can inherit fields from a parent dataclass and add new ones in the child [4].

@dataclass
class Employee:
    id: int
    name: str

@dataclass
class Manager(Employee):
    department: str

mgr = Manager(id=1, name="Bob", department="Sales")

Start Using Them Today

Dataclasses are one of the best features to have happened to Python for object-oriented programming fans [3]. They strip away the noise of boilerplate code, leaving you with clear, typed, and structured data containers.

Stop writing __init__ methods for simple data holders. Start using @dataclass to define your User, Product, or Config objects today. The next time you’re tempted to return a tuple of five values, pause and ask yourself: "Would a dataclass be better here?" The answer is almost always yes.

Go ahead and refactor one of your old classes into a dataclass right now. You’ll see how much cleaner your code becomes immediately. Happy coding!

If you found this helpful, consider buying me a coffee ☕ — it keeps these articles coming!

Also check out my AI tools collection: AI 次元世界 — free AI tools for developers.

How to Build a CLI Tool with Python and Click

qing — Wed, 26 Aug 2026 18:00:08 +0000

How to Build a CLI Tool with Python and Click

tags: python, cli, tutorial, tools

tags: python, testing, devops, tutorial

tags: python, automation, tools, tutorial

Build a File Sync Tool with Python and Watchdog

Imagine you’re working on a project where you constantly edit files in one folder, but you need those changes instantly reflected in another location—maybe a backup drive, a cloud staging folder, or a deployment directory. Doing this manually is tedious, and relying on cron jobs introduces lag. What if you could build a tool that watches for changes and syncs them in real time? That’s exactly what we’re going to do today using Python and the powerful watchdog library.

Why Watchdog?

watchdog is a cross-platform Python library that lets you monitor file system events—like file creation, modification, and deletion—and trigger custom actions in response [1][8]. Unlike polling-based solutions, it’s event-driven, meaning it reacts immediately when a change happens. This makes it perfect for building real-time sync tools, automated testers, or even live documentation generators.

What You’ll Build

By the end of this post, you’ll have a working file sync tool that:

Watches a source directory for changes
Automatically copies new or modified files to a destination directory
Deletes files in the destination if they’re removed from the source
Runs continuously without blocking your main workflow

And yes, you can use this today to automate your own workflows.

Step 1: Set Up Your Environment

First, make sure you have Python 3 installed. Then, install watchdog:

pip install watchdog

You’ll also need Python’s built-in os and shutil modules for file operations, so no extra installs there [2][4].

Create a project folder and set up two directories: one for your source files and one for the synced destination.

mkdir file_sync_demo
cd file_sync_demo
mkdir source destination

Step 2: Build the Event Handler

The core of watchdog is the event handler—a class that defines what to do when specific file system events occur. We’ll create a custom handler that inherits from FileSystemEventHandler and overrides methods like on_created, on_modified, and on_deleted.

Here’s the full working code:

import os
import shutil
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

class SyncHandler(FileSystemEventHandler):
    def __init__(self, source_dir, dest_dir):
        self.source_dir = source_dir
        self.dest_dir = dest_dir

    def on_created(self, event):
        if event.is_directory:
            return
        self.sync_file(event.src_path)

    def on_modified(self, event):
        if event.is_directory:
            return
        self.sync_file(event.src_path)

    def on_deleted(self, event):
        if event.is_directory:
            return
        dest_path = os.path.join(self.dest_dir, os.path.basename(event.src_path))
        if os.path.exists(dest_path):
            os.remove(dest_path)
            print(f"Deleted: {dest_path}")

    def sync_file(self, src_path):
        filename = os.path.basename(src_path)
        dest_path = os.path.join(self.dest_dir, filename)
        shutil.copy2(src_path, dest_path)
        print(f"Synced: {filename}")

if __name__ == "__main__":
    source = "source"
    destination = "destination"

    handler = SyncHandler(source, destination)
    observer = Observer()
    observer.schedule(handler, source, recursive=False)
    observer.start()

    print(f"Watching '{source}' for changes. Syncing to '{destination}'...")
    try:
        while True:
            pass
    except KeyboardInterrupt:
        observer.stop()
    observer.join()

Save this as sync.py in your project folder [2][8].

Step 3: How It Works

Let’s break down the key parts:

SyncHandler: Our custom event handler. It stores the source and destination paths and defines behavior for each event type.
on_created / on_modified: Both trigger the same sync_file method, which copies the file using shutil.copy2 (this preserves metadata like timestamps).
on_deleted: Removes the corresponding file from the destination if it exists.
Observer: The engine that watches the directory. We schedule it to watch the source folder with recursive=False to avoid watching subdirectories [3][7].
observer.start(): Begins monitoring in a background thread, so your script doesn’t block [7].

Step 4: Test It Out

Now, let’s see it in action.

Run the script:

   python sync.py

In another terminal, navigate to the source folder and create a file:

   cd source
   echo "Hello, sync!" > test.txt

Watch the output: you should see Synced: test.txt.
Check the destination folder—you’ll find test.txt there, identical to the source.

Try editing test.txt, moving it, or deleting it. The tool will react instantly [2].

Practical Tips & Enhancements

This is a minimal but functional sync tool. Here are a few ways to level it up:

Filter by file type: Add a patterns argument to observer.schedule() to watch only .txt or .py files [9].
Add logging: Use Python’s logging module instead of print() for production-ready output [4].
Handle race conditions: If a file is being written, on_modified might fire multiple times. You can add a small delay or check file size stability before syncing.
Make it recursive: Set recursive=True in schedule() if you want to sync subdirectories too [3].
Add CLI args: Use argparse to let users specify source/dest paths at runtime [1].

Why This Matters

Real-time file sync isn’t just convenient—it’s essential for modern development workflows. Whether you’re syncing config files to a server, mirroring assets for a website, or backing up critical data, having a lightweight, scriptable tool gives you full control without relying on third-party services.

And because it’s built in Python, you can extend it endlessly: add email notifications, integrate with cloud APIs, or even turn it into a web service.

Your Turn

Grab the code above, run it, and tweak it for your own needs. Try syncing a folder of your project files, or automate a backup for your documents. Once you see it working, you’ll never go back to manual copying.

If you build something cool with this, share it on Dev.to or tag me in your post. And if you hit any bugs or have ideas for improvements, drop a comment—let’s keep building better tools together.

Ready to sync? Run python sync.py and watch your files move in real time.

If you found this helpful, consider buying me a coffee ☕ — it keeps these articles coming!

Also check out my AI tools collection: AI 次元世界 — free AI tools for developers.

Build a Real-Time Chat App with FastAPI and WebSockets

qing — Wed, 26 Aug 2026 18:00:04 +0000

Build a Real-Time Chat App with FastAPI and WebSockets

tags: python, fastapi, websocket, tutorial

Building a Real-Time Chat App with FastAPI and WebSockets: A Step-by-Step Guide

As developers, we've all been there - we see a demo of a real-time chat app and think, "That's exactly what I need for my project." But, we all know that building such an app from scratch can be a daunting task. You need to worry about scalability, performance, and most importantly, real-time updates. In this post, we'll show you how to build a real-time chat app using FastAPI and WebSockets.

Setting Up the Project

Before we dive into the nitty-gritty of building a chat app, let's set up the project structure. FastAPI is a modern Python web framework that allows us to build high-performance APIs quickly. We'll create a new project using the following command:

mkdir real-time-chat-app
cd real-time-chat-app
mkdir app models routes utils

Our project structure will look like this:

real-time-chat-app/
app/
__init__.py
main.py
models/
__init__.py
user.py
message.py
routes/
__init__.py
auth.py
chat.py
utils/
__init__.py
websocket.py
requirements.txt

Next, let's install the required dependencies:

pip install fastapi uvicorn aiomysql

Defining the Data Models

In our chat app, we'll have two main data models: User and Message. We'll define these models in the models directory:

# app/models/user.py
from pydantic import BaseModel

class User(BaseModel):
    id: int
    username: str
    password: str

# app/models/message.py
from pydantic import BaseModel
from datetime import datetime

class Message(BaseModel):
    id: int
    content: str
    sender_id: int
    receiver_id: int
    timestamp: datetime

Setting Up the Database

For this example, we'll use a MySQL database. You can use any other database engine if you prefer. We'll use the aiomysql library to connect to the database.

First, let's create the database schema:

CREATE TABLE users (
    id INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(255),
    password VARCHAR(255)
);

CREATE TABLE messages (
    id INT PRIMARY KEY AUTO_INCREMENT,
    content VARCHAR(255),
    sender_id INT,
    receiver_id INT,
    timestamp DATETIME,
    FOREIGN KEY (sender_id) REFERENCES users(id),
    FOREIGN KEY (receiver_id) REFERENCES users(id)
);

Next, let's create a database connection using aiomysql:

# app/utils/db.py
import aiomysql

async def get_db():
    db = await aiomysql.connect(
        host="localhost",
        user="root",
        password="password",
        db="real_time_chat"
    )
    return db

Building the Chat API

Now that we have our data models and database connection set up, let's build the chat API. We'll create a new route for sending messages and another for retrieving messages.

First, let's create a message sending route:

# app/routes/chat.py
from fastapi import APIRouter, HTTPException
from app.models.message import Message
from app.utils.websocket import send_message_to_all

router = APIRouter()

@router.post("/messages/")
async def create_message(message: Message):
    db = await get_db()
    async with db.cursor() as cur:
        await cur.execute("INSERT INTO messages (content, sender_id, receiver_id) VALUES (%s, %s, %s)", (message.content, message.sender_id, message.receiver_id))
        await db.commit()
    await send_message_to_all(message)
    return {"message": "Message sent successfully"}

Next, let's create a route for retrieving messages:

# app/routes/chat.py
from fastapi import APIRouter
from app.models.message import Message

router = APIRouter()

@router.get("/messages/")
async def get_messages():
    db = await get_db()
    async with db.cursor() as cur:
        await cur.execute("SELECT * FROM messages")
        messages = await cur.fetchall()
    return [{"id": message[0], "content": message[1], "sender_id": message[2], "receiver_id": message[3], "timestamp": message[4]} for message in messages]

Setting Up WebSockets

Now that we have our chat API set up, let's set up WebSockets. WebSockets allow us to establish a persistent connection between the client and server, enabling real-time updates.

First, let's create a new file for handling WebSocket connections:

# app/utils/websocket.py
import asyncio
from fastapi import WebSocket

async def send_message_to_all(message: Message):
    await asyncio.wait([ws.send_json({"type": "message", "content": message.content}) for ws in await WebSocket.get_running_connections()])

async def handle_connection(websocket: WebSocket):
    await websocket.accept()
    while True:
        message = await websocket.receive_json()
        if message["type"] == "message":
            await send_message_to_all(message["content"])
        elif message["type"] == "disconnect":
            break

Finally, let's create a new route for handling WebSocket connections:

# app/routes/chat.py
from fastapi import APIRouter, WebSocket

router = APIRouter()

@router.get("/ws/")
async def get_websocket():
    return {"type": "websocket"}

Running the App

Now that we have our chat app set up, let's run it:

uvicorn app.main:app --host 0.0.0.0 --port 8000

Conclusion

In this post, we showed you how to build a real-time chat app using FastAPI and WebSockets. With this guide, you should be able to build a chat app that supports real-time updates and persistent connections.

Remember to replace the database connection settings and WebSocket connection settings with your own. With this app, you can create a real-time chat experience for your users.

What's next? You can extend this app to support file uploads, user authentication, and more. The possibilities are endless. Happy coding!

If you found this helpful, consider buying me a coffee ☕ — it keeps these articles coming!

Also check out my AI tools collection: AI 次元世界 — free AI tools for developers.

TypeScript for Python Developers: A Practical Guide

qing — Wed, 26 Aug 2026 16:00:57 +0000

TypeScript for Python Developers: A Practical Guide

tags: typescript, python, tutorial, beginners

From Python to TypeScript: Why the Switch?

As a Python developer, you're likely no stranger to the excitement of writing clean, readable, and maintainable code. But, have you ever wanted to take your code to the next level by adding the benefits of static typing? Look no further than TypeScript, the popular superset of JavaScript that's been gaining traction among developers across the globe.

But, before you start thinking, "JavaScript? Isn't that for web development?" Think again! TypeScript can be used for a wide range of applications, from backend services to desktop applications, and even mobile apps. And, with the rise of Node.js and the growing popularity of frameworks like Express.js and Nest.js, TypeScript is becoming an increasingly attractive choice for developers who want to build robust, scalable, and maintainable systems.

What is TypeScript, and Why Should I Care?

TypeScript is a statically-typed language that compiles to JavaScript, allowing you to write robust, maintainable, and scalable code for a wide range of applications. With TypeScript, you can take advantage of features like:

Static typing: TypeScript allows you to define the types of your variables, function parameters, and return types, making it easier to catch errors at compile-time rather than runtime.
Interfaces: TypeScript provides a powerful way to define interfaces, which can be used to ensure that objects conform to a specific shape and structure.
Modules: TypeScript supports modules, which allow you to organize your code into reusable, independent units.
Type inference: TypeScript can automatically infer the types of variables and function parameters, making it easier to write type-safe code.

Setting Up TypeScript for Your Python Project

So, how do you get started with TypeScript? Fortunately, it's easier than you think! Here are the basic steps to set up TypeScript for your Python project:

Install the TypeScript compiler: You'll need to install the TypeScript compiler, which can be done using npm (Node Package Manager) or yarn. Run npm install -g typescript or yarn global add typescript.
Create a tsconfig.json file: Create a tsconfig.json file in the root of your project, which will contain configuration settings for the TypeScript compiler.
Install the required dependencies: You'll need to install the required dependencies for your project, including any external libraries or frameworks.
Write your TypeScript code: Start writing your TypeScript code, making sure to follow the basic syntax and conventions of the language.

A Practical Example: Converting a Python Function to TypeScript

Let's take a look at a simple example of converting a Python function to TypeScript. Here's the Python code:

def greet(name: str) -> None:
    print(f"Hello, {name}!")

greet("John")

Now, let's convert this code to TypeScript:

function greet(name: string): void {
  console.log(`Hello, ${name}!`);
}

greet("John");

As you can see, the TypeScript code is almost identical to the Python code, with the main differences being:

Type annotations: We've added type annotations for the name parameter and the return type of the function.
Function signature: We've used a function keyword to define the function, rather than the def keyword used in Python.
Console.log: We've used console.log instead of print to log the greeting message to the console.

Best Practices for Writing TypeScript Code

So, how do you write effective TypeScript code? Here are some best practices to keep in mind:

Use type annotations: Type annotations are a key feature of TypeScript, and they can help you catch errors at compile-time rather than runtime.
Follow the basic syntax: TypeScript has a syntax that's similar to JavaScript, but with some key differences. Make sure to follow the basic syntax and conventions of the language.
Use interfaces: Interfaces can help you define the shape and structure of objects, making it easier to write maintainable and scalable code.
Keep your code organized: Keep your code organized by using modules and separate files for different components.

Conclusion and Call to Action

TypeScript is a powerful tool that can help you write robust, maintainable, and scalable code for a wide range of applications. By following the best practices outlined in this article, you can take the first steps towards converting your Python project to TypeScript.

So, what are you waiting for? Take the leap and start exploring the world of TypeScript today! Whether you're a seasoned developer or just starting out, TypeScript has something to offer everyone.

Build a GitHub Actions Bot That Pays You

qing — Wed, 26 Aug 2026 16:00:52 +0000

Build a GitHub Actions Bot That Pays You

tags: github, automation, money, devops

Paying Your Way: How to Build a GitHub Actions Bot That Earns You Money

Are you tired of feeling like your open-source contributions are going unnoticed? Well, we've got some good news for you: GitHub Actions can now pay you for your work. In this post, we'll show you how to build a bot that uses GitHub Actions to automatically detect and reward you for your contributions.

Setting Up the GitHub Actions Bot

Before we dive into the code, let's cover the basics of what we're trying to achieve. Our bot will use the GitHub Actions API to monitor your repositories, detect new contributions, and then trigger a payment to your bank account. Sounds simple, right?

To get started, you'll need to create a new GitHub token with the necessary permissions. You can do this by going to your GitHub account settings, clicking on "Developer settings," and then selecting "Personal access tokens." Create a new token with the following permissions:

repo
workflow
actions

Once you have your token, you'll need to store it securely. We recommend using a secrets manager like Hashicorp's Vault or a simple environment variable.

Installing the Required Dependencies

Next, let's set up our Python environment. We'll need the following dependencies:

requests for making API calls
github for interacting with the GitHub API
schedule for scheduling our bot to run at regular intervals

You can install these dependencies using pip:

pip install requests github schedule

Writing the Bot Code

Now it's time to write our bot code. We'll use the schedule library to schedule our bot to run every hour. In each run, our bot will check your repositories for new contributions and trigger a payment if necessary.

Here's the code:

import os
import schedule
import time
import requests
from github import Github
from github import RateLimitExceededException

# Set your GitHub token and repository name
GITHUB_TOKEN = os.environ['GITHUB_TOKEN']
REPO_NAME = 'your-repo-name'

# Set your payment details
PAYMENT_METHOD = 'bank-account'
PAYMENT_AMOUNT = 10  # in dollars

# Set your schedule
schedule.every(1).hours.do(job)

def job():
    # Create a GitHub API instance
    g = Github(GITHUB_TOKEN)

    # Get your repository
    repo = g.get_repo(REPO_NAME)

    # Check for new contributions
    for pull_request in repo.get_pulls(state='open'):
        if pull_request.created_at > pull_request.updated_at:
            # Trigger a payment
            payload = {
                'method': PAYMENT_METHOD,
                'amount': PAYMENT_AMOUNT
            }
            response = requests.post('https://api.github.com/repos/{}/actions/runs'.format(REPO_NAME), json=payload, headers={'Authorization': 'Bearer {}'.format(GITHUB_TOKEN)})
            if response.status_code == 201:
                print('Payment triggered successfully!')
            else:
                print('Error triggering payment:', response.text)

Setting Up the Payment Trigger

Now that we have our bot code, let's talk about how to set up the payment trigger. We'll use the GitHub API to create a new workflow that triggers a payment when a new contribution is detected.

Here's an example workflow:

name: Pay contributors

on:
  pull_request:
    types: [opened]

jobs:
  pay:
    runs-on: ubuntu-latest
    steps:
      - name: Trigger payment
        run: |
          curl -X POST \
            https://api.github.com/repos/${GITHUB_REPOSITORY}/actions/runs \
            -H 'Authorization: Bearer $GITHUB_TOKEN' \
            -H 'Content-Type: application/json' \
            -d '{"method": "bank-account", "amount": 10}'

Conclusion

In this post, we've shown you how to build a GitHub Actions bot that automatically detects and rewards your contributions with a payment. By following these steps, you can start earning money for your open-source work today.

Get started today by following these steps:

Create a new GitHub token with the necessary permissions.
Store your token securely using a secrets manager or environment variable.
Install the required dependencies using pip.
Write your bot code using the example provided above.
Set up the payment trigger using the GitHub API.

By following these steps, you'll be well on your way to building a bot that pays you for your contributions. Happy coding!

If you found this helpful, consider buying me a coffee ☕ — it keeps these articles coming!

Also check out my AI tools collection: AI 次元世界 — free AI tools for developers.

Automate Your Taxes: Python Scripts for Freelancers

qing — Wed, 26 Aug 2026 16:00:11 +0000

Automate Your Taxes: Python Scripts for Freelancers

tags: python, freelance, taxes, automation

Automate Your Taxes: Python Scripts for Freelancers

As a freelancer, managing your finances can be a daunting task, especially when it comes to taxes. You have to keep track of your income, expenses, and deductions, all while meeting the deadlines for tax submissions. But what if you could automate some of these tasks using Python scripts? Not only would it save you time and reduce stress, but it would also ensure accuracy and efficiency. In this article, we'll explore how you can create Python scripts to streamline your tax-related tasks.

Understanding Tax Requirements

Before we dive into the coding, let's take a look at the tax requirements for freelancers. As a freelancer, you're considered self-employed and are required to report your income and expenses on your tax return. You'll need to file a Schedule C (Form 1040) to report your business income and expenses. You'll also need to report your business mileage, travel expenses, and any other business-related expenses on your tax return.

Gathering Data

To automate your taxes, you'll need to gather data on your income and expenses. This can include:

Business income from clients
Business expenses, such as equipment, software, and travel costs
Business mileage and travel expenses
Any other business-related expenses

There are several tools available to help you track your income and expenses, including:

Accounting software like QuickBooks or Xero
Expense tracking apps like Expensify or Concur
Spreadsheets like Google Sheets or Microsoft Excel

Using Python to Automate Tax-Related Tasks

Now that we have our data, let's look at how we can use Python to automate some tax-related tasks. We'll focus on creating a script to calculate business income and expenses, as well as a script to calculate business mileage and travel expenses.

Business Income and Expenses

Let's start with a script to calculate business income and expenses. We'll use the pandas library to read in our data from a spreadsheet and the numpy library to perform calculations.

import pandas as pd
import numpy as np

# Load in data from spreadsheet
df = pd.read_excel('business_data.xlsx')

# Calculate total business income
business_income = df['Business Income'].sum()

# Calculate total business expenses
business_expenses = df['Business Expenses'].sum()

# Calculate net business income
net_business_income = business_income - business_expenses

print(f'Business Income: ${business_income:.2f}')
print(f'Business Expenses: ${business_expenses:.2f}')
print(f'Net Business Income: ${net_business_income:.2f}')

This script assumes that you have a spreadsheet with columns for business income and business expenses. You can modify the script to fit your specific needs.

Business Mileage and Travel Expenses

Next, let's look at a script to calculate business mileage and travel expenses. We'll use the pandas library to read in our data from a spreadsheet and the numpy library to perform calculations.

import pandas as pd
import numpy as np

# Load in data from spreadsheet
df = pd.read_excel('travel_data.xlsx')

# Calculate total business mileage
business_mileage = df['Business Mileage'].sum()

# Calculate total travel expenses
travel_expenses = df['Travel Expenses'].sum()

# Calculate net business travel expenses
net_business_travel_expenses = travel_expenses - (business_mileage * 0.58)

print(f'Business Mileage: {business_mileage} miles')
print(f'Travel Expenses: ${travel_expenses:.2f}')
print(f'Net Business Travel Expenses: ${net_business_travel_expenses:.2f}')

This script assumes that you have a spreadsheet with columns for business mileage and travel expenses. You can modify the script to fit your specific needs.

Conclusion

Automating your taxes using Python scripts can save you time, reduce stress, and ensure accuracy and efficiency. By using scripts to calculate business income and expenses, as well as business mileage and travel expenses, you can streamline your tax-related tasks and focus on growing your business.

Get started today!

Download Python and install the necessary libraries (pandas and numpy).
Create a spreadsheet to track your income and expenses.
Modify the scripts provided to fit your specific needs.
Run the scripts to automate your tax-related tasks.

With these scripts, you'll be able to automate your taxes and focus on what matters most – growing your business and achieving success as a freelancer.

If you found this helpful, consider buying me a coffee ☕ — it keeps these articles coming!

Also check out my AI tools collection: AI 次元世界 — free AI tools for developers.

How to Build a Profitable Niche Website as a Developer

qing — Wed, 26 Aug 2026 16:00:06 +0000

How to Build a Profitable Niche Website as a Developer

tags: website, money, seo, passive

Building a Profitable Niche Website as a Developer

Imagine having a side hustle that not only brings in a steady stream of income, but also allows you to leverage your skills as a developer to build something meaningful. A profitable niche website can be that side hustle, and in this article, we'll walk through the steps to build one.

Choosing a Profitable Niche

Before we dive into the technical aspects of building a niche website, we need to choose a profitable niche. This can be a challenging step, as there are countless options to choose from. However, here are a few tips to help you get started:

Research Popular Niches

Start by researching popular niches online. Use tools like Google Trends, Keyword Planner, or Ahrefs to identify trending topics. You can also use social media platforms to see what people are talking about.

Identify Your Expertise

Next, think about what you're knowledgeable about. What skills do you have that could be applicable to a niche website? Perhaps you're a coding expert, a writer, or a designer. Whatever your skills, use them to your advantage.

Validate Your Niche

Once you've identified a potential niche, it's time to validate it. Use social media, online forums, or Reddit to see if there's interest in your chosen niche. Create a Facebook group or a Discord channel to gauge interest.

Building Your Website

Now that we've chosen a profitable niche, it's time to build our website. Here are the technical steps to follow:

Step 1: Choose a Platform

There are two primary options for building a niche website: a Content Management System (CMS) or a custom-built solution. For most developers, a CMS like WordPress or Ghost is a good starting point. However, if you want more control over your website, consider building a custom solution using a framework like Django or Flask.

Step 2: Set Up Hosting

Once you've chosen a platform, it's time to set up hosting. You can choose from a range of options, including shared hosting, VPS hosting, or cloud hosting. For most small websites, shared hosting is sufficient.

Step 3: Design Your Website

Next, design your website. Use a tool like WordPress' built-in page builder or a third-party plugin like Elementor to create a visually appealing website. For custom-built solutions, use a framework like Bootstrap to create a responsive design.

Step 4: Develop Your Website

Now it's time to develop your website. Use your chosen framework or CMS to create the necessary pages, templates, and functionality.

Step 5: Optimize for SEO

Finally, optimize your website for SEO. Use tools like Google Search Console and Google Analytics to monitor your website's performance. Use meta tags, header tags, and internal linking to improve your website's search engine ranking.

Creating Content

Creating content is the heart of a niche website. Here are a few tips to keep in mind:

Step 1: Create High-Quality Content

Create content that's informative, engaging, and well-written. Use a conversational tone and avoid jargon.

Step 2: Use Content Marketing Strategies

Use content marketing strategies like email marketing, social media marketing, and influencer marketing to promote your content.

Step 3: Repurpose Your Content

Repurpose your content to reach a wider audience. Turn blog posts into videos, podcasts, or infographics.

Monetizing Your Website

Monetizing a niche website can be a challenge, but here are a few strategies to consider:

Step 1: Use Affiliate Marketing

Use affiliate marketing to earn commissions on products or services that align with your niche.

Step 2: Create Digital Products

Create digital products like ebooks, courses, or software that solve problems for your audience.

Step 3: Offer Services

Offer services like consulting, coaching, or freelance work that align with your expertise.

Code Example: Creating a Simple Blog with Flask

Here's a simple example of creating a blog using Flask:

from flask import Flask, render_template
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///blog.db'
db = SQLAlchemy(app)

class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    content = db.Column(db.Text, nullable=False)

@app.route('/')
def index():
    posts = Post.query.all()
    return render_template('index.html', posts=posts)

if __name__ == '__main__':
    app.run(debug=True)

This code creates a simple blog with a SQLite database and a Flask app. The Post model represents a blog post, and the index function returns a list of all posts.

Conclusion

Building a profitable niche website as a developer requires a combination of technical skills, creativity, and marketing expertise. By choosing a profitable niche, building a website with a CMS or custom-built solution, creating high-quality content, and monetizing your website with affiliate marketing, digital products, or services, you can create a side hustle that brings in a steady stream of income. Remember to optimize your website for SEO, use content marketing strategies, and repurpose your content to reach a wider audience. With this guide, you're ready to start building your profitable niche website today!

If you found this helpful, consider buying me a coffee ☕ — it keeps these articles coming!

Also check out my AI tools collection: AI 次元世界 — free AI tools for developers.

DEV Community: qing

How to Use OpenAI API to Build Profitable Apps

How to Use OpenAI API to Build Profitable Apps

How to Build Profitable Mobile Apps as a Python Dev

Choose the Right Framework for Your Business Model

Kivy: The UI Powerhouse

BeeWare (Briefcase): The Native Look

Build an AI-Driven Backend That Sells

A Working Python Code Example: The Monetizable AI Feature

Monetization Strategies That Actually Work for Python Apps

1. The "Freemium" AI Model

2. In-App Subscriptions via RevenueCat

3. Niche B2B Solutions

From Code to Cash: Deployment and Testing

Rigorous Testing on Real Devices

Packaging for the Stores

CI/CD for Profit

Launch and Iterate: The Profit Loop

Start Building Your First Profitable App Today

Build a Slack Bot That Automates Your Workflow

Build a Slack Bot That Automates Your Workflow

Why Build a Slack Bot Instead of Using Built-in Tools?

Step 1: Create Your Slack App and Bot User

Step 2: Set Up Your Python Environment

Step 3: Write Your First Automating Bot

How It Works

Step 4: Automate Real Workflows Today

1. Daily Digest of Sales Metrics

2. Auto-Remind Team Members Before Deadlines

3. Interactive Onboarding Checklist

Bonus: No-Code Alternative for Quick Wins

Your Next Move

Python Context Managers: The Complete Guide

Python Context Managers: The Complete Guide

What Is a Context Manager?

Why You Should Use Them TODAY

How to Use the Built-in with Statement

Creating Your Own Context Manager: Class-Based

The Easier Way: @contextmanager Decorator

Managing Multiple Dynamic Resources: ExitStack

Async Context Managers: asynccontextmanager

Common Pitfalls and Best Practices

Put This Into Practice Today

How to Scrape JavaScript-Heavy Sites with Playwright

How to Scrape JavaScript-Heavy Sites with Playwright

How to Scrape JavaScript-Heavy Sites with Playwright

Why Playwright Beats Traditional Scrapers

Setting Up Your Python Environment

Building Your First Scraper: A Real Example

Handling Dynamic Content and Waiting Strategies

Avoiding Detection and Rate Limiting

Debugging and Testing Selectors

When to Use Playwright vs. Other Tools

Take Action Today

Build an Email Notification System with Python

Build an Email Notification System with Python

Build an Email Notification System with Python

Why Python Is Perfect for Email Notifications

Step 1: Set Up Your Python Environment

Step 2: Configure Gmail for SMTP Access

Step 3: Write the Notification Function

Step 4: Automate Alerts for Real Events

Bonus: Add HTML and Attachments

Make It Production-Ready

Start Alerting Today

Mastering Python Dataclasses: A Complete Guide

Mastering Python Dataclasses: A Complete Guide

Mastering Python Dataclasses: A Complete Guide

What Are Dataclasses and Why Use Them?

The Basics: Defining Your First Dataclass

Advanced Features: Customizing Behavior

Making Objects Immutable with frozen

Customizing Fields with field()

Enforcing Keyword Arguments with kw_only

Dataclasses vs. Other Data Structures

Best Practices and Gotchas

Start Using Them Today

How to Build a CLI Tool with Python and Click

How to Build a CLI Tool with Python and Click

Build a File Sync Tool with Python and Watchdog

How to Use the Built-in `with` Statement

The Easier Way: `@contextmanager` Decorator

Managing Multiple Dynamic Resources: `ExitStack`

Async Context Managers: `asynccontextmanager`

Making Objects Immutable with `frozen`

Customizing Fields with `field()`

Enforcing Keyword Arguments with `kw_only`