Respan Dataset Explorer

What form of collagen should she take

Collagen supplements come in various forms, and the choice of which form to take depends on individual needs, preferences, and any specific recommendations from a healthcare provider. Here are the common forms of collagen supplements:

1. **Hydrolyzed Collagen (Collagen Peptides or Collagen Hydrolysate)**: This is one of the most common and easily absorbed forms of collagen. Because the collagen is broken down into smaller peptides, it is easier for the body to digest and absorb. It is often found in powder form and can be mixed into hot or cold liquids.

2. **Gelatin**: Gelatin is partially hydrolyzed collagen, which means it has been broken down but not to the same extent as collagen peptides. It thickens when cooled and is often used in cooking and baking. It's beneficial for gut health and joints, but it may not be as easy to incorporate into the diet as hydrolyzed collagen.

3. **Undenatured Type II Collagen**: This type of collagen is not hydrolyzed and is usually taken in capsule or tablet form. It is particularly associated with joint health, especially for conditions such as osteoarthritis.

4. **Collagen Protein (Collagen Powder)**: This form is similar to hydrolyzed collagen but is specifically marketed for its protein content and is often used to promote muscle mass or as a protein supplement.

5. **Topical Collagen**: There are also topical collagen creams and serums, but these are generally used for improving skin health rather than joint or bone issues.

6. **Collagen from Bone Broth**: Bone broth naturally contains collagen, and many people consume it for joint health. While this is a food source rather than a supplement per se, it can be a part of a diet for those looking to increase collagen intake.

When deciding on a form of collagen to take, consider the following factors:

- **Purpose of Supplementation**: For joint health, hydrolyzed collagen or undenatured Type II collagen are commonly recommended.
- **Ease of Use**: Hydrolyzed collagen can easily be added to drinks, which may be convenient for daily use.
- **Dietary Preferences**: Gelatin and bone broth are options for those who prefer food-based sources and are comfortable with the taste and texture these provide.
- **Absorption**: Hydrolyzed collagen is generally preferred for its higher absorption rate.
- **Medical Advice**: Always consult with a healthcare provider before starting any new supplement to ensure it is appropriate for your specific health needs and does not interact with your existing medications.

Specific to the patient in question, it would be essential to discuss with her healthcare provider which form of collagen would be most suitable in her case, considering her age, health status, existing medical conditions, and the medications she is currently taking (Candesartan and Cardizem). The healthcare provider can also advise on the appropriate dosage and any potential interactions or side effects.

How do I uninstall pip on mac

To uninstall `pip` on a Mac, you can follow these steps:

1. Open the Terminal application on your Mac. You can find it by going to Applications -> Utilities -> Terminal.
2. Type the following command and press Enter to see the list of installed packages: 

   ```
   pip list
   ```
   
3. Look for `pip` in the list of installed packages.
4. To uninstall `pip`, use the following command:

   ```
   pip uninstall pip
   ```

5. Confirm the uninstallation by typing `y` and pressing Enter when prompted.
   
That's it! `pip` should now be uninstalled from your Mac.

My pip is broken, calling it breaks it. How do I uninstall pip without using pip

If your pip is broken and calling it causes further issues, you can try uninstalling it manually. Here's how you can do it without using pip:

1. Find the location where pip is installed on your system. It is usually in the `Scripts` directory of the Python installation folder.

2. Open a command prompt or terminal and navigate to the directory where pip is located. For example, if you installed Python in the default location on Windows, the command should be something like:
```
cd C:\Python\Scripts
```

3. Once you are in the correct directory, you can remove pip by executing the following command:
```
python -m pip uninstall pip
```
or
```
python3 -m pip uninstall pip
```
If you have multiple Python versions installed, replace `python` with the correct version number (e.g., `python3.9`).

4. Follow the prompts to complete the uninstallation process.

This should uninstall pip from your system. However, be cautious as removing pip might cause further issues with your Python environment. It is generally recommended to fix broken installations rather than removing them entirely.

calling pip in terminal returns -bash: /usr/local/bin/pip: No such file or directory

This error message usually indicates that the pip command is not installed in the specified directory.

There are a few possibilities for why this might be happening:

1. Pip is not installed: Verify that pip is installed on your system by running the command `which pip` or `pip --version`. If it is not installed, you can install it using a package manager like apt (for Linux) or Homebrew (for macOS), or by using the official installation instructions from the Python website.

2. Pip is installed in a different location: It's possible that pip is installed in a different directory than `/usr/local/bin/`. You can use the `which pip` command to find the exact location of the pip executable and then use that path in the terminal.

3. Incorrect PATH variable: This error can also occur if the PATH variable is not set correctly. The PATH variable contains a list of directories where the system looks for executable files. Make sure that the directory containing the pip executable is included in the PATH variable.

To fix the issue, you can try the following steps:

1. Verify pip installation: Run the command `which pip` or `pip --version` to check if pip is installed and in your PATH.

2. Find the location of pip: If pip is installed, but not in the `/usr/local/bin/` directory, use the `which pip` command to find its exact location.

3. Update your PATH variable: If pip is installed in a different directory, update your PATH variable to include the correct directory. You can do this by editing your shell configuration file (e.g., `.bashrc`, `.bash_profile`, or `.zshrc`) and adding a line like `export PATH="/path/to/pip:$PATH"`. Make sure to replace `/path/to/pip` with the actual location of the pip executable.

4. Restart the terminal: After updating the PATH variable, restart your terminal or run `source <shell configuration file>` to apply the changes.

Once you have resolved the issue, you should be able to use the `pip` command without any errors.

import os
import subprocess
import numpy as np
import uuid  # Import uuid to generate unique IDs
from moviepy.editor import VideoFileClip
from scipy.io import wavfile
import random

temporary_audio_files = []

# Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi']
output_folder = 'Output'

def ask_for_number_of_moments(max_segments):
    while True:
        num_input = input(f"Veuillez entrer le nombre de moments forts à extraire (maximum {max_segments}): ")
        try:
            num = int(num_input)
            if num > 0 and num <= max_segments:
                return num
            else:
                print(f"Le nombre doit être supérieur à 0 et inférieur ou égal à {max_segments}. Veuillez réessayer.")
        except ValueError:
            print("Entrée non valide, veuillez réessayer avec un nombre entier.")

def ask_yes_no_question(question):
    answer = None
    while answer not in ('1', '2'):
        print(question)
        print("1- Oui")
        print("2- Non")
        answer = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip()
        if answer not in ('1', '2'):
            print("Entrée non valide, veuillez réessayer.")
    return answer == '1'
    
def ask_offset_type():
    print("Souhaitez-vous un décalage temporel relatif ou absolu ?")
    print("1- Relatif (pourcentage)")
    print("2- Absolu (secondes)")
    while True:
        choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip()
        if choice in ('1', '2'):
            return choice
        else:
            print("Entrée non valide, veuillez réessayer.")
            
def get_offset_value(video_duration, offset_type):
    if offset_type == '1':  # Relative offset
        while True:
            percent = input("Entrez le pourcentage du temps vidéo à ignorer : ")
            try:
                percent_value = float(percent)
                return percent_value * video_duration / 100
            except ValueError:
                print("Veuillez entrer un nombre valide.")
    else:  # Absolute offset
        while True:
            seconds = input("Entrez le nombre de secondes à ignorer : ")
            try:
                return float(seconds)
            except ValueError:
                print("Veuillez entrer un nombre valide.")
                
def ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds):
    while True:
        duration = input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire ? ")
        try:
            segment_duration = float(duration)
            if segment_duration > 0 and segment_duration <= allowable_duration:
                # Calculez le nombre maximal de segments pour une vidéo
                available_duration = video_duration - (starting_offset_seconds + ending_offset_seconds)
                max_segments = int(available_duration // segment_duration)
                return segment_duration, max_segments
            else:
                print(f"La durée doit être un nombre positif et inférieure ou égale à {allowable_duration} secondes.")
        except ValueError:
            print("Veuillez entrer un nombre valide.")

def ask_directory_preference():
    print("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?")
    print("1- Oui")
    print("2- Non")
    choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ")
    return choice.strip() == '1'  # Retourne True si l'utilisateur choisit '1' (Oui), False sinon

def calculate_loudness(audio_data):
    if audio_data.ndim == 1:
        volume = audio_data.astype('float32') ** 2
    else:
        volume = np.mean(audio_data.astype('float32') ** 2, axis=1)
    volume_dB = 10 * np.log10(volume + 1e-9)  # +1e-9 to avoid log(0) and convert to dB
    return volume_dB

def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset):
    rate, audio_data = wavfile.read(audio_filename)

    # Convert stereo to mono if necessary
    if audio_data.ndim == 2:
        audio_data = np.mean(audio_data, axis=1)

    volume_dB = calculate_loudness(audio_data)
    segment_half_duration = segment_duration / 2.0
    start_index = int(starting_offset * rate)
    end_index = int((video_duration - ending_offset) * rate)

    moments = []
    volumes = []

    while len(moments) < num_moments and (end_index - start_index) > 0:
        index = np.argmax(volume_dB[start_index:end_index])
        print(f"Current index: {index}, start_index: {start_index}, end_index: {end_index}")  # Ajouté pour le débogage
        moment = (start_index + index) / rate
        print(f"Added moment at {moment} seconds")  # Ajouté pour le débogage
        moment_volume = volume_dB[start_index + index]

        if moment - segment_half_duration < starting_offset or moment + segment_half_duration > video_duration - ending_offset:
            volume_dB[start_index + index] = -np.inf
            continue

        moments.append(moment)
        print(f"Added moment at {moment} seconds") # Ajouté pour le débogage
        volumes.append(moment_volume)

        # Clear the volume around the found moment to prevent picking up nearby moments
        # Increment the global index by adding the start_index
        global_index = start_index + index

        # Clear the volume around the found moment to prevent picking up nearby moments
        clear_range_start = max(0, global_index - int(rate * segment_half_duration))
        clear_range_end = min(len(volume_dB), global_index + int(rate * segment_half_duration))

        # Debug print statements to check if the index and the volume are cleared
        print(f"Clearing from {clear_range_start} to {clear_range_end}")
        print(f"Volume before clearing at index {global_index}: {volume_dB[global_index]}")
        
        volume_dB[clear_range_start:clear_range_end] = -np.inf
        
        print(f"Volume after clearing at index {global_index}: {volume_dB[global_index]}")

    return moments, volumes

def extract_segments(video_path, moments, segment_duration, video_duration, peak_position):
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    base_name = os.path.splitext(os.path.basename(video_path))[0]
    half_segment_duration = segment_duration / 2
    
    for i, moment in enumerate(moments):
        if peak_position == '1':  # 1/4
            start_time = max(moment - segment_duration * 0.25, 0)
        elif peak_position == '2':  # 1/2
            start_time = max(moment - segment_duration * 0.5, 0)
        elif peak_position == '3':  # 3/4
            start_time = max(moment - segment_duration * 0.75, 0)
        end_time = min(start_time + segment_duration, video_duration)

        output_filename = f"{base_name}_moment{i + 1}.mp4"
        output_path = os.path.join(output_folder, output_filename)

        command = [
            "ffmpeg",
            "-y",                     # Overwrite output files without asking
            "-ss", str(start_time),   # Start time
            "-i", video_path,         # Input file
            "-t", str(min(segment_duration, video_duration - start_time)),  # Duration or remaining video
            "-c:v", "libx264",        # Specify video codec for output
            "-preset", "medium",      # Specify the encoding preset (trade-off between encoding speed and quality)
            "-crf", "23",             # Specify the Constant Rate Factor for quality (lower means better quality)
            "-c:a", "aac",            # Specify audio codec for output
            "-strict", "-2",          # Necessary for some versions of ffmpeg to use experimental aac encoder
            "-b:a", "192k",           # Specify the audio bitrate
            output_path               # Output path
        ]

        try:
            subprocess.run(command, check=True, stderr=subprocess.PIPE)
            print(f"Extracted and re-encoded {output_filename}")
        except subprocess.CalledProcessError as e:
            # Catch the exception for this process, print an error message,
            # but don't break from the for loop.
            err_msg = e.stderr.decode('utf-8') if e.stderr else 'Unknown error'
            print(f"Failed to extract segment from {video_path}: {err_msg}")
        
def store_segment_info(video_path, moment, volume, order):
    base_name = os.path.splitext(os.path.basename(video_path))[0]
    output_filename = f"{base_name}_moment{order}.mp4"
    output_path = os.path.join(output_folder, output_filename)
    extracted_segments.append({
        'path': output_path,
        'timestamp': moment,
        'volume': volume
    })
        
def ask_sorting_preference():
    print("Comment souhaitez-vous trier les vidéos extraites ?")
    print("1- Par ordre de lecture de la vidéo")
    print("2- Par ordre inverse de lecture de la vidéo")
    print("3- Par volume croissant")
    print("4- Par volume décroissant")
    print("5- Aléatoire")
    choice = int(input("Veuillez entrer le numéro de votre choix : "))
    return choice
    
def sort_moments(moments, volumes, choice):
    if choice == 1:  # Par ordre de lecture de la vidéo
        zipped = sorted(zip(moments, volumes), key=lambda x: x[0])
    elif choice == 2:  # Par ordre inverse de lecture de la vidéo
        zipped = sorted(zip(moments, volumes), key=lambda x: x[0], reverse=True)
    elif choice == 3:  # Par volume croissant
        zipped = sorted(zip(moments, volumes), key=lambda x: x[1])
    elif choice == 4:  # Par volume décroissant
        zipped = sorted(zip(moments, volumes), key=lambda x: x[1], reverse=True)
    elif choice == 5:  # Pas de tri, sélection aléatoire
        zipped = list(zip(moments, volumes))
        random.shuffle(zipped)
    else:
        zipped = zip(moments, volumes)

    # Unzip the list of tuples to two lists
    sorted_moments, sorted_volumes = zip(*zipped) if zipped else ([], [])
    return list(sorted_moments), list(sorted_volumes)

def get_video_durations(include_subfolders):
    video_durations = {}
    for root, dirs, files in os.walk('.', topdown=True):
        # Si l'utilisateur ne souhaite pas inclure les sous-dossiers, nous modifions dirs sur place
        if not include_subfolders:
            dirs[:] = []  # Cela empêchera os.walk de descendre dans tous les sous-dossiers
        # La suite du traitement des fichiers reste inchangée
        for file in files:
            if file.lower().endswith(tuple(video_extensions)):
                video_path = os.path.join(root, file)
                try:
                    # Essayez d'ouvrir et d'extraire les métadonnées du fichier vidéo.
                    video_clip = VideoFileClip(video_path)
                    video_duration = video_clip.duration
                    video_durations[video_path] = video_duration
                except Exception as e:
                    # Si une erreur survient, affichez un message et ignorez le fichier vidéo.
                    print(f"Error processing video {video_path}: {e}")
                finally:
                    # Assurez-vous de fermer le clip pour libérer les ressources.
                    video_clip.close()
    return video_durations
    
def confirm_segment_number_or_ask_again(video_duration, starting_offset_seconds, ending_offset_seconds):
    allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds)
    while True:
        segment_duration, max_segments = ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds)
        print(f"Avec cette durée, vous pouvez extraire jusqu'à {max_segments} segments.")
        confirmation = ask_yes_no_question("Voulez-vous continuer avec ce nombre de segments ?")
        if confirmation:
            return segment_duration, max_segments
            
def ask_peak_position():
    print("Où doit être situé le pic sonore dans la vidéo extraite ?")
    print("1- A 1/4 du temps de lecture de la vidéo")
    print("2- A 1/2 du temps de lecture de la vidéo")
    print("3- A 3/4 du temps de lecture de la vidéo")
    while True:
        choice = input("Veuillez entrer le numéro de votre choix (1, 2, ou 3) : ").strip()
        if choice in ('1', '2', '3'):
            return choice
        else:
            print("Entrée non valide, veuillez réessayer.")
         
def main():
    include_subfolders = ask_yes_no_question("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?")
    video_durations = get_video_durations(include_subfolders)

    if not video_durations:
        print("Aucune vidéo trouvée pour l'analyse.")
        exit()

    perform_temporal_offset = ask_yes_no_question("Souhaitez-vous effectuer un retrait temporel (début et fin) pour l'analyse des vidéos ?")

    min_video_duration = min(video_durations.values())
    starting_offset_seconds = 0
    ending_offset_seconds = 0
    if perform_temporal_offset:
        offset_type = ask_offset_type()
        print("Configuration du retrait temporel pour le début de la vidéo:")
        starting_offset_seconds = get_offset_value(min_video_duration, offset_type)
        print("Configuration du retrait temporel pour la fin de la vidéo:")
        ending_offset_seconds = get_offset_value(min_video_duration, offset_type)

    segment_duration, max_segments = confirm_segment_number_or_ask_again(min_video_duration, starting_offset_seconds, ending_offset_seconds)
    num_moments = ask_for_number_of_moments(max_segments)
    sorting_preference = ask_sorting_preference()
    peak_position = ask_peak_position()
    
    processed_videos = 0

    while True:
        for video_path, duration in video_durations.items():
            available_duration = duration - (starting_offset_seconds + ending_offset_seconds)

            if available_duration <= segment_duration:
                print(f"La vidéo {video_path} est trop courte après les décalages. Ignorer.")
                continue

            if sorting_preference == 5:  # Aléatoire
                all_possible_moments = np.arange(0, available_duration - segment_duration, segment_duration) + (segment_duration / 2)
                np.random.shuffle(all_possible_moments)
                selected_moments = all_possible_moments[:num_moments]
                volumes = [0] * len(selected_moments)  # Les volumes sont justes pour la compatibilité avec extract_segments.
            else:
                audio_path = f'temp_audio_{uuid.uuid4().hex}.wav'
                try:
                    video_clip = VideoFileClip(video_path)
                    video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000)
                    video_clip.close()
                
                    moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds)
                    sorted_moments, sorted_volumes = sort_moments(moments, volumes, sorting_preference)
                    selected_moments = sorted_moments
                    volumes = sorted_volumes

                finally:
                    if os.path.exists(audio_path):
                        os.remove(audio_path)

            extract_segments(video_path, selected_moments, segment_duration, duration, peak_position)
            processed_videos += 1

            print(f"Traitement terminé pour la vidéo '{video_path}'")

        satisfied = ask_yes_no_question("Êtes-vous satisfait de la position du pic sonore dans les vidéos extraites ? Si non, vous pouvez modifier la position.")
        if satisfied:
            break
        else:
            peak_position = ask_peak_position()  # Demander à nouveau pour la position du pic sonore
        
    print(f"Le traitement de toutes les vidéos est terminé. {processed_videos} vidéos ont été traitées.")

if __name__ == "__main__":
    main()

Je voudrais qu'à la fin de l'exécution du script,plutôt que de demander à l'utilisateur s'il est satisfait du placement temporel, le script lui offre le choix de revenir à une des étapes principales du déroulement, via un menu :

1. Traiter les sous-dossiers ou non
2. Effectuer un retrait temporel
3. Changer la durée des segments
4. Changer le nombre de segments à extraire
5. Changer l'ordre de tri
6. Changer l'emplacement du pic sonore
7. Relancer l'extraction

S'il décide de changer un de ces éléments depuis ce menu, la configuration des autres paramètres reste inchangée. Une fois qu'il a modifié et validé son paramètre, le menu réapparait.

Pour permettre à l'utilisateur de revenir à des étapes spécifiques du processus en gardant les autres paramètres inchangés, vous pouvez organiser votre code en utilisant une boucle principale qui affiche un menu des options modifiables jusqu'à ce que l'utilisateur choisisse de terminer le processus.

Voici comment vous pouvez modifier le code pour ajouter cette fonctionnalité :

```python
# Ajoutez toutes vos fonctions existantes ici...

def main():
    # Définissez les variables au niveau de la fonction main comme variables extensibles,
    # afin qu'elles puissent être modifiées à partir des sous-fonctions.
    global include_subfolders, starting_offset_seconds, ending_offset_seconds
    global segment_duration, max_segments, num_moments, sorting_preference, peak_position

    # Initialisez vos variables avec des valeurs par défaut ou des appels de fonction.
    include_subfolders = ask_directory_preference()
    video_durations = get_video_durations(include_subfolders)

    if not video_durations:
        print("Aucune vidéo trouvée pour l'analyse.")
        exit()

    starting_offset_seconds = 0
    ending_offset_seconds = 0
    perform_temporal_offset = ask_yes_no_question("Souhaitez-vous effectuer un retrait temporel (début et fin) pour l'analyse des vidéos ?")

    if perform_temporal_offset:
        offset_type = ask_offset_type()
        print("Configuration du retrait temporel pour le début de la vidéo:")
        starting_offset_seconds = get_offset_value(min(video_durations.values()), offset_type)
        print("Configuration du retrait temporel pour la fin de la vidéo:")
        ending_offset_seconds = get_offset_value(min(video_durations.values()), offset_type)

    segment_duration, max_segments = confirm_segment_number_or_ask_again(min(video_durations.values()), starting_offset_seconds, ending_offset_seconds)
    num_moments = ask_for_number_of_moments(max_segments)
    sorting_preference = ask_sorting_preference()
    peak_position = ask_peak_position()

    while True:
        print(
            "\nMenu des options :\n"
            "1. Traiter les sous-dossiers ou non\n"
            "2. Effectuer un retrait temporel\n"
            "3. Changer la durée des segments\n"
            "4. Changer le nombre de segments à extraire\n"
            "5. Changer l'ordre de tri\n"
            "6. Changer l'emplacement du pic sonore\n"
            "7. Relancer l'extraction\n"
            "8. Quitter\n")

        choice = input("Veuillez entrer le numéro de votre choix : ").strip()

        if choice == '1':
            include_subfolders = ask_directory_preference()
            video_durations = get_video_durations(include_subfolders)

        elif choice == '2':
            # Récupérez les nouvelles valeurs.
            offset_type = ask_offset_type()
            # Utilisez une valeur minimale mise à jour si nécessaire.
            min_duration = min(video_durations.values())
            print("Configuration du retrait temporel pour le début de la vidéo:")
            starting_offset_seconds = get_offset_value(min_duration, offset_type)
            print("Configuration du retrait temporel pour la fin de la vidéo:")
            ending_offset_seconds = get_offset_value(min_duration, offset_type)

        elif choice == '3':
            segment_duration, max_segments = confirm_segment_number_or_ask_again(min(video_durations.values()), starting_offset_seconds, ending_offset_seconds)
        
        elif choice == '4':
            num_moments = ask_for_number_of_moments(max_segments)
        
        elif choice == '5':
            sorting_preference = ask_sorting_preference()
        
        elif choice == '6':
            peak_position = ask_peak_position()
        
        elif choice == '7':
            # Exécutez vos sous-fonctions pour effectuer l'extraction des segments.
            # Vous souhaiterez probablement encapsuler cela dans une autre fonction.
            perform_extraction(video_durations, ...)
        
        elif choice == '8':
            print("Fin du programme.")
            break
        
        else:
            print("Choix non valide. Veuillez réessayer.")

# Définissez toutes vos autres fonctions ici...

if __name__ == "__main__":
    main()
```

Dans ce code, les étapes de configuration initiale sont toujours exécutées lors du premier lancement du programme. Après cela, l'utilisateur peut naviguer dans le menu et choisir des options spécifiques à modifier. Les paramètres restent conservés d'une itération à l'autre jusqu'à ce qu'ils soient explicitement modifiés.

Notez que pour l'option 7 ("Relancer l'extraction"), vous voudrez mettre votre logique actuelle d'extraction des segments dans une nouvelle fonction (par exemple, `perform_extraction()`) que vous pouvez réutiliser sans avoir à réécrire ou copier-coller le même code. Vous devrez vous assurer que cette fonction a accès aux variables nécessaires, soit en les passant en tant que paramètres, soit en les définissant comme variables globales si nécessaire.

Crée la fonction perform_extraction pour permettre l'extraction, en te basant sur le script original

Pour créer la fonction `perform_extraction` qui va effectuer l'extraction des segments vidéo, nous allons regrouper des parties du script original concernant le processus d'extraction. Cette fonction devra prendre en compte les paramètres qui influencent l'extraction, tels que les offsets, la durée des segments, le nombre de moments, la préférence de tri, et la position du pic sonore.

Voici à quoi la fonction `perform_extraction` pourrait ressembler, en s'appuyant sur le script original :

```python
def perform_extraction(video_durations):
    global starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position
    
    processed_videos = 0

    for video_path, duration in video_durations.items():
        available_duration = duration - (starting_offset_seconds + ending_offset_seconds)

        if available_duration <= segment_duration:
            print(f"La vidéo {video_path} est trop courte après les décalages. Passer à la suivante.")
            continue

        if sorting_preference == 5:  # Aléatoire
            all_possible_moments = np.arange(starting_offset_seconds, duration - ending_offset_seconds - segment_duration, segment_duration) + (segment_duration / 2)
            np.random.shuffle(all_possible_moments)
            selected_moments = all_possible_moments[:num_moments]
            volumes = [0] * len(selected_moments)  # Les volumes sont factices et sont justes pour la compatibilité avec 'extract_segments'.
        else:
            audio_path = f'temp_audio_{uuid.uuid4().hex}.wav'
            try:
                # Utiliser 'with' pour garantir la fermeture du clip
                with VideoFileClip(video_path) as video_clip:
                    video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000)
    
                    moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds)
                    sorted_moments, sorted_volumes = sort_moments(moments, volumes, sorting_preference)
                    selected_moments = sorted_moments
                    volumes = sorted_volumes

            finally:
                if os.path.exists(audio_path):
                    os.remove(audio_path)

        extract_segments(video_path, selected_moments, segment_duration, duration, peak_position)
        processed_videos += 1

        print(f"Extraction terminée pour la vidéo '{video_path}'")

    print(f"L'extraction de toutes les vidéos est terminée. Nombre de vidéos traitées : {processed_videos}.")

    satisfied = ask_yes_no_question("Êtes-vous satisfait de la position du pic sonore dans les vidéos extraites ? Si non, vous pouvez modifier la position.")
    if satisfied:
        return
    else:
        peak_position = ask_peak_position()  # Demander à nouveau la position du pic sonore
```

Notez que cette fonction utilise des variables globales définies dans `main()`. Le but de cette approche est de permettre à `perform_extraction` de réutiliser les paramètres actuels sans avoir à les passer explicitement en tant que paramètres. Aussi, cette fonction ne doit pas être appelée avant que toutes les variables soient initialisées dans `main`.

Dans votre boucle principale (`main()`), vous devriez maintenant appeler cette fonction lorsque l'utilisateur choisit l'option 7 :

```python
elif choice == '7':
    perform_extraction(video_durations)
```

Assurez-vous d'inclure et de remplacer toute autre logique ou variable spécifique de votre code original dans la fonction `perform_extraction` pour répondre à vos besoins.

Je voudrais que dans le menu, le script spécifie après chaque entrée du menu le paramétrage tel qu'il est défini actuellement, entre parenthèses, en couleur jaune

Pour inclure les paramètres actuels dans le menu et les afficher en couleur jaune, vous pouvez utiliser la bibliothèque `termcolor` de Python. Avant de commencer, assurez-vous d'installer la bibliothèque `termcolor` en exécutant la commande suivante :

```bash
pip install termcolor
```

Ensuite, modifiez votre code pour utiliser `termcolor` et afficher les informations dans le menu :

```python
from termcolor import colored

def print_menu():
    global include_subfolders, starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position

    print("\nMenu des options :")
    print(f"1. Traiter les sous-dossiers ou non (actuel: {colored(include_subfolders, 'yellow')})")
    print(f"2. Effectuer un retrait temporel (début: {colored(starting_offset_seconds, 'yellow')}s, fin: {colored(ending_offset_seconds, 'yellow')}s)")
    print(f"3. Changer la durée des segments (actuel: {colored(segment_duration, 'yellow')}s)")
    print(f"4. Changer le nombre de segments à extraire (actuel: {colored(num_moments, 'yellow')})")
    print(f"5. Changer l'ordre de tri (actuel: {colored(sorting_preference, 'yellow')})")
    print(f"6. Changer l'emplacement du pic sonore (actuel: {colored(peak_position, 'yellow')})")
    print(f"7. Relancer l'extraction")
    print(f"8. Quitter")

# Le reste de votre code...
```

Et voici comment vous afficheriez le menu dans la boucle principale :

```python
def main():
    # Les déclarations et initialisations des variables globales...
    
    while True:
        print_menu()
        choice = input("Veuillez entrer le numéro de votre choix : ").strip()

        # Les choix de menu et la logique de traitement...
        
        # Le reste de votre code...

# Le reste de votre code...
```

Pour cette solution, nous utilisons la fonction `colored` de `termcolor` pour afficher le texte en jaune. Les paramètres actuels sont affichés à côté de chaque entrée de menu dans la couleur spécifiée.

Dans cette implémentation, assurez-vous de mettre à jour le code pour inclure les paramètres réels actuels à la place des noms de variables génériques. Par exemple, vous devrez peut-être transformer `sorting_preference` en une chaîne descriptive correspondant au choix actuel de l'utilisateur.

ou placer la fonction print menu

La fonction `print_menu` doit être définie au même niveau que les autres fonctions dans votre script. Elle peut être placée avant la fonction `main` ou après, cela n’a pas d’importance tant qu'elle est définie avant d'être appelée. En général, on place ce genre de fonctions d'affichage au début du script pour les avoir facilement accessibles et pour améliorer la lisibilité.

Lorsque vous appelez la fonction `print_menu` dans la boucle principale (`main()`), vous affichez le menu avec les paramètres actuels. Voici un exemple de comment cela peut être organisé :

```python
from termcolor import colored

def print_menu():
    # Utilise les variables globales pour afficher le menu avec les valeurs actuelles
    print("\nMenu des options :")
    print(f"1. Traiter les sous-dossiers ou non (actuel: {colored(str(include_subfolders), 'yellow')})")
    print(f"2. Effectuer un retrait temporel (début: {colored(str(starting_offset_seconds), 'yellow')}s, fin: {colored(str(ending_offset_seconds), 'yellow')}s)")
    print(f"3. Changer la durée des segments (actuel: {colored(str(segment_duration), 'yellow')}s)")
    print(f"4. Changer le nombre de segments à extraire (actuel: {colored(str(num_moments), 'yellow')})")
    print(f"5. Changer l'ordre de tri (actuel: {colored(str(sorting_preference_to_string(sorting_preference)), 'yellow')})")
    print(f"6. Changer l'emplacement du pic sonore (actuel: {colored(peak_position_to_string(peak_position), 'yellow')})")
    print("7. Relancer l'extraction")
    print("8. Quitter")

# ...autres fonctions...

def main():
    # Les déclarations et initialisations des variables globales...

    while True:
        print_menu()
        choice = input("Veuillez entrer le numéro de votre choix : ").strip()

        # Le reste de la gestion des choix du menu...
        # ...

# Le reste de votre code...

if __name__ == "__main__":
    main()
```

J'ai ajouté deux fonctions, `sorting_preference_to_string` et `peak_position_to_string`, qui sont supposées convertir les variables numériques `sorting_preference` et `peak_position` en une chaîne lisible par l'utilisateur. Vous devrez les implémenter pour fournir une description textuelle pour chaque valeur codée. Assurez-vous également lors des changements de paramètres d'actualiser les variables globales pour refléter les nouveaux choix de l'utilisateur.

Quant à la fonction `print_menu`, elle imprime chaque option de menu avec les paramètres actuels affichés en couleur jaune. Elle tire parti des variables globales qui doivent être déclarées à l'extérieur de la fonction mais avant son appel dans le code.

  File "H:\Tests\Final\Script extraction moments forts - Menu.py", line 22
    print(f"2. Effectuer un retrait temporel (début: {colored(str(starting_offset_seconds), 'yellow')}, fin: {colored(str(ending_offset_seconds), 'yellow')}s)”)
          ^
SyntaxError: unterminated string literal (detected at line 22)

L'erreur `SyntaxError: unterminated string literal` suggère qu'il y a un problème avec la façon dont la chaîne de caractères est fermée dans votre code. Cela peut être dû à une utilisation incorrecte des guillemets.

En regardant le code que vous avez fourni, on peut voir qu'à la fin de la ligne 22, vous utilisez un guillemet courbe droit (`”`) au lieu d'un guillemet droit standard (`"`). En Python, les chaînes de caractères doivent être délimitées par des guillemets droits (`"` ou `'`), et non par des guillemets courbes.

Pour corriger l'erreur, remplacez le guillemet courbe droit par un guillemet droit standard :

```python
print(f"2. Effectuer un retrait temporel (début: {colored(str(starting_offset_seconds), 'yellow')}, fin: {colored(str(ending_offset_seconds), 'yellow')}s)")
```

Après cette correction, la ligne devrait maintenant se terminer avec un guillemet droit standard, ce qui devrait résoudre le problème de la chaîne littérale non fermée. Assurez-vous que toutes les autres chaînes de caractères dans votre code utilisent également des guillemets droits standards pour éviter des erreurs similaires à l'avenir.

import os
import subprocess
import numpy as np
import uuid  # Import uuid to generate unique IDs
from moviepy.editor import VideoFileClip
from scipy.io import wavfile
import random
from termcolor import colored

temporary_audio_files = []

# Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi']
output_folder = 'Output'

def print_menu():
    global include_subfolders, starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position

    print("\nMenu des options :")
    print(f"1. Traiter les sous-dossiers ou non (actuel: {colored(str(include_subfolders), 'yellow')})")
    print(f"2. Effectuer un retrait temporel (début: {colored(str(starting_offset_seconds), 'yellow')}s, fin: {colored(str(ending_offset_seconds), 'yellow')}s)")
    print(f"3. Changer la durée des segments (actuel: {colored(str(segment_duration), 'yellow')}s)")
    print(f"4. Changer le nombre de segments à extraire (actuel: {colored(str(num_moments), 'yellow')})")
    print(f"5. Changer l'ordre de tri (actuel: {colored(str(sorting_preference_to_string(sorting_preference)), 'yellow')})")
    print(f"6. Changer l'emplacement du pic sonore (actuel: {colored(peak_position_to_string(peak_position), 'yellow')})")
    print(f"7. Relancer l'extraction")
    print(f"8. Quitter")


def ask_for_number_of_moments(max_segments):
    while True:
        num_input = input(f"Veuillez entrer le nombre de moments forts à extraire (maximum {max_segments}): ")
        try:
            num = int(num_input)
            if num > 0 and num <= max_segments:
                return num
            else:
                print(f"Le nombre doit être supérieur à 0 et inférieur ou égal à {max_segments}. Veuillez réessayer.")
        except ValueError:
            print("Entrée non valide, veuillez réessayer avec un nombre entier.")

def ask_yes_no_question(question):
    answer = None
    while answer not in ('1', '2'):
        print(question)
        print("1- Oui")
        print("2- Non")
        answer = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip()
        if answer not in ('1', '2'):
            print("Entrée non valide, veuillez réessayer.")
    return answer == '1'
    
def ask_offset_type():
    print("Souhaitez-vous un décalage temporel relatif ou absolu ?")
    print("1- Relatif (pourcentage)")
    print("2- Absolu (secondes)")
    while True:
        choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip()
        if choice in ('1', '2'):
            return choice
        else:
            print("Entrée non valide, veuillez réessayer.")
            
def get_offset_value(video_duration, offset_type):
    if offset_type == '1':  # Relative offset
        while True:
            percent = input("Entrez le pourcentage du temps vidéo à ignorer : ")
            try:
                percent_value = float(percent)
                return percent_value * video_duration / 100
            except ValueError:
                print("Veuillez entrer un nombre valide.")
    else:  # Absolute offset
        while True:
            seconds = input("Entrez le nombre de secondes à ignorer : ")
            try:
                return float(seconds)
            except ValueError:
                print("Veuillez entrer un nombre valide.")
                
def ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds):
    while True:
        duration = input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire ? ")
        try:
            segment_duration = float(duration)
            if segment_duration > 0 and segment_duration <= allowable_duration:
                # Calculez le nombre maximal de segments pour une vidéo
                available_duration = video_duration - (starting_offset_seconds + ending_offset_seconds)
                max_segments = int(available_duration // segment_duration)
                return segment_duration, max_segments
            else:
                print(f"La durée doit être un nombre positif et inférieure ou égale à {allowable_duration} secondes.")
        except ValueError:
            print("Veuillez entrer un nombre valide.")

def ask_directory_preference():
    print("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?")
    print("1- Oui")
    print("2- Non")
    choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ")
    return choice.strip() == '1'  # Retourne True si l'utilisateur choisit '1' (Oui), False sinon

def calculate_loudness(audio_data):
    if audio_data.ndim == 1:
        volume = audio_data.astype('float32') ** 2
    else:
        volume = np.mean(audio_data.astype('float32') ** 2, axis=1)
    volume_dB = 10 * np.log10(volume + 1e-9)  # +1e-9 to avoid log(0) and convert to dB
    return volume_dB

def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset):
    rate, audio_data = wavfile.read(audio_filename)

    # Convert stereo to mono if necessary
    if audio_data.ndim == 2:
        audio_data = np.mean(audio_data, axis=1)

    volume_dB = calculate_loudness(audio_data)
    segment_half_duration = segment_duration / 2.0
    start_index = int(starting_offset * rate)
    end_index = int((video_duration - ending_offset) * rate)

    moments = []
    volumes = []

    while len(moments) < num_moments and (end_index - start_index) > 0:
        index = np.argmax(volume_dB[start_index:end_index])
        print(f"Current index: {index}, start_index: {start_index}, end_index: {end_index}")  # Ajouté pour le débogage
        moment = (start_index + index) / rate
        print(f"Added moment at {moment} seconds")  # Ajouté pour le débogage
        moment_volume = volume_dB[start_index + index]

        if moment - segment_half_duration < starting_offset or moment + segment_half_duration > video_duration - ending_offset:
            volume_dB[start_index + index] = -np.inf
            continue

        moments.append(moment)
        print(f"Added moment at {moment} seconds") # Ajouté pour le débogage
        volumes.append(moment_volume)

        # Clear the volume around the found moment to prevent picking up nearby moments
        # Increment the global index by adding the start_index
        global_index = start_index + index

        # Clear the volume around the found moment to prevent picking up nearby moments
        clear_range_start = max(0, global_index - int(rate * segment_half_duration))
        clear_range_end = min(len(volume_dB), global_index + int(rate * segment_half_duration))

        # Debug print statements to check if the index and the volume are cleared
        print(f"Clearing from {clear_range_start} to {clear_range_end}")
        print(f"Volume before clearing at index {global_index}: {volume_dB[global_index]}")
        
        volume_dB[clear_range_start:clear_range_end] = -np.inf
        
        print(f"Volume after clearing at index {global_index}: {volume_dB[global_index]}")

    return moments, volumes

def extract_segments(video_path, moments, segment_duration, video_duration, peak_position):
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    base_name = os.path.splitext(os.path.basename(video_path))[0]
    half_segment_duration = segment_duration / 2
    
    for i, moment in enumerate(moments):
        if peak_position == '1':  # 1/4
            start_time = max(moment - segment_duration * 0.25, 0)
        elif peak_position == '2':  # 1/2
            start_time = max(moment - segment_duration * 0.5, 0)
        elif peak_position == '3':  # 3/4
            start_time = max(moment - segment_duration * 0.75, 0)
        end_time = min(start_time + segment_duration, video_duration)

        output_filename = f"{base_name}_moment{i + 1}.mp4"
        output_path = os.path.join(output_folder, output_filename)

        command = [
            "ffmpeg",
            "-y",                     # Overwrite output files without asking
            "-ss", str(start_time),   # Start time
            "-i", video_path,         # Input file
            "-t", str(min(segment_duration, video_duration - start_time)),  # Duration or remaining video
            "-c:v", "libx264",        # Specify video codec for output
            "-preset", "medium",      # Specify the encoding preset (trade-off between encoding speed and quality)
            "-crf", "23",             # Specify the Constant Rate Factor for quality (lower means better quality)
            "-c:a", "aac",            # Specify audio codec for output
            "-strict", "-2",          # Necessary for some versions of ffmpeg to use experimental aac encoder
            "-b:a", "192k",           # Specify the audio bitrate
            output_path               # Output path
        ]

        try:
            subprocess.run(command, check=True, stderr=subprocess.PIPE)
            print(f"Extracted and re-encoded {output_filename}")
        except subprocess.CalledProcessError as e:
            # Catch the exception for this process, print an error message,
            # but don't break from the for loop.
            err_msg = e.stderr.decode('utf-8') if e.stderr else 'Unknown error'
            print(f"Failed to extract segment from {video_path}: {err_msg}")
        
def store_segment_info(video_path, moment, volume, order):
    base_name = os.path.splitext(os.path.basename(video_path))[0]
    output_filename = f"{base_name}_moment{order}.mp4"
    output_path = os.path.join(output_folder, output_filename)
    extracted_segments.append({
        'path': output_path,
        'timestamp': moment,
        'volume': volume
    })
        
def ask_sorting_preference():
    print("Comment souhaitez-vous trier les vidéos extraites ?")
    print("1- Par ordre de lecture de la vidéo")
    print("2- Par ordre inverse de lecture de la vidéo")
    print("3- Par volume croissant")
    print("4- Par volume décroissant")
    print("5- Aléatoire")
    choice = int(input("Veuillez entrer le numéro de votre choix : "))
    return choice
    
def sort_moments(moments, volumes, choice):
    if choice == 1:  # Par ordre de lecture de la vidéo
        zipped = sorted(zip(moments, volumes), key=lambda x: x[0])
    elif choice == 2:  # Par ordre inverse de lecture de la vidéo
        zipped = sorted(zip(moments, volumes), key=lambda x: x[0], reverse=True)
    elif choice == 3:  # Par volume croissant
        zipped = sorted(zip(moments, volumes), key=lambda x: x[1])
    elif choice == 4:  # Par volume décroissant
        zipped = sorted(zip(moments, volumes), key=lambda x: x[1], reverse=True)
    elif choice == 5:  # Pas de tri, sélection aléatoire
        zipped = list(zip(moments, volumes))
        random.shuffle(zipped)
    else:
        zipped = zip(moments, volumes)

    # Unzip the list of tuples to two lists
    sorted_moments, sorted_volumes = zip(*zipped) if zipped else ([], [])
    return list(sorted_moments), list(sorted_volumes)

def get_video_durations(include_subfolders):
    video_durations = {}
    for root, dirs, files in os.walk('.', topdown=True):
        # Si l'utilisateur ne souhaite pas inclure les sous-dossiers, nous modifions dirs sur place
        if not include_subfolders:
            dirs[:] = []  # Cela empêchera os.walk de descendre dans tous les sous-dossiers
        # La suite du traitement des fichiers reste inchangée
        for file in files:
            if file.lower().endswith(tuple(video_extensions)):
                video_path = os.path.join(root, file)
                try:
                    # Essayez d'ouvrir et d'extraire les métadonnées du fichier vidéo.
                    video_clip = VideoFileClip(video_path)
                    video_duration = video_clip.duration
                    video_durations[video_path] = video_duration
                except Exception as e:
                    # Si une erreur survient, affichez un message et ignorez le fichier vidéo.
                    print(f"Error processing video {video_path}: {e}")
                finally:
                    # Assurez-vous de fermer le clip pour libérer les ressources.
                    video_clip.close()
    return video_durations
    
def confirm_segment_number_or_ask_again(video_duration, starting_offset_seconds, ending_offset_seconds):
    allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds)
    while True:
        segment_duration, max_segments = ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds)
        print(f"Avec cette durée, vous pouvez extraire jusqu'à {max_segments} segments.")
        confirmation = ask_yes_no_question("Voulez-vous continuer avec ce nombre de segments ?")
        if confirmation:
            return segment_duration, max_segments
            
def ask_peak_position():
    print("Où doit être situé le pic sonore dans la vidéo extraite ?")
    print("1- A 1/4 du temps de lecture de la vidéo")
    print("2- A 1/2 du temps de lecture de la vidéo")
    print("3- A 3/4 du temps de lecture de la vidéo")
    while True:
        choice = input("Veuillez entrer le numéro de votre choix (1, 2, ou 3) : ").strip()
        if choice in ('1', '2', '3'):
            return choice
        else:
            print("Entrée non valide, veuillez réessayer.")
         
def main():
    # Définissez les variables au niveau de la fonction main comme variables extensibles,
    # afin qu'elles puissent être modifiées à partir des sous-fonctions.
    global include_subfolders, starting_offset_seconds, ending_offset_seconds
    global segment_duration, max_segments, num_moments, sorting_preference, peak_position

    # Initialisez vos variables avec des valeurs par défaut ou des appels de fonction.
    include_subfolders = ask_directory_preference()
    video_durations = get_video_durations(include_subfolders)

    if not video_durations:
        print("Aucune vidéo trouvée pour l'analyse.")
        exit()

    starting_offset_seconds = 0
    ending_offset_seconds = 0
    perform_temporal_offset = ask_yes_no_question("Souhaitez-vous effectuer un retrait temporel (début et fin) pour l'analyse des vidéos ?")

    if perform_temporal_offset:
        offset_type = ask_offset_type()
        print("Configuration du retrait temporel pour le début de la vidéo:")
        starting_offset_seconds = get_offset_value(min(video_durations.values()), offset_type)
        print("Configuration du retrait temporel pour la fin de la vidéo:")
        ending_offset_seconds = get_offset_value(min(video_durations.values()), offset_type)

    # segment_duration, max_segments = confirm_segment_number_or_ask_again(min(video_durations.values()), starting_offset_seconds, ending_offset_seconds)
    # num_moments = ask_for_number_of_moments(max_segments)
    # sorting_preference = ask_sorting_preference()
    # peak_position = ask_peak_position()

    while True:
        print_menu()

        choice = input("Veuillez entrer le numéro de votre choix : ").strip()

        if choice == '1':
            include_subfolders = ask_directory_preference()
            video_durations = get_video_durations(include_subfolders)

        elif choice == '2':
            # Récupérez les nouvelles valeurs.
            offset_type = ask_offset_type()
            # Utilisez une valeur minimale mise à jour si nécessaire.
            min_duration = min(video_durations.values())
            print("Configuration du retrait temporel pour le début de la vidéo:")
            starting_offset_seconds = get_offset_value(min_duration, offset_type)
            print("Configuration du retrait temporel pour la fin de la vidéo:")
            ending_offset_seconds = get_offset_value(min_duration, offset_type)

        elif choice == '3':
            segment_duration, max_segments = confirm_segment_number_or_ask_again(min(video_durations.values()), starting_offset_seconds, ending_offset_seconds)
        
        elif choice == '4':
            num_moments = ask_for_number_of_moments(max_segments)
        
        elif choice == '5':
            sorting_preference = ask_sorting_preference()
        
        elif choice == '6':
            peak_position = ask_peak_position()
        
        elif choice == '7':
            # Exécutez vos sous-fonctions pour effectuer l'extraction des segments.
            # Vous souhaiterez probablement encapsuler cela dans une autre fonction.
            extract_segments(video_path, selected_moments, segment_duration, duration, peak_position)
        
        elif choice == '8':
            print("Fin du programme.")
            break
        
        else:
            print("Choix non valide. Veuillez réessayer.")
        
    print(f"Le traitement de toutes les vidéos est terminé. {processed_videos} vidéos ont été traitées.")

if __name__ == "__main__":
    main()


Je veux que le script affiche directement le menu.

Pour que le script affiche directement le menu principal dès son lancement et pour que les utilisateurs puissent modifier les paramètres ou commencer l'extraction sans devoir tout paramétrer à nouveau, vous devrez :

1. Initialiser les variables avec des valeurs par défaut.
2. Afficher le menu immédiatement dans la boucle principale.
3. Réaliser les actions en fonction du choix de l'utilisateur.
4. S'assurer que le menu redemande les entrées si l'utilisateur souhaite modifier le paramétrage.
5. Faire en sorte que l'entrée '7' déclenche un processus qui utilise tous les paramètres actuellement définis.

Voici comment vous pouvez modifier le code pour satisfaire ces conditions :

```python
# ...autres fonctions...

def perform_extraction(video_durations):
    global starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position, processed_videos

    processed_videos = 0
    for video_path, duration in video_durations.items():
        available_duration = duration - (starting_offset_seconds + ending_offset_seconds)

        # Votre logique d'extraction...
        # ...

    print(f"Le traitement de toutes les vidéos est terminé. {processed_videos} vidéos ont été traitées.")

def main():
    global include_subfolders, starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position, processed_videos

    # Initialisation des variables avec des valeurs par défaut
    include_subfolders = True
    starting_offset_seconds = 0
    ending_offset_seconds = 0
    segment_duration = 5.0  # Valeur par défaut, par exemple 5 secondes
    max_segments = 10       # Valeur par défaut, par exemple 10
    num_moments = 5         # Valeur par défaut, par exemple 5 moments
    sorting_preference = 1  # Valeur par défaut, par exemple tri par ordre de lecture de la vidéo
    peak_position = '2'     # Valeur par défaut, par exemple à 1/2 du temps de lecture de la vidéo
    processed_videos = 0
    
    # Chargement des durées des vidéos au démarrage du script
    video_durations = get_video_durations(include_subfolders)
    if not video_durations:
        print("Aucune vidéo trouvée pour l'analyse.")
        exit()

    while True:
        print_menu()
        choice = input("Veuillez entrer le numéro de votre choix : ").strip()
        if choice == '1':
            # Votre logique de menu...
            # ...
        elif choice == '7':
            perform_extraction(video_durations)
        # ...autres choix...
        
        # Affichage du menu à nouveau à la fin de la boucle while
        
# ...autres fonctions...

if __name__ == "__main__":
    main()
```

N'oubliez pas d'ajouter la logique de votre extraction au sein de la fonction `perform_extraction` en reprenant le code responsable de ce processus depuis votre script original.

Le script complet avec toutes les fonctions reste inchangé, excepté pour la fonction `main` qui vient maintenant initialiser quelques valeurs par défaut avant de rentrer dans la boucle qui affiche le menu. Vous pouvez ajuster les valeurs par défaut selon ce qui convient le mieux à votre usage typique.

Chaque fois que l'utilisateur choisit une option autre que '7', cela doit affecter ou mettre à jour les variables globales (si cela est nécessaire). Lorsque l'utilisateur choisit l'option '7', le script exécute la fonction `perform_extraction` avec les paramètres actuels. Après le traitement, ou si l'utilisateur choisit une autre option, le script affiche à nouveau le menu, permettant ainsi à l'utilisateur de faire d'autres choix ou de quitter le programme.