239 lines
7.9 KiB
Python
239 lines
7.9 KiB
Python
#!/bin/python3
|
|
import os
|
|
import re
|
|
import shutil
|
|
from datetime import datetime
|
|
import unicodedata
|
|
|
|
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_year_and_slug_on_filename(fichier):
|
|
fichier = fichier.replace('..', '.')
|
|
# mylog(f" ------------ find_year_and_slug in {fichier} -------------")
|
|
slug = ''
|
|
annee = '2024'
|
|
date_str = '2024-00-00'
|
|
date = '2024-00-00'
|
|
boom = fichier.split('__')
|
|
# print(boom)
|
|
|
|
if boom :
|
|
date_str = boom[0]
|
|
annee = date_str[:4]
|
|
slug = boom[1].replace('.org', '')
|
|
# date = datetime.strptime(date_str, "%Y%m%dT%H%M%S")
|
|
|
|
# Convertir la date en objet datetime
|
|
if "-" in date_str:
|
|
slug = enlever_premier_tiret_ou_underscore(slug)
|
|
|
|
# mylog(f" find_year_and_slug : Fichier: {fichier}")
|
|
# mylog(f" find_year_and_slug : année: {annee}")
|
|
# mylog(f" find_year_and_slug : str(date): {str(date)}")
|
|
# mylog(f" find_year_and_slug : slug: {slug}")
|
|
mylog(f" find_year_and_slug : chemin: {annee}/{slug}/")
|
|
return [date_str, annee, slug]
|
|
return [date_str, annee, fichier.replace(' ', '-').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'^\* (.+)$'
|
|
match = re.search(pattern, content, re.MULTILINE)
|
|
if match:
|
|
if match.group(1) != 'Article':
|
|
return match.group(1)
|
|
else:
|
|
pattern = r'^\*\* (.+)$'
|
|
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 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_text):
|
|
"""
|
|
Transforme un titre en un slug valide.
|
|
|
|
:param title_text: Titre en texte (str).
|
|
:return: Slug en minuscules avec des tirets (str).
|
|
"""
|
|
title_text = unicodedata.normalize('NFKD', title_text).encode('ascii', 'ignore').decode('ascii')
|
|
title_text = title_text.lower()
|
|
title_text = re.sub(r'[^a-z0-9\s-]', '', title_text)
|
|
title_text = re.sub(r'\s+', '-', title_text)
|
|
title_text = re.sub(r'-+', '-', title_text)
|
|
title_text = title_text.strip('-')
|
|
return title_text
|
|
|
|
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 = r'^(\d{4})\d{10}(.+)\.org$'
|
|
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]
|
|
|
|
# final_slug=slug.replace("_cipherbliss_blog_","")
|
|
# final_slug=final_slug.replace("_blog_cil_gometz_","")
|
|
slug=enlever_premier_tiret_ou_underscore(slug)
|
|
|
|
slug = f"{year}/{slug}"
|
|
|
|
|
|
|
|
return slug
|
|
return None
|
|
|