DEV Community: Free Python Code

Extract Text from Images in Python and EasyOCR

Free Python Code — Fri, 06 Mar 2026 17:21:51 +0000

Hi. 🙂✋

Today, I will share with you the best way to extract text from an image.
In this post i will use EasyOCR

EasyOCR supported 80+ languages like English, Arabic, etc.

pip install easyocr

Test image

Code


import easyocr

render = easyocr.Reader(['en'])

result = render.readtext('test.PNG')

for (bbox, text, prob) in result:
    print(text, prob)

result

Transaction history 0.7842562120735963
Date 0.9999991655349731
Status 0.9554524819849702
lype 0.507298361736864
Amount 0.9999717243897412
28 Jan, 2026 0.7362858686793263
Cancelled 0.9872234177018016
7 Withdrawn via 0.6650554314011714
Tipalti 0.974117337370147
-S1140 0.7596422017986225

I create an autocomplete plugin for sublime text.

Free Python Code — Fri, 06 Mar 2026 15:03:46 +0000

🐍 FreePythonCode Autocomplete

A lightweight, standalone Python autocompletion plugin for Sublime Text 4.
freepythoncode-autocomplete: Bringing the Brains back to Sublime Text

Why this plugin?

Zero Configuration: No need to install Python or Pip on your system.
Standalone: Comes bundled with Jedi and Parso.
Fast: Uses Sublime's Python 3.8 environment for optimal performance.

How it works

The plugin automatically detects the Python context and provides intelligent suggestions for classes, functions, and variables using the powerful Jedi engine.

Installation (Manual)

Open Sublime Text.
Go to Preferences -> Browse Packages...
Clone this repository into that folder:

   git clone https://github.com/amr2018/freepythoncode-autocomplete.git

💎 Credits & Acknowledgments

This project wouldn't be possible without the amazing open-source libraries and support:

Jedi - The core engine for Python autocompletion and static analysis.
Parso - The Python parser used by Jedi for understanding code structure.
Sublime Text - The legendary editor that we all love and strive to improve.
Gemini (Google AI) - For technical assistance, brainstorming, and helping in refining the code and documentation for this project.

Special thanks to the open-source community for maintaining the tools that make independent development possible. 🚀

Support the Project ☕

If you find this plugin helpful and want to support its development, you can buy me a coffee!

🚀 I Tested ElevenLabs Audio Isolation API with Python — Here’s What Happened

Free Python Code — Fri, 13 Feb 2026 08:59:30 +0000

Bad audio destroys good content.

You can have great ideas, clean code, and solid delivery — but if your audio has background noise, people click away.

So I decided to test ElevenLabs Audio Isolation using Python.

And honestly… the results surprised me.

🎯 The Goal

I wanted a simple script that:

Loads API key securely using .env

Sends an audio file to ElevenLabs

Automatically receives a cleaned version

Plays it back

Handles playback errors (like missing FFmpeg)

No heavy setup.
No manual editing.
Just API → cleaned audio.

🧠 Why This Is Interesting for Developers

We usually think of AI tools as:

Text generation

Chatbots

Image generation

But audio processing APIs like this open interesting use cases:

Cleaning podcast recordings automatically

Preprocessing audio before speech-to-text

Improving voiceovers programmatically

Automating content pipelines

It’s just one API call.

That’s powerful.

💻 The Core Idea

Instead of manually editing audio, the script does this:

Load environment variables

Initialize ElevenLabs client

Send raw audio bytes

Receive isolated audio

Play it instantly

Minimal code.
Real impact.

from os import getenv
from dotenv import load_dotenv
import webbrowser

from elevenlabs.client import ElevenLabs
from elevenlabs.play import play


load_dotenv()

api_key = getenv('api_key')


elevenlabs = ElevenLabs(api_key=api_key)


audio = elevenlabs.audio_isolation.convert(
    audio=open('catscan.mp3', 'rb').read()
)

try:
    play(audio)
except Exception as e:
    # If you are on linux, you need to install ffmpeg
    print(e)
    if 'ffmpeg' in str(e):
        print('Error playing audio, make sure you have ffmpeg installed')
        t = input('open ffmpeg installation guide on webbrowser? (y/n)')
        if t.lower() == 'y':
            webbrowser.open_new_tab(url='https://www.youtube.com/watch?v=5kjka11cKEY')
        else:
            print('You can install ffmpeg from here: https://ffmpeg.org/download.html')

⚡ The Result

The difference between the original and cleaned audio wasn’t subtle.

Background noise significantly reduced.
Voice clarity improved.

For content creators or devs building AI pipelines, this is extremely useful.

🔑 If You Want to Try It

You’ll need an ElevenLabs account to get an API key.

You can create one here:

👉 https://try.elevenlabs.io/2rb2e0emy5xg

After signup:

Go to the developer section

Generate your API key

Add it to your .env file

That’s it.

🛠 Things to Keep in Mind

If you're on Linux, make sure ffmpeg is installed for audio playback.

Otherwise, the API itself works fine — playback is the only dependency.

🤔 Final Thoughts

We’re entering a phase where:

Audio cleanup

Voice enhancement

Content automation

…can be done in a few lines of code.

That changes how we build tools.

Have you tried automating audio processing in your projects?

Would you integrate something like this into your workflow?

Let’s discuss 👇

Python AI Voice Generator with ElevenLabs v3, Emotional Audio Tags, and Instant Playback

Free Python Code — Fri, 13 Feb 2026 08:11:33 +0000

Hi. 🙂 ✋

In this post, I will show you how to make simple text-to-speech. Generator using an amazing API called ElevenLabs.

Let's start step by step

step 1

Create an account in ElevenLabs from here

step 2

Get Your API Key from here

Step 3

Install required libraries.

elevenlabs==2.35.0
python-dotenv==1.2.1

Step 4

Create .env to store your API key safely

Step 5

Writing code 😎

from os import getenv
from dotenv import load_dotenv
import webbrowser

from elevenlabs.client import ElevenLabs
from elevenlabs.play import play


load_dotenv()

api_key = getenv('api_key')

if not api_key:
    print('You need api key')
    print('Create account from : https://try.elevenlabs.io/2rb2e0emy5xg')
    print('Go to :https://elevenlabs.io/app/developers/api-keys')
    print('Or write any thing to open the link on webbrowser')
    text = input('write any thing:')
    webbrowser.open_new_tab(url='https://try.elevenlabs.io/2rb2e0emy5xg')


elevenlabs = ElevenLabs(api_key=api_key)


text = """
"Okay… [calm] breathe. Just one step at a time. [hesitates] I thought I was ready for this, but my hands are shaking.

[softly] Listen… I’m not angry. I’m just… disappointed. [frustrated sigh] Because you promised me you would show up.

[trying to sound fine] It’s okay! Really. I can handle it. [voice cracks] I can handle it… I just didn’t want to handle it alone.

[whispers] Do you hear that? The room gets so loud when nobody answers. [pauses] And then your brain starts filling in the silence with worst-case stories.

[sudden realization] Wait. No— I’m doing it again. [grounded] I’m here. I’m safe. I can choose what happens next.

[hopeful] Maybe this isn’t the end of the story. [small laugh] Maybe it’s the part where it finally turns.

[excited] Okay—okay. New plan. [confident] I’m going to call you once, then I’m going to move forward. [smiling] Because I’m done begging for a place in my own life."
"""
audio = elevenlabs.text_to_speech.convert(
    voice_id='hpp4J3VqNfWAUOO0d1Us',
    model_id='eleven_v3',
    text = text
)

try:
    play(audio)
except Exception as e:
    # If you are on linux, you need to install ffmpeg
    if 'ffmpeg' in str(e):
        print('Error playing audio, make sure you have ffmpeg installed')
        t = input('open ffmpeg installation guide on webbrowser? (y/n)')
        if t.lower() == 'y':
            webbrowser.open_new_tab(url='https://www.youtube.com/watch?v=5kjka11cKEY')
        else:
            print('You can install ffmpeg from here: https://ffmpeg.org/download.html')

Clean Pagination in FastAPI Using Python’s batched() Function

Free Python Code — Wed, 26 Nov 2025 18:07:38 +0000

Pagination is one of the most common requirements when building APIs. Almost every real-world application needs to return data in chunks instead of sending everything at once.

In this post, I’ll show you a clean and modern way to implement pagination in FastAPI using Python’s itertools.batched() function, without manual slicing or complex index calculations.

✅ Why Pagination Matters

Without pagination:

Responses become very large
Performance decreases
Memory usage increases
Mobile clients suffer

With pagination:

Faster API responses
Better user experience
Scalable backend design

✅ Project Idea

We’ll build a simple /posts endpoint that:

Loads posts from a JSON file
Supports page-based pagination
Uses batched() instead of manual slicing
Returns clean, structured API responses

✅ Example JSON Database

Here’s a sample of the JSON data we’ll be using:

{
  "posts": [
    {
      "id": 1,
      "userId": 101,
      "title": "Learning Python Basics",
      "content": "Today I started learning Python and wrote my first script.",
      "likes": 23,
      "comments": 2,
      "created_at": "2025-01-01T10:03:11Z"
    },
    {
      "id": 2,
      "userId": 102,
      "title": "Exploring SQLAlchemy ORM",
      "content": "SQLAlchemy relationships were confusing at first but now they're amazing.",
      "likes": 40,
      "comments": 5,
      "created_at": "2025-01-02T14:12:33Z"
    },
    {
      "id": 3,
      "userId": 103,
      "title": "How I Built My First API",
      "content": "Used FastAPI to build a simple notes app today.",
      "likes": 55,
      "comments": 7,
      "created_at": "2025-01-03T09:45:20Z"
    }
  ]
}

✅ The FastAPI Pagination Code

Here is the full implementation of our paginated endpoint:

from fastapi import FastAPI
from itertools import batched
import json

# Load posts from json DB
with open('data/fake_db.json', 'r') as f:
    posts_db = json.load(f)['posts']

app = FastAPI()

@app.get('/posts')
def show_posts(page_num: int = 0, posts_len: int = 3):
    sliced_posts = [
        list(posts) for posts in batched(posts_db, n=posts_len)
    ][page_num]

    return {'posts': sliced_posts}

✅ How It Works

Let’s break it down step by step:

1️⃣ Load the JSON Database

We load all posts into memory:

with open('data/fake_db.json', 'r') as f:
    posts_db = json.load(f)['posts']

2️⃣ Use `batched()` for Clean Chunking

Instead of manual slicing like this:

posts[start:end]

We use:

batched(posts_db, n=posts_len)

This automatically splits the list into groups of size posts_len.

3️⃣ Select the Page

We convert the batches into a list and select the requested page:

[list(posts) for posts in batched(posts_db, n=posts_len)][page_num]

This makes the logic:

Clean
Readable
Easy to maintain

✅ Example API Requests

🔹 Get First Page (Default)

GET /posts

🔹 Get Second Page With 5 Posts

GET /posts?page_num=1&posts_len=5

✅ Example API Response

{
  "posts": [
    {
      "id": 4,
      "userId": 104,
      "title": "Another Post",
      "content": "This is another example post.",
      "likes": 10,
      "comments": 1,
      "created_at": "2025-01-04T12:00:00Z"
    }
  ]
}

✅ Benefits of This Approach

✅ No manual index math
✅ Cleaner Python code
✅ Easier to read and debug
✅ Works great with small & medium datasets
✅ Perfect for demos, tutorials, and prototypes

⚠️ Important Note for Production

While this approach is great for learning and small projects, you should use database-level pagination for large datasets (LIMIT & OFFSET) instead of loading everything into memory.

✅ Conclusion

Using itertools.batched() with FastAPI gives you a very elegant way to implement pagination without messy slicing logic. It’s a great technique to keep your API clean and maintainable.

If you enjoyed this article, feel free to like, share, and follow for more backend & Python tips 🚀

🔐 Building an Ultra-Secure Token Generator in Python (Multi-Source Entropy + HMAC + Pepper)

Free Python Code — Fri, 14 Nov 2025 18:29:21 +0000

Security tokens are everywhere—authentication systems, API keys, session IDs, and cryptographic workflows. But generating truly unpredictable tokens is harder than most developers think.

In this article, I’ll walk you through how I built a high-entropy, multi-source token generator using Python.
It combines:

✅ Webcam entropy
✅ Microphone entropy
✅ System randomness
✅ CSPRNG (secrets)
✅ os.urandom()
✅ HMAC-SHA256
✅ A secret pepper (stored in environment variables)

The goal: Make tokens as unpredictable and tamper-resistant as possible.

🚀 Why Multi-Source Entropy?

Tokens generated only with random() (or any weak RNG) are predictable.
Even secrets.token_hex()—while secure—is still based on a single entropy source.

So I decided to stack entropy from multiple hardware and software sources:

Microphone noise

Webcam pixel randomness

CPU load

High-resolution timers

OS randomness

CSPRNG randomness

Mixing them together gives an attacker nothing stable to model or predict.

import os
import time
import hmac
import sounddevice as sd
import cv2
from hashlib import sha256
import secrets
import subprocess
from colored import stylize, fg
from dotenv import load_dotenv


load_dotenv()


PEPPER = os.getenv('PEPPER')

def camera_entropy():
    try:
        cam = cv2.VideoCapture(0)
        if not cam.isOpened():
            return b''

        # Capture a single frame
        ret, frame = cam.read()
        cam.release()

        if not ret:
            return b''

        # Convert frame (numpy array) to bytes
        return frame.tobytes()
    except:
        return b''


def microphone_entropy():
    try:
        sample_rate = 44100
        duration = 1

        rec = sd.rec(
            int(sample_rate * duration),
            samplerate=sample_rate,
            channels=1,
            dtype='int16'
        )
        sd.wait()
        return rec.tobytes()
    except:
        return b''


def system_entropy():
    try:
        cpu_load = subprocess.getoutput("wmic cpu get loadpercentage")
    except:
        cpu_load = "0"

    data = f"{cpu_load}{os.times()}{os.getenv('PROCESSOR_IDENTIFIER')}{time.perf_counter_ns()}"
    return data.encode()


def extra_entropy():
    mic = microphone_entropy()
    cam = camera_entropy()
    sys_info = system_entropy()
    timer = str(time.time_ns()).encode()
    os_rand = os.urandom(64)

    mix = mic + cam + sys_info + timer + os_rand
    return sha256(mix).digest()


def generate_token():
    # Mix CSPRNG + all entropy sources
    mix = str(secrets.token_bytes(32) + extra_entropy())
    hc = hmac.new(PEPPER.encode(), mix.encode(), digestmod=sha256).hexdigest()
    return hc


while True:
    print(stylize(f"Secure Token: {generate_token()}", fg(40)))

🧠 How It Works
🎤 1. Microphone Noise

Microphone audio is full of unpredictable static and background variation.
We record 1 second of raw audio and convert it to bytes.

📷 2. Camera Frame Entropy

A single webcam frame contains millions of pixel values.
Even tiny changes (light, movement, noise) create strong randomness.

🖥️ 3. System-Level Entropy

We add:

CPU load

OS timestamps

CPU model ID

High-precision timers (perf_counter_ns())

These are continuously changing values.

🔒 4. OS Randomness

os.urandom(64) gives cryptographically secure bytes from the OS entropy pool.

🔐 5. Secrets Generator

secrets.token_bytes(32) adds a strong CSPRNG value to the mix.

🧂 6. Pepper + HMAC

We finish with:

hmac.new(PEPPER.encode(), mix.encode(), sha256).hexdigest()

The PEPPER is a secret stored outside the code in .env.
Even if an attacker gets the script, they cannot reproduce or modify tokens without the pepper.

🔥 Why This Is Extremely Secure

This generator combines:

hardware noise

OS randomness

cryptographic RNG

realtime system variability

HMAC integrity

an external secret pepper

Each layer strengthens the previous one.

Even if someone tries to model one entropy source, they can’t model all of them at once.

⚠ A Note About Pepper Security

If you lose your PEPPER, you cannot verify tokens anymore.
It should be stored in:

.env

a secrets manager

environment variables

or encrypted storage

Never commit it to GitHub.

🧩 Possible Improvements

If you want to go even further:

Add disk I/O randomness

Hash multiple webcam frames

Add keyboard/mouse timing noise

Mix in network latency jitter

Use HKDF to derive multiple tokens

🏁 Final Thoughts

Cryptographic security is not about adding “a little randomness.”
It’s about combining unpredictable, independent sources that make attacks impossible.

This project is a fun—and powerful—example of how to push entropy to the next level.

How to Generate Sound Effects with Python and ElevenLabs in a Few Lines of Code

Free Python Code — Thu, 07 Aug 2025 17:34:33 +0000

Introduction

Ever needed a quick sound effect for a project, but didn't have a sound designer or the time to find the right audio clip? What if you could generate it from a simple text prompt using a powerful AI?

In this quick tutorial, we'll walk through how to use the ElevenLabs API and Python to create a custom sound effect, like "a dramatic explosion," with just a few lines of code. This is perfect for indie game developers, content creators, or anyone looking to add a little flair to their projects.

Install

pip install elevenlabs==2.9.1
pip install python-dotenv==1.1.1

Create an account in Elevenlabs from here

Go to API key

Create an API key and

Make sure that Sound Effects is "Has Access"

The Code

Here is the simple Python script we'll be using.

import os
from dotenv import load_dotenv
from elevenlabs.client import ElevenLabs

load_dotenv()

elevenlabs = ElevenLabs(
    api_key=os.getenv("ELEVENLABS_API_KEY"),
)

text_to_convert = "a dramatic explosion"

# The convert method returns a generator by default
audio_generator = elevenlabs.text_to_sound_effects.convert(
    text=text_to_convert
)

# Join the audio chunks from the generator into a single bytes object
audio_bytes = b"".join(audio_generator)

# Now, write the single bytes object to the file
with open("explosion.mp3", "wb") as f:
    f.write(audio_bytes)

print(f"Sound effect for '{text_to_convert}' saved to explosion.mp3")

How It Works
Dependencies: We start by importing the necessary libraries: os for handling environment variables, dotenv to load our API key, and elevenlabs for the core functionality.

Authentication: We initialize the ElevenLabs client with our API key, which is securely loaded from a .env file. This is a best practice for keeping your credentials safe.

The Magic: The text_to_sound_effects.convert() method is the heart of the script. It takes a text description—in this case, "a dramatic explosion"—and sends it to the ElevenLabs AI model.

Handling the Output: The method returns an audio generator, which we then join into a single bytes object. This is a crucial step to ensure the entire audio clip is saved correctly.

Saving the File: Finally, the code writes the bytes object to a file named explosion.mp3 and prints a confirmation message.

Conclusion & Call to Action
With just this small script, you can bring your ideas to life with custom audio. The ElevenLabs API offers a wide range of possibilities for creating unique sound effects and voiceovers.

Want to try it yourself? You can get started with the ElevenLabs text-to-sound effects tool for free.

👉 Try it here:

Python #ElevenLabs #SoundEffects #AI #Programming #APIs #Tutorial #DevCommunity #Audio #Code

🐍 Visualizing Function Execution in Python with a Simple Progress Bar

Free Python Code — Fri, 25 Jul 2025 16:14:14 +0000

Have you ever wanted to track the progress of a series of function calls in Python — maybe during some tasks that take time to complete?

In this short post, I’ll show you a minimal example of how to execute a list of functions sequentially while displaying a simple progress bar to track completion in the terminal.

🔧 Code Walkthrough

import time

def test_1():
    time.sleep(5)
    print('this is function 1')

def test_2():
    time.sleep(2)
    print('this is function 2')

def test_3():
    time.sleep(3)
    print('this is function 3')

def test_4():
    time.sleep(1)
    print('this is function 4')


func_list = [
    {'index': 1, 'func': test_1},
    {'index': 2, 'func': test_2},
    {'index': 3, 'func': test_3},
    {'index': 4, 'func': test_4},
]

for func_dict in func_list:
    index = func_dict['index']
    function = func_dict['func']

    # call function
    function()

    # progress bar
    progress_total = len(func_list)
    progress_bar = int((index / progress_total) * progress_total)

    # percent
    percent = int((index / progress_total) * 100)

    print('🟩' * progress_bar, f'{percent} %')

🧠 What’s Happening Here?

- time.sleep() is used to simulate time-consuming operations.
- We store functions in a list of dictionaries with their respective index.
- After each function call, we calculate:
- Progress bar length
- Percent complete
- A simple emoji-based progress bar (🟩) is printed after each function.

✅ Sample Output

this is function 1
🟩 25 %
this is function 2
🟩🟩 50 %
this is function 3
🟩🟩🟩 75 %
this is function 4
🟩🟩🟩🟩 100 %

💡 Ideas for Improvement

Add concurrent execution using asyncio or concurrent.futures.
Turn the progress bar into a dynamic inline update (e.g., using \r or libraries like tqdm).
Add color using the colorama library or similar.

If you found this helpful, drop a ❤️ or follow me for more Python tips!
Let me know in the comments: How would you improve this basic progress tracker?

How To Make a Smart Password Generator

Free Python Code — Sun, 20 Jul 2025 17:26:06 +0000

Hi 🙂🖐

In this post, I will share a simple idea with you.
This idea about password generation is that we will use a password to generate a password like this.

for ex:

abc123/* -> cwy572<>

As you can see, the password contains similar content to each
other


import string
from random import choice

def generate_like_this(password):
    password_content = [
        string.digits,
        string.punctuation,
        string.ascii_lowercase,
        string.ascii_uppercase
    ]

    new_pass = ''

    for p_char in password:
        for p_list in password_content:
            if p_char in p_list:
                new_pass += choice(p_list)

    return new_pass


result = generate_like_this('abc123/*')
print(result)

🧠 Why I Use Dynadot to Buy Domain Names for My Dev Projects 🚀

Free Python Code — Sun, 04 May 2025 09:25:08 +0000

As a developer, I've launched more than a few side projects — from APIs to landing pages and SaaS experiments. One thing I always need? A clean, simple, and affordable way to get a domain name fast.

Over time, I’ve tried multiple registrars, but most of them either:

Overcharge on renewals 💸

Add annoying upsells 😩

Or have dashboards that feel like they're stuck in 2008 😅

That’s when I found Dynadot, and here’s why I stuck with it:

✅ Developer-Friendly Features I Love:
Free WHOIS Privacy by default 🔒

Modern, minimal UI — easy to search, buy, and manage domains

No sneaky upsells or inflated renewals

DNS management, email forwarding, and more built right in

Tons of domains (.com, .dev, .tech, .io, .xyz...)

🚀 Quick Tip for Devs:
When I build a new tool or MVP, I usually:

Deploy to Vercel or Netlify

Grab a domain from Dynadot

Connect DNS in <5 minutes

That’s it. Simple, fast, done.

Want to Try It?
If you're spinning up a new project or portfolio and need a solid domain, you can start with Dynadot using my referral link:
👉 http://www.dynadot.com?s6r7d7GR8d7x8J7g

(Yes, it's a referral, and yes, I actually use it for all my domains 😄)

Let me know what registrar you use — I’m always curious to hear what works best for others.

Happy building! 🧑‍💻✨

How to disable the close or X button in Tkinter

Free Python Code — Sun, 24 Nov 2024 18:11:12 +0000

code:

import tkinter as tk

root = tk.Tk()
root.geometry('200x200')

# create a function to close the window
def close_window():
    root.destroy()

close_bt = tk.Button(root, text = 'close', command = close_window)
close_bt.pack()

# create a function to disable close bt of the main window
def disable_close_bt():
    return

root.protocol('WM_DELETE_WINDOW', disable_close_bt)
root.mainloop()

[SOlVED] SmileyDB3 Error KeyError: "" in Insert

Free Python Code — Wed, 14 Aug 2024 19:27:40 +0000

/AppData/Local/Programs/Python/Python312/Lib/site-packages/SmileyDB3/SmileyDB3.py
Traceback (most recent call last):
File "c:\Users\user\AppData\Local\Programs\Python\Python312\Lib\site-packages\SmileyDB3\SmileyDB3.py", line 344, in
items.Insert(data = {
File "c:\Users\user\AppData\Local\Programs\Python\Python312\Lib\site-packages\SmileyDB3\SmileyDB3.py", line 78, in Insert
(_index {self.types['INDEX']}, {self.get_types(data)})
^^^^^^^^^^^^^^^^^^^^
File "c:\Users\user\AppData\Local\Programs\Python\Python312\Lib\site-packages\SmileyDB3\SmileyDB3.py", line 60, in get_types
cols.append(f'{k} {self.types[str(type(data[k]))]}')
~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^
KeyError: "<class 'float'>"

Uninstall the library

pip uninstall SmileyDB3

Install the latest version

pip install SmileyDB3

https://github.com/amr2018/SmileyDB3/issues/1