Stéphan Peccini
6d2e877341
- Correction des 907 erreurs ruff (pathlib, imports, nommage, simplifications, docstrings) - Fix déduplication labels dans multiselect nœuds d'arrivée (analyse) - Expansion 1→N label→IDs pour le Sankey (Pays d'opération) - Ajout CLAUDE.md et document de design de l'audit - Mise à jour .gitignore (artefacts tests exploratoires) Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
422 lines
24 KiB
Python
422 lines
24 KiB
Python
import matplotlib.pyplot as plt
|
||
import streamlit as st
|
||
|
||
from app.plan_d_action.utils.data import (
|
||
INDICATEURS,
|
||
PRECONISATIONS,
|
||
afficher_bloc_ihh_isg,
|
||
afficher_caracteristiques_minerai,
|
||
afficher_description,
|
||
colorer_couleurs,
|
||
initialiser_seuils,
|
||
parse_chains_md,
|
||
poids_operation,
|
||
set_vulnerability,
|
||
)
|
||
|
||
|
||
def calcul_poids_chaine(poids_A: int, poids_F: int, poids_T: int, poids_E: int, poids_M: int) -> tuple[str,dict,int]:
|
||
"""Calcule le poids total et la criticite d'une chaine d'approvisionnement.
|
||
|
||
Args:
|
||
poids_A: Poids vulnerabilite assemblage (0-3).
|
||
poids_F: Poids vulnerabilite fabrication (0-3).
|
||
poids_T: Poids vulnerabilite traitement (0-3).
|
||
poids_E: Poids vulnerabilite extraction (0-3).
|
||
poids_M: Poids vulnerabilite substitution (0-3).
|
||
|
||
Returns:
|
||
tuple: (criticite_chaine: str, niveau_criticite: set, poids_total: int).
|
||
"""
|
||
poids_total = (\
|
||
poids_A * poids_operation["Assemblage"] + \
|
||
poids_F * poids_operation["Fabrication"] + \
|
||
poids_T * poids_operation["Traitement"] + \
|
||
poids_E * poids_operation["Extraction"] + \
|
||
poids_M * poids_operation["Substitution"] \
|
||
) / sum(poids_operation.values())
|
||
|
||
if poids_total < 3:
|
||
criticite_chaine = "Modérée"
|
||
niveau_criticite = {"Facile"}
|
||
elif poids_total < 6:
|
||
criticite_chaine = "Élevée"
|
||
niveau_criticite = {"Facile", "Modérée"}
|
||
else:
|
||
criticite_chaine = "Critique"
|
||
niveau_criticite = {"Facile", "Modérée", "Difficile"}
|
||
|
||
return criticite_chaine, niveau_criticite, poids_total
|
||
|
||
def analyser_chaines(chaines: list[dict], produits: dict, composants: dict, mineraux: dict, seuils: dict, top_n: int = 0) -> list[tuple[str, str, int]]:
|
||
"""Analyse toutes les chaines d'approvisionnement et calcule leur criticite.
|
||
|
||
Args:
|
||
chaines: Liste de dictionnaires {produit, composant, minerai}.
|
||
produits: Donnees IHH/ISG par produit.
|
||
composants: Donnees IHH/ISG par composant.
|
||
mineraux: Donnees IHH/ISG/ICS/IVC par minerai.
|
||
seuils: Seuils de vulnerabilite depuis config.yaml.
|
||
top_n: Nombre de resultats a retourner (0 = tous). Defaut: 0.
|
||
|
||
Returns:
|
||
list[dict]: Chaines avec criticite, triees par poids decroissant.
|
||
"""
|
||
resultats = []
|
||
|
||
for chaine in chaines:
|
||
sel_prod = chaine["produit"]
|
||
sel_comp = chaine["composant"]
|
||
sel_miner = chaine["minerai"]
|
||
|
||
poids_A, *_ = set_vulnerability(produits[sel_prod]["IHH_Assemblage"], produits[sel_prod]["ISG_Assemblage"], "IHH", "ISG", seuils)
|
||
poids_F, *_ = set_vulnerability(composants[sel_comp]["IHH_Fabrication"], composants[sel_comp]["ISG_Fabrication"], "IHH", "ISG", seuils)
|
||
poids_T, *_ = set_vulnerability(mineraux[sel_miner]["IHH_Traitement"], mineraux[sel_miner]["ISG_Traitement"], "IHH", "ISG", seuils)
|
||
poids_E, *_ = set_vulnerability(mineraux[sel_miner]["IHH_Extraction"], mineraux[sel_miner]["ISG_Extraction"], "IHH", "ISG", seuils)
|
||
poids_M, *_ = set_vulnerability(mineraux[sel_miner]["ICS"], mineraux[sel_miner]["IVC"], "ICS", "IVC", seuils)
|
||
|
||
criticite_chaine, niveau_criticite, poids_total = calcul_poids_chaine(
|
||
poids_A, poids_F, poids_T, poids_E, poids_M
|
||
)
|
||
|
||
resultats.append({
|
||
"chaine": chaine,
|
||
"criticite_chaine": criticite_chaine,
|
||
"niveau_criticite": niveau_criticite,
|
||
"poids_total": poids_total
|
||
})
|
||
|
||
# Tri décroissant
|
||
resultats.sort(key=lambda x: x["poids_total"], reverse=True)
|
||
|
||
# Si top_n n'est pas spécifié, tout est retourné
|
||
if top_n == 0 or top_n >= len(resultats):
|
||
return resultats
|
||
|
||
# Déterminer le seuil de coupure
|
||
seuil_poids = resultats[top_n - 1]["poids_total"]
|
||
|
||
# Inclure tous ceux dont le poids est égal au seuil
|
||
return [r for r in resultats if r["poids_total"] >= seuil_poids]
|
||
|
||
def tableau_de_bord(chains: list[dict], produits: dict, composants: dict, mineraux: dict, seuils: dict):
|
||
"""Affiche le tableau de bord interactif pour selectionner et analyser une chaine.
|
||
|
||
Args:
|
||
chains: Liste de toutes les chaines d'approvisionnement.
|
||
produits: Donnees IHH/ISG par produit.
|
||
composants: Donnees IHH/ISG par composant.
|
||
mineraux: Donnees IHH/ISG/ICS/IVC par minerai.
|
||
seuils: Seuils de vulnerabilite depuis config.yaml.
|
||
|
||
Returns:
|
||
tuple: Selectionsutilisateur et toutes les donnees de criticite calculees.
|
||
"""
|
||
col_left, col_right = st.columns([2, 3], gap="small", border=True)
|
||
with col_left:
|
||
st.markdown("**<u>Panneau de sélection</u>**", unsafe_allow_html=True)
|
||
|
||
produits_disponibles = sorted({c["produit"] for c in chains})
|
||
sel_prod = st.selectbox("Produit", produits_disponibles, index=produits_disponibles.index(st.session_state.sel_prod) if st.session_state.sel_prod else 0)
|
||
if sel_prod != st.session_state.sel_prod:
|
||
st.session_state.sel_prod = sel_prod
|
||
st.session_state.sel_comp = None
|
||
st.session_state.sel_miner = None
|
||
st.rerun()
|
||
|
||
composants_dispo = sorted({c["composant"] for c in chains if c["produit"] == sel_prod})
|
||
sel_comp = st.selectbox("Composant", composants_dispo, index=composants_dispo.index(st.session_state.sel_comp) if st.session_state.sel_comp else 0)
|
||
if sel_comp != st.session_state.sel_comp:
|
||
st.session_state.sel_comp = sel_comp
|
||
st.session_state.sel_miner = None
|
||
st.rerun()
|
||
|
||
mineraux_dispo = sorted({c["minerai"] for c in chains if c["produit"] == sel_prod and c["composant"] == sel_comp})
|
||
sel_miner = st.selectbox("Minerai", mineraux_dispo, index=mineraux_dispo.index(st.session_state.sel_miner) if st.session_state.sel_miner else 0)
|
||
if sel_miner != st.session_state.sel_miner:
|
||
st.session_state.sel_miner = sel_miner
|
||
st.rerun()
|
||
|
||
with col_right:
|
||
top_chains = analyser_chaines(chains, produits, composants, mineraux, seuils, top_n=5)
|
||
st.markdown("**<u>Top chaînes critiques pour sélection rapide</u>**", unsafe_allow_html=True)
|
||
for i, entry in enumerate(top_chains):
|
||
ch = entry["chaine"]
|
||
poids = entry["poids_total"]
|
||
criticite = entry["criticite_chaine"]
|
||
if st.button(f"**{ch['produit']} <-> {ch['composant']} <-> {ch['minerai']}** : {poids:.2f} → {criticite}", key=f"select_{i}"):
|
||
st.session_state.sel_prod = ch["produit"]
|
||
st.session_state.sel_comp = ch["composant"]
|
||
st.session_state.sel_miner = ch["minerai"]
|
||
st.rerun()
|
||
|
||
c1, c2 = st.columns([3, 2], gap="small", border=True, vertical_alignment='center')
|
||
with c1:
|
||
st.markdown("**<u>Synthèse des criticités</u>**", unsafe_allow_html=True)
|
||
poids_A, couleur_A, couleur_A_ihh, couleur_A_isg = set_vulnerability(produits[sel_prod]["IHH_Assemblage"], produits[sel_prod]["ISG_Assemblage"], "IHH", "ISG", seuils)
|
||
poids_F, couleur_F, couleur_F_ihh, couleur_F_isg = set_vulnerability(composants[sel_comp]["IHH_Fabrication"], composants[sel_comp]["ISG_Fabrication"], "IHH", "ISG", seuils)
|
||
poids_T, couleur_T, couleur_T_ihh, couleur_T_isg = set_vulnerability(mineraux[sel_miner]["IHH_Traitement"], mineraux[sel_miner]["ISG_Traitement"], "IHH", "ISG", seuils)
|
||
poids_E, couleur_E, couleur_E_ihh, couleur_E_isg = set_vulnerability(mineraux[sel_miner]["IHH_Extraction"], mineraux[sel_miner]["ISG_Extraction"], "IHH", "ISG", seuils)
|
||
poids_M, couleur_M, couleur_M_ics, couleur_M_ivc = set_vulnerability(mineraux[sel_miner]["ICS"], mineraux[sel_miner]["IVC"], "ICS", "IVC", seuils)
|
||
|
||
st.markdown(f"* **{sel_prod} - Assemblage** : {colorer_couleurs(couleur_A)} ({poids_A})")
|
||
st.markdown(f"* **{sel_comp} - Fabrication** : {colorer_couleurs(couleur_F)} ({poids_F})")
|
||
st.markdown(f"* **{sel_miner} - Traitement** : {colorer_couleurs(couleur_T)} ({poids_T})")
|
||
st.markdown(f"* **{sel_miner} - Extraction** : {colorer_couleurs(couleur_E)} ({poids_E})")
|
||
st.markdown(f"* **{sel_miner} - Minerai** : {colorer_couleurs(couleur_M)} ({poids_M})")
|
||
|
||
criticite_chaine, niveau_criticite, poids_total = calcul_poids_chaine(poids_A, poids_F, poids_T, poids_E, poids_M)
|
||
with c2:
|
||
st.error(f"**Criticité globale : {criticite_chaine} ({poids_total})**")
|
||
|
||
return (
|
||
sel_prod, sel_comp, sel_miner, niveau_criticite,
|
||
couleur_A, poids_A, couleur_F, poids_F, couleur_T, poids_T, couleur_E, poids_E, couleur_M, poids_M,
|
||
couleur_A_ihh, couleur_A_isg, couleur_F_ihh, couleur_F_isg, couleur_T_ihh, couleur_T_isg,couleur_E_ihh, couleur_E_isg, couleur_M_ics, couleur_M_ivc
|
||
)
|
||
|
||
def afficher_criticites(produits: dict, composants: dict, mineraux: dict, sel_prod: str, sel_comp: str, sel_miner: str, seuils: dict) -> None:
|
||
"""Affiche les graphiques de criticite IHH/ISG et ICS/IVC pour la chaine selectionnee."""
|
||
with st.expander("Vue d'ensemble des criticités", expanded=True):
|
||
st.markdown("## Vue d’ensemble des criticités", unsafe_allow_html=True)
|
||
|
||
col_left, col_right = st.columns([1, 1], gap="small", border=True)
|
||
|
||
with col_left:
|
||
fig1, ax1 = plt.subplots(figsize=(2, 2.4))
|
||
ax1.scatter([produits[sel_prod]["ISG_Assemblage"]], [produits[sel_prod]["IHH_Assemblage"]], label="Assemblage", s=5)
|
||
ax1.scatter([composants[sel_comp]["ISG_Fabrication"]], [composants[sel_comp]["IHH_Fabrication"]], label="Fabrication", s=5)
|
||
ax1.scatter([mineraux[sel_miner]["ISG_Extraction"]], [mineraux[sel_miner]["IHH_Extraction"]], label="Extraction", s=5)
|
||
ax1.scatter([mineraux[sel_miner]["ISG_Traitement"]], [mineraux[sel_miner]["IHH_Traitement"]], label="Traitement", s=5)
|
||
|
||
# Seuils ISG (vertical)
|
||
ax1.axvline(seuils["ISG"]["vert"]["max"], linestyle='--', color='green', alpha=0.7, linewidth=0.5) # Seuil vert-orange
|
||
ax1.axvline(seuils["ISG"]["rouge"]["min"], linestyle='--', color='red', alpha=0.7, linewidth=0.5) # Seuil orange-rouge
|
||
|
||
# Seuils IHH (horizontal)
|
||
ax1.axhline(seuils["IHH"]["vert"]["max"], linestyle='--', color='green', alpha=0.7, linewidth=0.5) # Seuil vert-orange
|
||
ax1.axhline(seuils["IHH"]["rouge"]["min"], linestyle='--', color='red', alpha=0.7, linewidth=0.5) # Seuil orange-rouge
|
||
|
||
ax1.set_xlim(0, 100)
|
||
ax1.set_ylim(0, 100)
|
||
ax1.set_xlabel("ISG", fontsize=4)
|
||
ax1.set_ylabel("IHH", fontsize=4)
|
||
ax1.tick_params(axis='both', which='major', labelsize=4)
|
||
ax1.legend(bbox_to_anchor=(0.5, -0.25), loc='upper center', fontsize=4)
|
||
plt.tight_layout()
|
||
st.pyplot(fig1)
|
||
|
||
with col_right:
|
||
fig2, ax2 = plt.subplots(figsize=(2, 2.1))
|
||
ax2.scatter([mineraux[sel_miner]["IVC"]], [mineraux[sel_miner]["ICS"]], color='green', s=5, label=sel_miner)
|
||
|
||
# Seuils IVC (vertical)
|
||
ax2.axvline(seuils["IVC"]["vert"]["max"], linestyle='--', color='green', alpha=0.7, linewidth=0.5) # Seuil vert-orange
|
||
ax2.axvline(seuils["IVC"]["rouge"]["min"], linestyle='--', color='red', alpha=0.7, linewidth=0.5) # Seuil orange-rouge
|
||
|
||
# Seuils ICS (horizontal)
|
||
ax2.axhline(seuils["ICS"]["vert"]["max"], linestyle='--', color='green', alpha=0.7, linewidth=0.5) # Seuil vert-orange
|
||
ax2.axhline(seuils["ICS"]["rouge"]["min"], linestyle='--', color='red', alpha=0.7, linewidth=0.5) # Seuil orange-rouge
|
||
|
||
ax2.set_xlim(0, max(100, mineraux[sel_miner]["IVC"]))
|
||
ax2.set_ylim(0, 1)
|
||
ax2.set_xlabel("IVC", fontsize=4)
|
||
ax2.set_ylabel("ICS", fontsize=4)
|
||
ax2.tick_params(axis='both', which='major', labelsize=4)
|
||
ax2.legend(bbox_to_anchor=(0.5, -0.25), loc='upper center', fontsize=4)
|
||
plt.tight_layout()
|
||
st.pyplot(fig2)
|
||
|
||
st.markdown(f"""
|
||
Les lignes pointillées en {colorer_couleurs("vert")} ou {colorer_couleurs("rouge")} représentent les seuils des indices concernés.\n
|
||
Les indices ISG (stabilité géopolitique) et IVC (concurrence intersectorielle) influent sur la probabilité de survenance d'un risque.\n
|
||
Les indices IHH (concentration géographique) et ICS (capacité de substitution) influent sur le niveau d'impact d'un risque.\n
|
||
Une opération se trouvant au-dessus des deux seuils a donc une forte probabilité d'être impactée avec un niveau élevé sur l'incapacité à continuer la production.
|
||
""")
|
||
|
||
def afficher_explications_et_details(
|
||
couleur_A, poids_A, couleur_F, poids_F, couleur_T, _poids_T, couleur_E, poids_E, couleur_M, poids_M,
|
||
produits, composants, mineraux, sel_prod, sel_comp, sel_miner,
|
||
couleur_A_ihh, couleur_A_isg, couleur_F_ihh, couleur_F_isg, couleur_T_ihh, couleur_T_isg,couleur_E_ihh, couleur_E_isg, couleur_M_ics, couleur_M_ivc, ui = True) -> str|None:
|
||
"""Affiche les explications detaillees des indices et ponderations pour chaque operation."""
|
||
with st.expander("Explications et détails", expanded = True):
|
||
from collections import Counter
|
||
couleurs = [couleur_A, couleur_F, couleur_T, couleur_E, couleur_M]
|
||
compte = Counter(couleurs)
|
||
nb_rouge = compte["Rouge"]
|
||
nb_orange = compte["Orange"]
|
||
nb_vert = compte["Vert"]
|
||
|
||
contenu_md = f"""
|
||
Pour cette chaîne :blue-background[**{sel_prod} <-> {sel_comp} <-> {sel_miner}**], avec {nb_rouge} criticité(s) de niveau {colorer_couleurs("Rouge")}, {nb_orange} {colorer_couleurs("Orange")} et {nb_vert} {colorer_couleurs("Vert")}, les indices individuels par opération sont :
|
||
|
||
* **{sel_prod} - Assemblage** : {colorer_couleurs(couleur_A)} ({poids_A})
|
||
* IHH = {produits[sel_prod]["IHH_Assemblage"]} ({colorer_couleurs(couleur_A_ihh)}) <-> ISG = {produits[sel_prod]["ISG_Assemblage"]} ({colorer_couleurs(couleur_A_isg)})
|
||
* pondération de l'Assemblage dans le calcul de la criticité globale : 1,5
|
||
* se référer à **{sel_prod} et Assemblage** plus bas pour le détail complet
|
||
* **{sel_comp} - Fabrication** : {colorer_couleurs(couleur_F)} ({poids_F})
|
||
* IHH = {composants[sel_comp]["IHH_Fabrication"]} ({colorer_couleurs(couleur_F_ihh)}) <-> ISG = {composants[sel_comp]["ISG_Fabrication"]} ({colorer_couleurs(couleur_F_isg)})
|
||
* pondération de la Fabrication dans le calcul de la criticité globale : 2
|
||
* se référer à **{sel_comp} et Fabrication** plus bas pour le détail complet
|
||
* **{sel_miner} - Traitement** : {colorer_couleurs(couleur_A)} ({poids_A})
|
||
* IHH = {mineraux[sel_miner]["IHH_Traitement"]} ({colorer_couleurs(couleur_T_ihh)}) <-> ISG = {mineraux[sel_miner]["ISG_Traitement"]} ({colorer_couleurs(couleur_T_isg)})
|
||
* pondération du Traitement dans le calcul de la criticité globale : 1,5
|
||
* se référer à **{sel_miner} — Vue globale** plus bas pour le détail complet de l'ensemble du minerai
|
||
* **{sel_miner} - Extraction** : {colorer_couleurs(couleur_E)} ({poids_E})
|
||
* IHH = {mineraux[sel_miner]["IHH_Extraction"]} ({colorer_couleurs(couleur_E_ihh)}) <-> ISG = {mineraux[sel_miner]["ISG_Extraction"]} ({colorer_couleurs(couleur_E_isg)})
|
||
* pondération de l'Extraction dans le calcul de la criticité globale : 1
|
||
* **{sel_miner} - Minerai** : {colorer_couleurs(couleur_M)} ({poids_M})
|
||
* ICS = {mineraux[sel_miner]["ICS"]} ({colorer_couleurs(couleur_M_ics)}) <-> IVC = {mineraux[sel_miner]["IVC"]} ({colorer_couleurs(couleur_M_ivc)})
|
||
* pondération de la Substitution dans le calcul de la criticité globale : 2
|
||
"""
|
||
contenu_md += "\n"
|
||
if ui:
|
||
st.markdown(contenu_md)
|
||
return None
|
||
return contenu_md
|
||
|
||
def afficher_preconisations_et_indicateurs_generiques(niveau_criticite: dict, _poids_A: int, _poids_F: int, _poids_T: int, _poids_E: int, _poids_M: int, ui: bool = True) -> tuple[str|None,str|None]:
|
||
"""Affiche les preconisations et indicateurs generiques selon le niveau de criticite global."""
|
||
contenu_md_left = "### Préconisations :\n\n"
|
||
contenu_md_left += "Mise en œuvre : \n"
|
||
|
||
for niveau, _contenu in PRECONISATIONS.items():
|
||
if niveau in niveau_criticite:
|
||
contenu_md_left += f"* {colorer_couleurs(niveau)}\n"
|
||
for p in PRECONISATIONS[niveau]:
|
||
contenu_md_left += f" - {p}\n"
|
||
|
||
contenu_md_right = "### Indicateurs :\n\n"
|
||
contenu_md_right += "Mise en œuvre : \n"
|
||
|
||
for niveau, _contenu in INDICATEURS.items():
|
||
if niveau in niveau_criticite:
|
||
contenu_md_right += f"* {colorer_couleurs(niveau)}\n"
|
||
for p in INDICATEURS[niveau]:
|
||
contenu_md_right += f" - {p}\n"
|
||
|
||
if ui:
|
||
with st.expander("Préconisations et indicateurs génériques"):
|
||
col_left, col_right = st.columns([1, 1], gap="small", border=True)
|
||
with col_left:
|
||
st.markdown(contenu_md_left)
|
||
with col_right:
|
||
st.markdown(contenu_md_right)
|
||
return None, None
|
||
return contenu_md_left, contenu_md_right
|
||
|
||
def afficher_preconisations_specifiques(operation: str, niveau_criticite_operation: dict) -> str:
|
||
"""Genere les preconisations specifiques a une operation selon son niveau de criticite."""
|
||
contenu_md = "#### Préconisations :\n\n"
|
||
contenu_md += "Mise en œuvre : \n"
|
||
for niveau, _contenu in PRECONISATIONS[operation].items():
|
||
if niveau in niveau_criticite_operation[operation]:
|
||
contenu_md += f"* {colorer_couleurs(niveau)}\n"
|
||
for p in PRECONISATIONS[operation][niveau]:
|
||
contenu_md += f" - {p}\n"
|
||
return(contenu_md)
|
||
|
||
def afficher_indicateurs_specifiques(operation: str, niveau_criticite_operation: dict) -> str:
|
||
"""Genere les indicateurs specifiques a une operation selon son niveau de criticite."""
|
||
contenu_md = "#### Indicateurs :\n\n"
|
||
contenu_md += "Mise en œuvre : \n"
|
||
for niveau, _contenu in INDICATEURS[operation].items():
|
||
if niveau in niveau_criticite_operation[operation]:
|
||
contenu_md += f"* {colorer_couleurs(niveau)}\n"
|
||
for p in INDICATEURS[operation][niveau]:
|
||
contenu_md += f" - {p}\n"
|
||
return(contenu_md)
|
||
|
||
def afficher_preconisations_et_indicateurs_specifiques(sel_prod: str, sel_comp: str, sel_miner: str, niveau_criticite_operation: dict) -> None:
|
||
"""Affiche les preconisations et indicateurs specifiques pour chaque operation de la chaine."""
|
||
for operation in ["Assemblage", "Fabrication", "Traitement", "Extraction"]:
|
||
if operation == "Assemblage":
|
||
item = sel_prod
|
||
elif operation == "Fabrication":
|
||
item = sel_comp
|
||
else:
|
||
item = sel_miner
|
||
with st.expander(f"Préconisations et indicateurs spécifiques - {operation}"):
|
||
st.markdown(f"### {operation} -> :blue-background[{item}]")
|
||
col_left, col_right = st.columns([1, 1], gap="small", border=True)
|
||
with col_left:
|
||
st.markdown(afficher_preconisations_specifiques(operation, niveau_criticite_operation))
|
||
with col_right:
|
||
st.markdown(afficher_indicateurs_specifiques(operation, niveau_criticite_operation))
|
||
|
||
def afficher_preconisations_et_indicateurs(niveau_criticite: dict, sel_prod: str, sel_comp: str, sel_miner: str, poids_A: int, poids_F: int, poids_T: int, poids_E: int, poids_M: int) -> None:
|
||
"""Affiche la section complete preconisations et indicateurs (generiques + specifiques)."""
|
||
st.markdown("## Préconisations et indicateurs")
|
||
|
||
afficher_preconisations_et_indicateurs_generiques(niveau_criticite, poids_A, poids_F, poids_T, poids_E, poids_M)
|
||
|
||
def affectation_poids(poids_operation):
|
||
if poids_operation < 3:
|
||
niveau_criticite = {"Facile"}
|
||
elif poids_operation < 6:
|
||
niveau_criticite = {"Facile", "Modérée"}
|
||
else:
|
||
niveau_criticite = {"Facile", "Modérée", "Difficile"}
|
||
return niveau_criticite
|
||
|
||
niveau_criticite_operation = {}
|
||
niveau_criticite_operation["Assemblage"] = affectation_poids(poids_A)
|
||
niveau_criticite_operation["Fabrication"] = affectation_poids(poids_F)
|
||
niveau_criticite_operation["Traitement"] = affectation_poids(poids_T)
|
||
niveau_criticite_operation["Extraction"] = affectation_poids(poids_E)
|
||
|
||
afficher_preconisations_et_indicateurs_specifiques(sel_prod, sel_comp, sel_miner, niveau_criticite_operation)
|
||
|
||
def afficher_details_operations(produits, composants, mineraux, sel_prod, sel_comp, sel_miner, details_sections) -> None:
|
||
"""Affiche les details complets (descriptions + IHH/ISG) pour chaque operation de la chaine."""
|
||
st.markdown("## Détails des opérations")
|
||
|
||
with st.expander(f"{sel_prod} et Assemblage"):
|
||
assemblage_details = details_sections.get(f"{sel_prod}_assemblage", "")
|
||
|
||
afficher_description(f"{sel_prod} et Assemblage", assemblage_details)
|
||
afficher_bloc_ihh_isg("Assemblage", produits[sel_prod]["IHH_Assemblage"], produits[sel_prod]["ISG_Assemblage"], assemblage_details)
|
||
|
||
with st.expander(f"{sel_comp} et Fabrication"):
|
||
fabrication_details = details_sections.get(f"{sel_comp}_fabrication", "")
|
||
afficher_description(f"{sel_comp} et Fabrication", fabrication_details)
|
||
afficher_bloc_ihh_isg("Fabrication", composants[sel_comp]["IHH_Fabrication"], composants[sel_comp]["ISG_Fabrication"], fabrication_details)
|
||
|
||
with st.expander(f"{sel_miner} — Vue globale"):
|
||
minerai_general = details_sections.get(f"{sel_miner}_general", "")
|
||
afficher_description(f"{sel_miner} — Vue globale", minerai_general)
|
||
|
||
extraction_details = details_sections.get(f"{sel_miner}_extraction", "")
|
||
afficher_bloc_ihh_isg("Extraction", mineraux[sel_miner]["IHH_Extraction"], mineraux[sel_miner]["ISG_Extraction"], extraction_details)
|
||
|
||
traitement_details = details_sections.get(f"{sel_miner}_traitement", "").removesuffix("\n---\n")
|
||
afficher_bloc_ihh_isg("Traitement", mineraux[sel_miner]["IHH_Traitement"], mineraux[sel_miner]["ISG_Traitement"], traitement_details)
|
||
|
||
afficher_caracteristiques_minerai(sel_miner, mineraux[sel_miner], minerai_general)
|
||
|
||
def initialiser_interface(filepath: str, config_path: str = "assets/config.yaml") -> None:
|
||
"""Point d'entree principal pour l'interface du plan d'action : charge donnees et affiche toutes sections."""
|
||
produits, composants, mineraux, chains, descriptions, details_sections = parse_chains_md(filepath)
|
||
|
||
if not chains:
|
||
st.warning("Aucune chaîne critique trouvée dans le fichier.")
|
||
return
|
||
|
||
seuils = initialiser_seuils(config_path)
|
||
|
||
sel_prod, sel_comp, sel_miner, niveau_criticite, \
|
||
couleur_A, poids_A, couleur_F, poids_F, couleur_T, poids_T, couleur_E, poids_E, couleur_M, poids_M, \
|
||
couleur_A_ihh, couleur_A_isg, couleur_F_ihh, couleur_F_isg, couleur_T_ihh, couleur_T_isg,couleur_E_ihh, couleur_E_isg, couleur_M_ics, couleur_M_ivc \
|
||
= tableau_de_bord(chains, produits, composants, mineraux, seuils)
|
||
|
||
afficher_criticites(produits, composants, mineraux, sel_prod, sel_comp, sel_miner, seuils)
|
||
|
||
afficher_explications_et_details(
|
||
couleur_A, poids_A, couleur_F, poids_F, couleur_T, poids_T, couleur_E, poids_E, couleur_M, poids_M,
|
||
produits, composants, mineraux, sel_prod, sel_comp, sel_miner,
|
||
couleur_A_ihh, couleur_A_isg, couleur_F_ihh, couleur_F_isg, couleur_T_ihh, couleur_T_isg,couleur_E_ihh, couleur_E_isg, couleur_M_ics, couleur_M_ivc)
|
||
|
||
afficher_preconisations_et_indicateurs(niveau_criticite, sel_prod, sel_comp, sel_miner, poids_A, poids_F, poids_T, poids_E, poids_M)
|
||
|
||
afficher_details_operations(produits, composants, mineraux, sel_prod, sel_comp, sel_miner, details_sections)
|