module utils, add article wololo

utils.py

@@ -1,661 +0,0 @@
-#!/bin/python3
-import os
-import re
-import shutil
-from datetime import datetime
-import unicodedata
-import pypandoc
-import subprocess
-import tempfile
-from md2gemini import md2gemini
-import locale
-
-from website_config import *
-
-# this path should be customized
-org_roam_dir: str = '/home/tykayn/Nextcloud/textes/orgmode/org-roam/'
-
-# Trouver l'identifiant OrgROAM
-pattern_roam_id_search = r':ID:(?:\s+)?([a-zA-Z0-9-]+)'
-# Expression régulière pour extraire la date et le slug du nom de fichier org
-regex = r"^([a-zA-Z0-9_-]+)\_\_(-[a-zA-Z0-9_-]+)\.org$"
-# Recherche de date de création du fichier org-roam dans un article gemini
-regex_orgroam = regex
-
-# show_logs=True
-show_logs = global_config["show_logs"]
-
-
-def mylog(*content):
-    """Fonction qui imprime tous les arguments passés selon le niveau de debug souhaité."""
-    if show_logs:
-        for c in content:
-            print('    ',c)
-
-
-def trouver_nom_article(fichier_org, blog_name, format="html"):
-    # mylog('fichier_org, ', fichier_org)
-    with open(fichier_org, 'r') as file:
-        lignes = file.readlines()
-
-    nom_article = ''
-
-#     mylog('trouver_nom_article format', format)
-    # Expressions régulières pour trouver les titres de niveau 1 et 2
-    if format == 'html':
-        titre_niveau_1 = r'<h1\s+(?:id|data-created)="[^"]*">(.*?)</h1>'
-        titre_niveau_2 = r'^\<h2.*?\>(.+)\<\/h2\>$'
-    else:
-        titre_niveau_1 = r'^\*+ (.+)$'
-        titre_niveau_2 = r'^\*\*+ (.+)$'
-
-    # Itérer sur les lignes du fichier
-    for ligne in lignes:
-        # Rechercher un titre de niveau 1
-        titre_niveau_1_match = re.match(titre_niveau_1, ligne)
-        if titre_niveau_1_match:
-            titre_niveau_1_texte = titre_niveau_1_match.group(1)
-            if titre_niveau_1_texte.lower() != "article" and titre_niveau_1_texte.lower() != "liens":
-                nom_article = titre_niveau_1_texte
-                break
-            else:
-                # Si le premier titre de niveau 1 est "Article", rechercher le premier titre de niveau 2
-                titre_niveau_2_match = re.match(titre_niveau_2, ligne)
-                if titre_niveau_2_match:
-                    nom_article = titre_niveau_2_match.group(1)
-                    break
-#     mylog(f"Nom de l'article : {nom_article}")
-
-    return nom_article.replace(blog_name + '_', '').replace('_', ' ')
-
-def find_org_roam_id(content):
-    match = re.search(pattern_roam_id_search, content)
-    if match:
-        return match.group(1)
-    return None
-
-def get_blog_template_conf(blogname) -> dict:
-    """
-    Retourne la configuration du blog spécifié.
-
-    :param blogname: Nom du blog (str).
-    :return: Configuration du blog (dict).
-    """
-    if blogname not in configs_sites:
-        return default_config
-    else:
-        return configs_sites[blogname]
-
-def find_year_and_slug_on_filename(filename):
-    # print(f"Traitement du fichier: {filename}")  # Debug
-    try:
-        # Supposons que le format attendu est "YYYYMMDDHHMMSS-slug.org"
-        date_str = filename[:14]  # Prend les 14 premiers caractères pour la date
-        annee = date_str[:4]      # Prend les 4 premiers caractères pour l'année
-        
-        # Gestion plus robuste du slug
-        if '-' in filename:
-            slug = filename.split('-', 1)[1].replace('.org', '')
-        else:
-            slug = filename.replace('.org', '')
-            
-        return date_str, annee, slug
-    except Exception as e:
-        print(f"Format de fichier non standard: {filename}")
-        return None, None, filename.replace('.org', '')
-
-
-def enlever_premier_tiret_ou_underscore(chaîne):
-    if chaîne.startswith('-') or chaîne.startswith('_'):
-        chaîne = chaîne[1:]
-    return chaîne
-
-
-# création des dossiers intermédiaires s'il y en a
-# déplace le fichier dans le dossier spécifié
-def create_path_folders_and_move_file(path, file):
-    os.makedirs(os.path.dirname(path), exist_ok=True)
-
-    shutil.move(file, path)
-
-
-def get_files_list_of_folder(folder_path):
-    # Vérifie si le dossier existe
-    if not os.path.exists(folder_path):
-        print(f" ------------ build_indexes: Erreur : Le dossier '{folder_path}' n'existe pas.")
-        return
-    mylog('----------- get_files_list_of_folder: folder_path : ', folder_path)
-    # Liste les fichiers articles, trie par nom décroissant
-    try:
-        fichiers_md = sorted(
-            [f.replace('.' + global_config['source_files_extension'], '.gmi') for f in os.listdir(folder_path) if
-             f.endswith(global_config['source_files_extension'])], reverse=True)
-        # print('fichiers trouvés:', len(fichiers_md))
-        return fichiers_md
-    except OSError as e:
-        print(f" ------------ build_indexes: Erreur lors de la lecture du dossier : {e}")
-        return
-
-
-def get_id_of_roam_note_content(content):
-    match = re.search(pattern_roam_id_search, content)
-    if match:
-        return match.group(1)
-    return None
-
-
-def find_first_level1_title(content):
-    pattern = r'^\*\s(.+)$'
-    match = re.search(pattern, content, re.MULTILINE)
-    if match:
-        if match.group(1) != 'Article':
-            return match.group(1)
-        else:
-            pattern = r'^\*\*\s(.+)$'
-            match = re.search(pattern, content, re.MULTILINE)
-            if match:
-                return match.group(1)
-    return None
-
-def find_extract_in_content_org(org_content):
-    # Supprimer les lignes qui commencent par #+
-    org_content = re.sub(r'^\s*#\+.*\n', '', org_content, flags=re.MULTILINE)
-
-    # Supprimer les sections de logbook
-    org_content = re.sub(r'^\*\* Logbook\n.*?(?=\*\* |\Z)', '', org_content, flags=re.DOTALL | re.MULTILINE)
-
-    # Supprimer les propriétés
-    org_content = re.sub(r'^:PROPERTIES:\n.*?:END:\n', '', org_content, flags=re.DOTALL | re.MULTILINE)
-
-    # Supprimer les lignes vides supplémentaires
-    org_content = re.sub(r'\n\s*\n+', '\n', org_content)
-
-    # Supprimer les espaces en début et fin de chaque ligne
-    org_content = '\n'.join(line.strip() for line in org_content.splitlines())
-
-    # Supprimer les espaces en début et fin du contenu final
-    return org_content.strip()
-
-def extract_body_content(html_content):
-    pattern = r'<body.*?>(.*?)</body>'
-    match = re.search(pattern, html_content, re.DOTALL)
-    if match:
-        return match.group(1)
-    else:
-        print('---- extract_body_content : no body found in this html')
-        return html_content
-
-def add_tags_from_content(tags=None, file_content="", words_to_check=None):
-    """
-    Ajoute des tags à l'ensemble `tags` si les mots correspondants sont trouvés dans le contenu du fichier.
-
-    :param tags: Ensemble de tags (set). Si None, un nouvel ensemble est créé (type set, optionnel).
-    :param file_content: Contenu du fichier (str).
-    :param words_to_check: Liste de mots à repérer (list). Si None, une liste vide est utilisée (type list, optionnel).
-    :return: Ensemble de tags mis à jour (set).
-    """
-    # Initialiser l'ensemble tags s'il est None
-    if tags is None:
-        tags = set()
-
-    # Initialiser la liste words_to_check s'il est None
-    if words_to_check is None:
-        words_to_check = []
-
-    # Convertir le contenu du fichier en minuscules pour une recherche insensible à la casse
-    file_content_lower = file_content.lower()
-
-    # Parcourir chaque mot à vérifier
-    for word in words_to_check:
-        # Vérifier si le mot est présent dans le contenu du fichier
-        # Chercher une correspondance sans mettre en lowercase si le tag est en majuscule, c'est sans doute un acronyme/sigle.
-        if word.isupper():
-            if word in file_content:
-                tags.add(word)
-        else:
-            if word.lower() in file_content_lower:
-                tags.add(word)
-
-    return tags
-# Variable globale pour stocker les fichiers sans tags
-untagged_files = []
-
-def save_untagged_files(output_file="sources/site_web/build/articles_without_tags.json"):
-    """
-    Sauvegarde la liste des fichiers sans tags dans un fichier JSON.
-    
-    :param output_file: Chemin du fichier JSON de sortie
-    """
-    import json
-    import os
-    
-    # Créer le dossier de sortie si nécessaire
-    os.makedirs(os.path.dirname(output_file), exist_ok=True)
-    
-    print('save_untagged_files', len(untagged_files))
-    # Sauvegarder la liste dans le fichier JSON
-    with open(output_file, 'w', encoding='utf-8') as f:
-        json.dump(untagged_files, f, ensure_ascii=False, indent=4)
-
-
-def extract_tags_from_file(file_path, excluded_tags, auto_detected_tags_list=global_config['auto_tag_terms']):
-    tags = set()
-    with open(file_path, 'r', encoding='utf-8') as file_content:
-        tag_found = False
-        for line in file_content:
-            if global_config['automatic_tagging_enabled'] and len(auto_detected_tags_list) > 0:
-                tags = add_tags_from_content(tags, line, auto_detected_tags_list)
-            # Check for orgmode tags :tag1:tag2:
-            if global_config.get('automatic_tagging_org_files', True):
-                if ':' in line:
-                    for word in line.split():
-                        if len(word) > 1 and word.startswith(':') and word.endswith(':'):
-                            tag = word[1:-1]
-                            if tag not in excluded_tags:
-                                tags.add(tag)
-                            tag_found = True
-            # Check for #+tags: tag1,tag2
-            if line.startswith('#+tags:'):
-                for tag in line[len('#+tags:'):].split(','):
-                    tag = tag.strip()
-                    if tag and tag not in excluded_tags:
-                        tags.add(tag)
-                        tag_found = True
-
-    if not tag_found:
-        untagged_files.append(file_path)
-    #     print('no tag in the article', file_path)
-    return tags
-
-def remove_properties_section(text):
-    pattern = r"<h1 id=\"article\">Article</h1>.+?</ul>"
-    replacement = ""
-    return re.sub(pattern, replacement, text, flags=re.DOTALL)
-
-
-def remove_article_head_properties_orgmode(text):
-    pattern = r":PROPERTIES:.+?:END:"
-    replacement = ""
-    return re.sub(pattern, replacement, text, flags=re.DOTALL)
-
-
-def remove_hint_html(text):
-    pattern = r"<p>ceci<sub>estduhtml</sub></p>"
-    replacement = ""
-    return re.sub(pattern, replacement, text, flags=re.DOTALL)
-
-
-def slugify_title(title):
-    """
-    Convertit un titre en slug URL-friendly en conservant les accents.
-    - Convertit en minuscules
-    - Conserve les accents francophones
-    - Remplace les caractères spéciaux par des tirets
-    - Supprime les tirets multiples
-    
-    Args:
-        title (str): Le titre à convertir
-    
-    Returns:
-        str: Le slug généré
-    """
-    # Conversion en minuscules
-    title = title.lower()
-    
-    # Liste des caractères autorisés (inclut les accents francophones)
-    # On garde a-z, 0-9, les accents français, les tirets
-    allowed_chars = r'[^a-zàâäéèêëîïôöùûüçñ0-9-]'
-    
-    # Remplacer les caractères non autorisés par des tirets
-    title = re.sub(allowed_chars, '-', title)
-    
-    # Supprimer les tirets en début et fin
-    title = title.strip('-')
-    
-    # Remplacer les tirets multiples par un seul
-    title = re.sub(r'-+', '-', title)
-    
-    return title
-
-def find_slug_in_file_basename(file_basename) -> str:
-    """
-    Extrait l'année et le slug du nom de fichier selon le format spécifié.
-
-    :param file_basename: Nom de fichier (str).
-    :return: Tuple contenant l'année et le slug (année, slug) ou None si non trouvé.
-    """
-    pattern = regex_orgroam
-    match = re.match(pattern, file_basename)
-    if match:
-        year = match.group(1)
-        slug = match.group(2)
-        # prendre la partie finale du nom du fichier
-        splitted = slug.split('_')
-        # print('len(splitted)', len(splitted), splitted)
-        if len(splitted) > 1:
-            slug = splitted[len(splitted)-1]
-
-        slug=enlever_premier_tiret_ou_underscore(slug)
-
-        slug = f"{year}/{slug}"
-
-
-
-        return slug
-    return None
-
-def get_stats_on_all_websites():
-    """
-    Retourne des statistiques sur tous les sites web dans le dossier sources/.
-    Pour chaque site, compte le nombre d'articles .org et trouve l'article le plus récent.
-    
-    :return: Dictionnaire avec les stats par site
-    """
-    stats = {}
-    base_dir = "sources"
-    
-    # Parcourir tous les dossiers de sites dans sources/
-    for site in os.listdir(base_dir):
-        site_path = os.path.join(base_dir, site)
-        
-        if not os.path.isdir(site_path):
-            continue
-            
-        # Initialiser les stats pour ce site
-        stats[site] = {
-            'nb_articles': 0,
-            'nb_mots': 0,
-            'dernier_article': None,
-            'date_dernier_article': None
-        }
-        
-        # Chercher les articles .org dans lang_fr et lang_en
-        for lang in ['lang_fr', 'lang_en']:
-            lang_path = os.path.join(site_path, lang)
-            
-            if not os.path.exists(lang_path):
-                continue
-                
-            # Lister tous les fichiers .org
-            org_files = [f for f in os.listdir(lang_path) if f.endswith('.org')]
-            stats[site]['nb_articles'] += len(org_files)
-            # Calculer le nombre total de mots pour ce dossier de langue
-            total_mots = 0
-            for org_file in org_files:
-                file_path = os.path.join(lang_path, org_file)
-                try:
-                    with open(file_path, 'r', encoding='utf-8') as f:
-                        contenu = f.read()
-                        # Compter les mots en divisant par les espaces
-                        total_mots += len(contenu.split())
-                except Exception as e:
-                    print(f"Erreur lors de la lecture de {file_path}: {e}")
-            
-            # Ajouter ou incrémenter le compteur de mots dans les stats
-            stats[site]['nb_mots'] += total_mots
-            
-            # Trouver le fichier le plus récent
-            for org_file in org_files:
-                file_path = os.path.join(lang_path, org_file)
-                mod_time = os.path.getmtime(file_path)
-                
-                if (stats[site]['date_dernier_article'] is None or 
-                    mod_time > stats[site]['date_dernier_article']):
-                    stats[site]['date_dernier_article'] = mod_time
-                    stats[site]['dernier_article'] = file_path
-                    
-        # Convertir le timestamp en date lisible
-        if stats[site]['date_dernier_article']:
-            stats[site]['date_dernier_article'] = datetime.fromtimestamp(
-                stats[site]['date_dernier_article']
-            ).strftime('%Y-%m-%d %H:%M:%S')
-            
-    return stats
-
-def convert_org_to_html(org_file, output_html_file):
-    """
-    Convertit un fichier Org en HTML en utilisant pypandoc.
-    
-    :param org_file: Chemin du fichier Org à convertir.
-    :param output_html_file: Chemin du fichier HTML de sortie.
-    """
-    try:
-        pypandoc.convert_file(org_file, 'html', outputfile=output_html_file)
-        print(f"Conversion réussie : {org_file} -> {output_html_file}")
-    except Exception as e:
-        print(f"Erreur lors de la conversion de {org_file} : {e}")
-
-
-
-def get_first_picture_url(content):
-    # Utiliser une expression régulière pour
-    # trouver la première URL d'image dans le contenu
-    pattern = r'\[\[(.*?)\]\]'
-    match = re.search(pattern, content)
-    if match:
-        return match.group(1)
-    else:
-        return None
-
-
-def org_to_gmi(org_text: str) -> str:
-    """
-    Convertit un texte au format Org en un fichier au format GMI (Gemini)
-    en utilisant pypandoc.
-
-    Args:
-    - org_text (str): Le texte au format Org à convertir.
-    """
-
-    # Nettoyer le contenu org en retirant les lignes commençant par #+post
-    cleaned_content = '\n'.join( line for line in org_text.splitlines() if not line.strip().startswith('#+') )
-    org_content = cleaned_content
-    # print('org to gmi org_content', org_content)
-    # Conversion du texte Org en GMI via Pandoc
-    try:
-        converted_text = pypandoc.convert_text(org_content, 'markdown', format='org')
-
-        output = f"""
--------------------
-
-{converted_text}
-
--------------------
-    """
-        
-    except RuntimeError as e:
-        print(f"Erreur de conversion : {e}")
-        return
- 
-    return output
-
-def count_files_in_directories(directories):
-    total_count = 0
-    # Exclure le dossier ".." du comptage
-    
-    for directory in directories:
-        if directory == "..":
-            continue
-
-        for root, dirs, files in os.walk(directory):
-            
-            print('files', files)
-            total_count += sum(1 for f in files if f.endswith(('.org', '.md', '.gmi')))
-            continue
-    return total_count
-
-def format_date_str(date_str):
-    """
-    Formate une chaîne de date dans différents formats possibles
-    """
-    try:
-        # Définir la locale en français
-        try:
-            locale.setlocale(locale.LC_TIME, 'fr_FR.UTF-8')
-        except:
-            try:
-                locale.setlocale(locale.LC_TIME, 'fra')
-            except:
-                print("Impossible de définir la locale en français")
-
-        # Format YYYYMMDDHHMMSS (14 caractères)
-        if len(date_str) == 14:
-            if 'T' not in date_str:
-                return datetime.strptime(date_str, '%Y%m%d%H%M%S').strftime('%d %B %Y à %H:%M:%S')
-            else:
-                # Si contient T, traiter comme YYYYMMDDTHHMM + 1 chiffre
-                base_date = date_str[:12]
-                return datetime.strptime(base_date, '%Y%m%dT%H%M').strftime('%d %B %Y à %H:%M')
-        
-        # Format YYYYMMDDTHHMMSS (15 caractères avec T)
-        elif len(date_str) == 15 and 'T' in date_str:
-            return datetime.strptime(date_str, '%Y%m%dT%H%M%S').strftime('%d %B %Y à %H:%M:%S')
-        
-        # Format YYYYMMDDTHHMM + chiffre optionnel (13 caractères avec T)
-        elif len(date_str) == 13 and 'T' in date_str:
-            # Toujours prendre les 12 premiers caractères (YYYYMMDDTHHMM)
-            base_date = date_str[:12]
-            return datetime.strptime(base_date, '%Y%m%dT%H%M').strftime('%d %B %Y à %H:%M')
-        
-        # Format YYYY-MM-DD
-        elif len(date_str) == 10 and '-' in date_str:
-            return datetime.strptime(date_str, '%Y-%m-%d').strftime('%d %B %Y')
-        
-        else:
-            print(f"Format de date non reconnu: {date_str}")
-            # Essayer d'extraire au moins la date de base
-            try:
-                base_date = date_str[:8]  # Prendre juste YYYYMMDD
-                return datetime.strptime(base_date, '%Y%m%d').strftime('%d %B %Y')
-            except ValueError:
-                return date_str
-            
-    except ValueError as e:
-        print(f"Erreur lors du formatage de la date {date_str}: {str(e)}")
-        # En cas d'erreur, essayer de parser juste la partie date
-        try:
-            base_date = date_str[:8]  # Prendre juste YYYYMMDD
-            return datetime.strptime(base_date, '%Y%m%d').strftime('%d %B %Y')
-        except ValueError:
-            return date_str
-
-
-
-
-
-def convert_org_to_gemini(org_content):
-    """
-    Convertit un contenu org en gemini en utilisant pandoc et md2gemini
-    
-    Args:
-        org_content (str): Contenu au format org
-    
-    Returns:
-        str: Contenu converti en format gemini
-    """
-
-    # Nettoyer le contenu org en retirant les lignes commençant par #+post
-    cleaned_content = '\n'.join( line for line in org_content.splitlines() if not line.strip().startswith('#+') )
-    org_content = cleaned_content
-
-    try:
-        # Créer un fichier temporaire avec le contenu org
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.org', encoding='utf-8') as temp_org:
-            temp_org.write(org_content)
-            temp_org.flush()
-            
-            # Première étape : conversion org vers markdown avec pandoc
-            pandoc_cmd = [
-                'pandoc',
-                '-f', 'org',
-                '-t', 'markdown',
-                temp_org.name
-            ]
-            
-            markdown_content = subprocess.check_output(
-                pandoc_cmd,
-                text=True,
-                stderr=subprocess.PIPE
-            )
-        
-        # Deuxième étape : conversion markdown vers gemini avec md2gemini
-        gemini_content = md2gemini(
-            markdown_content,
-            frontmatter=True,
-            links='inline',
-        )
-        
-        return gemini_content.strip()
-        
-    except subprocess.CalledProcessError as e:
-        print(f"Erreur lors de la conversion avec pandoc: {e.stderr}")
-        raise
-    except Exception as e:
-        print(f"Erreur lors de la conversion: {str(e)}")
-        raise
-
-
-def save_gemini_file(blog_name, article, articles_info, template_content):
-    """
-    Sauvegarde le contenu gemini d'un article
-    
-    Args:
-        blog_name (str): Nom du blog
-        article (dict): Dictionnaire contenant les informations de l'article
-        articles_info (dict): Dictionnaire contenant tous les articles
-        template_content (str): Contenu du template
-    """
-    # Créer le dossier de destination s'il n'existe pas
-    os.makedirs(f"gemini-capsules/{blog_name}/{article['annee']}", exist_ok=True)
-
-
-    # Construire les liens précédent/suivant
-    previous_article_link = ""
-    next_article_link = ""
-    tags = ""
-    if article['tags']:
-        tags = "Tags: " + ', '.join(article['tags'])
-    
-    if article['previous'] and articles_info and article['previous'] in articles_info:
-        prev = articles_info[article['previous']]
-        print('prev', prev['title'])
-        slug = slugify_title(prev['title'])
-        previous_article_link = f"=> {prev['annee']}/{slug}.gmi {prev['date_formattee']} - {prev['title']}"
-    
-    if article['next'] and articles_info and article['next'] in articles_info:
-        next_art = articles_info[article['next']]
-        print('next', next_art['title'])
-        slug = slugify_title(next_art['title'])
-        next_article_link = f"=> {next_art['annee']}/{slug}.gmi {next_art['date_formattee']} - {next_art['title']}"
-
-    # Construire le contenu gemini complet
-    gemini_content = f"""# {article['title']}
-
-Date: {article['date_formattee']}
-
-{article['gemini_content']}
------------------------------------------------
-
-{tags}
-
------------------------------------------------
-{template_content['AUTHOR']}
-{template_content['SOUTIEN']}
------------------------------------------------
-Navigation:
-"""
-
-    if previous_article_link:
-        gemini_content += f"\nArticle précédent:\n{previous_article_link}"
-    
-    if next_article_link:
-        gemini_content += f"\nArticle suivant:\n{next_article_link}"
-
-    gemini_content += f"""-----------------------------------------------
-    => index.gmi Index des articles
-    """
-    # Sauvegarder le fichier
-    slug = slugify_title(article['title'])
-    os.makedirs(f"gemini-capsules/{blog_name}/{article['annee']}", exist_ok=True)
-    with open(f"gemini-capsules/{blog_name}/{article['annee']}/{slug}.gmi", "w", encoding="utf-8") as f:
-        f.write(gemini_content)