feat(gps): add manual decimal<->DMS conversion and roadmap note

apps/gps_converter.py

@@ -9,155 +9,234 @@ class DataFrames:
     Dframe = pd.DataFrame()
 
 
-st.title("GPS Coordinate Converter")
-st.write(
-    """This program allows you to convert coordinates from degree-minute-second (13°15'6.20"N) to decimal (13.2517222222222) and vice versa.
-Please choose a file containing the latitude and longitude columns.
-                    """
-)
-
-decimal_to_degrees_sample_file_path = "samples/Decimal_to_DMS.xlsx"
-degrees_to_decimal_sample_file_path = "samples/DMS_to_Decimal.xlsx"
+def _validate_decimal_coordinate(value: float, axis: str) -> float:
+    if axis == "lat" and not (-90 <= value <= 90):
+        raise ValueError("Latitude must be between -90 and 90.")
+    if axis == "lon" and not (-180 <= value <= 180):
+        raise ValueError("Longitude must be between -180 and 180.")
+    return value
+
+
+def _decimal_to_dms_with_direction(value: float, axis: str) -> str:
+    _validate_decimal_coordinate(value, axis)
+    direction = "N" if value >= 0 else "S"
+    if axis == "lon":
+        direction = "E" if value >= 0 else "W"
+    dms = to_str_deg_min_sec(abs(value))
+    return f"{dms}{direction}"
+
+
+def _dms_to_decimal(value: str, axis: str) -> float:
+    normalized = value.strip().upper()
+    if axis == "lon":
+        normalized = normalized.replace("O", "W")
+    result = parse(normalized)
+    return _validate_decimal_coordinate(result, axis)
+
+
+def _show_map(df: pd.DataFrame, lat_col: str, lon_col: str, title: str = "Map Visualization"):
+    st.subheader(title)
+    try:
+        map_df = df.copy()
+        map_df[lat_col] = pd.to_numeric(map_df[lat_col], errors="coerce")
+        map_df[lon_col] = pd.to_numeric(map_df[lon_col], errors="coerce")
+        map_df = map_df.dropna(subset=[lat_col, lon_col])
+
+        if map_df.empty:
+            st.warning("No valid coordinates available for map display.")
+            return
+
+        hover_cols = [col for col in map_df.columns if col not in [lat_col, lon_col]]
+        if hover_cols:
+            map_df["hover_text"] = map_df[hover_cols].astype(str).agg("<br>".join, axis=1)
+        else:
+            map_df["hover_text"] = "Point"
+
+        fig = px.scatter_map(
+            map_df,
+            lat=lat_col,
+            lon=lon_col,
+            hover_name="hover_text",
+            zoom=5,
+            height=500,
+        )
+        fig.update_layout(
+            mapbox_style="open-street-map",
+            margin={"r": 0, "t": 0, "l": 0, "b": 0},
+        )
+        fig.update_traces(marker=dict(size=12, color="#FF4B4B"))
+        st.plotly_chart(fig, use_container_width=True)
+    except Exception as map_error:
+        st.warning(f"Could not display map. Error: {map_error}")
+
+
+def _render_import_mode():
+    st.write("Convert coordinates from an Excel file.")
+
+    decimal_to_degrees_sample_file_path = "samples/Decimal_to_DMS.xlsx"
+    degrees_to_decimal_sample_file_path = "samples/DMS_to_Decimal.xlsx"
+
+    col1, col2, _ = st.columns(3)
+
+    with col1:
+        st.download_button(
+            label="Download Decimal_to_DMS Sample File",
+            data=open(decimal_to_degrees_sample_file_path, "rb").read(),
+            file_name="Decimal_to_DMS.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        )
+    with col2:
+        st.download_button(
+            label="Download DMS_to_Decimal Sample File",
+            data=open(degrees_to_decimal_sample_file_path, "rb").read(),
+            file_name="DMS_to_Decimal.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        )
+
+    uploaded_file = st.file_uploader("Choose a file", type=["xlsx"], key="gps_file")
+    if uploaded_file is None:
+        st.info("Please choose a file containing the latitude and longitude columns.")
+        return
 
-col1, col2, col3 = st.columns(3)
+    DataFrames.Dframe = pd.read_excel(uploaded_file, keep_default_na=False)
+    columns = DataFrames.Dframe.columns.tolist()
 
-with col1:
-    st.download_button(
-        label="Download Decimal_to_DMS Sample File",
-        data=open(decimal_to_degrees_sample_file_path, "rb").read(),
-        file_name="Decimal_to_DMS.xlsx",
-        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-    )
-with col2:
-    st.download_button(
-        label="Download DMS_to_Decimal Sample File",
-        data=open(degrees_to_decimal_sample_file_path, "rb").read(),
-        file_name="DMS_to_Decimal.xlsx",
-        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    latitude_col = st.selectbox("Choose Latitude Column", options=columns)
+    longitude_col = st.selectbox("Choose Longitude Column", options=columns)
+    conversion_choice = st.selectbox(
+        "Choose Conversion Type",
+        options=["DMS to Decimal", "Decimal to DMS"],
     )
 
-uploaded_file = st.file_uploader("Choose a file", type=["xlsx"])
-col1_list = []
-if uploaded_file is not None:
-    DataFrames.Dframe = pd.read_excel(uploaded_file, keep_default_na=False)
-    col1_list = DataFrames.Dframe.columns.tolist()
+    if not st.button("CONVERT", type="primary", key="import_convert"):
+        return
 
-    latitude_dd = st.selectbox("Choose Latitude Column", options=col1_list)
-    longitude_dd = st.selectbox("Choose Longitude Column", options=col1_list)
+    try:
+        df = DataFrames.Dframe.copy()
+        df["converted_latitude"] = df[latitude_col]
+        df["converted_longitude"] = df[longitude_col]
 
-    conversion_choice = st.selectbox(
-        "Choose Conversion Type", options=["Decimal", "DegMinSec"]
+        if conversion_choice == "DMS to Decimal":
+            df["converted_latitude"] = df["converted_latitude"].apply(
+                lambda x: _dms_to_decimal(str(x), "lat")
+            )
+            df["converted_longitude"] = df["converted_longitude"].apply(
+                lambda x: _dms_to_decimal(str(x), "lon")
+            )
+            map_lat_col = "converted_latitude"
+            map_lon_col = "converted_longitude"
+        else:
+            df["converted_latitude"] = pd.to_numeric(df["converted_latitude"], errors="coerce")
+            df["converted_longitude"] = pd.to_numeric(df["converted_longitude"], errors="coerce")
+            if df["converted_latitude"].isna().any() or df["converted_longitude"].isna().any():
+                raise ValueError("Decimal columns contain invalid numeric values.")
+
+            df["converted_latitude"] = df["converted_latitude"].apply(
+                lambda x: _decimal_to_dms_with_direction(float(x), "lat")
+            )
+            df["converted_longitude"] = df["converted_longitude"].apply(
+                lambda x: _decimal_to_dms_with_direction(float(x), "lon")
+            )
+            map_lat_col = latitude_col
+            map_lon_col = longitude_col
+
+        DataFrames.Dframe = df
+        st.success("Coordinates converted successfully.")
+
+        AgGrid(
+            DataFrames.Dframe,
+            fit_columns_on_grid_load=True,
+            theme="streamlit",
+            enable_enterprise_modules=True,
+            filter=True,
+        )
+
+        _show_map(DataFrames.Dframe, map_lat_col, map_lon_col)
+
+    except Exception as error:
+        st.error(
+            "An error occurred. Ensure your selected columns contain valid coordinate values. "
+            f"Details: {error}"
+        )
+
+
+def _render_manual_mode():
+    st.write("Convert a single coordinate pair without importing a file.")
+    mode = st.radio(
+        "Choose manual conversion type",
+        options=["Decimal -> DMS", "DMS -> Decimal"],
+        horizontal=True,
     )
 
-    if st.button("CONVERT", type="primary"):
-
-        try:
-            # if not latitude_dd or not longitude_dd:
-            #     st.error("Please choose the latitude and longitude columns")
-
-            # if DataFrames.Dframe.empty:
-            #     st.error("Please choose a file first")
-
-            df = DataFrames.Dframe.copy()
-
-            df["converted_latitude"] = df[latitude_dd]
-            df["converted_longitude"] = df[longitude_dd]
-
-            if conversion_choice == "Decimal":
-                df["converted_longitude"] = df["converted_longitude"].str.replace(
-                    "O", "W"
-                )
-                df["converted_latitude"] = df["converted_latitude"].apply(parse)
-                df["converted_longitude"] = df["converted_longitude"].apply(parse)
-            else:
-                df["converted_latitude"] = df["converted_latitude"].apply(
-                    to_str_deg_min_sec
-                )
-                df["converted_longitude"] = df["converted_longitude"].apply(
-                    to_str_deg_min_sec
-                )
-                df["converted_latitude"] = df["converted_latitude"].apply(
-                    lambda x: x.replace("-", "") + "S" if "-" in x else x + "N"
-                )
-                df["converted_longitude"] = df["converted_longitude"].apply(
-                    lambda x: x.replace("-", "") + "W" if "-" in x else x + "E"
-                )
-
-            DataFrames.Dframe = df
-            st.success("Coordinates converted Sucessfully")
-
-            @st.fragment
-            def table_data():
-                if DataFrames.Dframe is not None:
-                    AgGrid(
-                        DataFrames.Dframe,
-                        fit_columns_on_grid_load=True,
-                        theme="streamlit",
-                        enable_enterprise_modules=True,
-                        filter=True,
-                        # columns_auto_size_mode=ColumnsAutoSizeMode.FIT_CONTENTS,
-                    )
-
-            table_data()
-
-            # Display map visualization
-            st.subheader("📍 Map Visualization")
+    if mode == "Decimal -> DMS":
+        col1, col2 = st.columns(2)
+        with col1:
+            latitude = st.number_input(
+                "Latitude (decimal)",
+                min_value=-90.0,
+                max_value=90.0,
+                value=0.0,
+                step=0.000001,
+                format="%.8f",
+            )
+        with col2:
+            longitude = st.number_input(
+                "Longitude (decimal)",
+                min_value=-180.0,
+                max_value=180.0,
+                value=0.0,
+                step=0.000001,
+                format="%.8f",
+            )
+
+        if st.button("Convert Decimal -> DMS", type="primary", key="manual_decimal_to_dms"):
             try:
-                map_df = DataFrames.Dframe.copy()
-
-                # Determine which columns contain decimal coordinates for mapping
-                if conversion_choice == "Decimal":
-                    lat_col = "converted_latitude"
-                    lon_col = "converted_longitude"
-                else:
-                    # For DMS output, use original decimal source columns
-                    lat_col = latitude_dd
-                    lon_col = longitude_dd
-                    # Ensure they are numeric
-                    map_df[lat_col] = pd.to_numeric(map_df[lat_col], errors="coerce")
-                    map_df[lon_col] = pd.to_numeric(map_df[lon_col], errors="coerce")
-
-                # Create hover text with available columns
-                hover_cols = [
-                    col
-                    for col in map_df.columns
-                    if col not in [lat_col, lon_col, "hover_text"]
-                ]
-                if hover_cols:
-                    map_df["hover_text"] = map_df[hover_cols].astype(str).agg(
-                        "<br>".join, axis=1
-                    )
-                else:
-                    map_df["hover_text"] = "Point"
-
-                # Filter out invalid coordinates
-                map_df = map_df.dropna(subset=[lat_col, lon_col])
-
-                if not map_df.empty:
-                    fig = px.scatter_map(
-                        map_df,
-                        lat=lat_col,
-                        lon=lon_col,
-                        hover_name="hover_text",
-                        zoom=5,
-                        height=500,
-                    )
-                    fig.update_layout(
-                        mapbox_style="open-street-map",
-                        margin={"r": 0, "t": 0, "l": 0, "b": 0},
-                    )
-                    fig.update_traces(marker=dict(size=12, color="#FF4B4B"))
-                    st.plotly_chart(fig, use_container_width=True)
-                else:
-                    st.warning("No valid coordinates available for map display.")
-            except Exception as map_error:
-                st.warning(
-                    f"Could not display map. Ensure coordinates are valid decimal values. Error: {map_error}"
-                )
-
-        except Exception as e:
-            st.error(
-                f"An error occurred. Make sure the file contains the latitude and longitude columns. Error: {e}"
+                lat_dms = _decimal_to_dms_with_direction(float(latitude), "lat")
+                lon_dms = _decimal_to_dms_with_direction(float(longitude), "lon")
+                st.success("Conversion successful.")
+                st.write(f"Latitude (DMS): `{lat_dms}`")
+                st.write(f"Longitude (DMS): `{lon_dms}`")
+
+                map_df = pd.DataFrame([{"latitude": latitude, "longitude": longitude}])
+                _show_map(map_df, "latitude", "longitude", title="Map Visualization (manual input)")
+            except Exception as error:
+                st.error(f"Invalid input. Details: {error}")
+
+    else:
+        col1, col2 = st.columns(2)
+        with col1:
+            latitude_dms = st.text_input(
+                "Latitude (DMS)",
+                placeholder="Example: 13 15 6.20N",
+            )
+        with col2:
+            longitude_dms = st.text_input(
+                "Longitude (DMS)",
+                placeholder="Example: 2 10 5.00W",
             )
-else:
-    st.info("Please choose a file containing the latitude and longitude columns")
+
+        if st.button("Convert DMS -> Decimal", type="primary", key="manual_dms_to_decimal"):
+            try:
+                latitude = _dms_to_decimal(latitude_dms, "lat")
+                longitude = _dms_to_decimal(longitude_dms, "lon")
+                st.success("Conversion successful.")
+                st.write(f"Latitude (decimal): `{latitude:.10f}`")
+                st.write(f"Longitude (decimal): `{longitude:.10f}`")
+
+                map_df = pd.DataFrame([{"latitude": latitude, "longitude": longitude}])
+                _show_map(map_df, "latitude", "longitude", title="Map Visualization (manual input)")
+            except Exception as error:
+                st.error(f"Invalid DMS value. Details: {error}")
+
+
+st.title("GPS Coordinate Converter")
+st.write(
+    "Convert coordinates between Decimal and Degree-Minute-Second (DMS). "
+    "You can convert from an Excel file or by entering values manually."
+)
+
+tab_import, tab_manual = st.tabs(["Import Excel", "Manual Input"])
+with tab_import:
+    _render_import_mode()
+with tab_manual:
+    _render_manual_mode()

documentations/oml_db_tools_improvement_roadmap.md

@@ -0,0 +1,109 @@
+# OML_DB - Roadmap d'amelioration des tools
+
+Date: 2026-02-23
+
+## Contexte
+Cette proposition est basee sur une analyse du codebase (et non seulement du menu UI), notamment:
+- `app.py`
+- `apps/database_page.py`
+- `utils/utils_vars.py`
+- `queries/process_all_db.py`
+- `apps/ciq_2g_generator.py`
+- `apps/ciq_3g_generator.py`
+- `apps/ciq_4g_generator.py`
+- `apps/clustering.py`
+- `apps/dump_compare.py`
+
+## Propositions cibles (specifiques au repo)
+1. Health Summary (nouveau tool)
+- Ajouter une page unique qui agrege:
+  - qualite DB
+  - KPI
+  - checks existants
+- Points de connexion:
+  - navigation: `app.py`
+  - donnees: `utils/utils_vars.py`, `utils/kpi_analysis_utils.py`
+
+2. Shared Dump Cache
+- Parser le dump une seule fois par session et reutiliser les donnees entre pages/tools.
+- Cible:
+  - `apps/database_page.py`
+  - harmonisation avec les autres pages qui relisent le meme dump.
+
+3. Export Job Runner + Progress
+- Encapsuler les exports lourds avec:
+  - statut
+  - progression
+  - log utilisateur
+- Cible:
+  - orchestration: `apps/database_page.py`
+  - execution: `queries/process_all_db.py`
+
+4. Validation Engine (fichiers en entree)
+- Validation schema avant calcul:
+  - colonnes obligatoires
+  - types minimaux
+  - messages d'erreur explicites
+- Priorite:
+  - `apps/clustering.py`
+  - `apps/dump_compare.py`
+
+5. CIQ Unified Generator
+- Factoriser le flux commun 2G/3G/4G:
+  - upload
+  - spinner
+  - session state
+  - download
+- Cible:
+  - `apps/ciq_2g_generator.py`
+  - `apps/ciq_3g_generator.py`
+  - `apps/ciq_4g_generator.py`
+
+6. Settings Persistence
+- Persister les toggles metier (ex: exclusion BSC 2G decom) entre refresh/restart.
+- Cible:
+  - `apps/database_page.py`
+  - `utils/utils_vars.py`
+
+## Priorisation impact / effort
+1. Validation Engine
+- Effort: S
+- Impact: Fort immediat (moins de plantages opaques)
+
+2. Export Job Runner + Progress
+- Effort: M
+- Impact: Fort UX (visibilite sur traitements longs)
+
+3. CIQ Unified Generator
+- Effort: M
+- Impact: Fort maintenance (moins de duplication)
+
+4. Shared Dump Cache
+- Effort: M/L
+- Impact: Fort perf (moins de re-parse)
+
+5. Health Summary
+- Effort: M/L
+- Impact: Fort operationnel (vision unique)
+
+6. Settings Persistence
+- Effort: M
+- Impact: Moyen/fort UX (moins de reconfiguration)
+
+## Plan de mise en oeuvre recommande
+Phase 1 (quick wins)
+- Validation Engine sur clustering + dump compare
+- Progress/log minimal sur exports database
+
+Phase 2
+- Factorisation CIQ generators
+- Persistence des settings critiques
+
+Phase 3
+- Shared Dump Cache transverse
+- Nouvelle page Health Summary
+
+## Notes techniques
+- Attention a l'usage de globals dans `UtilsVars`: definir clairement les regles d'invalidation quand un nouveau dump est charge.
+- Ajouter une convention de cles `st.session_state` pour eviter collisions entre pages.
+- Preferer des fonctions utilitaires partagees pour les patterns repetes (upload/validate/process/download).