rdt 1.14.0.dev0__tar.gz → 1.15.0.dev0__tar.gz

{rdt-1.14.0.dev0/rdt.egg-info → rdt-1.15.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rdt
-Version: 1.14.0.dev0
+Version: 1.15.0.dev0
 Summary: Reversible Data Transforms
 Author-email: "DataCebo, Inc." <info@sdv.dev>
 License: BSL-1.1
@@ -20,26 +20,31 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: <3.13,>=3.8
+Requires-Python: <3.14,>=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.21.0; python_version < "3.10"
 Requires-Dist: numpy>=1.23.3; python_version >= "3.10" and python_version < "3.12"
-Requires-Dist: numpy>=1.26.0; python_version >= "3.12"
+Requires-Dist: numpy>=1.26.0; python_version >= "3.12" and python_version < "3.13"
+Requires-Dist: numpy>=2.1.0; python_version >= "3.13"
 Requires-Dist: pandas>=1.4.0; python_version < "3.11"
 Requires-Dist: pandas>=1.5.0; python_version >= "3.11" and python_version < "3.12"
-Requires-Dist: pandas>=2.1.1; python_version >= "3.12"
+Requires-Dist: pandas>=2.1.1; python_version >= "3.12" and python_version < "3.13"
+Requires-Dist: pandas>=2.2.3; python_version >= "3.13"
 Requires-Dist: scipy>=1.7.3; python_version < "3.10"
 Requires-Dist: scipy>=1.9.2; python_version >= "3.10" and python_version < "3.12"
-Requires-Dist: scipy>=1.12.0; python_version >= "3.12"
+Requires-Dist: scipy>=1.12.0; python_version >= "3.12" and python_version < "3.13"
+Requires-Dist: scipy>=1.14.1; python_version >= "3.13"
 Requires-Dist: scikit-learn>=1.0.2; python_version < "3.10"
 Requires-Dist: scikit-learn>=1.1.0; python_version >= "3.10" and python_version < "3.11"
 Requires-Dist: scikit-learn>=1.1.3; python_version >= "3.11" and python_version < "3.12"
-Requires-Dist: scikit-learn>=1.3.1; python_version >= "3.12"
+Requires-Dist: scikit-learn>=1.3.1; python_version >= "3.12" and python_version < "3.13"
+Requires-Dist: scikit-learn>=1.5.2; python_version >= "3.13"
 Requires-Dist: Faker>=17
 Provides-Extra: copulas
-Requires-Dist: copulas>=0.12.0; extra == "copulas"
+Requires-Dist: copulas>=0.12.1; extra == "copulas"
 Provides-Extra: pyarrow
 Requires-Dist: pyarrow>=17.0.0; extra == "pyarrow"
 Provides-Extra: test

{rdt-1.14.0.dev0 → rdt-1.15.0.dev0}/pyproject.toml

@@ -13,27 +13,32 @@ classifiers = [
     'Programming Language :: Python :: 3.10',
     'Programming Language :: Python :: 3.11',
     'Programming Language :: Python :: 3.12',
+    'Programming Language :: Python :: 3.13',
     'Topic :: Scientific/Engineering :: Artificial Intelligence',
 ]
 keywords = ['machine learning', 'synthetic data generation', 'benchmark', 'generative models']
 dynamic = ['version']
 license = { text = 'BSL-1.1' }
-requires-python = '>=3.8,<3.13'
+requires-python = '>=3.8,<3.14'
 readme = 'README.md'
 dependencies = [
     "numpy>=1.21.0;python_version<'3.10'",
     "numpy>=1.23.3;python_version>='3.10' and python_version<'3.12'",
-    "numpy>=1.26.0;python_version>='3.12'",
+    "numpy>=1.26.0;python_version>='3.12' and python_version<'3.13'",
+    "numpy>=2.1.0;python_version>='3.13'",
     "pandas>=1.4.0;python_version<'3.11'",
     "pandas>=1.5.0;python_version>='3.11' and python_version<'3.12'",
-    "pandas>=2.1.1;python_version>='3.12'",
+    "pandas>=2.1.1;python_version>='3.12' and python_version<'3.13'",
+    "pandas>=2.2.3;python_version>='3.13'",
     "scipy>=1.7.3;python_version<'3.10'",
     "scipy>=1.9.2;python_version>='3.10' and python_version<'3.12'",
-    "scipy>=1.12.0;python_version>='3.12'",
+    "scipy>=1.12.0;python_version>='3.12' and python_version<'3.13'",
+    "scipy>=1.14.1;python_version>='3.13'",
     "scikit-learn>=1.0.2;python_version<'3.10'",
     "scikit-learn>=1.1.0;python_version>='3.10' and python_version<'3.11'",
     "scikit-learn>=1.1.3;python_version>='3.11' and python_version<'3.12'",
-    "scikit-learn>=1.3.1;python_version>='3.12'",
+    "scikit-learn>=1.3.1;python_version>='3.12' and python_version<'3.13'",
+    "scikit-learn>=1.5.2;python_version>='3.13'",
     'Faker>=17',
 ]
 
@@ -48,7 +53,7 @@ dependencies = [
 rdt = { main = 'rdt.cli.__main__:main' }
 
 [project.optional-dependencies]
-copulas = ['copulas>=0.12.0',]
+copulas = ['copulas>=0.12.1',]
 pyarrow = ['pyarrow>=17.0.0']
 test = [
     'rdt[pyarrow]',
@@ -139,7 +144,7 @@ collect_ignore = ['pyproject.toml']
 exclude_lines = ['NotImplementedError()']
 
 [tool.bumpversion]
-current_version = "1.14.0.dev0"
+current_version = "1.15.0.dev0"
 parse = '(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(\.(?P<release>[a-z]+)(?P<candidate>\d+))?'
 serialize = [
     '{major}.{minor}.{patch}.{release}{candidate}',

{rdt-1.14.0.dev0 → rdt-1.15.0.dev0}/rdt/__init__.py

@@ -4,7 +4,7 @@
 
 __author__ = 'DataCebo, Inc.'
 __email__ = 'info@sdv.dev'
-__version__ = '1.14.0.dev0'
+__version__ = '1.15.0.dev0'
 
 
 import sys

{rdt-1.14.0.dev0 → rdt-1.15.0.dev0}/rdt/transformers/__init__.py

@@ -28,6 +28,8 @@ from rdt.transformers.numerical import (
     ClusterBasedNormalizer,
     FloatFormatter,
     GaussianNormalizer,
+    LogScaler,
+    LogitScaler,
 )
 from rdt.transformers.pii.anonymizer import (
     AnonymizedFaker,
@@ -46,6 +48,7 @@ __all__ = [
     'FrequencyEncoder',
     'GaussianNormalizer',
     'LabelEncoder',
+    'LogScaler',
     'NullTransformer',
     'OneHotEncoder',
     'OptimizedTimestampEncoder',

{rdt-1.14.0.dev0 → rdt-1.15.0.dev0}/rdt/transformers/base.py

@@ -142,17 +142,6 @@ class BaseTransformer:
         elif model_missing_values is False:
             self._set_missing_value_generation('random')
 
-    def _set_missing_value_replacement(self, default, missing_value_replacement):
-        if missing_value_replacement is None:
-            warnings.warn(
-                "Setting 'missing_value_replacement' to 'None' is no longer supported. "
-                f"Imputing with the '{default}' instead.",
-                FutureWarning,
-            )
-            self.missing_value_replacement = default
-        else:
-            self.missing_value_replacement = missing_value_replacement
-
     @classmethod
     def get_name(cls):
         """Return transformer name.
@@ -478,7 +467,18 @@ class BaseTransformer:
 
         data = data.copy()
         columns_data = self._get_columns_data(data, self.output_columns)
+        original_missing_values = self.missing_value_generation
+        if self.missing_value_generation is not None and pd.isna(columns_data).any().any():
+            warnings.warn(
+                "The 'missing_value_generation' parameter is set to '"
+                f"{self.missing_value_generation}' but the data already contains missing values."
+                ' Missing value generation will be skipped.',
+                UserWarning,
+            )
+            self.missing_value_generation = None
+
         reversed_data = self._reverse_transform(columns_data)
+        self.missing_value_generation = original_missing_values
         data = data.drop(self.output_columns, axis=1)
         data = self._add_columns_to_data(data, reversed_data, self.columns)
 

{rdt-1.14.0.dev0 → rdt-1.15.0.dev0}/rdt/transformers/boolean.py

@@ -46,8 +46,8 @@ class BinaryEncoder(BaseTransformer):
         missing_value_generation='random',
     ):
         super().__init__()
+        self.missing_value_replacement = missing_value_replacement
         self._set_missing_value_generation(missing_value_generation)
-        self._set_missing_value_replacement('random', missing_value_replacement)
         if model_missing_values is not None:
             self._set_model_missing_values(model_missing_values)
 

{rdt-1.14.0.dev0 → rdt-1.15.0.dev0}/rdt/transformers/datetime.py

@@ -60,7 +60,7 @@ class UnixTimestampEncoder(BaseTransformer):
         enforce_min_max_values=False,
     ):
         super().__init__()
-        self._set_missing_value_replacement('mean', missing_value_replacement)
+        self.missing_value_replacement = missing_value_replacement
         self._set_missing_value_generation(missing_value_generation)
         self.enforce_min_max_values = enforce_min_max_values
         if model_missing_values is not None:
@@ -275,7 +275,7 @@ class OptimizedTimestampEncoder(UnixTimestampEncoder):
 
     def __init__(
         self,
-        missing_value_replacement=None,
+        missing_value_replacement='mean',
         model_missing_values=None,
         datetime_format=None,
         missing_value_generation='random',

{rdt-1.14.0.dev0 → rdt-1.15.0.dev0}/rdt/transformers/numerical.py

@@ -8,10 +8,10 @@ import numpy as np
 import pandas as pd
 import scipy
 
-from rdt.errors import TransformerInputError
+from rdt.errors import InvalidDataError, TransformerInputError
 from rdt.transformers.base import BaseTransformer
 from rdt.transformers.null import NullTransformer
-from rdt.transformers.utils import learn_rounding_digits
+from rdt.transformers.utils import learn_rounding_digits, logit, sigmoid
 
 EPSILON = np.finfo(np.float32).eps
 INTEGER_BOUNDS = {
@@ -87,7 +87,6 @@ class FloatFormatter(BaseTransformer):
         super().__init__()
         self.missing_value_replacement = missing_value_replacement
         self._set_missing_value_generation(missing_value_generation)
-        self._set_missing_value_replacement('mean', missing_value_replacement)
         if model_missing_values is not None:
             self._set_model_missing_values(model_missing_values)
 
@@ -626,3 +625,225 @@ class ClusterBasedNormalizer(FloatFormatter):
             recovered_data = np.stack([recovered_data, data[:, -1]], axis=1)  # noqa: PD013
 
         return super()._reverse_transform(recovered_data)
+
+
+class LogitScaler(FloatFormatter):
+    """Transformer for numerical data by applying a logit function.
+
+    This transformer works by replacing the values with a scaled
+    version and then applying a logit function. The reverse transform
+    applies a sigmoid to the data and then scales it back to the original space.
+
+    Null values are replaced using a ``NullTransformer``.
+
+    Args:
+        missing_value_replacement (object):
+            Indicate what to replace the null values with. If an integer or float is given,
+            replace them with the given value. If the strings ``'mean'`` or ``'mode'``
+            are given, replace them with the corresponding aggregation and if ``'random'``
+            replace each null value with a random value in the data range. Defaults to ``mean``.
+        missing_value_generation (str or None):
+            The way missing values are being handled. There are three strategies:
+
+                * ``random``: Randomly generates missing values based on the percentage of
+                  missing values.
+                * ``from_column``: Creates a binary column that describes whether the original
+                  value was missing. Then use it to recreate missing values.
+                * ``None``: Do nothing with the missing values on the reverse transform. Simply
+                  pass whatever data we get through.
+        min_value (float):
+            The min value for the logit function. Defaults to 0.
+        max_value (float):
+            max_value (float): The max value for the logit function. Defaults to 1.0.
+        learn_rounding_scheme (bool):
+            Whether or not to learn what place to round to based on the data seen during ``fit``.
+            If ``True``, the data returned by ``reverse_transform`` will be rounded to that place.
+            Defaults to ``False``.
+    """
+
+    def __init__(
+        self,
+        missing_value_replacement='mean',
+        missing_value_generation='random',
+        min_value=0.0,
+        max_value=1.0,
+        learn_rounding_scheme=False,
+    ):
+        if not (isinstance(min_value, int) or isinstance(min_value, float)) or not (
+            isinstance(max_value, int) or isinstance(max_value, float)
+        ):
+            error_msg = 'The min_value and max_value must be of type int or float.'
+            raise TransformerInputError(error_msg)
+        if min_value == max_value:
+            error_msg = 'The min_value and max_value for the logit function cannot be equal.'
+            raise TransformerInputError(error_msg)
+
+        super().__init__(
+            missing_value_replacement=missing_value_replacement,
+            missing_value_generation=missing_value_generation,
+            learn_rounding_scheme=learn_rounding_scheme,
+        )
+        self.min_value = min_value
+        self.max_value = max_value
+
+    def _validate_logit_inputs(self, data):
+        out_of_range_vals = data[(data < self.min_value) | (data > self.max_value)]
+        if len(out_of_range_vals) > 0:
+            num_vals_to_print = 5
+            out_of_range_vals = [str(x) for x in sorted(out_of_range_vals, key=lambda x: str(x))]
+            if len(out_of_range_vals) > 5:
+                extra_missing_vals = f'+ {len(out_of_range_vals) - num_vals_to_print} more'
+                out_of_range_vals = (
+                    f'[{", ".join(out_of_range_vals[:num_vals_to_print])} {extra_missing_vals}]'
+                )
+            else:
+                out_of_range_vals = f'[{", ".join(out_of_range_vals)}]'
+
+            raise InvalidDataError(
+                f"Unable to apply logit function to column '{self.columns[0]}' due to out of "
+                f'range values ({out_of_range_vals}).'
+            )
+
+    def _fit(self, data):
+        self._validate_logit_inputs(data)
+        return super()._fit(data)
+
+    def _transform(self, data):
+        transformed = super()._transform(data)
+        transformed_vals = transformed if transformed.ndim == 1 else transformed[:, 0]
+        self._validate_logit_inputs(transformed_vals)
+        logit_vals = logit(transformed_vals, self.min_value, self.max_value)
+        if transformed.ndim == 1:
+            return logit_vals
+
+        transformed[:, 0] = logit_vals
+        return transformed
+
+    def _reverse_transform(self, data):
+        if not isinstance(data, np.ndarray):
+            data = data.to_numpy()
+
+        sampled_vals = data if data.ndim == 1 else data[:, 0]
+        reversed_values = sigmoid(sampled_vals, self.min_value, self.max_value)
+        if data.ndim == 1:
+            return super()._reverse_transform(reversed_values)
+
+        data[:, 0] = reversed_values
+        return super()._reverse_transform(data)
+
+
+class LogScaler(FloatFormatter):
+    """Transformer for numerical data using log.
+
+    This transformer scales numerical values using log and an optional constant.
+    Null values are replaced using a ``NullTransformer``.
+
+    Args:
+        missing_value_replacement (object):
+            Indicate what to replace the null values with. If an integer or float is given,
+            replace them with the given value. If the strings ``'mean'`` or ``'mode'``
+            are given, replace them with the corresponding aggregation and if ``'random'``
+            replace each null value with a random value in the data range. Defaults to ``mean``.
+        missing_value_generation (str or None):
+            The way missing values are being handled. There are three strategies:
+                * ``random``: Randomly generates missing values based on the percentage of
+                  missing values.
+                * ``from_column``: Creates a binary column that describes whether the original
+                  value was missing. Then use it to recreate missing values.
+                * ``None``: Do nothing with the missing values on the reverse transform. Simply
+                  pass whatever data we get through.
+        constant (float):
+            The constant to set as the 0-value for the log-based transform. Defaults to 0
+            (do not modify the 0-value of the data).
+        invert (bool):
+            Whether to invert the data with respect to the constant value. If False, do not
+            invert the data (all values will be greater than the constant value). If True,
+            invert the data (all the values will be less than the constant value).
+            Defaults to False.
+        learn_rounding_scheme (bool):
+            Whether or not to learn what place to round to based on the data seen during ``fit``.
+            If ``True``, the data returned by ``reverse_transform`` will be rounded to that place.
+            Defaults to ``False``.
+    """
+
+    def __init__(
+        self,
+        missing_value_replacement='mean',
+        missing_value_generation='random',
+        constant: float = 0.0,
+        invert: bool = False,
+        learn_rounding_scheme: bool = False,
+    ):
+        if isinstance(constant, (int, float)):
+            self.constant = constant
+        else:
+            raise ValueError('The constant parameter must be a float or int.')
+        if isinstance(invert, bool):
+            self.invert = invert
+        else:
+            raise ValueError('The invert parameter must be a bool.')
+
+        super().__init__(
+            missing_value_replacement=missing_value_replacement,
+            missing_value_generation=missing_value_generation,
+            learn_rounding_scheme=learn_rounding_scheme,
+        )
+
+    def _validate_data(self, data: pd.Series):
+        column_name = self.get_input_column()
+        if self.invert:
+            if not all(data < self.constant):
+                raise InvalidDataError(
+                    f"Unable to apply a log transform to column '{column_name}' due to constant"
+                    ' being too small.'
+                )
+        else:
+            if not all(data > self.constant):
+                raise InvalidDataError(
+                    f"Unable to apply a log transform to column '{column_name}' due to constant"
+                    ' being too large.'
+                )
+
+    def _fit(self, data):
+        super()._fit(data)
+        data = super()._transform(data)
+
+        if data.ndim > 1:
+            self._validate_data(data[:, 0])
+        else:
+            self._validate_data(data)
+
+    def _log_transform(self, data):
+        self._validate_data(data)
+
+        if self.invert:
+            return np.log(self.constant - data)
+        else:
+            return np.log(data - self.constant)
+
+    def _transform(self, data):
+        data = super()._transform(data)
+
+        if data.ndim > 1:
+            data[:, 0] = self._log_transform(data[:, 0])
+        else:
+            data = self._log_transform(data)
+
+        return data
+
+    def _reverse_log(self, data):
+        if self.invert:
+            return self.constant - np.exp(data)
+        else:
+            return np.exp(data) + self.constant
+
+    def _reverse_transform(self, data):
+        if not isinstance(data, np.ndarray):
+            data = data.to_numpy()
+
+        if data.ndim > 1:
+            data[:, 0] = self._reverse_log(data[:, 0])
+        else:
+            data = self._reverse_log(data)
+
+        return super()._reverse_transform(data)

{rdt-1.14.0.dev0 → rdt-1.15.0.dev0}/rdt/transformers/utils.py

@@ -6,6 +6,7 @@ import string
 import sys
 import warnings
 from collections import defaultdict
+from decimal import Decimal
 
 import numpy as np
 import pandas as pd
@@ -126,6 +127,17 @@ def _from_generators(generators, max_repeat):
             yield ''.join(reversed(generated))
 
 
+def _cast_to_type(data, dtype):
+    if isinstance(data, pd.Series):
+        data = data.apply(dtype)
+    elif isinstance(data, (np.ndarray, list)):
+        data = np.array([dtype(value) for value in data])
+    else:
+        data = dtype(data)
+
+    return data
+
+
 def strings_from_regex(regex, max_repeat=16):
     """Generate strings that match the given regular expression.
 
@@ -280,6 +292,50 @@ def learn_rounding_digits(data):
     return None
 
 
+def logit(data, low, high):
+    """Apply a logit function to the data using ``low`` and ``high``.
+
+    Args:
+        data (pd.Series, pd.DataFrame, np.array, int, or float):
+            Data to apply the logit function to.
+        low (pd.Series, np.array, int, or float):
+            Low value/s to use when scaling.
+        high (pd.Series, np.array, int, or float):
+            High value/s to use when scaling.
+
+    Returns:
+        Logit scaled version of the input data.
+    """
+    data = (data - low) / (high - low)
+    data = _cast_to_type(data, Decimal)
+    data = data * Decimal(0.95) + Decimal(0.025)
+    data = _cast_to_type(data, float)
+    return np.log(data / (1.0 - data))
+
+
+def sigmoid(data, low, high):
+    """Apply a sigmoid function to the data using ``low`` and ``high``.
+
+    Args:
+        data (pd.Series, pd.DataFrame, np.array, int, float or datetime):
+            Data to apply the logit function to.
+        low (pd.Series, np.array, int, float or datetime):
+            Low value/s to use when scaling.
+        high (pd.Series, np.array, int, float or datetime):
+            High value/s to use when scaling.
+
+    Returns:
+        Sigmoid transform of the input data.
+    """
+    data = 1 / (1 + np.exp(-data))
+    data = _cast_to_type(data, Decimal)
+    data = (data - Decimal(0.025)) / Decimal(0.95)
+    data = _cast_to_type(data, float)
+    data = data * (high - low) + low
+
+    return data
+
+
 class WarnDict(dict):
     """Custom dictionary to raise a deprecation warning."""
 

{rdt-1.14.0.dev0 → rdt-1.15.0.dev0/rdt.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rdt
-Version: 1.14.0.dev0
+Version: 1.15.0.dev0
 Summary: Reversible Data Transforms
 Author-email: "DataCebo, Inc." <info@sdv.dev>
 License: BSL-1.1
@@ -20,26 +20,31 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: <3.13,>=3.8
+Requires-Python: <3.14,>=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.21.0; python_version < "3.10"
 Requires-Dist: numpy>=1.23.3; python_version >= "3.10" and python_version < "3.12"
-Requires-Dist: numpy>=1.26.0; python_version >= "3.12"
+Requires-Dist: numpy>=1.26.0; python_version >= "3.12" and python_version < "3.13"
+Requires-Dist: numpy>=2.1.0; python_version >= "3.13"
 Requires-Dist: pandas>=1.4.0; python_version < "3.11"
 Requires-Dist: pandas>=1.5.0; python_version >= "3.11" and python_version < "3.12"
-Requires-Dist: pandas>=2.1.1; python_version >= "3.12"
+Requires-Dist: pandas>=2.1.1; python_version >= "3.12" and python_version < "3.13"
+Requires-Dist: pandas>=2.2.3; python_version >= "3.13"
 Requires-Dist: scipy>=1.7.3; python_version < "3.10"
 Requires-Dist: scipy>=1.9.2; python_version >= "3.10" and python_version < "3.12"
-Requires-Dist: scipy>=1.12.0; python_version >= "3.12"
+Requires-Dist: scipy>=1.12.0; python_version >= "3.12" and python_version < "3.13"
+Requires-Dist: scipy>=1.14.1; python_version >= "3.13"
 Requires-Dist: scikit-learn>=1.0.2; python_version < "3.10"
 Requires-Dist: scikit-learn>=1.1.0; python_version >= "3.10" and python_version < "3.11"
 Requires-Dist: scikit-learn>=1.1.3; python_version >= "3.11" and python_version < "3.12"
-Requires-Dist: scikit-learn>=1.3.1; python_version >= "3.12"
+Requires-Dist: scikit-learn>=1.3.1; python_version >= "3.12" and python_version < "3.13"
+Requires-Dist: scikit-learn>=1.5.2; python_version >= "3.13"
 Requires-Dist: Faker>=17
 Provides-Extra: copulas
-Requires-Dist: copulas>=0.12.0; extra == "copulas"
+Requires-Dist: copulas>=0.12.1; extra == "copulas"
 Provides-Extra: pyarrow
 Requires-Dist: pyarrow>=17.0.0; extra == "pyarrow"
 Provides-Extra: test

{rdt-1.14.0.dev0 → rdt-1.15.0.dev0}/rdt.egg-info/requires.txt

@@ -19,14 +19,20 @@ scipy>=1.9.2
 pandas>=1.5.0
 scikit-learn>=1.1.3
 
-[:python_version >= "3.12"]
+[:python_version >= "3.12" and python_version < "3.13"]
 numpy>=1.26.0
 pandas>=2.1.1
 scipy>=1.12.0
 scikit-learn>=1.3.1
 
+[:python_version >= "3.13"]
+numpy>=2.1.0
+pandas>=2.2.3
+scipy>=1.14.1
+scikit-learn>=1.5.2
+
 [copulas]
-copulas>=0.12.0
+copulas>=0.12.1
 
 [dev]
 rdt[test]