Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-flash· GoogleHugging Face LMArena Human Preference 140K

Créer moi une application streamlit en python qui lit un fichier txt contenant des…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Metallama-3.3-70b-instruct’s answer.
  1. User

    Créer moi une application streamlit en python qui lit un fichier txt contenant des paramètres, de la forme "[key] [value]" pour chaque ligne à partir de la 5e ligne. Le but est d'afficher les données en reconaissant automatiquement le format (ex: str, int, float, bool) de pouvoir les modifier et remplacer ou créer un nouveau fichier dans le meme répertoire. représente les données de manière plus condensées car il y a plus de 200 lignes, de plus regroupe en catégorie puis par ordre alphabétique selon les key, les catégories sont identifiées dans les key sous le format suivant "[cat][key]". Aussi, il n'y a pas que des lignes sous la forme "[cat][key]" il y a aussi "[key]" tout court.

  2. Gemini Assistant

    Absolument ! Voici une application Streamlit en Python qui répond à vos exigences.

    Cette application vous permettra de :

    1. Uploader un fichier .txt contenant vos paramètres.
    2. Analyser automatiquement les lignes à partir de la 5ème, en reconnaissant les types (int, float, bool, str).
    3. Organiser les paramètres par catégorie (si [cat]_[key]) puis par ordre alphabétique des clés. Les paramètres sans catégorie sont regroupés sous "Général".
    4. Modifier les valeurs directement via des champs de saisie adaptés au type détecté.
    5. Ajouter de nouveaux paramètres, avec ou sans catégorie.
    6. Télécharger le fichier modifié (ou un nouveau fichier) dans le même format.

    1. Créez un fichier requirements.txt:

    streamlit
    

    2. Créez votre fichier Python (par exemple, app_params.py):

    import streamlit as st
    import os
    from io import StringIO
    
    # --- Initialisation de l'état de session Streamlit ---
    # Ces variables permettront de conserver les données à travers les reruns de l'application
    if 'parsed_data' not in st.session_state:
        st.session_state.parsed_data = None
    if 'original_header' not in st.session_state:
        st.session_state.original_header = []
    if 'file_name' not in st.session_state:
        st.session_state.file_name = None
    
    # --- Fonctions utilitaires ---
    
    def convert_type(value_str):
        """
        Tente de convertir une chaîne de caractères en int, float, bool, sinon retourne la chaîne.
        Retourne la valeur convertie et le type détecté (str).
        """
        value_str_lower = value_str.lower()
        if value_str_lower == 'true':
            return True, 'bool'
        if value_str_lower == 'false':
            return False, 'bool'
        try:
            return int(value_str), 'int'
        except ValueError:
            pass
        try:
            return float(value_str), 'float'
        except ValueError:
            pass
        return value_str, 'str' # Par défaut, c'est une chaîne
    
    def parse_txt_file(file_content_io):
        """
        Lit le contenu du fichier .txt, ignore les 4 premières lignes,
        et parse les paramètres en les catégorisant et détectant leur type.
    
        Retourne un dictionnaire {'categorized': {}, 'uncategorized': {}} et la liste des lignes d'en-tête.
        """
        lines = file_content_io.readlines()
        
        header_lines = lines[:4] # Garde les 4 premières lignes
        param_lines = lines[4:]  # Les lignes de paramètres commencent à la 5ème ligne
    
        categorized_data = {}
        uncategorized_data = {}
    
        for i, line in enumerate(param_lines):
            line = line.strip()
            if not line or line.startswith('#'): # Ignore les lignes vides ou commentées
                continue
    
            parts = line.split(' ', 1) # Splitte au premier espace pour séparer clé et valeur
            if len(parts) == 2:
                key_full, value_str = parts
                value, _ = convert_type(value_str)
    
                if '_' in key_full:
                    # Si la clé contient un underscore, on tente de la catégoriser
                    first_underscore_index = key_full.find('_')
                    category = key_full[:first_underscore_index]
                    actual_key = key_full[first_underscore_index+1:]
    
                    if category not in categorized_data:
                        categorized_data[category] = {}
                    categorized_data[category][actual_key] = value
                else:
                    # Sinon, c'est un paramètre non catégorisé
                    uncategorized_data[key_full] = value
            else:
                st.warning(f"Ligne {i+5} ignorée : format invalide '{line}'")
    
        return {'categorized': categorized_data, 'uncategorized': uncategorized_data}, header_lines
    
    def _update_param(category, key_in_category, widget_key):
        """
        Callback pour mettre à jour la valeur d'un paramètre dans st.session_state.parsed_data.
        La nouvelle valeur est lue directement depuis st.session_state[widget_key].
        """
        new_value = st.session_state[widget_key]
        if category == "uncategorized":
            st.session_state.parsed_data['uncategorized'][key_in_category] = new_value
        else:
            st.session_state.parsed_data['categorized'][category][key_in_category] = new_value
        # st.toast(f"Updated '{key_in_category}' to '{new_value}'") # Optionnel: afficher un petit message
    
    def generate_output_content(parsed_data, header_lines):
        """
        Reconstruit le contenu du fichier .txt à partir des données modifiées.
        """
        output_lines = [line.decode("utf-8") if isinstance(line, bytes) else line for line in header_lines]
    
        # Ajout des paramètres catégorisés
        for category in sorted(parsed_data['categorized'].keys()):
            for key_in_category in sorted(parsed_data['categorized'][category].keys()):
                value = parsed_data['categorized'][category][key_in_category]
                # Convertir les booléens en 'true'/'false' en minuscules
                if isinstance(value, bool):
                    value_str = str(value).lower()
                else:
                    value_str = str(value)
                output_lines.append(f"{category}_{key_in_category} {value_str}\n")
    
        # Ajout des paramètres non catégorisés
        for key in sorted(parsed_data['uncategorized'].keys()):
            value = parsed_data['uncategorized'][key]
            if isinstance(value, bool):
                value_str = str(value).lower()
            else:
                value_str = str(value)
            output_lines.append(f"{key} {value_str}\n")
                
        return "".join(output_lines)
    
    # --- Configuration de la page Streamlit ---
    st.set_page_config(
        page_title="Éditeur de Fichiers de Paramètres",
        layout="wide",
        initial_sidebar_state="expanded"
    )
    
    st.title("⚙️ Éditeur de Fichiers de Paramètres TXT")
    st.markdown("---")
    
    # --- Téléchargement de fichier ---
    st.sidebar.header("Charger un fichier")
    uploaded_file = st.sidebar.file_uploader("Choisissez un fichier .txt", type=["txt"])
    
    if uploaded_file is not None:
        # Vérifie si un nouveau fichier a été uploadé ou si l'état est vide
        if st.session_state.file_name != uploaded_file.name or st.session_state.parsed_data is None:
            st.session_state.file_name = uploaded_file.name
            # Decode le fichier en utf-8 et utilise StringIO pour le traiter comme un fichier texte
            st.session_state.parsed_data, st.session_state.original_header = parse_txt_file(StringIO(uploaded_file.getvalue().decode("utf-8")))
            st.sidebar.success(f"Fichier '{uploaded_file.name}' chargé avec succès.")
            st.experimental_rerun() # Rerun pour afficher les données chargées
        else:
            # Le fichier est déjà chargé, pas besoin de le re-parser
            pass
    
    # --- Affichage et modification des paramètres ---
    if st.session_state.parsed_data:
        st.header("Modifier les Paramètres")
    
        # Paramètres Catégorisés
        st.subheader("Paramètres Catégorisés")
        categorized = st.session_state.parsed_data['categorized']
        if categorized:
            for category in sorted(categorized.keys()):
                with st.expander(f"**{category.upper()}**"):
                    # En-têtes de colonnes dans l'expander
                    col1, col2 = st.columns([1, 2])
                    with col1:
                        st.markdown("**Clé**")
                    with col2:
                        st.markdown("**Valeur**")
    
                    for key_in_category in sorted(categorized[category].keys()):
                        current_value = categorized[category][key_in_category]
                        # Clé unique pour le widget Streamlit (nécessaire pour l'état de session)
                        widget_key = f"{category}_{key_in_category}_input" 
    
                        col1, col2 = st.columns([1, 2])
                        with col1:
                            st.text(key_in_category) # Affiche la clé en texte
                        with col2:
                            # Utiliser le widget approprié en fonction du type de données
                            if isinstance(current_value, bool):
                                st.checkbox(
                                    " ", # Label vide pour un affichage plus compact
                                    value=current_value,
                                    key=widget_key,
                                    on_change=_update_param,
                                    args=(category, key_in_category, widget_key)
                                )
                            elif isinstance(current_value, int):
                                st.number_input(
                                    " ",
                                    value=current_value,
                                    step=1, # Pour les entiers, le pas est 1
                                    key=widget_key,
                                    on_change=_update_param,
                                    args=(category, key_in_category, widget_key)
                                )
                            elif isinstance(current_value, float):
                                st.number_input(
                                    " ",
                                    value=current_value,
                                    step=0.1, # Pour les floats, un pas plus petit
                                    format="%.6f", # Format pour l'affichage des floats
                                    key=widget_key,
                                    on_change=_update_param,
                                    args=(category, key_in_category, widget_key)
                                )
                            else: # Traiter comme une chaîne par défaut
                                st.text_input(
                                    " ",
                                    value=str(current_value),
                                    key=widget_key,
                                    on_change=_update_param,
                                    args=(category, key_in_category, widget_key)
                                )
        else:
            st.info("Aucun paramètre catégorisé trouvé.")
    
        # Paramètres Non Catégorisés (Regroupés sous "Général")
        st.subheader("Paramètres Généraux")
        uncategorized = st.session_state.parsed_data['uncategorized']
        if uncategorized:
            with st.expander("**GÉNÉRAL**", expanded=True): # Expanded by default for common params
                col1, col2 = st.columns([1, 2])
                with col1:
                    st.markdown("**Clé**")
                with col2:
                    st.markdown("**Valeur**")
    
                for key_full in sorted(uncategorized.keys()):
                    current_value = uncategorized[key_full]
                    widget_key = f"uncategorized_{key_full}_input"
    
                    col1, col2 = st.columns([1, 2])
                    with col1:
                        st.text(key_full)
                    with col2:
                        if isinstance(current_value, bool):
                            st.checkbox(
                                " ",
                                value=current_value,
                                key=widget_key,
                                on_change=_update_param,
                                args=("uncategorized", key_full, widget_key)
                            )
                        elif isinstance(current_value, int):
                            st.number_input(
                                " ",
                                value=current_value,
                                step=1,
                                key=widget_key,
                                on_change=_update_param,
                                args=("uncategorized", key_full, widget_key)
                            )
                        elif isinstance(current_value, float):
                            st.number_input(
                                " ",
                                value=current_value,
                                step=0.1,
                                format="%.6f",
                                key=widget_key,
                                on_change=_update_param,
                                args=("uncategorized", key_full, widget_key)
                            )
                        else:
                            st.text_input(
                                " ",
                                value=str(current_value),
                                key=widget_key,
                                on_change=_update_param,
                                args=("uncategorized", key_full, widget_key)
                            )
        else:
            st.info("Aucun paramètre général (non catégorisé) trouvé.")
    
        st.markdown("---")
        st.header("Ajouter un Nouveau Paramètre")
        with st.form("add_param_form"):
            new_category = st.text_input("Catégorie (optionnel, laisser vide pour non-catégorisé)", help="Ex: 'NETWORK' si vous ajoutez 'NETWORK_IP_ADDRESS'")
            new_key = st.text_input("Clé (Ex: 'IP_ADDRESS' ou 'BUFFER_SIZE')", help="N'incluez PAS la catégorie ici. Si une catégorie est fournie, la clé complète sera 'CATÉGORIE_CLÉ'.")
            new_value_str = st.text_input("Valeur du paramètre")
            add_button = st.form_submit_button("Ajouter le Paramètre")
    
            if add_button:
                if not new_key:
                    st.warning("La clé ne peut pas être vide.")
                else:
                    exists = False
                    if new_category:
                        # Vérifier si la clé existe déjà dans la catégorie spécifiée
                        if new_key in st.session_state.parsed_data['categorized'].get(new_category, {}):
                            exists = True
                    else:
                        # Vérifier si la clé existe déjà parmi les non-catégorisés
                        if new_key in st.session_state.parsed_data['uncategorized']:
                            exists = True
    
                    if exists:
                        st.warning(f"Le paramètre '{new_key}' existe déjà dans sa catégorie (ou comme non-catégorisé). Veuillez modifier l'existant ou choisir une clé différente.")
                    else:
                        new_value, _ = convert_type(new_value_str)
                        if new_category:
                            if new_category not in st.session_state.parsed_data['categorized']:
                                st.session_state.parsed_data['categorized'][new_category] = {}
                            st.session_state.parsed_data['categorized'][new_category][new_key] = new_value
                            st.success(f"Ajouté : {new_category}_{new_key} = {new_value}")
                        else:
                            st.session_state.parsed_data['uncategorized'][new_key] = new_value
                            st.success(f"Ajouté : {new_key} = {new_value}")
                        st.experimental_rerun() # Rerun pour afficher le nouveau paramètre
    
        st.markdown("---")
        st.header("Sauvegarder les modifications")
        
        output_content = generate_output_content(st.session_state.parsed_data, st.session_state.original_header)
        
        suggested_filename = f"modified_{st.session_state.file_name}" if st.session_state.file_name else "modified_params.txt"
        
        st.download_button(
            label="Télécharger le Fichier Modifié",
            data=output_content,
            file_name=suggested_filename,
            mime="text/plain",
            help="Cliquez pour télécharger le fichier avec les modifications."
        )
    
    else:
        st.info("Veuillez charger un fichier .txt à l'aide du sélecteur de fichier dans la barre latérale pour commencer.")
    
    

    3. Créez un exemple de fichier de paramètres (params.txt):

    # Ceci est une ligne d'en-tête 1
    # Ceci est une ligne d'en-tête 2
    # Informations importantes
    # Date de création: 2023-10-27
    NETWORK_IP_ADDRESS 192.168.1.100
    NETWORK_PORT 8080
    NETWORK_ENABLE_FIREWALL true
    DATABASE_NAME my_app_db
    DATABASE_USER admin_user
    DATABASE_MAX_CONNECTIONS 50
    DATABASE_TIMEOUT 10.5
    LOGGING_LEVEL INFO
    LOGGING_FILE_PATH /var/log/app.log
    LOGGING_ROTATION_SIZE 1024000
    SERVER_THREADS 8
    SERVER_MAX_MEMORY 2048.75
    DEBUG_MODE false
    APPLICATION_VERSION 1.2.3
    API_KEY abcdef12345
    MAX_RETRIES 3
    TEMP_DIRECTORY /tmp/data
    

    4. Pour exécuter l'application :

    Ouvrez votre terminal, naviguez jusqu'au répertoire où vous avez enregistré app_params.py et requirements.txt, puis exécutez la commande suivante :

    pip install -r requirements.txt
    streamlit run app_params.py
    

    Votre navigateur s'ouvrira automatiquement à l'adresse de l'application Streamlit.


    Explications des fonctionnalités et du code :

    • st.session_state: Crucial pour les applications Streamlit. Il permet de conserver les données (vos paramètres parsés, l'en-tête original, le nom du fichier) à travers les reruns de l'application, ce qui est nécessaire pour maintenir l'état lorsque l'utilisateur interagit avec les widgets.
    • st.file_uploader: Permet à l'utilisateur de charger le fichier .txt.
    • parse_txt_file(file_content_io):
      • Lit les lignes du fichier.
      • Sépare les 4 premières lignes (l'en-tête) des lignes de paramètres.
      • Pour chaque ligne de paramètre, elle utilise line.split(' ', 1) pour s'assurer que si la valeur contient des espaces, toute la valeur est capturée.
      • Appelle convert_type pour déterminer le type de la valeur.
      • Utilise key_full.find('_') pour détecter si la clé est de type [cat]_[key]. Si oui, elle stocke le paramètre dans st.session_state.parsed_data['categorized'][category]. Sinon, elle le met dans st.session_state.parsed_data['uncategorized'].
    • Affichage des Paramètres:
      • Les catégories sont affichées dans des st.expander (déroulants) pour condenser l'affichage, car il y a potentiellement plus de 200 lignes.
      • Les paramètres "non catégorisés" sont regroupés sous un expander "GÉNÉRAL".
      • Les clés sont triées alphabétiquement dans chaque catégorie.
      • st.columns([1, 2]) est utilisé pour aligner la clé et son champ de saisie de valeur côte à côte.
      • Types de Widgets Automatiques:
        • st.checkbox pour les booléens.
        • st.number_input pour les entiers et les flottants, avec un step adapté.
        • st.text_input pour les chaînes de caractères.
      • on_change Callback: Chaque widget de modification appelle la fonction _update_param lorsque sa valeur change. Cela met à jour directement l'état de session, ce qui est très efficace pour Streamlit.
    • Ajouter un Nouveau Paramètre:
      • Un st.form est utilisé pour regrouper les champs de saisie pour la nouvelle clé, valeur et catégorie.
      • La logique de validation vérifie si la clé existe déjà (dans la bonne catégorie ou comme non-catégorisée) avant d'ajouter.
      • st.experimental_rerun() est appelé après l'ajout pour rafraîchir l'interface et montrer le nouveau paramètre.
    • generate_output_content(): Cette fonction reconstruit le fichier .txt en incluant l'en-tête original, puis tous les paramètres (catégorisés puis non-catégorisés), triés alphabétiquement. Les booléens sont reconvertis en true ou false en minuscules.
    • st.download_button: Permet à l'utilisateur de télécharger le fichier généré avec les modifications. Streamlit gère le téléchargement côté client, ce qui est parfait pour ce cas d'utilisation car l'application ne peut pas écrire directement sur le système de fichiers de l'utilisateur.

    Cette application devrait vous offrir une interface complète et intuitive pour gérer vos fichiers de paramètres !

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.