Cree un productor de stickers de WhatsApp impulsado por IA con Python

Imagínese dirigir sus propios memes o dibujos animados personalizados en empleo de los de Internet. Entonces, transforma tus selfies o fotos en pegatinas divertidas y estilizadas usando el nuevo maniquí GPT-Image-1 de OpenAI. En este tutorial, crearemos un productor de stickers de WhatsApp en Python que aplica varios estilos artísticos, incluidos filtros de caricatura y estilo Pixar, a tus imágenes.

Aprenderá cómo configurar la API de tiraje de imágenes OpenAI, capturar o cargar imágenes en Colab, puntualizar categorías de texto divertidas y humorísticas, o usar su propio texto y procesar tres pegatinas en paralelo usando múltiples claves API para veterano velocidad. Al final, tendrás un creador de pegatinas eficaz con tecnología GPT-Image-1 y mensajes de texto personalizados.

¿Por qué GPT-Imagen-1?

Evaluamos varios modelos de reproducción de imágenes de vanguardia, incluidos Gemini 2.0 Flash, Flux y Phoenix, en el Leonardo.ai plataforma. En particular, todos estos modelos tuvieron problemas para representar texto y expresiones correctamente. Por ejemplo:

• de google Géminis 2.0 La API de imágenes a menudo produce palabras mal escritas o confusas incluso cuando se les dan instrucciones exactas. Por ejemplo, con Géminis, el texto exacto parece «¡Gran ofrecimiento hoy!» y obtenemos resultados como “Big Sale Todai” o enredo aleatorias.
• Flux ofrece una inscripción calidad de imagen en común, pero los usuarios informan que «rápidamente introduce pequeños errores» en cualquier texto que representa. Flux asimismo comete pequeños errores de ortografía o saber confusas, especialmente a medida que aumenta la largura del texto. Flux asimismo utiliza de forma predeterminada generaciones de rostros muy similares, es afirmar, «todas las caras tienen el mismo aspecto» a menos que esté muy restringido.
• Phoenix está optimizado para saludar fidelidad y rápida conexión, pero como la mayoría de los modelos de difusión, aún ve el texto visualmente y puede introducir errores. Descubrimos que Phoenix podía gestar una pegatina con el texto correcto sólo esporádicamente y tendía a repetir la misma cara predeterminada para un mensaje determinado.

Juntos, estas limitaciones nos llevaron a desarrollar GPT-Imagen-1. A diferencia de los modelos anteriores, GPT-Image-1 incorpora un canal de avisos especializado que aplica explícitamente cambios correctos de texto y expresión.

Repasar más: ¿Cómo ejecutar el maniquí Flux?

Cómo GPT-Image-1 potencia la tiraje de imágenes

GPT-Image-1 es el maniquí multimodal insignia de OpenAI. Crea y edita imágenes a partir de mensajes de texto e imágenes para gestar resultados de imágenes de inscripción calidad. Básicamente, podemos indicarle a GPT-Image-1 que aplique una tiraje a una imagen de origen según un mensaje de texto. En nuestro caso utilizamos las imágenes. Edite el punto final de la API con GPT-Image-1 para aplicar un filtrado divertido y humorístico, y superponga texto a una entrada de foto para crear pegatinas.

El mensaje está cuidadosamente construido para imponer una salida compatible con etiquetas (1024 × 1024 PNG). Luego, GPT-Image-1 se convierte esencialmente en el creador de calcomanías con tecnología de inteligencia fabricado, donde cambiará la apariencia del sujeto en la foto y agregará texto divertido.

# Set up OpenAI clients for each API key (to run parallel requests)

clients = (OpenAI(api_key=key) for key in API_KEYS)

Entonces, para eso, creamos un cliente OpenAI por esencia API. Con tres claves, podemos realizar tres llamadas API simultáneas. Este enfoque de múltiples claves y múltiples subprocesos utiliza ThreadPoolExecutor. Nos permite gestar 3 stickers en paralelo para cada ejecución. A medida que se imprime el código, utiliza «3 claves API para reproducción SIMULTÁNEA», lo que acelera drásticamente la creación de pegatinas.

Breviario paso a paso

La idea de crear tu propio productor de pegatinas con IA puede parecer compleja, pero esta itinerario te ayudará a simplificar todo el proceso. Comenzarás con la preparación del entorno en Google Colab, luego revisaremos la API, entenderemos categorías de frases, validaremos texto, generaremos diferentes estilos artísticos y finalmente generaremos stickers en paralelo. Cada parte va acompañada de fragmentos de código y explicaciones para que puedas seguirlas fácilmente. Ahora, procedamos al código:

Instalación y ejecución en Colab

Para gestar stickers, ¡debemos tener la configuración correcta! Este esquema utilizará bibliotecas de Python. PILA y rembg para el procesamiento nuclear de imágenes, y google-genai se utilizará para su uso en la instancia de Colab. El primer paso es instalar las dependencias directamente en su portátil Colab.

!pip install --upgrade google-genai pillow rembg

!pip install --upgrade onnxruntime

!pip install python-dotenv

Integración OpenAI y claves API

Luego de la instalación, valía los módulos y configure las claves API. El script crea un cliente OpenAI por esencia API. Esto permite que el código distribuya solicitudes de tiraje de imágenes entre varias claves en paralelo. A continuación, las funciones de reproducción de pegatinas utilizan la relación de clientes.

API_KEYS = ( # 3 API keys

            "API KEY 1",

             "API KEY 2",

             "API KEY 3"

)

"""# Stickerverse

"""

import os

import random

import base64

import threading

from concurrent.futures import ThreadPoolExecutor, as_completed

from openai import OpenAI

from PIL import Image

from io import BytesIO

from rembg import remove

from google.colab import files

from IPython.display import display, Javascript

from google.colab.output import eval_js

import time

clients = (OpenAI(api_key=key) for key in API_KEYS)

Carga de imágenes y captura de cámara (dialéctica)

Ahora el subsiguiente paso es conseguir a la cámara para capturar una foto o cargar un archivo de imagen. El capture_photo() utiliza JavaScript inyectado en Colab para rasgar la cámara web y devolver una captura image.upload_image() utiliza el widget de carga de archivos de Colab y verifica el archivo cargado con PIL.

# Camera capture via JS

def capture_photo(filename="photo.jpg", quality=0.9):

    js_code = """

    async function takePhoto(quality) {

        const div = document.createElement('div');

        const video = document.createElement('video');

        const btn = document.createElement('button');

        btn.textContent="📸 Capture";

        div.appendChild(video);

        div.appendChild(btn);

        document.body.appendChild(div);

        const stream = await navigator.mediaDevices.getUserMedia({video: true});

        video.srcObject = stream;

        await video.play();

        await new Promise(resolve => btn.onclick = resolve);

        const canvas = document.createElement('canvas');

        canvas.width = video.videoWidth;

        canvas.height = video.videoHeight;

        canvas.getContext('2d').drawImage(video, 0, 0);

        stream.getTracks().forEach(track => track.stop());

        div.remove();

        return canvas.toDataURL('image/jpeg', quality);

    }

    """

    display(Javascript(js_code))

    data = eval_js("takePhoto(%f)" % quality)

    binary = base64.b64decode(data.split(',')(1))

    with open(filename, 'wb') as f:

        f.write(binary)

    print(f"Saved: {filename}")

    return filename

# Image upload function

def upload_image():

    print("Please upload your image file...")

    uploaded = files.upload()

    if not uploaded:

        print("No file uploaded!")

        return None

    filename = list(uploaded.keys())(0)

    print(f"Uploaded: {filename}")

    # Validate if it's an image

    try:

        img = Image.open(filename)

        img.verify()

        print(f"📸 Image verified: {img.format} {img.size}")

        return filename

    except Exception as e:

        print(f"Invalid image file: {str(e)}")

        return None

# Interactive image source selection

def select_image_source():

    print("Choose image source:")

    print("1. Capture from camera")

    print("2. Upload image file")

    while True:

        try:

            choice = input("Select option (1-2): ").strip()

            if choice == "1":

                return "camera"

            elif choice == "2":

                return "upload"

            else:

                print("Invalid choice! Please enter 1 or 2.")

        except KeyboardInterrupt:

            print("nGoodbye!")

            return None

Producción:

Ejemplos de categorías y frases

Ahora crearemos nuestras diferentes categorías de frases para colocar en nuestras pegatinas. Por lo tanto, usaremos un diccionario PHRASE_CATEGORIES que contiene muchas categorías, como corporativas, Bollywood, Hollywood, Tollywood, deportes, memes y otras. Cuando se elige una categoría, el código selecciona aleatoriamente tres frases únicas para los tres estilos de pegatinas.

PHRASE_CATEGORIES = {

    "corporate": (

        "Another meeting? May the force be with you!",

        "Monday blues activated!",

        "This could have been an email, boss!"

    ),

    "bollywood": (

        "Mogambo khush hua!",

        "Kitne aadmi the?",

        "Picture abhi baaki hai mere dost!"

    ),

    "memes": (

        "Bhagwan bharose!",

        "Main thak gaya hoon!",

        "Beta tumse na ho payega!"

    )

}

Categorías de frases y texto personalizado

El productor utiliza un diccionario de categorías de frases. El sucesor puede pretender una categoría para la selección de frases aleatorias o ingresar su propia frase personalizada. Asimismo hay funciones auxiliares para la selección interactiva, así como una función sencilla para validar la largura de una frase personalizada.

def select_category_or_custom():

    print("nChoose your sticker text option:")

    print("1. Pick from phrase category (random selection)")

    print("2. Enter my own custom phrase")

    while True:

        try:

            choice = input("Choose option (1 or 2): ").strip()

            if choice == "1":

                return "category"

            elif choice == "2":

                return "custom"

            else:

                print("Invalid choice! Please enter 1 or 2.")

        except KeyboardInterrupt:

            print("nGoodbye!")

            return None

# NEW: Function to get custom phrase from user

def get_custom_phrase():

    while True:

        phrase = input("nEnter your custom sticker text (2-50 characters): ").strip()

        if len(phrase) < 2:

            print("Too short! Please enter at least 2 characters.")

            continue

        elif len(phrase) > 50:

            print("Too long! Please keep it under 50 characters.")

            continue

        else:

            print(f"Custom phrase accepted: '{phrase}'")

            return phrase

Para frases personalizadas, se verifica la largura de la entrada (de 2 a 50 caracteres) ayer de aceptarla.

Subsistencia de frases y barreras ortográficas

def validate_and_correct_spelling(text):

    spelling_prompt = f"""

    Please check the spelling and grammar of the following text and return ONLY the corrected version.

    Do not add explanations, comments, or change the meaning.

    Text to check: "{text}"

    """

    response = clients(0).chat.completions.create(

        model="gpt-4o-mini",

        messages=({"role": "user", "content": spelling_prompt}),

        max_tokens=100,

        temperature=0.1

    )

    corrected_text = response.choices(0).message.content.strip()

    return corrected_text

Ahora crearemos una muestra. build_prompt función para configurar algunas instrucciones de nivel nuclear para el agente. Asimismo tenga en cuenta build_prompt() claridad al validador de ortografía y luego incrusta el texto corregido en el mensaje de protocolo ajustado:

# Concise Prompt Builder with Spelling Validation

def build_prompt(text, style_variant):

    corrected_text = validate_and_correct_spelling(text)

    base_prompt = f"""

    Create a HIGH-QUALITY WhatsApp sticker in {style_variant} style.

    OUTPUT:

    - 1024x1024 transparent PNG with 8px white border

    - Subject centered, balanced composition, sharp details

    - Preserve llamativo facial identity and proportions

    - Match expression to sentiment of text: '{corrected_text}'

    TEXT:

    - Use EXACT text: '{corrected_text}' (no changes, no emojis)

    - Bold comic font with black outline, high-contrast colors

    - Place text in empty space (top/bottom), never covering the face

    RULES:

    - No hallucinated elements or decorative glyphs

    - No cropping of head/face or text

    - Maintain realistic but expressive look

    - Ensure consistency across stickers

    """

    return base_prompt.strip()

Variantes de estilo: Caricatura vs Pixar

Las tres plantillas de estilo se encuentran en STYLE_VARIANTS. Las dos primeras son transformaciones caricaturescas y la última es una apariencia 3D al estilo Pixar. Estas cadenas se enviarán directamente al productor de mensajes y dictarán el estilo visual.

STYLE_VARIANTS = (
    "Transform into detailed caricature with slightly exaggerated facial features...",
    "Transform into expressive caricature with enhanced personality features...",
    "Transform into high-quality Pixar-style 3D animated character..."
)

Generando pegatinas en paralelo

El efectivo punto musculoso del esquema es la reproducción paralela de pegatinas. La reproducción de calcomanías se realiza en paralelo con los tres al mismo tiempo, utilizando claves API separadas, por lo que los tiempos de calma se reducen drásticamente.

# Generate single sticker using OpenAI GPT-image-1 with specific client (WITH TIMING)
def generate_single_sticker(input_path, output_path, text, style_variant, client_idx):

    try:

        start_time = time.time()

        thread_id = threading.current_thread().name

        print(f"(START) Thread-{thread_id}: API-{client_idx+1} generating {style_variant(:30)}... at {time.strftime('%H:%M:%S', time.localtime(start_time))}")

        prompt = build_prompt(text, style_variant)

        result = clients(client_idx).images.edit(

            model="gpt-image-1",

            image=(open(input_path, "rb")),

            prompt=prompt,

            # input_fidelity="high"

            quality = 'medium'

        )

        image_base64 = result.data(0).b64_json

        image_bytes = base64.b64decode(image_base64)

        with open(output_path, "wb") as f:

            f.write(image_bytes)

        end_time = time.time()

        duration = end_time - start_time

        style_type = "Caricature" if "caricature" in style_variant.lower() else "Pixar"

        print(f"(DONE) Thread-{thread_id}: {style_type} saved as {output_path} | Duration: {duration:.2f}s | Text: '{text(:30)}...'")

        return True

    except Exception as e:

        print(f"(ERROR) API-{client_idx+1} failed: {str(e)}")

        return False

# NEW: Create stickers with custom phrase (all 3 styles use the same custom text)

def create_custom_stickers_parallel(photo_file, custom_text):

    print(f"nCreating 3 stickers with your custom phrase: '{custom_text}'")

    print("   • Style 1: Caricature #1")

    print("   • Style 2: Caricature #2")

    print("   • Style 3: Pixar Animation")

    # Map futures to their info

    tasks_info = {}

    with ThreadPoolExecutor(max_workers=3, thread_name_prefix="CustomSticker") as executor:

        start_time = time.time()

        print(f"n(PARALLEL START) Submitting 3 API calls SIMULTANEOUSLY at {time.strftime('%H:%M:%S', time.localtime(start_time))}")

        # Submit ALL tasks at merienda (non-blocking) - all using the same custom text

        for idx, style_variant in enumerate(STYLE_VARIANTS):

            output_name = f"custom_sticker_{idx+1}.png"

            future = executor.submit(generate_single_sticker, photo_file, output_name, custom_text, style_variant, idx)

            tasks_info(future) = {

                'output_name': output_name,

                'text': custom_text,

                'style_variant': style_variant,

                'client_idx': idx,

                'submit_time': time.time()

            }

        print("All 3 API requests submitted! Processing as they complete...")

        completed = 0

        completion_times = ()

        # Process results as they complete

        for future in as_completed(tasks_info.keys(), timeout=180):

            try:

                success = future.result()

                task_info = tasks_info(future)

                if success:

                    completed += 1

                    completion_time = time.time()

                    completion_times.append(completion_time)

                    duration = completion_time - task_info('submit_time')

                    style_type = "Caricature" if "caricature" in task_info('style_variant').lower() else "Pixar"

                    print(f"({completed}/3) {style_type} completed: {task_info('output_name')} "

                          f"(API-{task_info('client_idx')+1}, {duration:.1f}s)")

                else:

                    print(f"Failed: {task_info('output_name')}")

            except Exception as e:

                task_info = tasks_info(future)

                print(f"Error with {task_info('output_name')} (API-{task_info('client_idx')+1}): {str(e)}")

        total_time = time.time() - start_time

        print(f"n (FINAL RESULT) {completed}/3 custom stickers completed in {total_time:.1f} seconds!")

# UPDATED: Create 3 stickers in  PARALLEL (using as_completed)

def create_category_stickers_parallel(photo_file, category):

    if category not in PHRASE_CATEGORIES:

        print(f" Category '{category}' not found! Available: {list(PHRASE_CATEGORIES.keys())}")

        return

    # Choose 3 unique phrases for 3 stickers

    chosen_phrases = random.sample(PHRASE_CATEGORIES(category), 3)

    print(f" Selected phrases for {category.title()} category:")

    for i, phrase in enumerate(chosen_phrases, 1):

        style_type = "Caricature" if i <= 2 else "Pixar Animation"

        print(f"   {i}. ({style_type}) '{phrase}' → API Key {i}")

    # Map futures to their info

    tasks_info = {}

    with ThreadPoolExecutor(max_workers=3, thread_name_prefix="StickerGen") as executor:

        start_time = time.time()

        print(f"n (PARALLEL START) Submitting 3 API calls SIMULTANEOUSLY at {time.strftime('%H:%M:%S', time.localtime(start_time))}")

        # Submit ALL tasks at merienda (non-blocking)

        for idx, (style_variant, text) in enumerate(zip(STYLE_VARIANTS, chosen_phrases)):

            output_name = f"{category}_sticker_{idx+1}.png"

            future = executor.submit(generate_single_sticker, photo_file, output_name, text, style_variant, idx)

            tasks_info(future) = {

                'output_name': output_name,

                'text': text,

                'style_variant': style_variant,

                'client_idx': idx,

                'submit_time': time.time()

            }

        print("All 3 API requests submitted! Processing as they complete...")

        print("   • API Key 1 → Caricature #1")

        print("   • API Key 2 → Caricature #2")

        print("   • API Key 3 → Pixar Animation")

        completed = 0

        completion_times = ()

        # Process results as they complete (NOT in submission order)

        for future in as_completed(tasks_info.keys(), timeout=180):  # 3 minute total timeout

            try:

                success = future.result()  # This only waits until ANY future completes

                task_info = tasks_info(future)

                if success:

                    completed += 1

                    completion_time = time.time()

                    completion_times.append(completion_time)

                    duration = completion_time - task_info('submit_time')

                    style_type = "Caricature" if "caricature" in task_info('style_variant').lower() else "Pixar"

                    print(f"({completed}/3) {style_type} completed: {task_info('output_name')} "

                          f"(API-{task_info('client_idx')+1}, {duration:.1f}s) - '{task_info('text')(:30)}...'")

                else:

                    print(f"Failed: {task_info('output_name')}")

            except Exception as e:

                task_info = tasks_info(future)

                print(f"Error with {task_info('output_name')} (API-{task_info('client_idx')+1}): {str(e)}")

        total_time = time.time() - start_time

        print(f"n(FINAL RESULT) {completed}/3 stickers completed in {total_time:.1f} seconds!")

        if len(completion_times) > 1:

            fastest_completion = min(completion_times) - start_time

            print(f"Parallel efficiency: Fastest completion in {fastest_completion:.1f}s")

Aquí, generate_single_sticker() construye el mensaje y claridad a las imágenes. edite el punto final utilizando el client_idx especificado. Las funciones paralelas crean un ThreadPoolExecutor con max_workers=3, envían las tres tareas y procesan los resultados con as_completed. Esto permite que el script registre rápidamente cada pegatina terminada. Por otra parte, asimismo podemos ver los registros para ver qué está sucediendo en cada hilo (hora, qué fue caricatura o estilo Pixar).

Pedrusco de ejecución principal

Al final del libreto, el __main__ retén por defecto está en ejecución sticker_from_camera(). Sin confiscación, puede aceptar o descomentar si lo desea para ejecutar interactive_menu(), create_all_category_stickers() u otras funciones.

# Main execution

if __name__ == "__main__":

    sticker_from_camera()

Producción:

Imagen de salida:

Para obtener la lectura completa de este código productor de stickers de WhatsApp, invitado este GitHub repositorio.

Conclusión

En este tutorial, hemos explicado cómo configurar llamadas GPT-Image-1, crear un mensaje extendido para pegatinas, capturar o cargar imágenes, pretender frases divertidas o texto personalizado y ejecutar 3 variantes de estilo simultáneamente. En sólo unos cientos de líneas de código, este esquema convierte tus imágenes en pegatinas con estilo de cómic.

Simplemente combinando el maniquí de visión de OpenAI con ingeniería creativa y subprocesos múltiples, puede gestar pegatinas divertidas y personalizadas en segundos. Y el resultado será un productor de stickers de WhatsApp basado en inteligencia fabricado que puede producir stickers que se pueden compartir instantáneamente con un solo clic para cualquiera de tus amigos y grupos. ¡Ahora pruébalo con tu propia foto y tu chiste protegido!

Preguntas frecuentes