pycoustic 0.1.7__tar.gz → 0.1.8__tar.gz

{pycoustic-0.1.7 → pycoustic-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pycoustic
-Version: 0.1.7
+Version: 0.1.8
 Summary: 
 Author: thumpercastle
 Author-email: tony.ryb@gmail.com

{pycoustic-0.1.7 → pycoustic-0.1.8}/pycoustic/log.py

@@ -6,6 +6,8 @@ import datetime as dt
 
 class Log:
     def __init__(self, path=""):
+        #TODO C:\Users\tonyr\PycharmProjects\pycoustic\.venv2\Lib\site-packages\pycoustic\log.py:15: UserWarning:
+        #Parsing dates in %Y/%m/%d %H:%M format when dayfirst=True was specified. Pass `dayfirst=False` or specify a format to silence this warning.
         """
         The Log class is used to store the measured noise data from one data logger.
         The data must be entered in a .csv file with headings in the specific format "Leq A", "L90 125" etc.
@@ -341,6 +343,9 @@ class Log:
         self._master = self._append_night_idx(data=self._master)
         self._antilogs = self._append_night_idx(data=self._antilogs)
 
+#C:\Users\tonyr\PycharmProjects\pycoustic\.venv2\Lib\site-packages\pycoustic\log.py:339: PerformanceWarning:
+#dropping on a non-lexsorted multi-index without a level parameter may impact performance.
+
     def get_period_times(self):
         """
         :return: the tuples of period start times.

pycoustic-0.1.8/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-0.1.8/pycoustic/streamlit-ai.py

@@ -0,0 +1,522 @@
+# Python 3.12
+# Streamlit app entrypoint for PyCoustic-like workflow
+
+from __future__ import annotations
+
+import io
+import re
+from typing import Dict, Iterable, List, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+import streamlit as st
+
+
+# -----------------------------
+# Plotting configuration
+# -----------------------------
+COLOURS: List[str] = [
+    "#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd",
+    "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf",
+]
+TEMPLATE: str = "plotly_white"
+
+
+# -----------------------------
+# Helpers
+# -----------------------------
+def _try_read_table(upload) -> pd.DataFrame:
+    # Try CSV first, then Excel
+    name = getattr(upload, "name", "uploaded")
+    data = upload.read() if hasattr(upload, "read") else upload.getvalue()
+    # ensure the buffer can be reused for Excel attempt
+    buf = io.BytesIO(data)
+
+    # CSV attempt
+    try:
+        df_csv = pd.read_csv(io.BytesIO(data))
+        if not df_csv.empty:
+            df_csv.attrs["__source_name__"] = name
+            return df_csv
+    except Exception:
+        pass
+
+    # Excel attempt
+    buf.seek(0)
+    try:
+        df_xls = pd.read_excel(buf)
+        if not df_xls.empty:
+            df_xls.attrs["__source_name__"] = name
+            return df_xls
+    except Exception:
+        pass
+
+    raise ValueError(f"Could not parse file: {name}")
+
+
+def _flatten_columns(df: pd.DataFrame) -> pd.DataFrame:
+    # Flatten MultiIndex columns if any
+    if isinstance(df.columns, pd.MultiIndex):
+        flat = [" | ".join([str(x) for x in tup if x is not None]) for tup in df.columns]
+        df = df.copy()
+        df.columns = flat
+    return df
+
+
+def _maybe_parse_datetime(df: pd.DataFrame) -> pd.DataFrame:
+    # Heuristic: try common datetime column names and parse them
+    dt_candidates = ["Datetime", "DateTime", "Timestamp", "Time", "Date", "Date_Time", "datetime", "time", "timestamp"]
+    for col in df.columns:
+        if col in dt_candidates or re.search(r"time|date|stamp", str(col), re.IGNORECASE):
+            try:
+                parsed = pd.to_datetime(df[col], errors="raise", utc=False, infer_datetime_format=True)
+                out = df.copy()
+                out[col] = parsed
+                return out
+            except Exception:
+                continue
+    return df
+
+
+def _detect_position_col(df: pd.DataFrame) -> Optional[str]:
+    candidates = ["Position", "Pos", "Mic", "Channel", "Location", "Site"]
+    for c in candidates:
+        if c in df.columns:
+            return c
+    # also try case-insensitive exact matches
+    lower_map = {str(c).lower(): c for c in df.columns}
+    for c in candidates:
+        if c.lower() in lower_map:
+            return lower_map[c.lower()]
+    return None
+
+
+def _metric_patterns() -> Dict[str, re.Pattern]:
+    # Detect wide spectral columns, e.g., "Leq_31.5", "Lmax_1000", "Leq 4k", "Lmax 1 kHz", "63 Hz"
+    # Strategy:
+    # - Either prefixed by a metric (Leq/Lmax) and then frequency
+    # - Or pure frequency with "Hz" and a separate metric column naming is handled by selection
+    def freq_part():
+        # numbers like 31.5, 1000, 1k, 2 kHz, etc.
+        return r"(?P<freq>(\d+(\.\d+)?)(\s*k(hz)?)?)"
+
+    # metric-first naming: "Leq_31.5", "Lmax 1000", "Leq-1k", "Leq 1 kHz"
+    metric_first = rf"^(?P<metric>Leq|Lmax)[\s_\-]*{freq_part()}(hz)?$"
+    # freq-first naming: "31.5", "63 Hz", "1k", with an optional suffix metric after a sep: "63Hz_Leq"
+    freq_first = rf"^{freq_part()}(hz)?[\s_\-]*(?P<metric>Leq|Lmax)?$"
+    return {
+        "metric_first": re.compile(metric_first, re.IGNORECASE),
+        "freq_first": re.compile(freq_first, re.IGNORECASE),
+    }
+
+
+def _parse_freq_to_hz(freq_str: str) -> Optional[float]:
+    if freq_str is None:
+        return None
+    s = str(freq_str).strip().lower().replace(" ", "")
+    s = s.replace("khz", "k").replace("hz", "")
+    # handle "1k" or "1.0k"
+    m = re.match(r"^(\d+(\.\d+)?)k$", s)
+    if m:
+        return float(m.group(1)) * 1000.0
+    try:
+        return float(s)
+    except Exception:
+        return None
+
+
+def spectra_to_rows(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Convert wide spectral columns into a tidy long form:
+    Columns like "Leq_31.5", "Lmax 63", "63 Hz Leq" -> rows with Frequency (Hz), Metric, Value.
+    Non-spectral columns are carried along.
+    """
+    df = _flatten_columns(df)
+    patterns = _metric_patterns()
+
+    spectral_cols: List[Tuple[str, str, float]] = []  # (original_col, metric, freq_hz)
+    for col in df.columns:
+        col_str = str(col)
+        matched = False
+
+        # metric first
+        m1 = patterns["metric_first"].match(col_str)
+        if m1:
+            metric = m1.group("metric").upper()
+            freq_hz = _parse_freq_to_hz(m1.group("freq"))
+            if metric in ("LEQ", "LMAX") and freq_hz is not None:
+                spectral_cols.append((col, metric, freq_hz))
+                matched = True
+
+        if matched:
+            continue
+
+        # frequency first
+        m2 = patterns["freq_first"].match(col_str)
+        if m2:
+            metric = m2.group("metric")
+            metric = metric.upper() if metric else None
+            freq_hz = _parse_freq_to_hz(m2.group("freq"))
+            if freq_hz is not None:
+                # If metric is not embedded, we will treat it as "LEQ" by default for plotting,
+                # but also keep the column name when we pivot.
+                spectral_cols.append((col, metric or "LEQ", freq_hz))
+
+    if not spectral_cols:
+        return pd.DataFrame(columns=["Frequency_Hz", "Metric", "Value"])
+
+    # Build tidy rows
+    id_cols = [c for c in df.columns if c not in [c0 for (c0, _, _) in spectral_cols]]
+    tidies: List[pd.DataFrame] = []
+    for (col, metric, f_hz) in spectral_cols:
+        block = pd.DataFrame(
+            {
+                "Frequency_Hz": f_hz,
+                "Metric": metric,
+                "Value": df[col].astype("float64").values,
+            }
+        )
+        # Attach IDs if present
+        if id_cols:
+            block = pd.concat([df[id_cols].reset_index(drop=True), block], axis=1)
+        tidies.append(block)
+
+    tidy = pd.concat(tidies, axis=0, ignore_index=True)
+    # Sort by frequency numeric
+    tidy = tidy.sort_values(["Metric", "Frequency_Hz"]).reset_index(drop=True)
+    return tidy
+
+
+def _resample_if_possible(df: pd.DataFrame, how: str) -> pd.DataFrame:
+    """
+    how: '', '1min', '5min', '1H', '1D'
+    """
+    if not how:
+        return df
+
+    # find a datetime column
+    dt_col = None
+    for c in df.columns:
+        if pd.api.types.is_datetime64_any_dtype(df[c]):
+            dt_col = c
+            break
+
+    if dt_col is None:
+        return df  # nothing to resample on
+
+    df_sorted = df.sort_values(dt_col)
+    df_sorted = df_sorted.set_index(dt_col)
+
+    # numeric only for resample
+    numeric_cols = df_sorted.select_dtypes(include=["number"]).columns
+    if len(numeric_cols) == 0:
+        return df
+
+    grouped = df_sorted[numeric_cols].resample(how).mean().reset_index()
+    # put back other columns in a sensible way (drop or take first)
+    return grouped
+
+
+def _build_summary(df: pd.DataFrame, group_cols: List[str]) -> pd.DataFrame:
+    if not group_cols:
+        # simple numeric summary
+        numeric_cols = df.select_dtypes(include=["number"]).columns
+        if len(numeric_cols) == 0:
+            return pd.DataFrame()
+        s = df[numeric_cols].agg(["count", "mean", "std", "min", "max"]).T.reset_index()
+        s.columns = ["Metric"] + list(s.columns[1:])
+        return s
+
+    # groupby summary on numeric columns
+    numeric_cols = df.select_dtypes(include=["number"]).columns
+    if len(numeric_cols) == 0:
+        return pd.DataFrame()
+
+    g = df.groupby(group_cols, dropna=False)[numeric_cols].agg(["count", "mean", "std", "min", "max"])
+    g = g.reset_index()
+
+    # flatten resulting MultiIndex columns
+    out_cols = []
+    for tup in g.columns:
+        if isinstance(tup, tuple):
+            lvl0, lvl1 = tup
+            if lvl1 == "":
+                out_cols.append(str(lvl0))
+            elif lvl0 in group_cols:
+                out_cols.append(str(lvl0))
+            else:
+                out_cols.append(f"{lvl0}__{lvl1}")
+        else:
+            out_cols.append(str(tup))
+    g.columns = out_cols
+    return g
+
+
+def _guess_resample_options(df: pd.DataFrame) -> List[Tuple[str, str]]:
+    # Label, pandas rule
+    has_dt = any(pd.api.types.is_datetime64_any_dtype(df[c]) for c in df.columns)
+    if not has_dt:
+        return [("None", "")]
+    return [
+        ("None", ""),
+        ("1 minute", "1min"),
+        ("5 minutes", "5min"),
+        ("15 minutes", "15min"),
+        ("Hourly", "1H"),
+        ("Daily", "1D"),
+    ]
+
+
+def _plot_spectra(tidy_spec: pd.DataFrame, color_by: Optional[str]) -> go.Figure:
+    fig = go.Figure()
+    if tidy_spec.empty:
+        fig.update_layout(template=TEMPLATE)
+        return fig
+
+    # X is frequency Hz (log10)
+    x = tidy_spec["Frequency_Hz"].to_numpy(dtype=float)
+
+    # determine trace grouping
+    if color_by and color_by in tidy_spec.columns:
+        groups = list(tidy_spec[color_by].astype(str).unique())
+        for i, key in enumerate(groups):
+            sub = tidy_spec[tidy_spec[color_by].astype(str) == str(key)]
+            # Keep metric separated as line style if available
+            if "Metric" in sub.columns and sub["Metric"].nunique() > 1:
+                for metric in sorted(sub["Metric"].unique()):
+                    subm = sub[sub["Metric"] == metric]
+                    fig.add_trace(
+                        go.Scatter(
+                            x=subm["Frequency_Hz"],
+                            y=subm["Value"],
+                            mode="lines+markers",
+                            name=f"{key} – {metric}",
+                            line=dict(color=COLOURS[i % len(COLOURS)], dash="solid" if metric == "LEQ" else "dash"),
+                            marker=dict(size=6),
+                        )
+                    )
+            else:
+                fig.add_trace(
+                    go.Scatter(
+                        x=sub["Frequency_Hz"],
+                        y=sub["Value"],
+                        mode="lines+markers",
+                        name=str(key),
+                        line=dict(color=COLOURS[i % len(COLOURS)]),
+                        marker=dict(size=6),
+                    )
+                )
+    else:
+        # single trace per metric
+        if "Metric" in tidy_spec.columns:
+            for i, metric in enumerate(sorted(tidy_spec["Metric"].unique())):
+                sub = tidy_spec[tidy_spec["Metric"] == metric]
+                fig.add_trace(
+                    go.Scatter(
+                        x=sub["Frequency_Hz"],
+                        y=sub["Value"],
+                        mode="lines+markers",
+                        name=str(metric),
+                        line=dict(color=COLOURS[i % len(COLOURS)]),
+                        marker=dict(size=6),
+                    )
+                )
+        else:
+            fig.add_trace(
+                go.Scatter(
+                    x=x,
+                    y=tidy_spec["Value"],
+                    mode="lines+markers",
+                    name="Spectrum",
+                    line=dict(color=COLOURS[0]),
+                    marker=dict(size=6),
+                )
+            )
+
+    fig.update_layout(
+        template=TEMPLATE,
+        xaxis=dict(
+            type="log",
+            title="Frequency (Hz)",
+            tickvals=[31.5, 63, 125, 250, 500, 1000, 2000, 4000, 8000],
+            ticktext=["31.5", "63", "125", "250", "500", "1k", "2k", "4k", "8k"],
+            gridcolor="rgba(0,0,0,0.1)",
+        ),
+        yaxis=dict(title="Level (dB)", gridcolor="rgba(0,0,0,0.1)"),
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
+        margin=dict(l=50, r=30, t=40, b=50),
+    )
+    return fig
+
+
+def _download_csv_button(label: str, df: pd.DataFrame, key: str):
+    csv = df.to_csv(index=False).encode("utf-8")
+    st.download_button(
+        label=label,
+        data=csv,
+        file_name=f"{key}.csv",
+        mime="text/csv",
+        use_container_width=True,
+    )
+
+
+# -----------------------------
+# UI
+# -----------------------------
+def main():
+    st.set_page_config(page_title="PyCoustic – Streamlit", layout="wide")
+
+    st.title("PyCoustic – Streamlit App")
+    st.caption("Upload measurement logs, explore summaries and spectra, and export results.")
+
+    with st.sidebar:
+        st.header("Inputs")
+        uploads = st.file_uploader(
+            "Upload one or more files (CSV or Excel)",
+            type=["csv", "txt", "xlsx", "xls"],
+            accept_multiple_files=True,
+        )
+
+        st.markdown("---")
+        st.subheader("Options")
+
+        # These options approximate a typical workflow
+        resample_label = "Resample period"
+        resample_options: List[Tuple[str, str]] = [("None", "")]
+        # temporarily show None; we'll refine after reading a file
+
+        # placeholder UI to avoid reflow
+        resample_choice_label = st.selectbox(resample_label, [x[0] for x in resample_options], index=0, key="resample_placeholder")
+
+        group_hint = st.text_input("Optional Group Column (e.g., Position/Location)", value="")
+
+        st.markdown("---")
+        st.subheader("Spectra")
+        colour_by = st.text_input("Colour lines by column (e.g., Position or source)", value="source")
+        show_markers = st.checkbox("Show markers", value=True)
+
+        st.markdown("---")
+        st.subheader("Display")
+        show_raw_preview = st.checkbox("Show raw preview table", value=False)
+
+    if not uploads:
+        st.info("Upload files to begin.")
+        return
+
+    # Read and combine
+    logs: List[str] = []
+    frames: List[pd.DataFrame] = []
+    for uf in uploads:
+        try:
+            df = _try_read_table(uf)
+            df = _flatten_columns(df)
+            df = _maybe_parse_datetime(df)
+            df["source"] = getattr(uf, "name", df.attrs.get("__source_name__", "uploaded"))
+            frames.append(df)
+            logs.append(f"Loaded: {df['source'].iloc[0]} (rows={len(df)}, cols={len(df.columns)})")
+        except Exception as e:
+            logs.append(f"Error reading {getattr(uf, 'name', '?')}: {e}")
+
+    if not frames:
+        st.error("No readable files.")
+        st.text_area("Logs", value="\n".join(logs), height=160)
+        return
+
+    raw_master = pd.concat(frames, axis=0, ignore_index=True)
+    # Now that we have data, rebuild resample options
+    resample_options = _guess_resample_options(raw_master)
+    resample_choice_label = st.sidebar.selectbox(
+        "Resample period",
+        [x[0] for x in resample_options],
+        index=0,
+        key="resample_choice",
+    )
+    resample_rule = dict(resample_options)[resample_choice_label]
+
+    # Optional resampling
+    df_used = _resample_if_possible(raw_master, resample_rule) if resample_rule else raw_master
+
+    # Try to determine a reasonable group column
+    detected_group_col = _detect_position_col(df_used)
+    group_col = (st.sidebar.text_input("Detected Group Column", value=detected_group_col or "") or "").strip()
+    if not group_col and group_hint.strip():
+        group_col = group_hint.strip()
+    if group_col and group_col not in df_used.columns:
+        st.warning(f"Group column '{group_col}' not found. It will be ignored.")
+        group_col = ""
+
+    # Build spectra in tidy form
+    tidy_spec = spectra_to_rows(df_used)
+
+    tabs = st.tabs(["Summary", "Spectra", "Raw Data", "Logs"])
+
+    # Summary tab
+    with tabs[0]:
+        st.subheader("Summary")
+        group_cols: List[str] = []
+        if group_col:
+            group_cols.append(group_col)
+        if "source" in df_used.columns:
+            group_cols.append("source")
+
+        summary_df = _build_summary(df_used, group_cols)
+        if summary_df.empty:
+            st.info("No numeric data to summarize.")
+        else:
+            st.dataframe(summary_df, use_container_width=True, hide_index=True)
+            _download_csv_button("Download summary CSV", summary_df, "summary")
+
+    # Spectra tab
+    with tabs[1]:
+        st.subheader("Spectra")
+
+        # Allow user to filter a group (optional)
+        filters_cols = []
+        if group_col:
+            filters_cols.append(group_col)
+        if "source" in tidy_spec.columns:
+            filters_cols.append("source")
+
+        sub = tidy_spec.copy()
+        # Dynamic filters
+        if not sub.empty and filters_cols:
+            cols = st.columns(len(filters_cols))
+            for i, colname in enumerate(filters_cols):
+                with cols[i]:
+                    uniq = sorted([str(x) for x in sub[colname].dropna().unique()])
+                    if len(uniq) <= 1:
+                        continue
+                    selected = st.multiselect(f"Filter {colname}", options=uniq, default=uniq)
+                    sub = sub[sub[colname].astype(str).isin(selected)]
+
+        # Plot
+        if sub.empty:
+            st.info("No spectral data detected in the uploaded files.")
+        else:
+            fig = _plot_spectra(sub, color_by=(colour_by if colour_by in sub.columns else None))
+            if not show_markers:
+                for tr in fig.data:
+                    tr.mode = "lines"
+            st.plotly_chart(fig, use_container_width=True)
+
+            # Download tidy spectra
+            _download_csv_button("Download tidy spectra CSV", sub, "spectra_tidy")
+
+    # Raw Data tab
+    with tabs[2]:
+        st.subheader("Raw Data")
+        if show_raw_preview:
+            st.dataframe(raw_master, use_container_width=True, hide_index=True)
+        else:
+            st.caption("Enable 'Show raw preview table' in the sidebar to render the full table.")
+        _download_csv_button("Download combined raw CSV", raw_master, "raw_combined")
+
+    # Logs tab
+    with tabs[3]:
+        st.subheader("Logs")
+        st.text_area("Ingestion log", value="\n".join(logs), height=240, label_visibility="collapsed")
+
+
+if __name__ == "__main__":
+    main()

{pycoustic-0.1.7 → pycoustic-0.1.8}/pycoustic/survey.py

@@ -10,7 +10,7 @@ pd.set_option('display.max_rows', None)
 
 #survey.leq_spectra() bug
 #TODO: C:\Users\tonyr\PycharmProjects\pycoustic\.venv1\Lib\site-packages\pycoustic\survey.py:287: FutureWarning: The behavior of pd.concat with len(keys) != len(objs) is deprecated. In a future version this will raise instead of truncating to the smaller of the two sequences combi = pd.concat(all_pos, axis=1, keys=["UA1", "UA2"])
-
+#TODO: Survey should make a deep copy of Log objects. Otherwise setting time periods messes it up for other instances.
 
 class Survey:
     """
@@ -200,6 +200,7 @@ class Survey:
         return combi
 
     def counts(self, cols=None, day_t="60min", evening_t="60min", night_t="15min"):
+        #TODO Need to order rows and rename from 'date'
         """
         Returns counts for each time period. For example, this can return the number of L90 occurrences at each decibel
         level for daytime and night-time periods.
@@ -327,3 +328,91 @@ class Survey:
             raise ValueError("No weather history available. Use Survey.weather() first.")
         return pd.DataFrame([self._weatherhist.min(), self._weatherhist.max(), self._weatherhist.mean()],
                             index=["Min", "Max", "Mean"]).drop(columns=["dt"]).round(decimals=1)
+
+
+# TODO: Fix this bug in weatherhist
+# survey.weather(api_key=r"eef3f749e018627b70c2ead1475a1a32", postcode="HA8")
+#                     dt   temp pressure humidity clouds wind_speed wind_deg  \
+# 0  2025-09-03 08:59:00  17.52      998       97     75       6.69      210
+# 1  2025-09-03 14:59:00  19.85      997       84     40       9.26      220
+# 2  2025-09-03 20:59:00  16.27   1003.0     90.0   20.0       4.63    240.0
+# 3  2025-09-04 02:59:00  14.59   1005.0     91.0   99.0       3.09    230.0
+# 4  2025-09-04 08:59:00  15.08     1004       93     40       4.12      200
+# 5  2025-09-04 14:59:00  18.73     1007       63     40       8.75      260
+# 6  2025-09-04 20:59:00  15.64   1013.0     76.0    0.0        3.6    270.0
+# 7  2025-09-05 02:59:00  11.42   1016.0     94.0    0.0       3.09    260.0
+# 8  2025-09-05 08:59:00  14.12   1020.0     89.0   20.0       3.09    270.0
+# 9  2025-09-05 14:59:00  22.16   1021.0     50.0    0.0       4.12    280.0
+# 10 2025-09-05 20:59:00  17.38   1023.0     75.0   75.0       3.09    220.0
+# 11 2025-09-06 02:59:00  14.37   1022.0     83.0   99.0       1.78    187.0
+# 12 2025-09-06 08:59:00  16.44   1020.0     73.0  100.0       3.48    138.0
+# 13 2025-09-06 14:59:00  23.21   1037.0     50.0    0.0       7.72    160.0
+# 14 2025-09-06 20:59:00   18.5   1035.0     75.0   93.0        3.6    120.0
+# 15 2025-09-07 02:59:00  16.06   1031.0     77.0   84.0       3.09    120.0
+# 16 2025-09-07 08:59:00  18.78   1029.0     77.0    0.0       4.63    110.0
+# 17 2025-09-07 14:59:00  23.82   1027.0     67.0   75.0       8.75    200.0
+# 18 2025-09-07 20:59:00  19.38   1031.0     76.0   72.0       4.63    200.0
+# 19 2025-09-08 02:59:00  14.49   1034.0     91.0    4.0       1.54    190.0
+# 20 2025-09-08 08:59:00  14.84   1037.0     85.0   20.0       4.12    240.0
+#             rain wind_gust   uvi
+# 0   {'1h': 0.25}       NaN   NaN
+# 1   {'1h': 1.27}     14.92   NaN
+# 2            NaN       NaN   NaN
+# 3            NaN       NaN   NaN
+# 4   {'1h': 1.27}       NaN   NaN
+# 5   {'3h': 0.13}       NaN   NaN
+# 6            NaN       NaN   NaN
+# 7            NaN       NaN   NaN
+# 8            NaN       NaN   NaN
+# 9            NaN       NaN   NaN
+# 10           NaN       NaN   NaN
+# 11           NaN      3.31   0.0
+# 12           NaN       7.4  0.86
+# 13           NaN       NaN  2.96
+# 14           NaN       NaN   0.0
+# 15           NaN       NaN   0.0
+# 16           NaN       NaN   1.1
+# 17           NaN       NaN  2.24
+# 18           NaN       NaN   0.0
+# 19           NaN       NaN   0.0
+# 20           NaN       NaN  1.12
+# survey.weather_summary()
+# Traceback (most recent call last):
+#   File "<input>", line 1, in <module>
+#   File "C:\Users\tonyr\PycharmProjects\pycoustic\.venv2\Lib\site-packages\pycoustic\survey.py", line 328, in weather_summary
+#     return pd.DataFrame([self._weatherhist.min(), self._weatherhist.max(), self._weatherhist.mean()],
+#                          ^^^^^^^^^^^^^^^^^^^^^^^
+#   File "C:\Users\tonyr\PycharmProjects\pycoustic\.venv2\Lib\site-packages\pandas\core\frame.py", line 11643, in min
+#     result = super().min(axis, skipna, numeric_only, **kwargs)
+#              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#   File "C:\Users\tonyr\PycharmProjects\pycoustic\.venv2\Lib\site-packages\pandas\core\generic.py", line 12388, in min
+#     return self._stat_function(
+#            ^^^^^^^^^^^^^^^^^^^^
+#   File "C:\Users\tonyr\PycharmProjects\pycoustic\.venv2\Lib\site-packages\pandas\core\generic.py", line 12377, in _stat_function
+#     return self._reduce(
+#            ^^^^^^^^^^^^^
+#   File "C:\Users\tonyr\PycharmProjects\pycoustic\.venv2\Lib\site-packages\pandas\core\frame.py", line 11562, in _reduce
+#     res = df._mgr.reduce(blk_func)
+#           ^^^^^^^^^^^^^^^^^^^^^^^^
+#   File "C:\Users\tonyr\PycharmProjects\pycoustic\.venv2\Lib\site-packages\pandas\core\internals\managers.py", line 1500, in reduce
+#     nbs = blk.reduce(func)
+#           ^^^^^^^^^^^^^^^^
+#   File "C:\Users\tonyr\PycharmProjects\pycoustic\.venv2\Lib\site-packages\pandas\core\internals\blocks.py", line 404, in reduce
+#     result = func(self.values)
+#              ^^^^^^^^^^^^^^^^^
+#   File "C:\Users\tonyr\PycharmProjects\pycoustic\.venv2\Lib\site-packages\pandas\core\frame.py", line 11481, in blk_func
+#     return op(values, axis=axis, skipna=skipna, **kwds)
+#            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#   File "C:\Users\tonyr\PycharmProjects\pycoustic\.venv2\Lib\site-packages\pandas\core\nanops.py", line 147, in f
+#     result = alt(values, axis=axis, skipna=skipna, **kwds)
+#              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#   File "C:\Users\tonyr\PycharmProjects\pycoustic\.venv2\Lib\site-packages\pandas\core\nanops.py", line 404, in new_func
+#     result = func(values, axis=axis, skipna=skipna, mask=mask, **kwargs)
+#              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#   File "C:\Users\tonyr\PycharmProjects\pycoustic\.venv2\Lib\site-packages\pandas\core\nanops.py", line 1098, in reduction
+#     result = getattr(values, meth)(axis)
+#              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#   File "C:\Users\tonyr\PycharmProjects\pycoustic\.venv2\Lib\site-packages\numpy\_core\_methods.py", line 48, in _amin
+#     return umr_minimum(a, axis, None, out, keepdims, initial, where)
+#            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+# TypeError: '<=' not supported between instances of 'dict' and 'dict'

{pycoustic-0.1.7 → pycoustic-0.1.8}/pycoustic/weather.py

@@ -93,3 +93,4 @@ class WeatherHistory:
 
     def get_weather_history(self):
         return self._hist
+

{pycoustic-0.1.7 → pycoustic-0.1.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pycoustic"
-version = "0.1.7"
+version = "0.1.8"
 description = ""
 authors = ["thumpercastle <tony.ryb@gmail.com>"]
 readme = "README.md"