pycoustic 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

pycoustic/pycoustic_gui_app.py

@@ -0,0 +1,277 @@
+import os
+import tempfile
+from typing import List, Dict
+
+import pandas as pd
+import plotly.graph_objects as go
+import streamlit as st
+
+from log import *
+from survey import *
+
+# Streamlit app config
+st.set_page_config(page_title="Pycoustic Acoustic Survey Explorer", layout="wide")
+
+# Graph colour palette config
+COLOURS = {
+    "Leq A": "#9e9e9e",   # light grey
+    "L90 A": "#4d4d4d",   # dark grey
+    "Lmax A": "#fc2c2c",  # red
+}
+# Graph template config
+TEMPLATE = "plotly"
+
+if "apply_agg" not in st.session_state:
+    st.session_state["apply_agg"] = False
+if "period_last" not in st.session_state:
+    st.session_state["period_last"] = ""
+
+with st.sidebar:
+    # File Upload in expander container
+    with st.expander("File Upload", expanded=True):
+        files = st.file_uploader(
+            "Select one or more CSV files",
+            type="csv",
+            accept_multiple_files=True,
+        )
+        if not files:
+            st.stop()
+    # Integration period entry in expander container
+    with st.expander("Integration Period", expanded=True):
+        int_period = st.number_input(
+            "Insert new integration period (must be larger than data)",
+            step=1,
+            value=15,
+        )
+        period_select = st.selectbox(
+            "Please select time period",
+            ("second(s)", "minute(s)", "hour(s)"),
+            index=1,
+        )
+
+        # Build the period string
+        suffix_map = {"second(s)": "s", "minute(s)": "min", "hour(s)": "h"}
+        period = f"{int_period}{suffix_map.get(period_select, '')}"
+
+        # If the period changed since last time, reset the "apply_agg" flag
+        if st.session_state["period_last"] != period:
+            st.session_state["apply_agg"] = False
+            st.session_state["period_last"] = period
+
+        # Button to trigger aggregation for ALL positions
+        apply_agg_btn = st.button("Apply Integration Period")
+        if apply_agg_btn:
+            st.session_state["apply_agg"] = True
+
+# Main Window / Data Load
+with st.spinner("Processing Data...", show_time=True):
+    # Load each uploaded CSV into a pycoustic Log
+    logs: Dict[str, Log] = {}
+    for upload_file in files:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".csv") as tmp:
+            tmp.write(upload_file.getbuffer())
+            path = tmp.name
+        try:
+            logs[upload_file.name] = Log(path)
+        except Exception as err:
+            st.error(f"Failed to load `{upload_file.name}` into Pycoustic: {err}")
+        finally:
+            os.unlink(path)
+
+    # Build Survey and pull summary + spectra
+    summary_df = leq_spec_df = lmax_spec_df = None
+    summary_error = ""
+    if logs:
+        try:
+            survey = Survey()
+            if callable(getattr(survey, "add_log", None)):
+                for name, lg in logs.items():
+                    survey.add_log(lg, name=name)
+            elif hasattr(survey, "_logs"):
+                survey._logs = logs
+
+            summary_df = survey.resi_summary()
+            leq_spec_df = getattr(survey, "typical_leq_spectra", lambda: None)()
+            lmax_spec_df = getattr(survey, "lmax_spectra", lambda: None)()
+        except Exception as err:
+            summary_error = str(err)
+    else:
+        summary_error = "No valid logs loaded."
+
+    # Helper list of “position” names (i.e. filenames)
+    pos_list = list(logs.keys())
+
+    # Helper: turn a “spectra” DataFrame into a long‐format table for plotting
+    def spectra_to_rows(df: pd.DataFrame, pos_names: List[str]) -> pd.DataFrame | None:
+        if df is None:
+            return None
+        if not isinstance(df.columns, pd.MultiIndex):
+            tidy = df.reset_index().rename(columns={df.index.name or "index": "Period"})
+            if "Position" not in tidy.columns:
+                tidy.insert(0, "Position", pos_names[0] if pos_names else "Pos1")
+            return tidy
+
+        # If there is a MultiIndex
+        bands = [band for _, band in df.columns][: len({band for _, band in df.columns})]
+        set_len = len(bands)
+        blocks = []
+        for i, pos in enumerate(pos_names):
+            start, end = i * set_len, (i + 1) * set_len
+            if end > df.shape[1]:
+                break
+            sub = df.iloc[:, start:end].copy()
+            sub.columns = [str(b) for b in bands]
+            sub = sub.reset_index().rename(columns={df.index.names[-1] or "index": "Period"})
+            if "Position" not in sub.columns:
+                sub.insert(0, "Position", pos)
+            blocks.append(sub)
+        return pd.concat(blocks, ignore_index=True)
+
+    #Create tabs
+    ui_tabs = st.tabs(["Summary"] + pos_list)
+
+    #Summary tab
+    with ui_tabs[0]:
+        st.subheader("Broadband Summary")
+        if summary_df is not None:
+            st.dataframe(summary_df)
+        else:
+            st.warning(f"Summary unavailable: {summary_error}")
+
+        # Plot “Typical Leq Spectra” and “Lmax Spectra”, if available
+        for title, df_data in (
+            ("Typical Leq Spectra", leq_spec_df),
+            ("Lmax Spectra", lmax_spec_df),
+        ):
+            tidy = spectra_to_rows(df_data, pos_list)
+            if tidy is None:
+                continue
+
+            freq_cols = [c for c in tidy.columns if c not in ("Position", "Period", "A")]
+            if freq_cols:
+                fig = go.Figure()
+                for pos in pos_list:
+                    subset = tidy[tidy["Position"] == pos]
+                    for _, row in subset.iterrows():
+                        period_label = row["Period"]
+                        # Cast to string so .lower() is safe
+                        period_label_str = str(period_label)
+                        mode = (
+                            "lines+markers"
+                            if period_label_str.lower().startswith("day")
+                            else "lines"
+                        )
+                        label = (
+                            f"{pos} {period_label_str}"
+                            if len(pos_list) > 1
+                            else period_label_str
+                        )
+                        fig.add_trace(
+                            go.Scatter(
+                                x=freq_cols,
+                                y=row[freq_cols],
+                                mode=mode,
+                                name=label,
+                            )
+                        )
+                fig.update_layout(
+                    template=TEMPLATE,
+                    title=f"{title} - Day & Night",
+                    xaxis_title="Octave band (Hz)",
+                    yaxis_title="dB",
+                )
+                st.plotly_chart(fig, use_container_width=True)
+            else:
+                st.warning(f"No frequency columns found for `{title}`.")
+
+    # Position‐Specific Tabs
+    for tab, uf in zip(ui_tabs[1:], files):
+        with tab:
+            log = logs.get(uf.name)
+            if log is None:
+                st.error(f"Log for `{uf.name}` not found.")
+                continue
+
+            # Decide whether to show raw or aggregated data
+            if st.session_state["apply_agg"]:
+                # 1) Re-aggregate / resample using the chosen period
+                try:
+                    df_used = log.as_interval(t=period)
+                    df_used = df_used.reset_index().rename(
+                        columns={df_used.index.name or "index": "Timestamp"}
+                    )
+                    subheader = "Integrated Survey Data"
+                except Exception as e:
+                    st.error(f"Failed to apply integration period for `{uf.name}`: {e}")
+                    continue
+            else:
+                # 2) Show the raw data (from log._master) if available
+                try:
+                    raw_master = log._master  # original DataFrame, indexed by Timestamp
+                    df_used = raw_master.reset_index().rename(columns={"Time": "Timestamp"})
+                    subheader = "Raw Survey Data"
+                except Exception as e:
+                    st.error(f"Failed to load raw data for `{uf.name}`: {e}")
+                    continue
+
+            # Prepare a flattened‐column header copy JUST FOR PLOTTING
+            df_plot = df_used.copy()
+            if isinstance(df_plot.columns, pd.MultiIndex):
+                flattened_cols = []
+                for lvl0, lvl1 in df_plot.columns:
+                    lvl0_str = str(lvl0)
+                    lvl1_str = str(lvl1) if lvl1 is not None else ""
+                    flattened_cols.append(f"{lvl0_str} {lvl1_str}".strip())
+                df_plot.columns = flattened_cols
+
+            #  Time‐history Graph (Leq A, L90 A, Lmax A) using df_plot 
+            required_cols = {"Leq A", "L90 A", "Lmax A"}
+            if required_cols.issubset(set(df_plot.columns)):
+                fig = go.Figure()
+                fig.add_trace(
+                    go.Scatter(
+                        x=df_plot["Timestamp"],
+                        y=df_plot["Leq A"],
+                        name="Leq A",
+                        mode="lines",
+                        line=dict(color=COLOURS["Leq A"], width=1),
+                    )
+                )
+                fig.add_trace(
+                    go.Scatter(
+                        x=df_plot["Timestamp"],
+                        y=df_plot["L90 A"],
+                        name="L90 A",
+                        mode="lines",
+                        line=dict(color=COLOURS["L90 A"], width=1),
+                    )
+                )
+                fig.add_trace(
+                    go.Scatter(
+                        x=df_plot["Timestamp"],
+                        y=df_plot["Lmax A"],
+                        name="Lmax A",
+                        mode="markers",
+                        marker=dict(color=COLOURS["Lmax A"], size=3),
+                    )
+                )
+                fig.update_layout(
+                    template=TEMPLATE,
+                    margin=dict(l=0, r=0, t=0, b=0),
+                    xaxis=dict(
+                        title="Time & Date (hh:mm & dd/mm/yyyy)",
+                        type="date",
+                        tickformat="%H:%M<br>%d/%m/%Y",
+                        tickangle=0,
+                    ),
+                    yaxis_title="Measured Sound Pressure Level dB(A)",
+                    legend=dict(orientation="h", yanchor="top", y=-0.25, xanchor="left", x=0),
+                    height=600,
+                )
+                st.plotly_chart(fig, use_container_width=True)
+            else:
+                st.warning(f"Required columns {required_cols} missing in {subheader}.")
+
+            # --- Finally, display the TABLE with MultiIndex intact ---
+            st.subheader(subheader)
+            st.dataframe(df_used, hide_index=True)

pycoustic/pycoustic_streamlit_gpt5.py

@@ -0,0 +1,421 @@
+# Python
+# streamlit_pycoustic_app.py
+import io
+import json
+import tempfile
+from datetime import time
+
+import pandas as pd
+import streamlit as st
+
+# Import pycoustic classes
+from pycoustic import Log, Survey
+
+# python
+import os
+from typing import Optional
+
+class _SafeNoop:
+    """
+    Minimal no-op proxy that safely absorbs attribute access and calls.
+    Prevents AttributeError like "'str' object has no attribute ...".
+    """
+    def __init__(self, name: str = "object"):
+        self._name = name
+
+    def __getattr__(self, item):
+        return _SafeNoop(f"{self._name}.{item}")
+
+    def __call__(self, *args, **kwargs):
+        return None
+
+    def __repr__(self) -> str:
+        return f"<_SafeNoop {self._name}>"
+
+def _sanitize_session_state() -> None:
+    """
+    Replace any string left in common survey/log slots with a safe no-op proxy.
+    This avoids downstream AttributeError when code expects objects.
+    """
+    try:
+        import streamlit as st  # type: ignore
+    except Exception:
+        return
+
+    for key in ("survey", "log_obj", "log"):
+        if key in st.session_state:
+            val = st.session_state.get(key)
+            if isinstance(val, str):
+                # Preserve original label if useful for UI
+                st.session_state[f"{key}_name"] = val
+                # Install a no-op proxy in place of the string
+                st.session_state[key] = _SafeNoop(key)
+
+# Run sanitization as early as possible
+_sanitize_session_state()
+
+def _resolve_survey_like() -> Optional[object]:
+    """
+    Return the first available survey-like object from session state,
+    or None if nothing usable is present.
+    """
+    try:
+        import streamlit as st  # type: ignore
+    except Exception:
+        return None
+
+    for key in ("survey", "log_obj", "log"):
+        if key in st.session_state:
+            return st.session_state.get(key)
+    return None
+
+def _coerce_hm_tuple(val) -> tuple[int, int]:
+    """
+    Coerces an input into a (hour, minute) tuple.
+    Accepts tuples, lists, or 'HH:MM' / 'H:M' strings.
+    """
+    if isinstance(val, (tuple, list)) and len(val) == 2:
+        return int(val[0]), int(val[1])
+    if isinstance(val, str):
+        parts = val.strip().split(":")
+        if len(parts) == 2:
+            return int(parts[0]), int(parts[1])
+    # Fallback to 00:00 if invalid
+    return 0, 0
+
+def _set_periods_on_survey(day_tuple, eve_tuple, night_tuple) -> None:
+    """
+    Accepts (hour, minute) tuples and updates the Survey periods, if available.
+    Safely no-ops if a proper survey object isn't present.
+    """
+    survey = _resolve_survey_like()
+    if survey is None:
+        return
+
+    times = {
+        "day": _coerce_hm_tuple(day_tuple),
+        "evening": _coerce_hm_tuple(eve_tuple),
+        "night": _coerce_hm_tuple(night_tuple),
+    }
+
+    setter = getattr(survey, "set_periods", None)
+    if callable(setter):
+        try:
+            setter(times=times)
+        except Exception:
+            # Swallow to keep the UI responsive even if backend rejects values
+            pass
+
+def _looks_like_path(s: str) -> bool:
+    s = s.strip()
+    return (
+        s.lower().endswith(".csv")
+        or os.sep in s
+        or "/" in s
+        or "\\" in s
+    )
+
+def _usable_acoustic_obj(obj) -> bool:
+    # Consider it usable if it exposes either API used elsewhere.
+    return hasattr(obj, "set_periods") or hasattr(obj, "_leq_by_date")
+
+def _coerce_or_clear_state_key(st, key: str) -> None:
+    """
+    If st.session_state[key] is a string:
+      - If it looks like a CSV path, try to build a Log object from it.
+      - Otherwise, move it to key_name and clear the object slot to avoid attribute errors.
+    """
+    if key not in st.session_state:
+        return
+
+    val = st.session_state.get(key)
+
+    # Already usable object
+    if _usable_acoustic_obj(val):
+        return
+
+    # Try to coerce from a CSV-like path string
+    if isinstance(val, str):
+        if _looks_like_path(val):
+            try:
+                import pycoustic as pc  # Lazy import
+                st.session_state[key] = pc.Log(path=val.strip())
+                return
+            except Exception:
+                # Fall through to clearing if coercion fails
+                pass
+
+        # Preserve label for UI, clear the object slot to avoid attribute errors
+        st.session_state[f"{key}_name"] = val
+        st.session_state[key] = None
+
+def _normalize_session_state() -> None:
+    try:
+        import streamlit as st  # type: ignore
+    except Exception:
+        return
+
+    # Coerce or clear common object keys
+    for k in ("survey", "log_obj", "log"):
+        _coerce_or_clear_state_key(st, k)
+
+    # Promote first usable object into the canonical "survey" slot
+    if not _usable_acoustic_obj(st.session_state.get("survey")):
+        for k in ("log_obj", "log"):
+            candidate = st.session_state.get(k)
+            if _usable_acoustic_obj(candidate):
+                st.session_state["survey"] = candidate
+                break
+
+# Run normalization early so downstream code doesn't encounter attribute errors
+_normalize_session_state()
+
+
+# --------------- Helpers ---------------
+
+def save_upload_to_tmp(uploaded_file) -> str:
+    """Persist an uploaded CSV to a temporary file and return its path."""
+    # Create a persistent temporary file (delete later on reset)
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".csv") as tmp:
+        tmp.write(uploaded_file.getbuffer())
+        return tmp.name
+
+
+def build_survey(log_map: dict, times_kwarg: dict | None = None) -> Survey:
+    """Create a Survey, attach logs, and optionally call set_periods(times=...)."""
+    survey = Survey()
+
+    # Attach logs to the Survey (simple, direct assignment to internal storage)
+    # If a public adder method exists, prefer that; fallback to internal attribute.
+    if hasattr(survey, "add_log"):
+        for key, lg in log_map.items():
+            try:
+                survey.add_log(key, lg)  # type: ignore[attr-defined]
+            except Exception:
+                # Fallback if signature differs
+                setattr(survey, "_logs", log_map)
+                break
+    else:
+        setattr(survey, "_logs", log_map)
+
+    # Apply periods if provided
+    if times_kwarg is not None:
+        try:
+            survey.set_periods(times=times_kwarg)
+        except Exception as e:
+            st.warning(f"set_periods failed with provided times: {e}")
+
+    return survey
+
+
+def flatten_columns(df: pd.DataFrame) -> pd.DataFrame:
+    """Flatten MultiIndex columns for nicer display in Streamlit."""
+    if isinstance(df.columns, pd.MultiIndex):
+        flat = df.copy()
+        flat.columns = [" / ".join(map(str, c)) for c in df.columns.to_flat_index()]
+        return flat
+    return df
+
+
+def parse_extra_kwargs(raw: str) -> dict:
+    """Parse a JSON dict from a text area. Returns {} on error."""
+    if not raw or not raw.strip():
+        return {}
+    try:
+        parsed = json.loads(raw)
+        if not isinstance(parsed, dict):
+            st.warning("Extra kwargs JSON should be an object/dict; ignoring.")
+            return {}
+        return parsed
+    except Exception as e:
+        st.warning(f"Unable to parse extra kwargs JSON. Ignoring. Error: {e}")
+        return {}
+
+
+# --------------- Streamlit App ---------------
+
+st.set_page_config(page_title="pycoustic GUI", layout="wide")
+st.title("pycoustic Streamlit GUI")
+
+# Initialize session state
+ss = st.session_state
+ss.setdefault("tmp_paths", [])          # List[str] for cleanup
+ss.setdefault("logs", {})               # Dict[str, Log]
+ss.setdefault("survey", None)           # Survey or None
+ss.setdefault("resi_df", None)          # Cached summary
+ss.setdefault("periods_times", {        # Default times for set_periods()
+    "day": (7, 0),
+    "evening": (23, 0),
+    "night": (23, 0),
+})
+ss.setdefault("lmax_n", 5)
+ss.setdefault("lmax_t", 30)
+ss.setdefault("extra_kwargs_raw", "{}")
+
+with st.expander("1) Load CSV data", expanded=True):
+    st.write("Upload one or more CSV files to create Log objects for a single Survey.")
+
+    uploaded = st.file_uploader(
+        "Select CSV files",
+        type=["csv"],
+        accept_multiple_files=True,
+        help="Each CSV should match the expected pycoustic format."
+    )
+
+    if uploaded:
+        st.caption("Assign a position name for each file (defaults to base filename).")
+
+        # Build a list of (file, default_name) for user naming
+        pos_names = []
+        for idx, f in enumerate(uploaded):
+            default_name = f.name.rsplit(".", 1)[0]
+            name = st.text_input(
+                f"Position name for file {idx + 1}: {f.name}",
+                value=default_name,
+                key=f"pos_name_{f.name}_{idx}"
+            )
+            pos_names.append((f, name.strip() or default_name))
+
+        col_l, col_r = st.columns([1, 1])
+        replace = col_l.checkbox("Replace existing survey/logs", value=True)
+        load_btn = col_r.button("Load CSVs")
+
+        if load_btn:
+            if replace:
+                # Reset previous state
+                for p in ss["tmp_paths"]:
+                    try:
+                        # Cleanup files on supported OS; not critical if fails
+                        import os
+                        os.unlink(p)
+                    except Exception:
+                        pass
+                ss["tmp_paths"] = []
+                ss["logs"] = {}
+                ss["survey"] = None
+                ss["resi_df"] = None
+
+            added = 0
+            for f, pos_name in pos_names:
+                try:
+                    tmp_path = save_upload_to_tmp(f)
+                    ss["tmp_paths"].append(tmp_path)
+                    log_obj = Log(path=tmp_path)
+                    ss["logs"][pos_name] = log_obj
+                    added += 1
+                except Exception as e:
+                    st.error(f"Failed to load {f.name}: {e}")
+
+            if added > 0:
+                st.success(f"Loaded {added} file(s) into logs.")
+            else:
+                st.warning("No files loaded. Please check the CSV format and try again.")
+
+    if ss["logs"]:
+        st.info(f"Current logs in session: {', '.join(ss['logs'].keys())}")
+
+with st.expander("2) Configure periods (survey.set_periods)", expanded=True):
+    st.write("Set daily period start times. These will be passed as times=... to set_periods().")
+
+    # Show time pickers; convert to tuples (hour, minute)
+    day_t = st.time_input("Day start", value=time(ss["periods_times"]["day"][0], ss["periods_times"]["day"][1]))
+    eve_t = st.time_input("Evening start", value=time(ss["periods_times"]["evening"][0], ss["periods_times"]["evening"][1]))
+    night_t = st.time_input("Night start", value=time(ss["periods_times"]["night"][0], ss["periods_times"]["night"][1]))
+
+    # Update in session
+    new_times = {
+        "day": (day_t.hour, day_t.minute),
+        "evening": (eve_t.hour, eve_t.minute),
+        "night": (night_t.hour, night_t.minute),
+    }
+
+    apply_periods = st.button("Apply periods to Survey")
+
+    if apply_periods:
+        if not ss["logs"]:
+            st.warning("Load logs first.")
+        else:
+            ss["periods_times"] = new_times
+            # Build or update Survey
+            ss["survey"] = build_survey(ss["logs"], times_kwarg=ss["periods_times"])
+            # Invalidate old summary
+            ss["resi_df"] = None
+            st.success("Periods applied to Survey.")
+
+with st.expander("3) Compute results (survey.resi_summary)", expanded=True):
+    st.write("Set kwargs for resi_summary(). Adjust lmax_n and lmax_t, and optionally pass extra kwargs as JSON.")
+
+    col1, col2 = st.columns([1, 1])
+    ss["lmax_n"] = col1.number_input("lmax_n", min_value=1, value=int(ss["lmax_n"]), step=1)
+    ss["lmax_t"] = col2.number_input("lmax_t", min_value=1, value=int(ss["lmax_t"]), step=1)
+
+    ss["extra_kwargs_raw"] = st.text_area(
+        "Extra kwargs (JSON object)",
+        value=ss["extra_kwargs_raw"],
+        height=120,
+        help="Example: {\"include_LAE\": true} (only pass valid kwargs for resi_summary)"
+    )
+
+    compute = st.button("Update resi_summary")
+
+    if compute:
+        if ss["survey"] is None:
+            if not ss["logs"]:
+                st.warning("Load logs first.")
+            else:
+                # Create Survey if missing
+                ss["survey"] = build_survey(ss["logs"], times_kwarg=ss["periods_times"])
+
+        if ss["survey"] is not None:
+            kwargs = parse_extra_kwargs(ss["extra_kwargs_raw"])
+            kwargs["lmax_n"] = int(ss["lmax_n"])
+            kwargs["lmax_t"] = int(ss["lmax_t"])
+
+            try:
+                df = ss["survey"].resi_summary(**kwargs)
+                if df is None or (hasattr(df, "empty") and df.empty):
+                    st.info("resi_summary returned no data.")
+                    ss["resi_df"] = None
+                else:
+                    ss["resi_df"] = df
+                    st.success("resi_summary updated.")
+            except Exception as e:
+                st.error(f"resi_summary failed: {e}")
+
+# --------------- Results ---------------
+st.subheader("resi_summary results")
+if ss["resi_df"] is not None:
+    show_df = flatten_columns(ss["resi_df"])
+    st.dataframe(show_df, use_container_width=True)
+
+    # Download
+    try:
+        csv_buf = io.StringIO()
+        show_df.to_csv(csv_buf)
+        st.download_button(
+            "Download CSV",
+            data=csv_buf.getvalue(),
+            file_name="resi_summary.csv",
+            mime="text/csv"
+        )
+    except Exception as e:
+        st.warning(f"Unable to prepare CSV download: {e}")
+else:
+    st.info("No results yet. Load CSVs, apply periods, and compute resi_summary.")
+
+# --------------- Utilities ---------------
+with st.sidebar:
+    st.header("Utilities")
+    if st.button("Reset session"):
+        # Clean up temp files
+        for p in ss["tmp_paths"]:
+            try:
+                import os
+                os.unlink(p)
+            except Exception:
+                pass
+        for key in list(st.session_state.keys()):
+            del st.session_state[key]
+        st.experimental_rerun()
+
+    st.caption("Tip: After uploading and loading files, set periods, then compute resi_summary.")