gensor 0.0.1__py3-none-any.whl

gensor/getters.py

@@ -0,0 +1,79 @@
+"""Fetching the data from various sources."""
+
+from pathlib import Path
+from typing import Literal
+
+from pandas import read_sql
+from sqlalchemy import MetaData, Table, select
+
+from .db.connection import DatabaseConnection
+from .dtypes import Dataset, Timeseries
+from .exceptions import NoFilesToLoad
+from .parse import parse_vanessen_csv
+
+
+def read_from_csv(path: Path, file_format: Literal["vanessen"] = "vanessen", **kwargs):
+    """Loads the data from the Van Essen CSV file(s) and returns a list of Timeseries objects.
+
+    Args:
+        path (Path): The path to the file or directory containing the files.
+        **kwargs (dict): Optional keyword arguments passed to `parse_vanessen_csv()` to specify the regex patterns for the serial number and station.
+            serial_number_pattern (str): The regex pattern to extract the serial number from the file.
+            location_pattern (str): The regex pattern to extract the station from the file.
+            col_names (list): The column names for the dataframe.
+    """
+
+    parsers = {
+        "vanessen": parse_vanessen_csv,
+    }
+
+    if not isinstance(path, Path):
+        message = "The path argument must be a Path object."
+        raise TypeError(message)
+
+    if path.is_dir() and not any(path.iterdir()):
+        raise NoFilesToLoad()
+
+    files = (
+        [file for file in path.iterdir() if file.is_file()] if path.is_dir() else [path]
+    )
+
+    parser = parsers[file_format]
+    ds = Dataset()
+    for f in files:
+        print(f"Loading file: {f}")
+        ts_in_file: list = parser(f, **kwargs)
+        ds.add(ts_in_file)
+
+    return ds
+
+
+def read_from_sql(
+    db: DatabaseConnection, location: str, sensor: str, variable: str, unit: str
+) -> list[Timeseries]:
+    """Returns the timeseries from a sql database.
+
+    Parameters:
+        db (DatabaseConnection): The database connection object
+        location (str): The station name
+        sensor (str): Sensor name
+        variable (str): The measurement type
+        unit (str): Unit of the measurement
+
+    """
+    metadata = MetaData()
+    schema = Table(f"{location}_{sensor}_{variable}", metadata)
+
+    query = select(schema)
+    df = read_sql(query, con=db.engine)
+
+    ts_object = Timeseries(
+        timeseries=df, variable=variable, location=location, sensor=sensor, unit=unit
+    )
+
+    return ts_object
+
+
+def read_from_api() -> Dataset:
+    """Fetch data from the API."""
+    return NotImplemented

gensor/parse/__init__.py

@@ -0,0 +1,3 @@
+from .vanessen import parse_vanessen_csv
+
+__all__ = ["parse_vanessen_csv"]

gensor/parse/vanessen.py

@@ -0,0 +1,125 @@
+"""Logic parsing CSV files from van Essen Instruments Divers."""
+
+import re
+from io import StringIO
+from pathlib import Path
+from typing import Any
+
+import chardet
+import pytz
+from pandas import DataFrame, read_csv, to_datetime
+
+from ..dtypes import Timeseries
+
+
+def detect_encoding(path: Path, num_bytes: int = 1024) -> str:
+    """Detect the encoding of a file using chardet.
+
+    Args:
+        path (Path): The path to the file.
+        num_bytes (int): Number of bytes to read for encoding detection (default is 1024).
+
+    Returns:
+        str: The detected encoding of the file.
+    """
+    with path.open("rb") as f:
+        raw_data = f.read(num_bytes)
+    result = chardet.detect(raw_data)
+    return result["encoding"] or "utf-8"
+
+
+def handle_timestamps(df: DataFrame, tz: str) -> DataFrame:
+    """Converts the timestamps in the dataframe to the specified timezone.
+
+    The timezone is obtained from the file metadata. If the timezone is UTC, the offset is extracted
+    and the timestamps are converted to the corresponding timezone. If the timezone is not UTC, the
+    timestamps are converted to UTC and then to the specified timezone.
+
+    Args:
+        df (pd.DataFrame): The dataframe with the data.
+        tz (str): The timezone string obtained from the file metadata.
+    """
+
+    if tz.startswith("UTC"):
+        offset_hours = int(tz[3:])
+        timezone = pytz.FixedOffset(offset_hours * 60)
+    else:
+        timezone = pytz.UTC
+
+    df.index = to_datetime(df.index).tz_localize("UTC").tz_convert(timezone)
+
+    return df
+
+
+def parse_vanessen_csv(path: Path, **kwargs) -> list[Any]:
+    """Parses a van Essen csv file and returns a list of Timeseries objects. At this point it
+    does not matter whether the file is a barometric or piezometric logger file.
+
+    The function will use regex patterns to extract the serial number and station from the file. It is
+    important to use the appropriate regex patterns, particularily for the station. If the default patterns
+    are not working (whihc most likely will be the case), the user should provide their own patterns. The patterns
+    can be provided as keyword arguments to the function and it is possible to use OR (|) in the regex pattern.
+
+    Args:
+        path (Path): The path to the file.
+        **kwargs (dict): Optional keyword arguments to specify the regex patterns for the serial number and station.
+            serial_number_pattern (str): The regex pattern to extract the serial number from the file.
+            location_pattern (str): The regex pattern to extract the station from the file.
+            col_names (list): The column names for the dataframe.
+
+    Returns:
+        list: A list of Timeseries objects.
+    """
+
+    data = {
+        "sensor": kwargs.get("serial_number_pattern", r"[A-Za-z]{2}\d{3,4}"),
+        "location": kwargs.get(
+            "location_pattern", r"[A-Za-z]{2}\d{2}[A-Za-z]{1}|Barodiver"
+        ),
+    }
+
+    column_names = kwargs.get("col_names", ["timestamp", "pressure", "temperature"])
+
+    encoding = detect_encoding(path, num_bytes=10_000)
+
+    with path.open(mode="r", encoding=encoding) as f:
+        text = f.read()
+
+        try:
+            data = {k: re.search(v, text).group() for k, v in data.items()}
+        except AttributeError:
+            print(
+                f"Skipping file {path} due to missing patterns. If this is not expected, please provide the correct patterns."
+            )
+            return []
+
+        data_io = StringIO(
+            text[
+                text.index("Date/time") : text.index(
+                    "END OF DATA FILE OF DATALOGGER FOR WINDOWS"
+                )
+            ]
+        )
+
+        df = read_csv(
+            data_io, skiprows=1, header=None, names=column_names, index_col="timestamp"
+        )
+
+        timezone_match = re.search(
+            kwargs.get("timezone_pattern", r"UTC[+-]?\d+"), text
+        ).group()
+
+        df = handle_timestamps(df, timezone_match)
+
+        ts_list = [
+            Timeseries(
+                ts=df[col],
+                variable=col,
+                location=data.get("location"),
+                sensor=data.get("sensor"),
+                unit="cmH2O" if col == "pressure" else "degC",
+            )
+            for col in df.columns
+        ]
+
+    return ts_list

gensor/preprocessing.py

@@ -0,0 +1,280 @@
+"""Class and methods for preprocessing groundwater level data."""
+
+from typing import Any, Literal
+
+import numpy as np
+from pandas import Series
+from scipy import stats
+from sklearn.ensemble import IsolationForest
+from sklearn.neighbors import LocalOutlierFactor
+from sklearn.preprocessing import (
+    MaxAbsScaler,
+    MinMaxScaler,
+    RobustScaler,
+    StandardScaler,
+)
+
+
+class Transform:
+    def __init__(
+        self,
+        data: Series,
+        method: Literal[
+            "difference",
+            "log",
+            "square_root",
+            "box_cox",
+            "standard_scaler",
+            "minmax_scaler",
+            "robust_scaler",
+            "maxabs_scaler",
+        ],
+        **kwargs: Any,
+    ) -> None:
+        self.data = data
+
+        if method == "difference":
+            self.transformed_data, self.scaler = self.difference(**kwargs)
+        elif method == "log":
+            self.transformed_data, self.scaler = self.log()
+        elif method == "square_root":
+            self.transformed_data, self.scaler = self.square_root()
+        elif method == "box_cox":
+            self.transformed_data, self.scaler = self.box_cox(**kwargs)
+        elif method == "standard_scaler":
+            self.transformed_data, self.scaler = self.standard_scaler()
+        elif method == "minmax_scaler":
+            self.transformed_data, self.scaler = self.minmax_scaler()
+        elif method == "robust_scaler":
+            self.transformed_data, self.scaler = self.robust_scaler()
+        elif method == "maxabs_scaler":
+            self.transformed_data, self.scaler = self.maxabs_scaler()
+        else:
+            raise NotImplementedError()
+
+    def get_transformation(self) -> tuple:
+        return self.transformed_data, self.scaler
+
+    def difference(self, **kwargs: int) -> tuple[Series, str]:
+        """Difference the time series data.
+
+        Args:
+            periods (int): The number of periods to shift. Defaults to 1.
+
+        Returns:
+            pandas.Series: The differenced time series data.
+        """
+        periods = kwargs.get("periods", 1)
+        transformed = self.data.diff(periods=periods).dropna()
+        return (transformed, "difference")
+
+    def log(self) -> tuple[Series, str]:
+        """Take the natural logarithm of the time series data.
+
+        Returns:
+            pandas.Series: The natural logarithm of the time series data.
+        """
+        transformed = self.data.apply(lambda x: x if x <= 0 else np.log(x))
+        return (transformed, "log")
+
+    def square_root(self) -> tuple[Series, str]:
+        """Take the square root of the time series data.
+
+        Returns:
+            pandas.Series: The square root of the time series data.
+        """
+        transformed = self.data.apply(lambda x: x if x <= 0 else np.sqrt(x))
+        return (transformed, "square_root")
+
+    def box_cox(self, **kwargs: float) -> tuple[Series, str]:
+        """Apply the Box-Cox transformation to the time series data. Only works
+            for all positive datasets!
+
+        Args:
+            lmbda (float): The transformation parameter. Defaults to 0.
+
+        Returns:
+            pandas.Series: The Box-Cox transformed time series data.
+        """
+
+        lmbda = kwargs.get("lmbda", None)
+
+        if (self.data <= 0).any():
+            message = (
+                "Box-Cox transformation requires all values to be strictly positive."
+            )
+            raise ValueError(message)
+
+        if not lmbda:
+            result = stats.boxcox(self.data, lmbda=lmbda)
+            transformed_series = Series(result, index=self.data.index)
+        else:
+            result = stats.boxcox(self.data, lmbda=lmbda)
+            transformed_series = Series(result[0], index=self.data.index)
+
+        return transformed_series, "box-cox"
+
+    def standard_scaler(self) -> tuple[Series, Any]:
+        """Normalize a pandas Series using StandardScaler."""
+        scaler = StandardScaler()
+        scaled_values = scaler.fit_transform(
+            self.data.to_numpy().reshape(-1, 1)
+        ).flatten()
+        scaled_series = Series(scaled_values, index=self.data.index)
+        return scaled_series, scaler
+
+    def minmax_scaler(self) -> tuple[Series, Any]:
+        """Normalize a pandas Series using MinMaxScaler."""
+        scaler = MinMaxScaler()
+        scaled_values = scaler.fit_transform(
+            self.data.to_numpy().reshape(-1, 1)
+        ).flatten()
+        scaled_series = Series(scaled_values, index=self.data.index)
+        return scaled_series, scaler
+
+    def robust_scaler(self) -> tuple[Series, Any]:
+        """Normalize a pandas Series using RobustScaler."""
+        scaler = RobustScaler()
+        scaled_values = scaler.fit_transform(
+            self.data.to_numpy().reshape(-1, 1)
+        ).flatten()
+        scaled_series = Series(scaled_values, index=self.data.index)
+        return scaled_series, scaler
+
+    def maxabs_scaler(self) -> tuple[Series, Any]:
+        """Normalize a pandas Series using MaxAbsScaler."""
+        scaler = MaxAbsScaler()
+        scaled_values = scaler.fit_transform(
+            self.data.to_numpy().reshape(-1, 1)
+        ).flatten()
+        scaled_series = Series(scaled_values, index=self.data.index)
+        return scaled_series, scaler
+
+
+class OutlierDetection:
+    """Class for detecting outliers in time series data."""
+
+    def __init__(
+        self,
+        data: Series,
+        method: Literal["iqr", "zscore", "isolation_forest", "lof"],
+        **kwargs: Any,
+    ) -> None:
+        """Find outliers in a time series using the specified method."""
+        if method == "iqr":
+            self.outliers = self.iqr(data, **kwargs)
+        elif method == "zscore":
+            self.outliers = self.zscore(data, **kwargs)
+        elif method == "isolation_forest":
+            self.outliers = self.isolation_forest(data, **kwargs)
+        elif method == "lof":
+            self.outliers = self.lof(data, **kwargs)
+        else:
+            raise NotImplementedError()
+
+    def iqr(self, data: Series, **kwargs: float) -> Series:
+        """Use interquartile range (IQR).
+
+        Parameters:
+            data (pandas.Series): The time series data.
+
+        Keyword Args:
+            k (float): The multiplier for the IQR to define the range. Defaults to 1.5.
+
+        Returns:
+            pandas.Series: Outliers detected in the data.
+        """
+
+        k: float = kwargs.get("k", 1.5)
+
+        Q1 = data.quantile(0.25)
+        Q3 = data.quantile(0.75)
+        IQR = Q3 - Q1
+
+        lower_bound = Q1 - k * IQR
+        upper_bound = Q3 + k * IQR
+
+        outliers = data[(data < lower_bound) | (data > upper_bound)]
+
+        return outliers
+
+    def zscore(self, data: Series, **kwargs: float) -> Series:
+        """Detect outliers in a time series using the z-score method.
+
+        Args:
+            data (pandas.Series): The time series data.
+
+        Keyword Args:
+            threshold (float): The threshold for the z-score method. Defaults to 3.0.
+
+        Returns:
+            pandas.Series: Outliers detected in the data.
+        """
+
+        threshold = kwargs.get("threshold", 3.0)
+
+        mean = data.mean()
+        std_dev = data.std()
+
+        outliers: Series = data[(data - mean).abs() > threshold * std_dev]
+
+        return outliers
+
+    def isolation_forest(self, data: Series, **kwargs: Any) -> Series:
+        """Detect outliers in a time series using the isolation forest method.
+
+        Args:
+            data (pandas.Series): The time series data.
+
+        Keyword Args:
+            n_estimators (int): The number of base estimators in the ensemble. Defaults to 100.
+            max_samples (int | 'auto' | float): The number of samples to draw from X to train each base estimator. Defaults to 'auto'.
+            contamination (float): The proportion of outliers in the data. Defaults to 0.01.
+            max_features (int | float): The number of features to draw from X to train each base estimator. Defaults to 1.0.
+            bootstrap (bool): Whether to use bootstrapping when sampling the data. Defaults to False.
+            n_jobs (int): The number of jobs to run in parallel. Defaults to 1.
+            random_state (int | RandomState | None): The random state to use. Defaults to None.
+            verbose (int): The verbosity level. Defaults to 0.
+            warm_start (bool): Whether to reuse the solution of the previous call to fit and add more estimators to the ensemble. Defaults to False.
+
+        Note:
+            For details on kwargs see: sklearn.ensemble.IsolationForest.
+        """
+
+        X = data.to_numpy().reshape(-1, 1)
+
+        clf = IsolationForest(**kwargs)
+        clf.fit(X)
+
+        is_outlier = clf.predict(X)
+        outliers: Series = data[is_outlier == -1]
+
+        return outliers
+
+    def lof(self, data: Series, **kwargs: Any) -> Series:
+        """Detect outliers in a time series using the local outlier factor (LOF) method.
+
+        Args:
+            data (pandas.Series): The time series data.
+
+        Keyword Args:
+            n_neighbors (int): The number of neighbors to consider for each sample. Defaults to 20.
+            algorithm (str): The algorithm to use. Either 'auto', 'ball_tree', 'kd_tree' or 'brute'. Defaults to 'auto'.
+            leaf_size (int): The leaf size of the tree. Defaults to 30.
+            metric (str): The distance metric to use. Defaults to 'minkowski'.
+            p (int): The power parameter for the Minkowski metric. Defaults to 2.
+            contamination (float): The proportion of outliers in the data. Defaults to 0.01.
+            novelty (bool): Whether to consider the samples as normal or outliers. Defaults to False.
+            n_jobs (int): The number of jobs to run in parallel. Defaults to 1.
+        Note:
+            For details on kwargs see: sklearn.neighbors.LocalOutlierFactor.
+        """
+
+        X = data.to_numpy().reshape(-1, 1)
+
+        clf = LocalOutlierFactor(**kwargs)
+
+        is_outlier = clf.fit_predict(X)
+        outliers: Series = data[is_outlier == -1]
+
+        return outliers

gensor/smoothing.py

@@ -0,0 +1,66 @@
+"""Tools for smoothing the data."""
+
+from matplotlib import pyplot as plt
+from pandas import Series
+from sklearn.metrics import mean_squared_error
+
+from .dtypes import Timeseries
+
+
+def smooth_data(
+    data: Timeseries,
+    window: int = 5,
+    method: str = "rolling_mean",
+    print_statistics: bool = False,
+    inplace: bool = False,
+    plot: bool = False,
+) -> Series | None:
+    """Smooth a time series using a rolling mean or median.
+
+    Args:
+        data (pandas.Series): The time series data.
+        window (int): The size of the window for the rolling mean or median. Defaults to 5.
+        method (str): The method to use for smoothing. Either 'rolling_mean' or 'rolling_median'. Defaults to 'rolling_mean'.
+
+    Returns:
+        pandas.Series: The smoothed time series.
+    """
+    if method == "rolling_mean":
+        smoothed_data = data.ts.rolling(window=window, center=True).mean()
+    elif method == "rolling_median":
+        smoothed_data = data.ts.rolling(window=window, center=True).median()
+    else:
+        raise NotImplementedError()
+
+    valid_indices = smoothed_data.notna()
+    original_data_aligned = data.ts[valid_indices]
+    smoothed_data_aligned = smoothed_data[valid_indices]
+
+    if print_statistics:
+        mse = mean_squared_error(original_data_aligned, smoothed_data_aligned)
+        print(f"Mean Squared Error of {method}: {mse:.2f}")
+
+    if plot:
+        plt.figure(figsize=(12, 6))
+        plt.plot(
+            data.timeseries.index, data.timeseries, label="Original Data", color="black"
+        )
+        plt.plot(
+            smoothed_data.index,
+            smoothed_data,
+            label=f"Moving Average ({method})",
+            color="green",
+            linestyle="dotted",
+        )
+
+        plt.legend()
+        plt.title("Groundwater Level with Moving Average")
+        plt.xlabel("Date")
+        plt.ylabel("Groundwater Level")
+        plt.show()
+
+    if inplace:
+        data.ts = smoothed_data
+        return None
+    else:
+        return smoothed_data

gensor/trend.py

@@ -0,0 +1,31 @@
+"""Analyse trends in the logger data."""
+
+import numpy as np
+from matplotlib import pyplot as plt
+
+from .dtypes import Timeseries
+
+
+def trend_analysis(ts: Timeseries, plot=True) -> None:
+    time_numeric = np.arange(len(ts.timeseries))
+
+    # Perform linear regression using numpy's polyfit
+    # This returns the slope and intercept of the best fit line
+    slope, intercept = np.polyfit(time_numeric, ts.timeseries, 1)
+
+    # Print the slope and intercept
+    print(f"Slope: {slope}, Intercept: {intercept}")
+
+    if plot:
+        # Compute the values of the trend line
+        trend_line = intercept + slope * time_numeric
+
+        # Plotting the original series and the trend line
+        plt.figure(figsize=(10, 5))
+        plt.plot(ts.timeseries.index, ts.timeseries, label="Original Data")
+        plt.plot(ts.timeseries.index, trend_line, color="red", label="Trend Line")
+        plt.xlabel("Time")
+        plt.ylabel("Groundwater Level")
+        plt.title("Groundwater Level Trend Analysis")
+        plt.legend()
+        plt.show()

gensor-0.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024, Mateusz Zawadzki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gensor-0.0.1.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.1
+Name: gensor
+Version: 0.0.1
+Summary: Library for handling groundwater sensor data.
+Home-page: https://github.com/zawadzkim/gensor
+Author: Mateusz Zawadzki
+Author-email: fzawadzkimat@outlook.com
+Requires-Python: >=3.11
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: chardet (>=5.2.0,<6.0.0)
+Requires-Dist: matplotlib (>=3.9.2,<4.0.0)
+Requires-Dist: numpy (>=2.1.0,<3.0.0)
+Requires-Dist: pandas (>=2.2.2,<3.0.0)
+Requires-Dist: pandera (>=0.20.3,<0.21.0)
+Requires-Dist: pydantic (>=2.8.2,<3.0.0)
+Requires-Dist: pytz (>=2024.1,<2025.0)
+Requires-Dist: scikit-learn (>=1.5.1,<2.0.0)
+Requires-Dist: scipy (>=1.14.1,<2.0.0)
+Requires-Dist: sqlalchemy (>=2.0.32,<3.0.0)
+Project-URL: Documentation, https://zawadzkim.github.io/gensor/
+Project-URL: Repository, https://github.com/zawadzkim/gensor
+Description-Content-Type: text/markdown
+
+# gensor
+
+[![Release](https://img.shields.io/github/v/release/zawadzkim/gensor)](https://img.shields.io/github/v/release/zawadzkim/gensor)
+[![Build status](https://img.shields.io/github/actions/workflow/status/zawadzkim/gensor/main.yml?branch=main)](https://github.com/zawadzkim/gensor/actions/workflows/main.yml?query=branch%3Amain)
+[![codecov](https://codecov.io/gh/zawadzkim/gensor/branch/main/graph/badge.svg)](https://codecov.io/gh/zawadzkim/gensor)
+[![Commit activity](https://img.shields.io/github/commit-activity/m/zawadzkim/gensor)](https://img.shields.io/github/commit-activity/m/zawadzkim/gensor)
+[![License](https://img.shields.io/github/license/zawadzkim/gensor)](https://img.shields.io/github/license/zawadzkim/gensor)
+
+Library for handling groundwater sensor data.
+
+- **Github repository**: <https://github.com/zawadzkim/gensor/>
+- **Documentation** <https://zawadzkim.github.io/gensor/>
+
+## Getting started with your project
+
+First, create a repository on GitHub with the same name as this project, and then run the following commands:
+
+```bash
+git init -b main
+git add .
+git commit -m "init commit"
+git remote add origin git@github.com:zawadzkim/gensor.git
+git push -u origin main
+```
+
+Finally, install the environment and the pre-commit hooks with
+
+```bash
+make install
+```
+
+You are now ready to start development on your project!
+The CI/CD pipeline will be triggered when you open a pull request, merge to main, or when you create a new release.
+
+To finalize the set-up for publishing to PyPi or Artifactory, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/publishing/#set-up-for-pypi).
+For activating the automatic documentation with MkDocs, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/mkdocs/#enabling-the-documentation-on-github).
+To enable the code coverage reports, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/codecov/).
+
+## Releasing a new version
+
+- Create an API Token on [Pypi](https://pypi.org/).
+- Add the API Token to your projects secrets with the name `PYPI_TOKEN` by visiting [this page](https://github.com/zawadzkim/gensor/settings/secrets/actions/new).
+- Create a [new release](https://github.com/zawadzkim/gensor/releases/new) on Github.
+- Create a new tag in the form `*.*.*`.
+- For more details, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/cicd/#how-to-trigger-a-release).
+
+---
+
+Repository initiated with [fpgmaas/cookiecutter-poetry](https://github.com/fpgmaas/cookiecutter-poetry).
+