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

pycoustic/streamlit-new.py

@@ -0,0 +1,142 @@
+import os
+import tempfile
+from typing import List, Dict
+
+import pandas as pd
+import plotly.graph_objects as go
+import streamlit as st
+
+# Import pycoustic classes
+from log import *
+from survey import *
+from weather import *
+
+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", "{}")
+
+
+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
+
+
+# File Upload in expander container
+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())}")
+
+ss["survey"] = Survey()
+for k in ss["logs"].keys():
+    ss["survey"].add_log(ss["survey"], name="k")
+    st.text(k)
+
+st.text(type(ss["survey"]))
+st.table(ss["survey"].resi_summary())
+
+with st.expander("Broadband Summary", expanded=True):
+    df = ss["survey"]._logs
+    st.text(df)
+    #test

pycoustic/streamlit_pycoustic_gpt5_dead.py

@@ -0,0 +1,234 @@
+# streamlit_pycoustic_app.py
+import ast
+import datetime as dt
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, Iterable
+
+import streamlit as st
+
+from pycoustic import Log, Survey
+
+
+def _parse_kwargs(text: str) -> Dict[str, Any]:
+    """
+    Safely parse a Python dict literal from text area.
+    Returns {} if empty or invalid.
+    """
+    if not text or not text.strip():
+        return {}
+    try:
+        parsed = ast.literal_eval(text)
+        return parsed if isinstance(parsed, dict) else {}
+    except Exception:
+        return {}
+
+
+def _display_result(obj: Any):
+    """
+    Display helper to handle common return types.
+    """
+    # Plotly Figure-like
+    if hasattr(obj, "to_plotly_json"):
+        st.plotly_chart(obj, use_container_width=True)
+        return
+
+    # Pandas DataFrame-like
+    if hasattr(obj, "to_dict") and hasattr(obj, "columns"):
+        st.dataframe(obj, use_container_width=True)
+        return
+
+    # Dict/list -> JSON
+    if isinstance(obj, (dict, list)):
+        st.json(obj)
+        return
+
+    # Fallback
+    st.write(obj)
+
+
+def _ensure_state():
+    if "survey" not in st.session_state:
+        st.session_state["survey"] = None
+    if "periods" not in st.session_state:
+        st.session_state["periods"] = {"day": (7, 0), "evening": (19, 0), "night": (23, 0)}
+
+
+def _write_uploaded_to_temp(uploaded) -> str:
+    """
+    Persist an UploadedFile to a temporary file and return the path.
+    Using a real file path keeps Log(...) happy across environments.
+    """
+    suffix = Path(uploaded.name).suffix or ".csv"
+    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+        tmp.write(uploaded.getbuffer())
+        return tmp.name
+
+
+def _build_survey_from_files(files) -> Survey:
+    """
+    Create a Survey and attach Log objects for each uploaded file.
+    """
+    survey = Survey()
+    for f in files:
+        # Persist to disk to ensure compatibility with pandas and any path usage in Log
+        tmp_path = _write_uploaded_to_temp(f)
+        log_obj = Log(path=tmp_path)
+
+        key = Path(f.name).stem
+        # Attach Log to survey
+        if hasattr(survey, "add_log"):
+            try:
+                survey.add_log(key, log_obj)
+            except TypeError:
+                survey.add_log(log_obj, key)
+        else:
+            # Fallback to internal storage if no public API is available
+            survey._logs[key] = log_obj  # noqa: SLF001
+    return survey
+
+
+def _apply_periods_to_all_logs(survey: Survey, times: Dict[str, tuple[int, int]]):
+    """
+    Apply set_periods to each Log attached to the Survey.
+    This avoids calling set_periods on Survey if it doesn't exist.
+    """
+    logs: Iterable[Log] = getattr(survey, "_logs", {}).values()
+    for log in logs:
+        if hasattr(log, "set_periods"):
+            log.set_periods(times=times)
+
+
+def _render_period_controls(survey: Survey):
+    st.subheader("Assessment Periods")
+
+    # Current periods from session (defaults set in _ensure_state)
+    periods = st.session_state["periods"]
+    day_h, day_m = periods["day"]
+    eve_h, eve_m = periods["evening"]
+    night_h, night_m = periods["night"]
+
+    c1, c2, c3 = st.columns(3)
+    with c1:
+        day_time = st.time_input("Day starts", value=dt.time(day_h, day_m), key="period_day_start")
+    with c2:
+        eve_time = st.time_input("Evening starts", value=dt.time(eve_h, eve_m), key="period_eve_start")
+    with c3:
+        night_time = st.time_input("Night starts", value=dt.time(night_h, night_m), key="period_night_start")
+
+    new_periods = {
+        "day": (int(day_time.hour), int(day_time.minute)),
+        "evening": (int(eve_time.hour), int(eve_time.minute)),
+        "night": (int(night_time.hour), int(night_time.minute)),
+    }
+
+    if st.button("Apply periods to all logs", key="apply_periods"):
+        try:
+            _apply_periods_to_all_logs(survey, new_periods)
+            st.session_state["periods"] = new_periods
+            st.success("Periods applied to all logs.")
+        except Exception as e:
+            st.warning(f"Could not set periods: {e}")
+
+
+def _render_method_runner(survey: Survey, method_name: str, help_text: str = ""):
+    """
+    Generic UI for running a Survey method with kwargs provided via text area.
+    """
+    with st.expander(method_name, expanded=True):
+        if help_text:
+            st.caption(help_text)
+
+        kwargs_text = st.text_area(
+            "kwargs (Python dict literal)",
+            value="{}",
+            key=f"kwargs_{method_name}",
+            placeholder='Example: {"position": "UA1", "date": "2023-06-01"}',
+            height=100,
+        )
+
+        kwargs = _parse_kwargs(kwargs_text)
+        if st.button(f"Run {method_name}", key=f"run_{method_name}"):
+            try:
+                fn = getattr(survey, method_name)
+                result = fn(**kwargs)
+                _display_result(result)
+            except AttributeError:
+                st.error(f"Survey has no method named '{method_name}'.")
+            except Exception as e:
+                st.error(f"Error running {method_name}: {e}")
+
+
+def main():
+    st.set_page_config(page_title="pycoustic GUI", layout="wide")
+    st.title("pycoustic – Streamlit GUI")
+
+    _ensure_state()
+
+    st.sidebar.header("Load CSV Logs")
+    files = st.sidebar.file_uploader(
+        "Upload one or more CSV files",
+        type=["csv"],
+        accept_multiple_files=True,
+        help="Each file becomes a Log; all Logs go into one Survey."
+    )
+
+    build = st.sidebar.button("Create / Update Survey", type="primary")
+
+    if build and files:
+        try:
+            survey = _build_survey_from_files(files)
+            # Apply default periods to all logs
+            _apply_periods_to_all_logs(survey, st.session_state["periods"])
+            st.session_state["survey"] = survey
+            st.success("Survey created/updated.")
+        except Exception as e:
+            st.error(f"Unable to create Survey: {e}")
+
+    survey: Survey = st.session_state.get("survey")
+
+    if survey is None:
+        st.info("Upload CSV files in the sidebar and click 'Create / Update Survey' to begin.")
+        return
+
+    # Period controls
+    _render_period_controls(survey)
+
+    st.markdown("---")
+    st.header("Survey Outputs")
+
+    _render_method_runner(
+        survey,
+        "resi_summary",
+        help_text="Summary results for residential assessment. Provide any optional kwargs here."
+    )
+    _render_method_runner(
+        survey,
+        "modal",
+        help_text="Run modal analysis over the survey. Provide any optional kwargs here."
+    )
+    _render_method_runner(
+        survey,
+        "leq_spectra",
+        help_text="Compute or plot Leq spectra. Provide any optional kwargs here."
+    )
+    _render_method_runner(
+        survey,
+        "lmax_spectra",
+        help_text="Compute or plot Lmax spectra. Provide any optional kwargs here."
+    )
+
+    st.markdown("---")
+    with st.expander("Loaded Logs", expanded=False):
+        try:
+            names = list(getattr(survey, "_logs", {}).keys())
+            if names:
+                st.write(", ".join(names))
+            else:
+                st.write("No logs found in survey.")
+        except Exception:
+            st.write("Unable to list logs.")
+
+
+if __name__ == "__main__":
+    main()

pycoustic/survey.py

@@ -39,6 +39,17 @@ class Survey:
         df.columns = new_cols
         return df
 
+    # def _leq_by_date(self, data, cols=None):
+    #     """
+    #     Delegate Leq-by-date computation to one of the underlying Log instances.
+    #     Assumes all logs share the same period configuration.
+    #     """
+    #     if not getattr(self, "_logs", None):
+    #         raise AttributeError("Survey has no logs available to compute _leq_by_date")
+    #     any_log = next(iter(self._logs.values()))
+    #     if not hasattr(any_log, "_leq_by_date"):
+    #         raise AttributeError("Underlying Log does not implement _leq_by_date")
+    #     return any_log._leq_by_date(data, cols=cols)
     # ###########################---PUBLIC---######################################
 
     def set_periods(self, times=None):
@@ -105,51 +116,54 @@ class Survey:
             leq_cols = [("Leq", "A")]
         if max_cols is None:
             max_cols = [("Lmax", "A")]
-        for key in self._logs.keys():
-            log = self._logs[key]
+
+        for key, lg in self._logs.items():  # changed: iterate items() to get lg directly
             combined_list = []
+            headers_for_log = []  # new: collect headers per log
+
             # Day
-            days = log._leq_by_date(log._get_period(data=log.get_antilogs(), period="days"), cols=leq_cols)
+            days = lg.leq_by_date(lg.get_period(data=lg.get_antilogs(), period="days"), cols=leq_cols)
             days.sort_index(inplace=True)
             combined_list.append(days)
-            period_headers = ["Daytime" for i in range(len(leq_cols))]
+            headers_for_log.extend(["Daytime"] * len(leq_cols))  # changed: don't reset global headers
+
             # Evening
-            if log.is_evening():
-                evenings = log._leq_by_date(log._get_period(data=log.get_antilogs(), period="evenings"), cols=leq_cols)
+            if lg.is_evening():
+                evenings = lg.leq_by_date(lg.get_period(data=lg.get_antilogs(), period="evenings"), cols=leq_cols)
                 evenings.sort_index(inplace=True)
                 combined_list.append(evenings)
-                for i in range(len(leq_cols)):
-                    period_headers.append("Evening")
+                headers_for_log.extend(["Evening"] * len(leq_cols))
+
             # Night Leq
-            nights = log._leq_by_date(log._get_period(data=log.get_antilogs(), period="nights"), cols=leq_cols)
+            nights = lg.leq_by_date(lg.get_period(data=lg.get_antilogs(), period="nights"), cols=leq_cols)
             nights.sort_index(inplace=True)
             combined_list.append(nights)
-            for i in range(len(leq_cols)):
-                period_headers.append("Night-time")
+            headers_for_log.extend(["Night-time"] * len(leq_cols))
+
             # Night max
-            maxes = log.as_interval(t=lmax_t)
-            maxes = log._get_period(data=maxes, period="nights", night_idx=True)
-            maxes = log.get_nth_high_low(n=lmax_n, data=maxes)[max_cols]
+            maxes = lg.as_interval(t=lmax_t)
+            maxes = lg.get_period(data=maxes, period="nights", night_idx=True)
+            maxes = lg.get_nth_high_low(n=lmax_n, data=maxes)[max_cols]
             maxes.sort_index(inplace=True)
-            #  +++
-            # SS Feb2025  - Code changed to prevent exception
-            #maxes.index = maxes.index.date
             try:
                 maxes.index = pd.to_datetime(maxes.index)
                 maxes.index = maxes.index.date
             except Exception as e:
                 print(f"Error converting index to date: {e}")
-            # SSS ---
             maxes.index.name = None
             combined_list.append(maxes)
-            for i in range(len(max_cols)):
-                period_headers.append("Night-time")
+            headers_for_log.extend(["Night-time"] * len(max_cols))
+
             summary = pd.concat(objs=combined_list, axis=1)
             summary = self._insert_multiindex(df=summary, super=key)
             combi = pd.concat(objs=[combi, summary], axis=0)
+
+            # append this log's headers to the global list
+            period_headers.extend(headers_for_log)
+
         combi = self._insert_header(df=combi, new_head_list=period_headers, header_idx=0)
         return combi
-
+#test
     def modal(self, cols=None, by_date=False, day_t="60min", evening_t="60min", night_t="15min"):
         """
         Get a dataframe summarising Modal L90 values for each time period, as suggested by BS 4142:2014.

{pycoustic-0.1.8.dist-info → pycoustic-0.1.9.dist-info}/METADATA

@@ -1,11 +1,13 @@
 Metadata-Version: 2.3
 Name: pycoustic
-Version: 0.1.8
+Version: 0.1.9
 Summary: 
 Author: thumpercastle
 Author-email: tony.ryb@gmail.com
-Requires-Python: >=3.11.9,<4.0
+Requires-Python: >=3.10,<=3.13
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: numpy (==2.2.6)

pycoustic-0.1.9.dist-info/RECORD

@@ -0,0 +1,14 @@
+pycoustic/__init__.py,sha256=jq9Tzc5nEgXh8eNf0AkAypmw3Dda9A-iSy-tyFaTksA,89
+pycoustic/log.py,sha256=e8rAy9hIYP2H-3vTDVe0-6swe_n_gXjuFCu6Q-xNiYQ,17827
+pycoustic/pycoustic_gui_app-ai.py,sha256=nEX7Q5oWzTLmtC_xqbh74vXpQak8gwuqf2ScPq1Ir7o,24432
+pycoustic/pycoustic_gui_app.py,sha256=Hs61Y8fAp7uoRONa4RLSVl0UvGXZZ96n5eJGilErlAU,11143
+pycoustic/pycoustic_streamlit_gpt5.py,sha256=gpkPPBGwADt9HFI4S7YD1U-TjpLTMVwcBUJd7wTefek,14259
+pycoustic/streamlit-ai.py,sha256=OZdrQbGwQyVvA_4Q8bTOCZUZGdSlZG9NL9z3f16W-A8,16414
+pycoustic/streamlit-new.py,sha256=AR5dwQinMXugvGcyNvI_W59bfFRGj6E90Fqah9toKto,4885
+pycoustic/streamlit_pycoustic_gpt5_dead.py,sha256=sFUxLkvNUZoh2cVzruqsJJiLIlJxOQQpYYK6oHZfPlM,7309
+pycoustic/survey.py,sha256=6gC2sd0vOusx8bEyCwqmfSR5k04VeV93Ong0OdEVVks,24071
+pycoustic/tkgui.py,sha256=YAy5f_qkXZ3yU8BvB-nIVQX1fYwPs_IkwmDEXHPMAa4,13997
+pycoustic/weather.py,sha256=q9FbDKjY0WaNvaYMHeDk7Bhbq0_Q7ehsTM_vUaCjeAk,3753
+pycoustic-0.1.9.dist-info/METADATA,sha256=2NDXL0ovNkEJKxx-P2ErBkdTHNA1AWL77RFAaKQdI6o,8515
+pycoustic-0.1.9.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+pycoustic-0.1.9.dist-info/RECORD,,

pycoustic-0.1.8.dist-info/RECORD

@@ -1,10 +0,0 @@
-pycoustic/__init__.py,sha256=jq9Tzc5nEgXh8eNf0AkAypmw3Dda9A-iSy-tyFaTksA,89
-pycoustic/log.py,sha256=S9Vc2hgHShd2YnDAdBs6by_8hE6l1HIoPgZ0po-KT5I,17614
-pycoustic/pycoustic_gui_app.py,sha256=Hs61Y8fAp7uoRONa4RLSVl0UvGXZZ96n5eJGilErlAU,11143
-pycoustic/streamlit-ai.py,sha256=bGYPvrHmQEFua8IrJhBNAdXDzUnQvcjINaRx2-F-5Ms,18637
-pycoustic/survey.py,sha256=pvdiR4wn1Zicr7rL1fZ5IgUnls5Ikg2j1RFw36WgcB0,23471
-pycoustic/tkgui.py,sha256=YAy5f_qkXZ3yU8BvB-nIVQX1fYwPs_IkwmDEXHPMAa4,13997
-pycoustic/weather.py,sha256=q9FbDKjY0WaNvaYMHeDk7Bhbq0_Q7ehsTM_vUaCjeAk,3753
-pycoustic-0.1.8.dist-info/METADATA,sha256=AqC1SlTm94A-qFF0Sm13c2JZW4pVBdFfsYWWHBymN2o,8413
-pycoustic-0.1.8.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-pycoustic-0.1.8.dist-info/RECORD,,