mlreserving 0.3.0__tar.gz

mlreserving-0.3.0/LICENSE

@@ -0,0 +1,32 @@
+The Clear BSD License
+
+Copyright (c) [2025] [T. Moudiki]
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted (subject to the limitations in the disclaimer
+below) provided that the following conditions are met:
+
+     * Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+
+     * Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+
+     * Neither the name of the copyright holder nor the names of its
+     contributors may be used to endorse or promote products derived from this
+     software without specific prior written permission.
+
+NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY
+THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

mlreserving-0.3.0/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: mlreserving
+Version: 0.3.0
+Summary: Model-agnostic Probabilistic Machine Learning Reserving
+Home-page: https://github.com/Techtonique/mlreserving
+Author: T. Moudiki
+Author-email: "T. Moudiki" <thierry.moudiki@gmail.com>
+Project-URL: Repository, https://github.com/Techtonique/mlreserving
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: nnetsauce>=0.17.0
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: scikit-learn>=1.0.0
+Requires-Dist: joblib>=1.1.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# MLReserving
+
+A machine learning-based reserving model for (longitudinal data) insurance claims.
+
+## Installation
+
+```bash
+pip install mlreserving
+```
+
+## Usage
+
+```python
+from mlreserving import MLReserving
+import pandas as pd
+
+# Create your triangle data
+# Load the dataset
+url = "https://raw.githubusercontent.com/Techtonique/datasets/refs/heads/main/tabular/triangle/raa.csv"
+data = pd.read_csv(url)
+
+# Initialize and fit the model
+model = MLReserving(model=mdl,
+                    level=80,  # 80% confidence level
+                    random_state=42)
+model.fit(data)
+
+# Make predictions
+result = model.predict()
+
+# Get IBNR, latest, and ultimate values
+ibnr = model.get_ibnr()
+latest = model.get_latest()
+ultimate = model.get_ultimate()
+```
+
+## Features
+
+- Machine learning based reserving model
+- Support for prediction intervals
+- Flexible model selection
+- Handles both continuous and categorical features
+
+## License
+
+BSD Clause Clear License

mlreserving-0.3.0/README.md

@@ -0,0 +1,46 @@
+# MLReserving
+
+A machine learning-based reserving model for (longitudinal data) insurance claims.
+
+## Installation
+
+```bash
+pip install mlreserving
+```
+
+## Usage
+
+```python
+from mlreserving import MLReserving
+import pandas as pd
+
+# Create your triangle data
+# Load the dataset
+url = "https://raw.githubusercontent.com/Techtonique/datasets/refs/heads/main/tabular/triangle/raa.csv"
+data = pd.read_csv(url)
+
+# Initialize and fit the model
+model = MLReserving(model=mdl,
+                    level=80,  # 80% confidence level
+                    random_state=42)
+model.fit(data)
+
+# Make predictions
+result = model.predict()
+
+# Get IBNR, latest, and ultimate values
+ibnr = model.get_ibnr()
+latest = model.get_latest()
+ultimate = model.get_ultimate()
+```
+
+## Features
+
+- Machine learning based reserving model
+- Support for prediction intervals
+- Flexible model selection
+- Handles both continuous and categorical features
+
+## License
+
+BSD Clause Clear License

mlreserving-0.3.0/mlreserving/__init__.py

@@ -0,0 +1,13 @@
+"""
+Machine learning based (longitudinal) reserving model
+"""
+
+__version__ = "0.2.0"
+
+# Import main classes/functions that should be available at package level
+# from .module_name import ClassName, function_name 
+
+from .ml_reserving import MLReserving
+from .utils import triangle_to_df, df_to_triangle 
+
+__all__ = ["MLReserving", "triangle_to_df", "df_to_triangle", "__version__"] 

mlreserving-0.3.0/mlreserving/ml_reserving.py

@@ -0,0 +1,381 @@
+"""
+Main implementation of machine learning reserving
+"""
+
+import pandas as pd
+import numpy as np
+from collections import namedtuple
+from copy import deepcopy
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.linear_model import RidgeCV
+from sklearn.preprocessing import StandardScaler, OneHotEncoder
+from nnetsauce import PredictionInterval
+from .utils import df_to_triangle, triangle_to_df
+
+
+def arcsinh(x):
+    """Arcsinh transformation with offset for zero values"""
+    return np.arcsinh(x + 1)
+
+def inv_arcsinh(x):
+    """Inverse arcsinh transformation with offset"""
+    return np.sinh(x) - 1
+
+class MLReserving:
+    """
+    Machine learning based reserving model
+    
+    Parameters
+    ----------
+    model : object, optional
+        model to use (must implement fit and predict methods), default is RidgeCV
+    level: a float;
+        Confidence level for prediction intervals. Default is 95,
+        equivalent to a miscoverage error of 5 (%)
+    replications: an integer;
+        Number of replications for simulated conformal (default is `None`),
+        for type_pi = "bootstrap" or "kde"
+    conformal_method: a string
+        conformal prediction method "splitconformal" or "localconformal"
+    type_pi: a string;
+        type of prediction interval: currently `None`
+        split conformal prediction without simulation, "kde" or "bootstrap"
+    use_factors : bool, default=False
+        Whether to treat origin and development years as categorical variables
+    random_state : int, default=42
+        Random state for reproducibility
+    """
+    
+    def __init__(self, 
+                 model=None, 
+                 level=95,
+                 replications=None,
+                 conformal_method="splitconformal",
+                 type_pi=None,
+                 use_factors=False,
+                 random_state=42):
+        if model is None:
+            model = RidgeCV(alphas=[10**i for i in range(-5, 5)])
+        assert conformal_method in ("splitconformal", "localconformal"),\
+              "must have conformal_method in ('splitconformal', 'localconformal')"    
+        self.conformal_method = conformal_method
+        self.model = PredictionInterval(model, level=level, 
+                                        type_pi=type_pi, 
+                                        type_split="sequential",
+                                        method=conformal_method,
+                                        replications=replications)
+        self.level = level 
+        self.replications = replications
+        self.type_pi = type_pi 
+        self.use_factors = use_factors
+        self.origin_col = None
+        self.development_col = None
+        self.value_col = None
+        self.max_dev = None
+        self.origin_years = None
+        self.cumulated = None 
+        self.latest_ = None
+        self.ultimate_ = None
+        self.ultimate_lower_ = None
+        self.ultimate_upper_ = None
+        self.ibnr_mean_ = None
+        self.ibnr_lower_ = None
+        self.ibnr_upper_ = None
+        self.X_test_ = None 
+        self.full_data_ = None 
+        self.full_data_upper_ = None 
+        self.full_data_lower_ = None 
+        self.full_data_sims_ = []
+        self.scaler = StandardScaler()
+        self.origin_encoder = OneHotEncoder(sparse_output=False, handle_unknown='ignore')
+        self.dev_encoder = OneHotEncoder(sparse_output=False, handle_unknown='ignore')
+        
+    def fit(self, data, origin_col="origin", 
+            development_col="development", 
+            value_col="values", 
+            cumulated=True):
+        """
+        Fit the model to the triangle data
+        
+        Parameters
+        ----------
+        data : pandas.DataFrame
+            Input data with origin, development, and value columns
+        origin_col : str, default="origin"
+            Name of the origin year column
+        development_col : str, default="development"
+            Name of the development year column
+        value_col : str, default="values"
+            Name of the value column
+        cumulated: bool, default=True
+            If the triangle is cumulated
+            
+        Returns
+        -------
+        self : object
+            Returns self
+        """
+        # Store column names
+        self.origin_col = origin_col
+        self.development_col = development_col
+        self.value_col = value_col
+        self.cumulated = cumulated
+        
+        df = data.copy()
+        df["dev"] = df[development_col] - df[origin_col] + 1
+        df["calendar"] = df[origin_col] + df["dev"] - 1
+        df = df.sort_values([origin_col, "dev"])
+
+        # If data is cumulated, convert to incremental first
+        if self.cumulated:
+            # Calculate incremental values
+            df[value_col] = df.groupby(origin_col)[value_col].diff().fillna(method='bfill')
+
+        self.max_dev = df["dev"].max()
+        self.origin_years = df[origin_col].unique()
+        
+        # Create full grid of all possible combinations
+        full_grid = pd.MultiIndex.from_product(
+            [self.origin_years, range(1, self.max_dev + 1)],
+            names=[origin_col, "dev"]
+        ).to_frame(index=False)
+        
+        # Merge with original data
+        full_data = pd.merge(
+            full_grid, 
+            df[[origin_col, "dev", value_col]], 
+            on=[origin_col, "dev"], 
+            how="left"
+        )
+        
+        # Calculate calendar year
+        full_data["calendar"] = full_data[origin_col] + full_data["dev"] - 1
+        
+        # Calculate latest values for each origin year
+        self.latest_ = full_data.groupby(origin_col)[value_col].last()
+        
+        # Apply transformations
+        if self.use_factors:
+            # One-hot encode origin and development years
+            origin_encoded = self.origin_encoder.fit_transform(full_data[[origin_col]])
+            dev_encoded = self.dev_encoder.fit_transform(full_data[["dev"]])
+            
+            # Create feature names for the encoded columns
+            origin_feature_names = [f"origin_{year}" for year in self.origin_years]
+            dev_feature_names = [f"dev_{i}" for i in range(1, self.max_dev + 1)]
+            
+            # Add encoded features to the dataframe
+            full_data = pd.concat([
+                full_data,
+                pd.DataFrame(origin_encoded, columns=origin_feature_names, index=full_data.index),
+                pd.DataFrame(dev_encoded, columns=dev_feature_names, index=full_data.index)
+            ], axis=1)
+            
+            # Add calendar year as a feature
+            full_data["log_calendar"] = np.log(full_data["calendar"])
+            feature_cols = origin_feature_names + dev_feature_names + ["log_calendar"]
+        else:
+            # Use log transformations
+            full_data["log_origin"] = np.log(full_data[origin_col])
+            full_data["log_dev"] = np.log(full_data["dev"])
+            full_data["log_calendar"] = np.log(full_data["calendar"])
+            feature_cols = ["log_origin", "log_dev", "log_calendar"]
+        
+        # Transform response if not NaN
+        full_data[f"arcsinh_{value_col}"] = full_data[value_col].apply(
+            lambda x: arcsinh(x) if pd.notnull(x) else x
+        )
+        
+        full_data["to_predict"] = full_data[value_col].isna()
+
+        self.full_data_ = deepcopy(full_data)
+        self.full_data_lower_ = deepcopy(full_data)
+        self.full_data_upper_ = deepcopy(full_data)
+        
+        train_data = full_data[~full_data["to_predict"]]
+        test_data = full_data[full_data["to_predict"]]
+        
+        # Prepare features for training
+        X_train = train_data[feature_cols].values
+        X_test = test_data[feature_cols].values
+        
+        # Scale features
+        X_train_scaled = self.scaler.fit_transform(X_train)
+        self.X_test_ = self.scaler.transform(X_test)
+        
+        y_train = train_data[f"arcsinh_{value_col}"].values
+
+        self.model.fit(X_train_scaled, y_train)
+        
+        return self
+    
+    def predict(self):
+        """
+        Make predictions for the missing values in the triangle
+        
+        Returns
+        -------
+        DescribeResult
+            Named tuple containing mean, lower, and upper triangles
+        """
+        preds = self.model.predict(self.X_test_, return_pi=True)            
+        
+        to_predict = self.full_data_["to_predict"]        
+
+        # Transform predictions back to original scale
+        mean_pred = inv_arcsinh(preds.mean)
+        lower_pred = inv_arcsinh(preds.lower)
+        upper_pred = inv_arcsinh(preds.upper)
+        
+        # Store predictions in the full data
+        self.full_data_.loc[to_predict, self.value_col] = mean_pred
+        self.full_data_lower_.loc[to_predict, self.value_col] = lower_pred
+        self.full_data_upper_.loc[to_predict, self.value_col] = upper_pred
+
+        # Calculate IBNR based on predicted values (in incremental form)
+        test_data = self.full_data_[to_predict]
+        
+        # Group by origin year and sum predictions
+        self.ibnr_mean_ = test_data.groupby(self.origin_col)[self.value_col].sum()
+        self.ibnr_lower_ = self.full_data_lower_[to_predict].groupby(self.origin_col)[self.value_col].sum()
+        self.ibnr_upper_ = self.full_data_upper_[to_predict].groupby(self.origin_col)[self.value_col].sum()
+
+        # If data was originally cumulated, convert predictions back to cumulative
+        if self.cumulated:
+            for df in [self.full_data_, self.full_data_lower_, self.full_data_upper_]:
+                # Calculate cumulative values
+                df[self.value_col] = df.groupby(self.origin_col)[self.value_col].cumsum()
+
+        # Calculate triangles using utility function
+        mean_triangle = df_to_triangle(
+            self.full_data_,
+            origin_col=self.origin_col,
+            development_col="dev",
+            value_col=self.value_col
+        )
+        lower_triangle = df_to_triangle(
+            self.full_data_lower_,
+            origin_col=self.origin_col,
+            development_col="dev",
+            value_col=self.value_col
+        )
+        upper_triangle = df_to_triangle(
+            self.full_data_upper_,
+            origin_col=self.origin_col,
+            development_col="dev",
+            value_col=self.value_col
+        )
+
+        # Calculate ultimate values
+        if self.cumulated:
+            # For cumulative data, ultimate is the last value in each origin year
+            self.ultimate_ = self.full_data_.groupby(self.origin_col)[self.value_col].last()
+            self.ultimate_lower_ = self.full_data_lower_.groupby(self.origin_col)[self.value_col].last()
+            self.ultimate_upper_ = self.full_data_upper_.groupby(self.origin_col)[self.value_col].last()
+        else:
+            # For incremental data, ultimate is latest + IBNR
+            self.ultimate_ = self.latest_ + self.ibnr_mean_
+            self.ultimate_lower_ = self.latest_ + self.ibnr_lower_
+            self.ultimate_upper_ = self.latest_ + self.ibnr_upper_
+
+        DescribeResult = namedtuple("DescribeResult", 
+                                    ("mean", "lower", "upper"))
+        return DescribeResult(mean_triangle.T, 
+                                lower_triangle.T, 
+                                upper_triangle.T)
+            
+    def get_ibnr(self):
+        """
+        Get the IBNR (Incurred But Not Reported) values for each origin year
+        
+        Returns
+        -------
+        pandas.DataFrame
+            IBNR values (mean, lower, upper) indexed by origin year
+        """
+        if self.ibnr_mean_ is None:
+            raise ValueError("Model must be fitted and predict() must be called before getting IBNR values")
+
+        DescribeResult = namedtuple("DescribeResult", 
+                                    ("mean", "lower", "upper")) 
+           
+        return DescribeResult(self.ibnr_mean_, self.ibnr_lower_, self.ibnr_upper_)
+        
+    def get_latest(self):
+        """
+        Get the latest known values for each origin year
+        
+        Returns
+        -------
+        pandas.Series
+            Latest known values indexed by origin year
+        """
+        if self.latest_ is None:
+            raise ValueError("Model must be fitted before getting latest values")
+        return self.latest_
+        
+    def get_ultimate(self):
+        """
+        Get the ultimate loss estimates for each origin year
+        
+        Returns
+        -------
+        pandas.DataFrame
+            Ultimate loss estimates (mean, lower, upper) indexed by origin year
+        """
+        if self.ultimate_ is None:
+            raise ValueError("Model must be fitted before getting ultimate values")
+    
+        DescribeResult = namedtuple("DescribeResult", 
+                                      ("mean", "lower", "upper"))   
+                     
+        return DescribeResult(self.ultimate_,
+                              self.ultimate_lower_,
+                              self.ultimate_upper_)
+
+    def get_summary(self):
+        """
+        Get a summary of reserving results including latest values, ultimate estimates,
+        and IBNR values with confidence intervals.
+        
+        Returns
+        -------
+        dict
+            Dictionary containing two keys:
+            - 'ByOrigin': DataFrame with results by origin year
+            - 'Totals': Series with total values
+        """
+        if self.ultimate_ is None:
+            raise ValueError("Model must be fitted before getting summary")
+
+        # Get latest values
+        latest = self.get_latest()
+        
+        # Get ultimate values
+        ultimate = self.get_ultimate()
+        
+        # Get IBNR values
+        ibnr = self.get_ibnr()
+        
+        # Create summary by origin
+        summary_by_origin = pd.DataFrame({
+            'Latest': latest,
+            'Mean Ultimate': ultimate.mean,
+            'Mean IBNR': ibnr.mean,
+            f'IBNR {self.level}%': ibnr.upper,
+            f'Ultimate Lo{self.level}': ultimate.lower,
+            f'Ultimate Hi{self.level}': ultimate.upper
+        })
+        
+        # Calculate totals
+        totals = pd.Series({
+            'Latest': latest.sum(),
+            'Mean Ultimate': ultimate.mean.sum(),
+            'Mean IBNR': ibnr.mean.sum(),
+            f'Total IBNR {self.level}%': ibnr.upper.sum()
+        })
+        
+        return {
+            'ByOrigin': summary_by_origin,
+            'Totals': totals
+        }

mlreserving-0.3.0/mlreserving/utils.py

@@ -0,0 +1,89 @@
+"""
+Utility functions for mlreserving package
+"""
+
+import pandas as pd
+import numpy as np
+
+
+def df_to_triangle(df, origin_col="origin", development_col="development", value_col="values"):
+    """
+    Convert a data frame with origin, development, and value columns into a triangle format
+    
+    Parameters
+    ----------
+    df : pandas.DataFrame
+        Input data with origin, development, and value columns
+    origin_col : str, default="origin"
+        Name of the origin year column
+    development_col : str, default="development"
+        Name of the development year column
+    value_col : str, default="values"
+        Name of the value column
+        
+    Returns
+    -------
+    pandas.DataFrame
+        Triangle format with origin years as index and development years as columns
+    """
+    # Calculate development lag and calendar year
+    df = df.copy()
+    
+    # If development_col is not 'dev', calculate it
+    if development_col != "dev":
+        df["dev"] = df[development_col] - df[origin_col] + 1
+    
+    df["calendar"] = df[origin_col] + df["dev"] - 1
+    
+    # Create triangle
+    triangle = df.pivot(
+        index=origin_col,
+        columns="dev",
+        values=value_col
+    ).sort_index()
+    
+    return triangle
+
+def triangle_to_df(triangle, origin_col="origin", 
+                   development_col="development", 
+                   value_col="values"):
+    """
+    Convert a triangle format into a data frame with origin, development, and value columns
+    
+    Parameters
+    ----------
+    triangle : pandas.DataFrame
+        Triangle format with origin years as index and development years as columns
+    origin_col : str, default="origin"
+        Name of the origin year column
+    development_col : str, default="development"
+        Name of the development year column
+    value_col : str, default="values"
+        Name of the value column
+        
+    Returns
+    -------
+    pandas.DataFrame
+        Data frame with origin, development, and value columns
+    """
+    # Reset index to get origin years as a column
+    df = triangle.reset_index()
+    
+    # Melt the development columns into rows
+    df = pd.melt(
+        df,
+        id_vars=[origin_col],
+        var_name="dev",
+        value_name=value_col
+    )
+    
+    # Calculate development year and calendar year
+    df[development_col] = df[origin_col] + df["dev"] - 1
+    df["calendar"] = df[origin_col] + df["dev"] - 1
+    
+    # Reorder columns and sort by calendar year
+    df = df[[origin_col, development_col, "dev", "calendar", value_col]]
+
+    df.sort_values("calendar", inplace=True)
+    
+    return df

mlreserving-0.3.0/mlreserving.egg-info/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: mlreserving
+Version: 0.3.0
+Summary: Model-agnostic Probabilistic Machine Learning Reserving
+Home-page: https://github.com/Techtonique/mlreserving
+Author: T. Moudiki
+Author-email: "T. Moudiki" <thierry.moudiki@gmail.com>
+Project-URL: Repository, https://github.com/Techtonique/mlreserving
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: nnetsauce>=0.17.0
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: scikit-learn>=1.0.0
+Requires-Dist: joblib>=1.1.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# MLReserving
+
+A machine learning-based reserving model for (longitudinal data) insurance claims.
+
+## Installation
+
+```bash
+pip install mlreserving
+```
+
+## Usage
+
+```python
+from mlreserving import MLReserving
+import pandas as pd
+
+# Create your triangle data
+# Load the dataset
+url = "https://raw.githubusercontent.com/Techtonique/datasets/refs/heads/main/tabular/triangle/raa.csv"
+data = pd.read_csv(url)
+
+# Initialize and fit the model
+model = MLReserving(model=mdl,
+                    level=80,  # 80% confidence level
+                    random_state=42)
+model.fit(data)
+
+# Make predictions
+result = model.predict()
+
+# Get IBNR, latest, and ultimate values
+ibnr = model.get_ibnr()
+latest = model.get_latest()
+ultimate = model.get_ultimate()
+```
+
+## Features
+
+- Machine learning based reserving model
+- Support for prediction intervals
+- Flexible model selection
+- Handles both continuous and categorical features
+
+## License
+
+BSD Clause Clear License

mlreserving-0.3.0/mlreserving.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+mlreserving/__init__.py
+mlreserving/ml_reserving.py
+mlreserving/utils.py
+mlreserving.egg-info/PKG-INFO
+mlreserving.egg-info/SOURCES.txt
+mlreserving.egg-info/dependency_links.txt
+mlreserving.egg-info/requires.txt
+mlreserving.egg-info/top_level.txt

mlreserving-0.3.0/mlreserving.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mlreserving-0.3.0/mlreserving.egg-info/requires.txt

@@ -0,0 +1,5 @@
+nnetsauce>=0.17.0
+numpy>=1.20.0
+pandas>=1.3.0
+scikit-learn>=1.0.0
+joblib>=1.1.0

mlreserving-0.3.0/mlreserving.egg-info/top_level.txt

@@ -0,0 +1 @@
+mlreserving

mlreserving-0.3.0/pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+name = "mlreserving"
+version = "0.3.0"
+description = "Model-agnostic Probabilistic Machine Learning Reserving"
+requires-python = ">=3.7"
+authors = [
+    {name = "T. Moudiki", email = "thierry.moudiki@gmail.com"},
+]
+dependencies = [
+    "nnetsauce>=0.17.0",
+    "numpy>=1.20.0",
+    "pandas>=1.3.0",
+    "scikit-learn>=1.0.0",
+    "joblib>=1.1.0"
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: BSD License",
+    "Operating System :: OS Independent",
+]
+readme = "README.md"
+
+[project.urls]
+Repository = "https://github.com/Techtonique/mlreserving"
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["mlreserving"]
+
+[tool.setuptools.dynamic]
+version = {attr = "mlreserving.__version__"}
+
+[tool.setuptools.package-data]
+mlreserving = ["*.py"]

mlreserving-0.3.0/setup.cfg

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

mlreserving-0.3.0/setup.py

@@ -0,0 +1,33 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="mlreserving",
+    version="0.3.0",
+    packages=find_packages(),
+    install_requires=[
+        "nnetsauce",
+    ],
+    extras_require={
+        "dev": [
+            "pytest>=7.0.0",
+            "black>=22.0.0",
+            "flake8>=4.0.0",
+            "sphinx>=4.0.0",
+        ],
+    },
+    python_requires=">=3.7",
+    author="T. Moudiki",
+    author_email="thierry.moudiki@gmail.com",
+    description="Model-agnostic Probabilistic Machine Learning Reserving",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/Techtonique/mlreserving",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Science/Research",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    ],
+)