tseda 0.1.0__tar.gz

tseda-0.1.0/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: tseda
+Version: 0.1.0
+Summary: A package for exploration of regularly sampled time series.
+License-Expression: LicenseRef-Proprietary
+Keywords: time-series,ssa,dash,analytics,decomposition
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: dash>=4.1.0
+Requires-Dist: dash-bootstrap-components>=2.0.4
+Requires-Dist: google-genai>=1.56.0
+Requires-Dist: importlib-resources>=6.5.2
+Requires-Dist: ipython>=9.8.0
+Requires-Dist: jupyter>=1.1.1
+Requires-Dist: jupyter-ai>=2.31.7
+Requires-Dist: jupyter-dash>=0.4.2
+Requires-Dist: kaggle>=2.0.0
+Requires-Dist: kdepy>=1.1.12
+Requires-Dist: kmds>=0.3.1
+Requires-Dist: matplotlib>=3.10.8
+Requires-Dist: numpy>=2.4.0
+Requires-Dist: pandas>=2.3.3
+Requires-Dist: plotly>=6.5.0
+Requires-Dist: python-dotenv>=1.2.1
+Requires-Dist: req>=1.0.0
+Requires-Dist: ruptures>=1.1.10
+Requires-Dist: scikit-learn>=1.8.0
+Requires-Dist: scipy<1.16.0
+Requires-Dist: seaborn>=0.13.2
+Requires-Dist: skrub>=0.7.2
+Requires-Dist: ssalib>=0.1.3
+Requires-Dist: statsmodels>=0.14.6
+Requires-Dist: streamlit>=1.52.2
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=7.0.0; extra == "dev"
+
+# Time Series Explorer (`tseda`)
+
+An application for time series exploration.
+
+## Overview
+
+`tseda` lets you explore regularly sampled time series with a sampling frequency of one hour or greater. It is currently limited to 2,000 samples (this is configurable).
+
+## Three-Step Exploration Workflow
+
+### (a) Initial Assessment
+
+Explore the distribution and spread of values using a kernel density estimate and box plot. You get to see the raw distribution of the values. The PACF and ACF provide clues about seasonality and autoregressive components.
+
+### (b) Decomposition Using Singular Spectral Analysis
+
+On the basis of the sampling frequency, a window for SSA is determined. This is a heuristic assignment. For example:
+
+| Sampling Frequency | Window Size |
+|--------------------|-------------|
+| Hourly             | 24          |
+| Monthly            | 12          |
+| Quarterly          | 4           |
+
+This can be changed in the UI. Based on the eigen value distribution, observations from the ACF plot and the eigen vector plot, the seasonal components can be determined if present. Based on these initial plots, the user needs to input a set of groupings and reconstruct the series with these groupings. The reconstruction plots are shown. If there is structure in the series, then change point analysis can be done using the fact that the components are smooth. A change point plot is shown. The explained variance from signal and noise components and the assessment of the noise structure (independent or correlated) is provided.
+
+### (c) Observation Logging
+
+The SSA is based on the eigen decomposition of the trajectory matrix. Though the raw signal is correlated, the eigenvectors are uncorrelated. If we assume that the signal is Gaussian, this also implies independence. We can use the Akaike Information Criterion for model selection and determine the AIC as a function of the rank of the model. This is shown in the observation page. An automatic summary of all the observations is provided.
+
+## Notebook Interface
+
+The package also provides a notebook interface to these features. If you have a new dataset that you want to analyze, look at the data loader directory for examples. Download your dataset, clean it, produce your time series, and analyze it with `tseda`.
+
+## Getting Started
+
+### 1. Install Dependencies
+
+Create and activate a virtual environment, then install the required packages:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate        # Windows: .venv\Scripts\activate
+pip install -r requirements.txt
+```
+
+Or, if you are using the package in editable/development mode:
+
+```bash
+pip install -e .
+```
+
+### 2. Run the App
+
+```bash
+python src/tseda/user_interface/ts_analyze_ui.py
+```
+
+The app will start a local web server. Open your browser and navigate to the URL printed in the terminal (typically `http://127.0.0.1:8050`).
+
+### 3. Upload Your Data
+
+- Click **"Drag and Drop or Select Files"** in the Initial Assessment panel.
+- Your file must be a **CSV or Excel** file with at least two columns: a **timestamp** column (first) and a **numeric value** column (second).
+- The data must be **regularly sampled at hourly or lower frequency** (e.g., hourly, daily, monthly).
+- The dataset must contain **no missing values** (NA / NaN). Clean your data before uploading.
+- Files are limited to **2,000 rows** (configurable via `MAX_FILE_LINES` in `ts_analyze_ui.py`).
+
+### 4. Explore in Three Steps
+
+| Step | Panel | What to do |
+|------|-------|------------|
+| 1 | **Initial Assessment of Time Series** | Review distribution plots (KDE, box plot) and the ACF / PACF for autocorrelation patterns. |
+| 2 | **Time Series Decomposition** | Review the eigenvalue plot, then enter component groupings (e.g., Trend, Seasonal, Noise) and click **Apply Grouping**. |
+| 3 | **Observation Logging** | Review the AIC rank diagnostics, read the auto-generated summary, and add your own observations before saving the report. |
+
+## Build And Publish With uv
+
+1. Build source and wheel distributions:
+
+```bash
+uv build
+```
+
+2. Validate distributions before upload:
+
+```bash
+uvx twine check dist/*
+```
+
+3. Publish to PyPI using an API token:
+
+```bash
+export UV_PUBLISH_TOKEN="pypi-..."
+uv publish
+```
+
+4. Publish to TestPyPI first (recommended):
+
+```bash
+export UV_PUBLISH_TOKEN="pypi-..."
+uv publish --publish-url https://test.pypi.org/legacy/
+```

tseda-0.1.0/README.md

@@ -0,0 +1,103 @@
+# Time Series Explorer (`tseda`)
+
+An application for time series exploration.
+
+## Overview
+
+`tseda` lets you explore regularly sampled time series with a sampling frequency of one hour or greater. It is currently limited to 2,000 samples (this is configurable).
+
+## Three-Step Exploration Workflow
+
+### (a) Initial Assessment
+
+Explore the distribution and spread of values using a kernel density estimate and box plot. You get to see the raw distribution of the values. The PACF and ACF provide clues about seasonality and autoregressive components.
+
+### (b) Decomposition Using Singular Spectral Analysis
+
+On the basis of the sampling frequency, a window for SSA is determined. This is a heuristic assignment. For example:
+
+| Sampling Frequency | Window Size |
+|--------------------|-------------|
+| Hourly             | 24          |
+| Monthly            | 12          |
+| Quarterly          | 4           |
+
+This can be changed in the UI. Based on the eigen value distribution, observations from the ACF plot and the eigen vector plot, the seasonal components can be determined if present. Based on these initial plots, the user needs to input a set of groupings and reconstruct the series with these groupings. The reconstruction plots are shown. If there is structure in the series, then change point analysis can be done using the fact that the components are smooth. A change point plot is shown. The explained variance from signal and noise components and the assessment of the noise structure (independent or correlated) is provided.
+
+### (c) Observation Logging
+
+The SSA is based on the eigen decomposition of the trajectory matrix. Though the raw signal is correlated, the eigenvectors are uncorrelated. If we assume that the signal is Gaussian, this also implies independence. We can use the Akaike Information Criterion for model selection and determine the AIC as a function of the rank of the model. This is shown in the observation page. An automatic summary of all the observations is provided.
+
+## Notebook Interface
+
+The package also provides a notebook interface to these features. If you have a new dataset that you want to analyze, look at the data loader directory for examples. Download your dataset, clean it, produce your time series, and analyze it with `tseda`.
+
+## Getting Started
+
+### 1. Install Dependencies
+
+Create and activate a virtual environment, then install the required packages:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate        # Windows: .venv\Scripts\activate
+pip install -r requirements.txt
+```
+
+Or, if you are using the package in editable/development mode:
+
+```bash
+pip install -e .
+```
+
+### 2. Run the App
+
+```bash
+python src/tseda/user_interface/ts_analyze_ui.py
+```
+
+The app will start a local web server. Open your browser and navigate to the URL printed in the terminal (typically `http://127.0.0.1:8050`).
+
+### 3. Upload Your Data
+
+- Click **"Drag and Drop or Select Files"** in the Initial Assessment panel.
+- Your file must be a **CSV or Excel** file with at least two columns: a **timestamp** column (first) and a **numeric value** column (second).
+- The data must be **regularly sampled at hourly or lower frequency** (e.g., hourly, daily, monthly).
+- The dataset must contain **no missing values** (NA / NaN). Clean your data before uploading.
+- Files are limited to **2,000 rows** (configurable via `MAX_FILE_LINES` in `ts_analyze_ui.py`).
+
+### 4. Explore in Three Steps
+
+| Step | Panel | What to do |
+|------|-------|------------|
+| 1 | **Initial Assessment of Time Series** | Review distribution plots (KDE, box plot) and the ACF / PACF for autocorrelation patterns. |
+| 2 | **Time Series Decomposition** | Review the eigenvalue plot, then enter component groupings (e.g., Trend, Seasonal, Noise) and click **Apply Grouping**. |
+| 3 | **Observation Logging** | Review the AIC rank diagnostics, read the auto-generated summary, and add your own observations before saving the report. |
+
+## Build And Publish With uv
+
+1. Build source and wheel distributions:
+
+```bash
+uv build
+```
+
+2. Validate distributions before upload:
+
+```bash
+uvx twine check dist/*
+```
+
+3. Publish to PyPI using an API token:
+
+```bash
+export UV_PUBLISH_TOKEN="pypi-..."
+uv publish
+```
+
+4. Publish to TestPyPI first (recommended):
+
+```bash
+export UV_PUBLISH_TOKEN="pypi-..."
+uv publish --publish-url https://test.pypi.org/legacy/
+```

tseda-0.1.0/pyproject.toml

@@ -0,0 +1,63 @@
+[project]
+name = "tseda"
+version = "0.1.0"
+description = "A package for exploration of regularly sampled time series."
+readme = "README.md"
+requires-python = ">=3.13"
+license = "LicenseRef-Proprietary"
+keywords = ["time-series", "ssa", "dash", "analytics", "decomposition"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Operating System :: OS Independent",
+  "Intended Audience :: Science/Research",
+  "Topic :: Scientific/Engineering :: Information Analysis",
+]
+dependencies = [
+    "dash>=4.1.0",
+    "dash-bootstrap-components>=2.0.4",
+    "google-genai>=1.56.0",
+    "importlib-resources>=6.5.2",
+    "ipython>=9.8.0",
+    "jupyter>=1.1.1",
+    "jupyter-ai>=2.31.7",
+    "jupyter-dash>=0.4.2",
+    "kaggle>=2.0.0",
+    "kdepy>=1.1.12",
+    "kmds>=0.3.1",
+    "matplotlib>=3.10.8",
+    "numpy>=2.4.0",
+    "pandas>=2.3.3",
+    "plotly>=6.5.0",
+    "python-dotenv>=1.2.1",
+    "req>=1.0.0",
+    "ruptures>=1.1.10",
+    "scikit-learn>=1.8.0",
+    "scipy<1.16.0",
+    "seaborn>=0.13.2",
+    "skrub>=0.7.2",
+    "ssalib>=0.1.3",
+    "statsmodels>=0.14.6",
+    "streamlit>=1.52.2",
+]
+
+  [project.optional-dependencies]
+  dev = [
+    "pytest>=8.0",
+    "pytest-cov>=7.0.0",
+  ]
+
+  [build-system]
+  requires = ["setuptools>=68", "wheel"]
+  build-backend = "setuptools.build_meta"
+
+
+  [tool.setuptools.packages.find]
+  where = ["src"]
+  include = ["tseda*"]
+
+  [tool.setuptools.package-data]
+  tseda = [
+    "config/*.csv",
+    "images/*",
+  ]

tseda-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tseda-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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)