tseda 0.1.0__py3-none-any.whl

tseda/change_point/change_point_estimator.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+import ruptures as rpt
+
+
+class PELT_ChangePointEstimator:
+	"""Estimate change points with the PELT algorithm and return a predicted segment series."""
+
+	def __init__(self, series: pd.Series, model: str = "rbf") -> None:
+		if series is None or len(series) == 0:
+			raise ValueError("Input series must be a non-empty pandas Series.")
+
+		self._series = series
+		self._model = model
+		self._n = len(series)
+		self._penalty = float(2 * np.log(self._n))
+
+		values = series.to_numpy().reshape(-1, 1)
+		self._algo = rpt.Pelt(model=model).fit(values)
+		self._change_pts = self._algo.predict(pen=self._penalty)
+		self._predicted_series = self._build_predicted_series(self._change_pts)
+
+	def _build_predicted_series(self, change_points: list[int]) -> pd.Series:
+		segment_labels: list[str] = []
+		start_idx = 0
+
+		for segment_no, end_idx in enumerate(change_points, start=1):
+			segment_length = max(0, end_idx - start_idx)
+			segment_labels.extend([f"segment-{segment_no}"] * segment_length)
+			start_idx = end_idx
+
+		if len(segment_labels) < self._n:
+			segment_labels.extend([f"segment-{len(change_points) + 1}"] * (self._n - len(segment_labels)))
+
+		return pd.Series(segment_labels[: self._n], index=self._series.index, name="segment")
+
+	def predict_series(self) -> pd.Series:
+		"""Return the predicted segment label series."""
+		return self._predicted_series.copy()
+
+
+class ChangePointEstimator:
+	"""Compatibility wrapper used by existing tests and call sites."""
+
+	def __init__(self, series: pd.Series) -> None:
+		if series is None or len(series) == 0:
+			raise ValueError("Input series must be a non-empty pandas Series.")
+
+		self._series = series
+		self._df = pd.DataFrame({"date": series.index, "signal": series.values})
+		self._change_pts: list[int] | None = None
+
+	def estimate_change_points(self, penalty_coeff: float = 2.0) -> pd.Series:
+		"""Run PELT and assign segment labels for each observation."""
+		n = len(self._series)
+		penalty = float(penalty_coeff * np.log(n))
+		values = self._series.to_numpy().reshape(-1, 1)
+
+		algo = rpt.Pelt(model="rbf").fit(values)
+		self._change_pts = algo.predict(pen=penalty)
+
+		segment_labels: list[str] = []
+		start_idx = 0
+		for segment_no, end_idx in enumerate(self._change_pts, start=1):
+			segment_length = max(0, end_idx - start_idx)
+			segment_labels.extend([f"segment-{segment_no}"] * segment_length)
+			start_idx = end_idx
+
+		if len(segment_labels) < n:
+			segment_labels.extend([f"segment-{len(self._change_pts) + 1}"] * (n - len(segment_labels)))
+
+		self._df["segment"] = segment_labels[:n]
+		return self._df["segment"]
+
+        

tseda/config/prompts_config.csv

@@ -0,0 +1,5 @@
+previous_state,prompt
+START,You should upload a regularly sampled csv file for analysis
+FILE_PROCESSED,"You should estimate the densite for the series and inspect its plot to see if there are multiple modes. If you see this, it means there were different regimes in your time series and you should analyze and explore these regimes independently. You can get an approximate estimate of the inflection points in the density estimate, so that you can sense if there are multiple regimes. You can then apply a change point detection algorithm to estimate the location of these changes. Shall I proceed with the inflection point estimation in the density curve?"
+INFLECTION_POINTS_EST,You should run a change point detection algorithm to locate the estimated time of change of your time series behavior. Shall I do that?
+CHANGE_POINTS_IDENTIFIED,You should plot the change points on the time series with the different segment color coded. Shall I do that?

tseda/data_writers/kmds_writer.py

@@ -0,0 +1,58 @@
+from kmds.tagging.tag_types import ExploratoryTags
+from kmds.ontology.intent_types import IntentType
+from owlready2 import *
+from kmds.utils.load_utils import *
+
+class KMDSDataWriter:
+    def __init__(self, file_path: str):
+        self._file_path = file_path
+        self._onto = self.load_kb()
+        return
+    
+    def load_kb(self) -> Ontology:
+        onto2 :Ontology = load_kb(self._file_path)
+        return onto2
+    
+    def add_exploratory_obs(self, obs: str, file_path: str) -> None:
+        the_workflow: Workflow = get_workflow(self._onto)
+
+
+        
+        with self._onto:
+        # add the new observation
+            observation_count :int = len(the_workflow.has_exploratory_observations)+ 1
+            e1 = ExploratoryObservation(namespace=self._onto)
+
+            e1.finding = obs
+            e1.finding_sequence = observation_count
+            e1.exploratory_observation_type = ExploratoryTags.DATA_QUALITY_OBSERVATION.value
+            e1.intent = IntentType.DATA_UNDERSTANDING.value
+            the_workflow.has_exploratory_observations.append(e1)
+
+            self._onto.save(file=file_path, format="rdfxml")
+
+        return
+    
+    def delete_exploratory_obs(self, obs_seq: int) -> None:
+        the_workflow: Workflow = get_workflow(self._onto)
+        with self._onto:
+            del the_workflow.has_exploratory_observations[obs_seq - 1]
+
+            obs_len = len(the_workflow.has_exploratory_observations)
+            for idx in range(obs_len):
+                the_workflow.has_exploratory_observations[idx].finding_sequence = idx + 1
+
+            self._onto.save(file=self._file_path, format="rdfxml")
+
+        return
+    
+    def update_exploratory_obs(self, obs: str, obs_seq: int) -> None:
+        the_workflow: Workflow = get_workflow(self._onto)
+        with self._onto:
+            the_workflow.has_exploratory_observations[obs_seq - 1].finding = obs
+
+            self._onto.save(file=self._file_path, format="rdfxml")
+
+        return
+
+

tseda/dataloader/coffee_prices_data_loader.py

@@ -0,0 +1,30 @@
+from .local_dataloader import LocalDataLoader
+import pandas as pd
+
+class CoffeePricesDataLoader(LocalDataLoader):
+    def __init__(self, file_path: str = "data/coffee_prices.csv"):
+        super().__init__(file_path)
+
+    def load_coffee_prices(self) -> pd.DataFrame:
+        """Load coffee prices data from a local CSV file."""
+        data = self.load_data()
+        data.columns = ["date", "signal"]
+        data.date = pd.to_datetime(data.date)
+
+
+        if not data.empty:
+            # Additional processing specific to coffee prices can be added here
+            return data
+        else:
+            print("No data loaded.")
+            return pd.DataFrame()
+
+    def get_series(self) -> pd.Series:
+        """Get the 'signal' series from the coffee prices data."""
+        data = self.load_coffee_prices()
+        data.index = data.date
+        if not data.empty:
+            return data["signal"]
+        else:
+            print("No data available to extract series.")
+            return pd.Series(dtype=float)

tseda/dataloader/kaggle_data_loader.py

@@ -0,0 +1,25 @@
+import os
+from kaggle.api.kaggle_api_extended import KaggleApi
+from dotenv import load_dotenv
+from sys import exit
+from pathlib import Path
+
+def download_kaggle_dataset(dataset_slug, download_path):
+    """
+    dataset_slug: The part of the URL after kaggle.com/datasets/
+    Example: 'arashnic/max-planck-weather-dataset'
+    """
+
+    path = Path(download_path)
+    if not path.is_dir():
+        print("Directory does not exist or is not valid., please check the path and try again.")
+        exit(1)
+    
+    load_dotenv()  # Load environment variables from .env file
+    api = KaggleApi()
+    api.authenticate()
+    
+    print(f"Downloading {dataset_slug}...")
+    api.dataset_download_files(dataset_slug, path=download_path, unzip=True)
+    print("Download complete.")
+

tseda/dataloader/kmds_data_loader.py

@@ -0,0 +1,82 @@
+from owlready2 import *
+from kmds.utils.load_utils import *
+import pandas as pd
+
+class KMDSDataLoader:
+    def __init__(self, file_path: str):
+        self._file_path = file_path
+        self._onto = self.load_kb()
+        
+
+        return
+    
+    def load_kb(self) -> Ontology:
+        onto2 :Ontology = load_kb(self._file_path)
+        return onto2
+    
+    def load_exploratory_obs(self) -> pd.DataFrame:
+        
+
+        the_workflow: Workflow = get_workflow(self._onto)
+        exp_obs: List[ExploratoryObservation] = the_workflow.has_exploratory_observations
+        records = []
+
+        for o in exp_obs:
+            a_row = {}
+            a_row["finding_seq"] = o.finding_sequence
+            #a_row["obs_type"] = o.exploratory_observation_type
+            a_row["finding"] = o.finding
+            records.append(a_row)
+        df = pd.DataFrame(records)
+
+        return df
+    
+    def load_data_rep_obs(self) -> pd.DataFrame:
+        the_workflow: Workflow = get_workflow(self._onto)
+        dr_obs: List[DataRepresentationObservation] = the_workflow.has_data_representation_observations
+        records = []
+        for o in dr_obs:
+            a_row = {}
+            a_row["finding_seq"] = o.finding_sequence
+            a_row["obs_type"] = o.data_representation_observation_type
+            a_row["finding"] = o.finding
+            records.append(a_row)
+        df = pd.DataFrame(records)
+
+        return df
+    def load_modelling_choice_obs(self) -> pd.DataFrame:
+        the_workflow: Workflow = get_workflow(self._onto)
+        mc_obs: List[ModellingChoiceObservation] = the_workflow.has_modelling_choice_observations
+        records = []
+        for o in mc_obs:
+            a_row = {}
+            a_row["finding_seq"] = o.finding_sequence
+            a_row["obs_type"] = o.modelling_choice_observation_type
+            a_row["finding"] = o.finding
+            records.append(a_row)
+        df = pd.DataFrame(records)
+
+        return df   
+    
+    def load_modelling_selection_obs(self) -> pd.DataFrame:
+        the_workflow: Workflow = get_workflow(self._onto)
+        ms_obs: List[ModellingSelectionObservation] = the_workflow.has_modelling_selection_observations
+        records = []
+        for o in ms_obs:
+            a_row = {}
+            a_row["finding_seq"] = o.finding_sequence
+            a_row["obs_type"] = o.modelling_selection_observation_type
+            a_row["finding"] = o.finding
+            records.append(a_row)
+        df = pd.DataFrame(records)
+
+        return df
+    
+    def export_all_observations(self) -> pd.DataFrame:
+        exp_df  = load_exp_observations(self._onto)
+        dr_df = load_data_rep_observations(self._onto)
+        mc_df = load_modelling_choice_observations(self._onto)
+        ms_df = load_model_selection_observations(self._onto)
+        df_consolidated = pd.concat([exp_df, dr_df, mc_df, ms_df], ignore_index=True)
+
+        return df_consolidated

tseda/dataloader/local_dataloader.py

@@ -0,0 +1,21 @@
+
+import pandas as pd
+
+class LocalDataLoader:
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+
+    def load_data(self) -> pd.DataFrame:
+        """Load data from a local CSV file into a pandas DataFrame."""
+        try:
+            data = pd.read_csv(self.file_path)
+            return data
+        except FileNotFoundError:
+            print(f"Error: The file at {self.file_path} was not found.")
+            return pd.DataFrame()
+        except pd.errors.EmptyDataError:
+            print("Error: The file is empty.")
+            return pd.DataFrame()
+        except Exception as e:
+            print(f"An unexpected error occurred: {e}")
+            return pd.DataFrame()

tseda/dataloader/synthetic_series_data_loader.py

@@ -0,0 +1,39 @@
+from .local_dataloader import LocalDataLoader
+import pandas as pd
+from datetime import datetime, timedelta
+import numpy as np
+from scipy.stats import norm
+from math import ceil
+
+class SyntheticSeriesDataLoader(LocalDataLoader):
+    def __init__(self, file_path: str = "data/synthetic_series.csv"):
+        super().__init__(file_path)
+
+    def get_series(self) -> pd.Series:
+        """Get the 'signal' series from the synthetic series data."""
+        now = datetime.now()
+        p1_peak = 5
+        p2_peak = 7
+        p1 = 6
+        p2 = 10
+        N = ceil(24*90/1)  # 90 days of hourly data
+        time_idx = [float(i) for i in range(N)]
+        p1_omega = [(2*np.pi* t)/(p1) for t in time_idx]
+        p2_omega = [(2*np.pi* t)/(p2) for t in time_idx]
+        p1_vals = [p1_peak*np.sin(w) for w in p1_omega]
+        p2_vals = [p2_peak*np.sin(w) for w in p2_omega]
+        noise = norm.rvs(loc=0, scale=0.5, size=N)
+        level = [20 for _ in range(N)]
+        signal = np.array(level) + np.array(p1_vals) + np.array(p2_vals) + np.array(noise)
+        time_vals = [now + timedelta(hours=i) for i in range(N)]
+        data = {"time": time_vals, "signal": signal}
+        df = pd.DataFrame.from_dict(data)
+        df.index = df.time
+        if not df.empty:
+            series = df["signal"]
+            series.index = df.time
+
+            return series
+        else:
+            print("No data available to extract series.")
+            return pd.Series(dtype=float)

tseda/dataloader/white_noise_data_loader.py

@@ -0,0 +1,26 @@
+from .local_dataloader import LocalDataLoader
+import pandas as pd
+from datetime import datetime, timedelta
+import numpy as np
+
+class WhiteNoiseDataLoader(LocalDataLoader):
+    def __init__(self, file_path: str = "data/white_noise_series.csv"):
+        super().__init__(file_path)
+
+    def get_series(self) -> pd.Series:
+        """Generate a white noise series for 30 days with hourly frequency."""
+        num_days = 30
+        samples_per_day = 24
+        num_samples = num_days * samples_per_day
+        
+        # Create a datetime index for 30 days with hourly frequency
+        start_date = datetime.now()
+        time_index = pd.to_datetime([start_date + timedelta(hours=i) for i in range(num_samples)])
+        
+        # Generate white noise data
+        white_noise = np.random.normal(loc=0, scale=1, size=num_samples)
+        
+        # Create a pandas Series
+        series = pd.Series(white_noise, index=time_index)
+        
+        return series