pycoustic 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

pycoustic/__init__.py

@@ -1,2 +1,3 @@
 from .log import Log
-from .survey import Survey
+from .survey import Survey
+from .weather import WeatherHistory

pycoustic/log.py

@@ -1,7 +1,7 @@
 import pandas as pd
 import numpy as np
 import datetime as dt
-import warnings
+
 
 
 class Log:
@@ -356,3 +356,9 @@ class Log:
             return False
         else:
             return True
+
+    def get_start(self):
+        return self._start
+
+    def get_end(self):
+        return self._end

pycoustic/survey.py

@@ -1,7 +1,13 @@
 import pandas as pd
 import numpy as np
+from .weather import WeatherHistory
 
 
+DECIMALS=0
+
+# pd.set_option('display.max_columns', None)
+# pd.set_option('display.max_rows', None)
+
 class Survey:
     """
     Survey Class is an overarching class which takes multiple Log objects and processes and summarises them together.
@@ -12,6 +18,7 @@ class Survey:
 
     def __init__(self):
         self._logs = {}
+        self._weather = WeatherHistory()
 
     def _insert_multiindex(self, df=None, super=None, name1="Position", name2="Date"):
         subs = df.index.to_list()   # List of subheaders (dates)
@@ -281,6 +288,18 @@ class Survey:
         combi = combi.transpose()
         return combi
 
+    def get_start_end(self):
+        starts = [self._logs[key].get_start() for key in self._logs.keys()]
+        ends = [self._logs[key].get_end() for key in self._logs.keys()]
+        return min(starts), max(ends)
+
+    def weather(self, interval=6, api_key="", country="GB", postcode="WC1", tz="",):
+        start, end = self.get_start_end()
+        self._weather.reinit(start=start, end=end, interval=interval, api_key=api_key, country=country,
+                             postcode=postcode, tz=tz, units="metric")
+        self._weather.compute_weather_history()
+        return self._weather.get_weather_history()
+
     # def typical_leq_spectra(self, leq_cols=None):
     #     """
     #     DEPRECATED 2025/06/05. Replaced by .leq_spectra() **TT**

pycoustic/tkgui.py

@@ -0,0 +1,349 @@
+import tkinter as tk
+from tkinter import filedialog ,Toplevel, IntVar, Checkbutton, Button
+from tkinter import ttk
+from tkinter import messagebox
+from log import Log
+from survey import Survey
+import os
+import pandas as pd
+from tkinter import StringVar
+#import matplotlib
+#from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
+
+#from src import log  # Assuming log is an instance of a class with the required methods
+test = 0
+
+class Application(tk.Tk):
+    
+    def __init__(self):
+        super().__init__()
+        self.title("src Log Viewer")
+        self.geometry("1200x800")
+        import tkinter as tk
+
+        # Create an instance of Survey
+        self.survey = Survey()
+
+        self.create_widgets()
+
+    def create_widgets(self):
+
+        self.grid_columnconfigure((0,1,2), weight=1)
+
+        self.grid_columnconfigure((3,4,5), weight=2)
+
+        self.log_label = ttk.Label(self, text="csv file name:")
+        self.log_label.grid(row=0, column=0, padx=5, pady=5, sticky="e")
+
+        self.log_file = ttk.Label(self, text="Click Browse to select")
+        self.log_file.grid(row=0, column=1, padx=5, pady=5, sticky="w")
+
+        self.browse_button1 = ttk.Button(self, text="Browse", command=self.browse_log)
+        self.browse_button1.grid(row=0, column=2, padx=5, pady=5, sticky="w")
+
+        self.analysis_label = ttk.Label(self, text="Select Analysis Type:")
+        self.analysis_label.grid(row=3, column=0, padx=5, pady=10, sticky="e")
+
+        self.analysis_var = StringVar()
+        self.analysis_combobox = ttk.Combobox(self, textvariable=self.analysis_var, values=["resi_summary", "modal_l90", "lmax_spectra", "Typical_leq_spectra"])
+        self.analysis_combobox.set("resi_summary")
+        self.analysis_combobox.grid(row=3, column=1, padx=5, pady=10, sticky="w")
+        self.analysis_var.trace("w", self.on_analysischange)
+
+        self.parameters_label = ttk.Label(self, text="Parameters")
+        self.parameters_label.grid(row=4, column=0, padx=5, pady=5, sticky="e")
+
+        self.parameters_entry = ttk.Entry(self, width=20)
+        self.parameters_entry.insert(0, 'None,None,10,2min')
+        self.parameters_entry.grid(row=4, column=1, padx=5, pady=10, sticky="w")
+
+        self.parameters_label = ttk.Label(self, text="(leq_cols,max_cols,lmax_n,lmax_t )")
+        self.parameters_label.grid(row=4, column=2, padx=5, pady=5, sticky="w")
+
+        self.execute_button = ttk.Button(self, text="Select Columns", command=self.Column_Selection_Modal)
+        self.execute_button.grid(row=5, column=0, padx=5, pady=10, sticky="e")
+
+        self.execute_button = ttk.Button(self, text="Execute", command=self.execute_code)
+        self.execute_button.grid(row=5, column=2, padx=5, pady=10, sticky="w")
+
+        self.tree = ttk.Treeview(self, show="headings")
+        self.tree_scroll_y = ttk.Scrollbar(self, orient="vertical", command=self.tree.yview)
+        self.tree_scroll_y.grid(row=6, column=6, sticky="ns")
+
+        self.tree_scroll_x = ttk.Scrollbar(self, orient="horizontal", command=self.tree.xview)
+        self.tree_scroll_x.grid(row=7, column=0, columnspan=3, sticky="ew")
+
+        self.tree.configure(yscrollcommand=self.tree_scroll_y.set, xscrollcommand=self.tree_scroll_x.set)
+
+        self.tree.grid(row=6, column=0, columnspan=4, padx=20, pady=20, sticky="nsew")
+    """
+      # Button to open the modal dialog
+        open_dialog_button = ttk.Button(self, text="Show Time Series", command=self.open_modal_dialog)
+        open_dialog_button.grid(row=5, column=2, padx=5, pady=10, sticky="w")
+
+
+    # Commented out section that displays a graph
+    def open_modal_dialog(self):
+        dialog = Toplevel(self)
+        dialog.title("Modal Dialog")
+
+        # Make the dialog modal
+        dialog.transient(self)
+        dialog.grab_set()
+
+        # Center the dialog on the screen
+        window_width = self.winfo_width()
+        window_height = self.winfo_height()
+        window_x = self.winfo_x()
+        window_y = self.winfo_y()
+
+        dialog_width = 900
+        dialog_height = 600
+
+        position_right = int(window_x + (window_width / 2) - (dialog_width / 2))
+        position_down = int(window_y + (window_height / 2) - (dialog_height / 2))
+
+        dialog.geometry(f"{dialog_width}x{dialog_height}+{position_right}+{position_down}")
+        import matplotlib.pyplot as plt
+
+        # Create a figure and axis
+        fig, ax = plt.subplots()
+
+        # Plot the data
+        #print ("----",self.df.columns[1][0],self.df.columns[1][1] )        
+        #print ("----",type(self.df.columns[1]))
+        
+        leq_a_column = [col for col in self.df.columns if isinstance(col, tuple) and col[0] == "Leq" and col[1] == "A"]
+        if not leq_a_column:
+            messagebox.showerror("Error", "No columns found with ('Leq', 'A') in the header.")
+            return
+
+        l90_a_columns = [col for col in self.df.columns if isinstance(col, tuple) and col[0] == "L90" and col[1] == "A"]
+        if not l90_a_columns:
+            messagebox.showerror("Error", "No columns found with ('L90', 'A') in the header.")
+            return
+
+
+        self.df["Date"] = pd.to_datetime(self.df.index)
+        #print(self.df)
+
+        ax.plot(self.df["Date"], self.df[leq_a_column[0]], label='LAeq')
+        ax.plot(self.df["Date"], self.df[l90_a_column[0]], label='LA90')
+        #ax.plot(self.df['Index'], self.df['L90 A'], label='la90')
+
+        # Format the x-axis to show dates properly
+        fig.autofmt_xdate()
+
+        # Add labels and title
+        ax.set_xlabel('Date')
+        ax.set_ylabel('Values')
+        ax.set_title('Time Series Line Chart')
+        ax.legend()
+
+        # Create a canvas to display the plot in the Tkinter dialog
+        canvas = FigureCanvasTkAgg(fig, master=dialog)
+        canvas.draw()
+        canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
+        #else:
+        #    messagebox.showerror("Error", "DataFrame does not contain required columns: 'date', 'Laeq', 'la90'")
+
+        # OK button to close the dialog
+        ok_button = ttk.Button(dialog, text="OK", command=dialog.destroy)
+        ok_button.pack(pady=20)
+
+    """
+
+    def on_analysischange(self, *args):
+        analysis_type = self.analysis_combobox.get()
+        if analysis_type == "resi_summary":
+            self.parameters_entry.config(state='normal')
+        else:
+            self.parameters_entry.config(state='disabled')
+        return
+ 
+  
+    def browse_log(self):
+        self.logpath = os.getcwd  ()
+        file_path = tk.filedialog.askopenfilename(initialdir=self.logpath, filetypes=[("CSV files", "*.csv")])
+        if file_path:
+            self.logname = os.path.basename(file_path)
+            self.logpath = os.path.dirname(file_path)
+            self.log_file.config(text=self.logname)
+
+            strPath = self.logpath + "\\" + self.logname
+            self.log  = Log(path=strPath)
+            self.survey.add_log(data=self.log, name="Position 1")
+
+            self.df = self.log.get_data()
+
+            # Clear the treeview
+            for item in self.tree.get_children():
+                self.tree.delete(item)
+
+            # Round the dataframe values to 1 decimal place, except for the column headers
+            self.df = self.df.round(1)
+ 
+            # Insert new data into the treeview
+            self.tree["columns"] = ["Index"] + list(self.df.columns)
+            self.tree.heading("Index", text="Index")
+            self.tree.column("Index", width=150, stretch=True)
+
+            i = 0 
+            for col in self.df.columns:
+                self.tree.heading(col, text=col)
+                i=i+1
+                if i < 12:
+                    self.tree.column(col, width=75,stretch=True, anchor="center")
+                else:
+                    self.tree.column(col, width=0,stretch=False, anchor="center")
+          
+            for index, row in self.df.iterrows():
+                self.tree.insert("", "end", values=[index] + list(row))
+            return
+ 
+    def execute_code(self):
+        analysis_type = self.analysis_combobox.get()
+        parameters = self.parameters_entry.get()
+
+        try:
+            df = pd.DataFrame()
+            if analysis_type == "resi_summary":
+                params = parameters.split(",")
+                p = [None if x == "None" else x for x in params]
+                df =self.survey.resi_summary(leq_cols=p[0], max_cols=p[1], lmax_n=int(params[2]), lmax_t=params[3])  
+                print ("df id a ",type(df))
+            elif analysis_type == "modal_l90":
+                df = self.survey.modal()
+            elif analysis_type == "lmax_spectra":
+                df = self.survey.lmax_spectra()
+            elif analysis_type == "Leq_spectra":
+                df = self.survey.leq_spectra()
+            else:
+                messagebox.showerror("Error", "Please select an analysis type.")
+                return
+        except Exception as e:
+            messagebox.showerror("Error", f"An error occurred: {e}")
+            return
+        
+        # Clear the treeview
+        for item in self.tree.get_children():
+            self.tree.delete(item)
+
+        # Set new column headers based on the dataframe
+        #self.tree["columns"] = list(df.columns)
+
+        # Insert new data into the treeview
+        self.tree["columns"] = ["Index"] + list(df.columns)
+        self.tree.heading("Index", text="Index")
+        self.tree.column("Index", width=150, anchor="center", stretch=True)
+        
+
+        for col in df.columns:
+            self.tree.heading(col, text=col)
+            self.tree.column(col, width=75, anchor="center", stretch=True)
+   
+        # Insert new data into the treeview
+        for index, row in df.iterrows():
+            self.tree.insert("", "end", values=[index] + list(row))
+
+        # Copy the DataFrame to the clipboard
+        df.to_clipboard(index=True)
+        messagebox.showinfo("Success", "DataFrame copied to clipboard.")
+
+
+    def Column_Selection_Modal(self):   
+        # Create a modal dialog
+        #print ("def Column_Selection_Modal(self):")
+
+        dialog = Toplevel(self)
+        dialog.title("Select Columns")
+
+        # Make the dialog modal
+        dialog.transient(self)
+        dialog.grab_set()
+
+        #self.window.update_idletasks()
+        window_width = self.winfo_width()
+        window_height = self.winfo_height()
+        window_x = self.winfo_x()
+        window_y = self.winfo_y()
+
+        dialog_width = 300
+        dialog_height = 600
+
+        position_right = int(window_x + (window_width / 2) - (dialog_width / 2))
+        position_down = int(window_y + (window_height / 2) - (dialog_height / 2))
+
+        dialog.geometry(f"{dialog_width}x{dialog_height}+{position_right}+{position_down}")
+
+        # Configure grid rows and columns
+        for i in range(12):  # Adjust the range as needed
+            dialog.rowconfigure(i,weight =1,uniform = 'a')
+
+        for i in range(3):  # Adjust the range as needed
+            dialog.grid_columnconfigure(i,  weight =1,minsize = 20,uniform = 'a')
+
+        # Get the column identifiers
+        column_ids = self.tree["columns"]
+        #print ("col ids",column_ids)
+
+        # Get the column headers
+        column_headers = [self.tree.heading(col)["text"] for col in column_ids]
+
+        # Get the column widths
+        column_widths = [self.tree.column(col)["width"] for col in column_ids]
+
+
+        self.column_vars = {}
+        for i, column in enumerate(column_headers):
+            # Check if the column is visible in self.tree
+            self.column_vars[column] = IntVar(master=dialog, value=1 if column_widths[i] > 0 else 0)
+        self.cb = []
+
+        # Create checkboxes for each column
+        for i, column in enumerate(column_headers):
+            #print(f"Column: {column}, Value: {self.column_vars[column].get()}")            
+            self.cb.append( Checkbutton(dialog, text=column, variable=self.column_vars[column]))
+            #self.cb[i].grid(row=i+1, column=(i-1)/10, sticky='w')
+            self.cb[i].grid(row=i%10, column=i//10, sticky='w')
+
+        for i, column in enumerate(column_headers):
+            self.column_vars[column].set(1 if column_widths[i] > 0 else 0)
+
+        # OK button to apply the selection
+        ttk.Button(dialog, text="OK", command=lambda: self.apply_column_selection(dialog)).grid(row=13, column=1, ipady=10)
+       # Cancel button
+        def on_cancel():
+            #print("Cancel clicked")
+            dialog.destroy()
+
+        cancel_button = ttk.Button(dialog, text="Cancel", command=on_cancel)
+        cancel_button.grid(row=13,column = 2, sticky = "w",ipady = 10)   
+
+        return     
+
+    def apply_column_selection(self, dialog):
+
+        #print("def apply_column_selection")
+
+        # Get the selected columns
+        selected_columns = [column for column, var in self.column_vars.items() if var.get() == 1]
+
+        # Set the column widths based on the selection
+        for column in self.tree["columns"]:
+            column_text = self.tree.heading(column)["text"]
+            if column_text in selected_columns:
+                self.tree.column(column, width=250,stretch=True, anchor="center")  # Set to a default width
+            else:
+                self.tree.column(column, width=0,stretch=False, anchor="center")  # Hide the column
+
+        # Display the selected columns in the listbox
+        #for item in self.tree:
+        #    display_text = " | ".join(str(item[column]) for column in selected_columns)
+        #    self.listbox.insert(END, display_text)
+        # Close the dialog
+        dialog.destroy()
+
+if __name__ == "__main__":
+    app = Application()
+    app.mainloop()

pycoustic/weather.py

@@ -0,0 +1,99 @@
+import requests
+import pandas as pd
+import datetime as dt
+
+test=0
+
+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
+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)
+        print(query)
+        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)
+        print(response.json())
+        # 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):
+        # construct timestamps
+        timestamps = self._construct_timestamps()
+        # make calls to API
+        responses = []
+        for ts in timestamps:
+            print(f"ts: {ts}")
+            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
+        print(df)
+        self._hist = df
+        return df
+
+    def get_weather_history(self):
+        return self._hist

pycoustic-0.1.3.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.3
+Name: pycoustic
+Version: 0.1.3
+Summary: 
+Author: thumpercastle
+Author-email: tony.ryb@gmail.com
+Requires-Python: >=3.10,<4.0
+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)
+Requires-Dist: openpyxl (==3.1.5)
+Requires-Dist: pandas (==2.2.3)
+Requires-Dist: requests (>=2.32.4,<3.0.0)
+Description-Content-Type: text/markdown
+
+# pycoustic - Toolkit for Analysing Noise Survey Data
+## Overview
+pycoustic is a Python-based toolkit designed to assist acoustic consultants and engineers in analyzing noise survey data. The library provides various tools and utilities for processing, interpreting, and visualizing noise measurements.
+
+## Requirements
+This toolkit was written in Python 3.12. See the pyrpoject.toml for the latest dependencies.
+
+## Features
+- Import and process noise survey data from .csv files
+- Analyse and recompute sound levels and statistical meausres (Leq, Lmax, L90 etc.)
+- Handle large datasets from multiple measurement positions efficiently
+- Visualise noise data through customisable plots (WIP)
+- Generate reports with summary statistics (WIP)
+
+## Installation
+The library is not currently available through pip or Anaconda (we're working on it). You can pull the code from git, or simply download the files on this GitHub page.
+
+## Usage
+**Before you start**
+Make sure your input data is in the correct format. See the file UA1_py.csv for reference. Namely:
+- Your data must be in .csv format.
+- Timestamps should ideally be in the format *dd-mm-yyyy hh:mm*, other formats may work, but their performance is not tried and tested.
+- Column headers should be in the Tuple-like format as per the example csv files attached. The measurement index should be first, and the frequency band or weighting should be second. e.g. the LAeq column should have the header *"Leq A"*, the L90 column at 125 Hz should have the header *"L90 125"*, and so on.
+- Make sure you past your data and columns into a fresh csv tab. If you end up having to chop the data and delete columns or rows, repaste it into a fresh tab when it is ready to be presented to the toolkit. Failure to do so can result in a ValueError. See **Troubleshooting** below.
+- If you do use this toolkit, please attribute it appropriately, and carry out your own checks to ensure you are satisfied with the outputs. See **Terms of Use** below.
+### Basic Workflow
+1. **Import the library**\
+   Import the library into your script or active console.
+   ```
+   from pycoustic import*
+   ```
+2. **Load Data**\
+   A single measurement position can be loaded into a Log object.
+   ```
+   log1 = Log(path="path/to/data_for_pos1.csv")
+   log2 = Log(path="path/to/data_for_pos2.csv")
+   ```
+3. **Combine Data**\
+   The data from multiple measurement positions can be combined together within a Survey object.
+   First we need to create a Survey object, and then add each Log one at a time.
+   ```
+   surv = Survey()
+   surv.add_log(data=log1, name="Position 1")
+   surv.add_log(data=log2, name="Position 2")
+   ```
+4. **Analyse the Survey Data**
+   The following are methods of the Survey() object representing the typical use cases for acoustic consultants in the UK.
+   ### Survey.resi_summary()
+   This method provides a summary of the measurement data for residential projects, with a focus on typical assessment procedures in the UK.
+   It presents A-weighted Leqs for each day and night period (and evenings, if enabled), as well as the nth-highest LAmax during each night-time period.
+   Optional arguments are:\
+   **leq_cols** *List of tuples* *(default [("Leq", "A")]* Which column(s) you want to present as Leqs - this can be any Leq or statistical column.\
+   **max_cols** *List of tuples* *(default [("Leq", "A")]* Which column(s) you want to present as an nth-highest value - this can be any column.\
+   **lmax_n** *Int* *(default 10)* The nth-highest value to present.\
+   **lmax_t** *Str* *(default "2min")* The time period T over which Lmaxes are presented. This must be equal to or longer than the period of the raw data.
+   
+   ### Survey.modal_l90()
+   Compute the modal L90 for daytime, evening (if enabled) and night-time periods. By default, this is set to T=60min for (23:00 to 07:00) periods, and T=15min for night-time (23:00 to 07:00) periods, as per BS 4142:2014.
+   
+   ### Survey.lmax_spectra()
+   Compute the Lmax Event spectra for the nth-highest Lmax during each night-time period.\
+   **Note** the date presented alongside the Lmax event is actually the starting date of the night-time period. i.e. an Lmax event with a stamp of 20/12/2024 at 01:22 would actually have occurred on 21/12/2024 at 01:22. These stamps can also sometimes be out by a minute (known bug).
+   
+   ### Survey.typical_leq_spectra()
+   Compute the Leq spectra for daytime, evening (if enabled) and night-time periods. This will present the overall Leqs across the survey, not the Leq for each day.
+   
+
+### Other methods
+### Known issues
+- Lmax night-time timestamps can sometimes by out by a minute.
+- [RESOLVED 07/02/2025] modal_L90 keyword 'cols' does not work due to headers not being properly allocated.
+## Troubleshooting
+### ValueError: NaTType does not support time
+This error occurs when trying to create a Log() object with a csv file. It occurs because the source csv file contains empty cells which were previously allocated (filled). It usually happens when you have entered data into some row(s) or column(s) and then deleted it, leaving previously-full cells which are now empty.\
+**Solution:** Create a new tab in your source csv file, and paste in your headers and data as you wish it to be presented to the toolkit, avoiding having to delete any columns and rows. Delete the old tab. If you do have to delete any data in the new tab, you will need to repeat the process to ensure this error is not thrown up again.
+
+## Terms of use
+The pycoustic toolkit was built by Tony Trup of [Timbral](https://www.timbral.co.uk).
+Neither I nor Timbral Ltd. accept any liability for the outputs of this toolkit. You use it at your own risk, and you should carry out your own checks and balances to ensure you are satistfied that the output is accurate.
+This is an open source project, and I welcome suggestions for changes, improvements or new features. You can also write your own methods or functions and share them with me, either by getting in touch offline, or by creating a new branch from this Git repository.
+You may use this toolkit subject to the licence conditions below. For clarity, you may use this toolkit or adaptations of it in your day-to-day engineering work, but incorporating it into a commercial software product or service is not permitted.
+This project is being shared under a [Creative Commons CC BY-NC-SA 4.0 Licence](https://creativecommons.org/licenses/by-nc-sa/4.0/).
+Attribution — You must give appropriate credit , provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.
+NonCommercial — You may not use the material for commercial purposes.
+ShareAlike — If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original.

pycoustic-0.1.3.dist-info/RECORD

@@ -0,0 +1,8 @@
+pycoustic/__init__.py,sha256=0UGHX-vdulM9x1j8g_DcR_BbtBk0gEFg9l4KjLl4Qrk,85
+pycoustic/log.py,sha256=HNdS2hKKbUdqY7iAMj9QJqoI9r4ZtJ7GCXnIx8XpTH4,17145
+pycoustic/survey.py,sha256=6bQW1UniUgUdj7jOpqTagdos6IRVPhURegmq9PgBYjQ,18453
+pycoustic/tkgui.py,sha256=vvB0D29GER-i7lC_SUuzKrzbh1EFAAhpRaHi7kggtYk,13985
+pycoustic/weather.py,sha256=xEp5-ZYlYJXB-G2QQuEETTfyMALAWJtSWtLn5XHDRFo,3822
+pycoustic-0.1.3.dist-info/METADATA,sha256=nJy_wiOSY2K08rQKE2z420Ln0MtTqoXKQvRsFuCfzQo,7476
+pycoustic-0.1.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+pycoustic-0.1.3.dist-info/RECORD,,

{pycoustic-0.1.1.dist-info → pycoustic-0.1.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.5.1
+Generator: poetry-core 2.1.3
 Root-Is-Purelib: true
 Tag: py3-none-any

pycoustic-0.1.1.dist-info/METADATA

@@ -1,16 +0,0 @@
-Metadata-Version: 2.1
-Name: pycoustic
-Version: 0.1.1
-Summary: 
-Author: thumpercastle
-Author-email: tony.ryb@gmail.com
-Requires-Python: >=3.10,<4.0
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Requires-Dist: numpy (==2.2.6)
-Requires-Dist: openpyxl (==3.1.5)
-Requires-Dist: pandas (==2.2.3)
-Description-Content-Type: text/markdown
-
-

pycoustic-0.1.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-pycoustic/__init__.py,sha256=Midt6cul_fLEpsI002sx-Yi_-gZV2Hs36mxIlnDs82I,48
-pycoustic/log.py,sha256=TagYIfubFl5BnHwSPunELYejbr13mJvLoENCkHkSaJ4,17054
-pycoustic/survey.py,sha256=fv5K7s-fOYks8ei-NRa19b-zWlT_ZQuDJMjKgYesXXM,17639
-pycoustic-0.1.1.dist-info/METADATA,sha256=WQMdpIRk-aLBHE0efTyRMv29mlvPLWPNys5U_-r8GFA,436
-pycoustic-0.1.1.dist-info/WHEEL,sha256=kLuE8m1WYU0Ig0_YEGrXyTtiJvKPpLpDEiChiNyei5Y,88
-pycoustic-0.1.1.dist-info/RECORD,,