Automatisation avec Python

import os
from pathlib import Path

def renommer_fichiers(dossier, ancien_motif, nouveau_motif):
    """Remplace un motif dans les noms de fichiers"""
    chemin = Path(dossier)
    
    for fichier in chemin.iterdir():
        if fichier.is_file() and ancien_motif in fichier.name:
            nouveau_nom = fichier.name.replace(ancien_motif, nouveau_motif)
            nouveau_chemin = fichier.parent / nouveau_nom
            fichier.rename(nouveau_chemin)
            print(f"Renommé: {fichier.name} -> {nouveau_nom}")

# Exemple: remplacer "photo" par "vacances" dans tous les noms
renommer_fichiers("./images", "photo", "vacances_2024")

# Ajouter numérotation
def numeroter_fichiers(dossier, prefixe="fichier"):
    """Numérote les fichiers: fichier_001.jpg, fichier_002.jpg..."""
    chemin = Path(dossier)
    fichiers = sorted(chemin.glob("*.*"))
    
    for i, fichier in enumerate(fichiers, start=1):
        extension = fichier.suffix
        nouveau_nom = f"{prefixe}_{i:03d}{extension}"
        nouveau_chemin = fichier.parent / nouveau_nom
        fichier.rename(nouveau_chemin)
        print(f"{fichier.name} -> {nouveau_nom}")

numeroter_fichiers("./photos", "vacances")

import shutil
from pathlib import Path

def organiser_par_type(dossier_source):
    """Trie les fichiers par extension dans des sous-dossiers"""
    source = Path(dossier_source)
    
    # Catégories de fichiers
    categories = {
        'Images': ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.svg'],
        'Documents': ['.pdf', '.doc', '.docx', '.txt', '.xlsx', '.ppt'],
        'Videos': ['.mp4', '.avi', '.mkv', '.mov', '.wmv'],
        'Audio': ['.mp3', '.wav', '.flac', '.m4a'],
        'Archives': ['.zip', '.rar', '.7z', '.tar', '.gz'],
        'Code': ['.py', '.js', '.html', '.css', '.java', '.cs']
    }
    
    for fichier in source.iterdir():
        if fichier.is_file():
            extension = fichier.suffix.lower()
            
            # Trouver la catégorie
            categorie = 'Autres'
            for cat, exts in categories.items():
                if extension in exts:
                    categorie = cat
                    break
            
            # Créer dossier si nécessaire
            dossier_dest = source / categorie
            dossier_dest.mkdir(exist_ok=True)
            
            # Déplacer le fichier
            destination = dossier_dest / fichier.name
            shutil.move(str(fichier), str(destination))
            print(f"Déplacé {fichier.name} vers {categorie}/")

organiser_par_type("./downloads")

from pathlib import Path
import re

def rechercher_dans_fichiers(dossier, motif, extensions=['.txt', '.py', '.md']):
    """Recherche un motif dans tous les fichiers"""
    chemin = Path(dossier)
    resultats = []
    
    for fichier in chemin.rglob("*"):  # rglob = récursif
        if fichier.is_file() and fichier.suffix in extensions:
            try:
                with open(fichier, 'r', encoding='utf-8') as f:
                    for num_ligne, ligne in enumerate(f, start=1):
                        if re.search(motif, ligne, re.IGNORECASE):
                            resultats.append({
                                'fichier': fichier,
                                'ligne': num_ligne,
                                'contenu': ligne.strip()
                            })
            except Exception as e:
                print(f"Erreur lecture {fichier}: {e}")
    
    return resultats

# Rechercher tous les TODO dans le code
resultats = rechercher_dans_fichiers("./projet", r"TODO|FIXME", ['.py', '.js'])
for r in resultats:
    print(f"{r['fichier']}:{r['ligne']} - {r['contenu']}")

import pandas as pd
from pathlib import Path

def fusionner_csv(dossier, fichier_sortie):
    """Fusionne tous les CSV d'un dossier en un seul"""
    chemin = Path(dossier)
    tous_csv = list(chemin.glob("*.csv"))
    
    if not tous_csv:
        print("Aucun fichier CSV trouvé")
        return
    
    # Lire et combiner
    dfs = []
    for csv in tous_csv:
        df = pd.read_csv(csv)
        dfs.append(df)
    
    df_combine = pd.concat(dfs, ignore_index=True)
    df_combine.to_csv(fichier_sortie, index=False)
    print(f"Fusionné {len(tous_csv)} fichiers -> {fichier_sortie}")
    print(f"Total lignes: {len(df_combine)}")

fusionner_csv("./exports", "donnees_completes.csv")

import pandas as pd

def nettoyer_donnees(fichier_entree, fichier_sortie):
    """Nettoie un fichier de données"""
    df = pd.read_csv(fichier_entree)
    
    print(f"Lignes initiales: {len(df)}")
    print(f"Colonnes: {list(df.columns)}")
    
    # Supprimer doublons
    df = df.drop_duplicates()
    print(f"Après suppression doublons: {len(df)}")
    
    # Supprimer lignes avec valeurs manquantes
    df = df.dropna()
    print(f"Après suppression NA: {len(df)}")
    
    # Nettoyer espaces dans strings
    for col in df.select_dtypes(include=['object']).columns:
        df[col] = df[col].str.strip()
    
    # Convertir types
    if 'date' in df.columns:
        df['date'] = pd.to_datetime(df['date'])
    
    # Statistiques
    print("\nStatistiques:")
    print(df.describe())
    
    # Sauvegarder
    df.to_csv(fichier_sortie, index=False)
    print(f"\nDonnées nettoyées sauvegardées: {fichier_sortie}")

nettoyer_donnees("donnees_brutes.csv", "donnees_propres.csv")

import pandas as pd

def generer_rapport_excel(donnees, fichier_sortie):
    """Crée un rapport Excel formaté avec plusieurs feuilles"""
    # Créer writer Excel
    with pd.ExcelWriter(fichier_sortie, engine='xlsxwriter') as writer:
        workbook = writer.book
        
        # Formats
        header_format = workbook.add_format({
            'bold': True,
            'bg_color': '#4F46E5',
            'font_color': 'white',
            'border': 1
        })
        
        # Données exemple
        df = pd.DataFrame(donnees)
        
        # Feuille données
        df.to_excel(writer, sheet_name='Données', index=False)
        worksheet = writer.sheets['Données']
        
        # Ajuster largeur colonnes
        for i, col in enumerate(df.columns):
            max_len = max(df[col].astype(str).str.len().max(), len(col)) + 2
            worksheet.set_column(i, i, max_len)
        
        # Feuille statistiques
        stats = df.describe()
        stats.to_excel(writer, sheet_name='Statistiques')
        
        # Graphique
        chart = workbook.add_chart({'type': 'column'})
        chart.add_series({
            'values': f"=Données!$B$2:$B${len(df)+1}",
            'name': 'Valeurs'
        })
        worksheet.insert_chart('D2', chart)

# Exemple
donnees = {
    'Produit': ['A', 'B', 'C', 'D'],
    'Ventes': [100, 150, 200, 175],
    'Prix': [10, 15, 20, 18]
}
generer_rapport_excel(donnees, "rapport_ventes.xlsx")

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

def envoyer_email(destinataire, sujet, message, fichier_joint=None):
    """Envoie un email avec pièce jointe optionnelle"""
    expediteur = "votre@email.com"
    mot_de_passe = "votre_mot_de_passe"  # Utiliser variables d'environnement !
    
    # Créer message
    msg = MIMEMultipart()
    msg['From'] = expediteur
    msg['To'] = destinataire
    msg['Subject'] = sujet
    
    # Corps du message
    msg.attach(MIMEText(message, 'plain'))
    
    # Pièce jointe
    if fichier_joint:
        with open(fichier_joint, '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= {fichier_joint}'
            )
            msg.attach(part)
    
    # Envoyer
    try:
        with smtplib.SMTP('smtp.gmail.com', 587) as server:
            server.starttls()
            server.login(expediteur, mot_de_passe)
            server.send_message(msg)
            print(f"Email envoyé à {destinataire}")
    except Exception as e:
        print(f"Erreur: {e}")

# Utilisation
envoyer_email(
    "destinataire@example.com",
    "Rapport mensuel",
    "Bonjour,\n\nVeuillez trouver le rapport ci-joint.",
    "rapport.pdf"
)

import pandas as pd
from jinja2 import Template

def envoyer_emails_masse(fichier_contacts, template_html):
    """Envoie des emails personnalisés en masse"""
    # Lire contacts
    df = pd.read_csv(fichier_contacts)
    
    # Template email
    template = Template(template_html)
    
    for _, contact in df.iterrows():
        # Personnaliser message
        message = template.render(
            nom=contact['nom'],
            prenom=contact['prenom'],
            solde=contact['solde']
        )
        
        # Envoyer (utiliser fonction précédente)
        # envoyer_email(contact['email'], "Relevé de compte", message)
        print(f"Email préparé pour {contact['prenom']} {contact['nom']}")

# Template HTML
template_html = """


    
Bonjour {{ prenom }} {{ nom }},
    
Votre solde actuel est de {{ solde }} CHF.
    
Cordialement,
L'équipe


"""

envoyer_emails_masse("contacts.csv", template_html)

import schedule
import time
from datetime import datetime

def backup_quotidien():
    """Sauvegarde quotidienne"""
    print(f"[{datetime.now()}] Backup en cours...")
    # Votre code de backup ici
    shutil.copytree("./data", f"./backups/backup_{datetime.now():%Y%m%d}")
    print("Backup terminé")

def rapport_hebdomadaire():
    """Rapport envoyé chaque lundi"""
    print("Génération rapport hebdomadaire...")
    # Générer et envoyer rapport

def nettoyage_logs():
    """Nettoie les logs de plus de 30 jours"""
    print("Nettoyage des logs...")
    # Supprimer vieux logs

# Planifier les tâches
schedule.every().day.at("02:00").do(backup_quotidien)
schedule.every().monday.at("09:00").do(rapport_hebdomadaire)
schedule.every().hour.do(nettoyage_logs)

# Boucle principale
print("Scheduler démarré...")
while True:
    schedule.run_pending()
    time.sleep(60)  # Vérifier chaque minute

# Éditer crontab
crontab -e

# Syntaxe: minute heure jour mois jour_semaine commande

# Tous les jours à 2h du matin
0 2 * * * /usr/bin/python3 /chemin/vers/script.py

# Tous les lundis à 9h
0 9 * * 1 /usr/bin/python3 /chemin/vers/rapport.py

# Toutes les heures
0 * * * * /usr/bin/python3 /chemin/vers/cleanup.py

# Toutes les 15 minutes
*/15 * * * * /usr/bin/python3 /chemin/vers/monitoring.py

import subprocess
import os

# Exécuter commande simple
resultat = subprocess.run(['ls', '-la'], capture_output=True, text=True)
print(resultat.stdout)

# Avec shell (attention sécurité!)
subprocess.run('echo "Hello" > fichier.txt', shell=True)

# Vérifier code retour
resultat = subprocess.run(['git', 'status'], capture_output=True)
if resultat.returncode == 0:
    print("Commande réussie")
else:
    print(f"Erreur: {resultat.stderr}")

# Script de backup Git automatique
def backup_git_repos(dossier_repos, dossier_backup):
    """Backup de tous les repos Git"""
    for repo in os.listdir(dossier_repos):
        chemin_repo = os.path.join(dossier_repos, repo)
        
        if os.path.isdir(os.path.join(chemin_repo, '.git')):
            print(f"Backup de {repo}...")
            
            # Pull dernières modifications
            subprocess.run(['git', 'pull'], cwd=chemin_repo)
            
            # Créer archive
            archive = os.path.join(dossier_backup, f"{repo}_backup.tar.gz")
            subprocess.run(['tar', '-czf', archive, chemin_repo])
            
            print(f"✓ {repo} sauvegardé")

backup_git_repos("./projets", "./backups")

import shutil
import smtplib
from email.mime.text import MIMEText

def verifier_espace_disque(seuil_pourcentage=80):
    """Vérifie l'espace disque et envoie alerte si > seuil"""
    usage = shutil.disk_usage("/")
    
    total_gb = usage.total / (1024**3)
    used_gb = usage.used / (1024**3)
    free_gb = usage.free / (1024**3)
    pourcentage = (usage.used / usage.total) * 100
    
    print(f"Espace disque:")
    print(f"Total: {total_gb:.2f} GB")
    print(f"Utilisé: {used_gb:.2f} GB ({pourcentage:.1f}%)")
    print(f"Libre: {free_gb:.2f} GB")
    
    if pourcentage > seuil_pourcentage:
        message = f"""
        ALERTE: Espace disque faible!
        
        Utilisé: {pourcentage:.1f}%
        Libre: {free_gb:.2f} GB
        
        Action requise.
        """
        # envoyer_email("admin@example.com", "Alerte espace disque", message)
        print("⚠️  ALERTE ENVOYÉE")
    else:
        print("✓ Espace disque OK")

# Exécuter avec cron toutes les heures
verifier_espace_disque()

import pandas as pd
from datetime import datetime, timedelta
import matplotlib.pyplot as plt

def generer_rapport_mensuel(fichier_donnees):
    """Génère rapport mensuel avec graphiques"""
    # Lire données
    df = pd.read_csv(fichier_donnees)
    df['date'] = pd.to_datetime(df['date'])
    
    # Filtrer mois courant
    debut_mois = datetime.now().replace(day=1)
    fin_mois = debut_mois + timedelta(days=32)
    fin_mois = fin_mois.replace(day=1) - timedelta(days=1)
    
    df_mois = df[(df['date'] >= debut_mois) & (df['date'] <= fin_mois)]
    
    # Statistiques
    stats = {
        'total_ventes': df_mois['montant'].sum(),
        'nb_commandes': len(df_mois),
        'panier_moyen': df_mois['montant'].mean(),
        'meilleur_jour': df_mois.groupby(df_mois['date'].dt.day)['montant'].sum().idxmax()
    }
    
    # Graphique ventes par jour
    ventes_jour = df_mois.groupby(df_mois['date'].dt.day)['montant'].sum()
    plt.figure(figsize=(12, 6))
    plt.bar(ventes_jour.index, ventes_jour.values)
    plt.title(f"Ventes - {debut_mois:%B %Y}")
    plt.xlabel("Jour du mois")
    plt.ylabel("Montant (CHF)")
    plt.savefig(f"rapport_{debut_mois:%Y%m}.png")
    
    # Générer rapport texte
    rapport = f"""
    RAPPORT MENSUEL - {debut_mois:%B %Y}
    =====================================
    
    Total ventes: {stats['total_ventes']:.2f} CHF
    Nombre commandes: {stats['nb_commandes']}
    Panier moyen: {stats['panier_moyen']:.2f} CHF
    Meilleur jour: {stats['meilleur_jour']}
    
    Graphique sauvegardé: rapport_{debut_mois:%Y%m}.png
    """
    
    with open(f"rapport_{debut_mois:%Y%m}.txt", 'w') as f:
        f.write(rapport)
    
    print(rapport)
    return stats

# Planifier exécution le 1er de chaque mois
generer_rapport_mensuel("ventes.csv")