pycoustic 0.1.8__py3-none-any.whl → 0.1.10__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

@@ -1,6 +1,6 @@
 import pandas as pd
 import numpy as np
-from .weather import WeatherHistory
+# from .weather import WeatherHistory
 
 
 DECIMALS=1
@@ -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.
@@ -179,17 +193,17 @@ class Survey:
             pos_summary = []
             # Daytime
             period_headers = ["Daytime"]
-            days = log.get_modal(data=log._get_period(data=log.as_interval(t=day_t), period="days"), by_date=by_date, cols=cols)
+            days = log.get_modal(data=log.get_period(data=log.as_interval(t=day_t), period="days"), by_date=by_date, cols=cols)
             days.sort_index(inplace=True)
             pos_summary.append(days)
             # Evening
             if log.is_evening():
                 period_headers.append("Evening")
-                evenings = log.get_modal(data=log._get_period(data=log.as_interval(t=evening_t), period="evenings"), by_date=by_date, cols=cols)
+                evenings = log.get_modal(data=log.get_period(data=log.as_interval(t=evening_t), period="evenings"), by_date=by_date, cols=cols)
                 evenings.sort_index(inplace=True)
                 pos_summary.append(evenings)
             # Night time
-            nights = log.get_modal(data=log._get_period(data=log.as_interval(t=night_t), period="nights"), by_date=by_date, cols=cols)
+            nights = log.get_modal(data=log.get_period(data=log.as_interval(t=night_t), period="nights"), by_date=by_date, cols=cols)
             nights.sort_index(inplace=True)
             pos_summary.append(nights)
             period_headers.append("Night-time")
@@ -220,17 +234,17 @@ class Survey:
             pos_summary = []
             # Daytime
             period_headers = ["Daytime"]
-            days = log.counts(data=log._get_period(data=log.as_interval(t=day_t), period="days"), cols=cols)
+            days = log.counts(data=log.get_period(data=log.as_interval(t=day_t), period="days"), cols=cols)
             days.sort_index(inplace=True)
             pos_summary.append(days)
             # Evening
             if log.is_evening():
                 period_headers.append("Evening")
-                evenings = log.counts(data=log._get_period(data=log.as_interval(t=evening_t), period="evenings"), cols=cols)
+                evenings = log.counts(data=log.get_period(data=log.as_interval(t=evening_t), period="evenings"), cols=cols)
                 evenings.sort_index(inplace=True)
                 pos_summary.append(evenings)
             # Night time
-            nights = log.counts(data=log._get_period(data=log.as_interval(t=night_t), period="nights"), cols=cols)
+            nights = log.counts(data=log.get_period(data=log.as_interval(t=night_t), period="nights"), cols=cols)
             nights.sort_index(inplace=True)
             pos_summary.append(nights)
             period_headers.append("Night-time")
@@ -262,7 +276,7 @@ class Survey:
         for key in self._logs.keys():
             log = self._logs[key]
             combined_list = []
-            maxes = log.get_nth_high_low(n=n, data=log._get_period(data=log.as_interval(t=t), period=period))[["Lmax", "Time"]]
+            maxes = log.get_nth_high_low(n=n, data=log.get_period(data=log.as_interval(t=t), period=period))[["Lmax", "Time"]]
             maxes.sort_index(inplace=True)
             combined_list.append(maxes)
             summary = pd.concat(objs=combined_list, axis=1)
@@ -285,15 +299,15 @@ class Survey:
         for key in self._logs.keys():
             log = self._logs[key]
             # Day
-            days = log._get_period(data=log.get_antilogs(), period="days")
+            days = log.get_period(data=log.get_antilogs(), period="days")
             days = days[leq_cols].apply(lambda x: np.round(10*np.log10(np.mean(x)), DECIMALS))
             # Night-time
-            nights = log._get_period(data=log.get_antilogs(), period="nights")
+            nights = log.get_period(data=log.get_antilogs(), period="nights")
             nights = nights[leq_cols].apply(lambda x: np.round(10*np.log10(np.mean(x)), DECIMALS))
             df = pd.DataFrame
             # Evening
             if log.is_evening():
-                evenings = log._get_period(data=log.get_antilogs(), period="evenings")
+                evenings = log.get_period(data=log.get_antilogs(), period="evenings")
                 evenings = evenings[leq_cols].apply(lambda x: np.round(10 * np.log10(np.mean(x)), DECIMALS))
                 df = pd.concat([days, evenings, nights], axis=1, keys=["Daytime", "Evening", "Night-time"])
             else:
@@ -330,6 +344,101 @@ class Survey:
                             index=["Min", "Max", "Mean"]).drop(columns=["dt"]).round(decimals=1)
 
 
+
+appid = ""
+# with open("tests/openweather_app_id.txt") as f:
+#     appid = f.readlines()[0]
+
+w_dict = {
+    "start": "2022-09-16 12:00:00",
+    "end": "2022-09-17 18:00:00",
+    "interval": 6,
+    "api_key": appid,
+    "country": "GB",
+    "postcode": "WC1",
+    "tz": "GB"
+}
+
+
+def test_weather_obj(weather_test_dict):
+    hist = WeatherHistory(start=w_dict["start"], end=w_dict["end"], interval=w_dict["interval"],
+                          api_key=w_dict["api_key"], country=w_dict["country"], postcode=w_dict["postcode"],
+                          tz=w_dict["tz"])
+    hist.compute_weather_history()
+    return hist
+
+#TODO: Make this take the start and end times of a Survey object.
+#TODO: Implement post codes instead of coordinates
+#TODO: Implement the WeatherHistory as methods within Survey.
+class WeatherHistory:
+    def __init__(self):
+        return
+
+    def reinit(self, start=None, end=None, interval=6, api_key="", country="GB", postcode="WC1", tz="",
+                 units="metric"):
+        if api_key==None:
+            raise ValueError("API key is missing")
+        if type(start) == str:
+            self._start = dt.datetime.strptime(start, "%Y-%m-%d %H:%M:%S")
+        else:
+            self._start = start
+        if type(end) == str:
+            self._end = dt.datetime.strptime(end, "%Y-%m-%d %H:%M:%S")
+        else:
+            self._end = end
+        self._interval = interval
+        self._api_key = str(api_key)
+        self._lat, self._lon = self.get_latlon(api_key=api_key, country=country, postcode=postcode)
+        self._hist = None
+        self._units = units
+
+    def get_latlon(self, api_key="", country="GB", postcode=""):
+        query = str("http://api.openweathermap.org/geo/1.0/zip?zip=" + postcode + "," + country + "&appid=" + api_key)
+        resp = requests.get(query)
+        return resp.json()["lat"], resp.json()["lon"]
+
+    def _construct_api_call(self, timestamp):
+        base = "https://api.openweathermap.org/data/3.0/onecall/timemachine?"
+        query = str(base + "lat=" + str(self._lat) + "&" + "lon=" + str(self._lon) + "&" + "units=" + self._units + \
+                    "&" + "dt=" + str(timestamp) + "&" + "appid=" + self._api_key)
+        return query
+
+    def _construct_timestamps(self):
+        next_time = (self._start + dt.timedelta(hours=self._interval))
+        timestamps = [int(self._start.timestamp())]
+        while next_time < self._end:
+            timestamps.append(int(next_time.timestamp()))
+            next_time += dt.timedelta(hours=self._interval)
+        return timestamps
+
+    def _make_and_parse_api_call(self, query):
+        response = requests.get(query)
+        # This drops some unwanted cols like lat, lon, timezone and tz offset.
+        resp_dict = response.json()["data"][0]
+        del resp_dict["weather"]    # delete weather key as not useful.
+        # TODO: parse 'weather' nested dict.
+        return resp_dict
+
+    def compute_weather_history(self, drop_cols):
+        # construct timestamps
+        timestamps = self._construct_timestamps()
+        # make calls to API
+        responses = []
+        for ts in timestamps:
+            query = self._construct_api_call(timestamp=ts)
+            response_dict = self._make_and_parse_api_call(query=query)
+            responses.append(pd.Series(response_dict))
+        df = pd.concat(responses, axis=1).transpose()
+        for col in ["dt", "sunrise", "sunset"]:
+            df[col] = df[col].apply(lambda x: dt.datetime.fromtimestamp(int(x)))  # convert timestamp into datetime
+        df.drop(columns=drop_cols, inplace=True)
+        return df
+
+    def get_weather_history(self):
+        return self._hist
+
+
+
 # TODO: Fix this bug in weatherhist
 # survey.weather(api_key=r"eef3f749e018627b70c2ead1475a1a32", postcode="HA8")
 #                     dt   temp pressure humidity clouds wind_speed wind_deg  \
@@ -415,4 +524,10 @@ class Survey:
 #   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'
+# TypeError: '<=' not supported between instances of 'dict' and 'dict'
+
+
+#TODO: Fix this error:
+#
+# C:\Users\tonyr\PycharmProjects\pycoustic\pycoustic\survey.py:316: 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

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

@@ -1,11 +1,13 @@
 Metadata-Version: 2.3
 Name: pycoustic
-Version: 0.1.8
+Version: 0.1.10
 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)