Extraction et analyse de données HTML

L'analyse du DOM est fondamentale pour le web scraping. L'utilisation de requests couplée à BeautifulSoup permet de récupérer et de parser efficacement le contenu HTML d'une page, offrant une alternative robuste aux parseurs natifs.

import requests
from bs4 import BeautifulSoup

def fetch_and_parse(target_url):
    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'}
    response = requests.get(target_url, headers=headers)
    response.raise_for_status()
    
    soup = BeautifulSoup(response.text, 'html.parser')
    
    # Extraction d'un élément unique
    main_title = soup.find('h1').get_text(strip=True) if soup.find('h1') else None
    
    # Extraction de multiples éléments
    paragraphs = [p.get_text(strip=True) for p in soup.find_all('p')]
    
    # Recherche par attributs CSS
    specific_div = soup.find('div', class_='content-wrapper')
    
    return {
        'title': main_title,
        'paragraphs': paragraphs,
        'has_target_div': specific_div is not None
    }

Décodage de codes QR par programme

Pour traiter des images contenant des codes QR, la bibliothèque pyzbar combinée à Pillow offre une solution performante pour décoder les données encodées directement depuis des fichiers image.

from pyzbar.pyzbar import decode
from PIL import Image

def extract_qr_data(image_path):
    try:
        img = Image.open(image_path)
        decoded_objects = decode(img)
        
        if not decoded_objects:
            return "Aucun code QR détecté dans l'image."
            
        return [obj.data.decode('utf-8') for obj in decoded_objects]
    except Exception as e:
        return f"Erreur lors de la lecture : {str(e)}"

Capture d'écran programmatique et optimisée

La bibliothèque mss est nettement plus rapide que les alternatives classiques pour la capture d'écran. Elle permet de saisir l'intégralité de l'écran ou des zones spécifiques avec une latence minimale, ce qui est idéal pour l'automatisation.

import mss
import mss.tools
import time

def capture_full_screen(output_file):
    with mss.mss() as sct:
        monitor = sct.monitors[1]
        sct_img = sct.grab(monitor)
        mss.tools.to_png(sct_img.rgb, sct_img.size, output=output_file)

def capture_region(output_file, top, left, width, height, delay=0):
    time.sleep(delay)
    region = {"top": top, "left": left, "width": width, "height": height}
    with mss.mss() as sct:
        sct_img = sct.grab(region)
        mss.tools.to_png(sct_img.rgb, sct_img.size, output=output_file)

Conversion de documents PDF en livres audio

Il est possible de transformer des documents textuels en fichiers audio en extrayant le contenu avec pypdf et en synthétisant la voix via gTTS (Google Text-to-Speech).

from pypdf import PdfReader
from gtts import gTTS
import os

def pdf_to_audiobook(pdf_path, output_dir, lang='fr'):
    os.makedirs(output_dir, exist_ok=True)
    reader = PdfReader(pdf_path)
    
    for i, page in enumerate(reader.pages):
        text = page.extract_text()
        if text and text.strip():
            tts = gTTS(text=text, lang=lang, slow=False)
            tts.save(os.path.join(output_dir, f'page_{i+1}.mp3'))

Manipulation et édition de fcihiers PDF

La gestion programmatique des PDF (fusion, rotation, suppression de pages) est grandement facilitée par la bibliothèque moderne pypdf. Voici des fonctions utilitaires pour les opérations les plus courantes.

from pypdf import PdfReader, PdfWriter

def merge_pdf_documents(file_list, output_path):
    writer = PdfWriter()
    for pdf_file in file_list:
        reader = PdfReader(pdf_file)
        for page in reader.pages:
            writer.add_page(page)
            
    with open(output_path, 'wb') as out:
        writer.write(out)

def rotate_pdf_pages(input_path, output_path, angle=90):
    reader = PdfReader(input_path)
    writer = PdfWriter()
    
    for page in reader.pages:
        page.rotate(angle)
        writer.add_page(page)
        
    with open(output_path, 'wb') as out:
        writer.write(out)

def remove_pdf_pages(input_path, output_path, pages_to_remove):
    reader = PdfReader(input_path)
    writer = PdfWriter()
    
    for i, page in enumerate(reader.pages):
        if i not in pages_to_remove:
            writer.add_page(page)
            
    with open(output_path, 'wb') as out:
        writer.write(out)

Accès direct aux solutions techniques via le terminal

L'outil en ligne de commande howdoi permet de récupérer des solutions directement depuis Stack Overflow sans quitter le terminal. Il peut être facilement intégré dans des scripts d'automatisation.

import subprocess

def query_stackoverflow(question):
    cmd = ['howdoi', '-c', '-n', '3', question]
    try:
        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
        return result.stdout
    except subprocess.CalledProcessError as e:
        return f"Erreur lors de la requête : {e.stderr}"

# Exemple d'utilisation
# print(query_stackoverflow("python merge dictionaries"))

Contrôle d'appareils Android via ADB

Android Debug Bridge (ADB) permet d'interagir avec un appareil Android. En encapsluant les commandes ADB dans des fonctions Python via le module subprocess, on peut automatiser des interactions tactiles et système complexes.

import subprocess

def execute_adb_command(command):
    full_cmd = f"adb {command}"
    process = subprocess.Popen(full_cmd.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    stdout, stderr = process.communicate()
    return stdout.decode('utf-8').strip()

def perform_swipe(start_x, start_y, end_x, end_y, duration_ms=300):
    return execute_adb_command(f"shell input swipe {start_x} {start_y} {end_x} {end_y} {duration_ms}")

def initiate_call(phone_number):
    return execute_adb_command(f"shell am start -a android.intent.action.CALL -d tel:{phone_number}")

def capture_device_screen(output_file):
    execute_adb_command("shell screencap -p /sdcard/screen.png")
    execute_adb_command(f"pull /sdcard/screen.png {output_file}")
    execute_adb_command("shell rm /sdcard/screen.png")

Surveillance thermique du processeur et du GPU

Pour monitorer les températures des composants matériels, l'utilisation de psutil pour le CPU et GPUtil pour le GPU offre une approche fiable, évitant les dépendances complexes et obsolètes liées à WMI ou .NET.

import psutil
import GPUtil
import time

def monitor_hardware_temperatures(interval=2):
    try:
        while True:
            # Température CPU
            temps = psutil.sensors_temperatures()
            if 'coretemp' in temps:
                cpu_temp = temps['coretemp'][0].current
                print(f"Température CPU (Core 0): {cpu_temp}°C")
                
            # Température GPU
            gpus = GPUtil.getGPUs()
            for gpu in gpus:
                print(f"GPU {gpu.name} - Temp: {gpu.temperature}°C | Charge: {gpu.load * 100:.1f}%")
                
            time.sleep(interval)
            print("-" * 40)
    except KeyboardInterrupt:
        print("Surveillance arrêtée par l'utilisateur.")

Publication automatisée sur les réseaux sociaux

L'API non officielle instagrapi permet d'automatiser les publications de médias sur Instagram de manière fiable, en gérant l'authentification, les uploads de photos et les vidéos (Reels).

from instagrapi import Client

def publish_media_to_instagram(username, password, media_path, caption):
    cl = Client()
    try:
        cl.login(username, password)
        
        if media_path.lower().endswith(('.mp4', '.mov')):
            cl.clip_upload(media_path, caption)
            print("Vidéo (Reel) publiée avec succès.")
        else:
            cl.photo_upload(media_path, caption)
            print("Photo publiée avec succès.")
            
    except Exception as e:
        print(f"Échec de la publication : {str(e)}")
    finally:
        cl.logout()

Ajout de filigrane textuel sur des vidéos

La bibliothèque moviepy est idéale pour le montage vidéo programmatique. Voici comment superposer un filigrane textuel dynamique avec une opacité ajustée sur une vidéo existante.

from moviepy.editor import VideoFileClip, TextClip, CompositeVideoClip

def add_dynamic_watermark(input_video, output_video, watermark_text):
    clip = VideoFileClip(input_video)
    
    # Création du clip texte
    txt_clip = (TextClip(watermark_text, fontsize=40, color='white', 
                         font='Arial-Bold', stroke_color='black', stroke_width=2)
                .set_position(('right', 'bottom'))
                .set_duration(clip.duration))
                
    # Application d'une légère transparence et positionnement
    txt_clip = txt_clip.margin(right=20, bottom=20, opacity=0).set_opacity(0.7)
    
    # Composition finale
    final_clip = CompositeVideoClip([clip, txt_clip])
    
    # Export
    final_clip.write_videofile(output_video, codec='libx264', audio_codec='aac')