make release-tag: Merge branch 'main' into stable

Author: amontanez24

HISTORY.md

@@ -1,5 +1,17 @@
 # History
 
+## v1.15.1 - 2025-04-02
+
+### Bugs Fixed
+
+* `learn_rounding_digits` should work for numerical data of `object` dtype - Issue [#972](https://github.com/sdv-dev/RDT/issues/972) by @fealho
+* `BaseTransformer.__repr__` errors if transformer has required arguments - Issue [#961](https://github.com/sdv-dev/RDT/issues/961) by @fealho
+* The `AnonymizedFaker` does not match cardinality across multiple applications of `reverse_transform` - Issue [#951](https://github.com/sdv-dev/RDT/issues/951) by @pvk-developer
+
+### Maintenance
+
+* All bump-version commands are failing - Issue [#974](https://github.com/sdv-dev/RDT/issues/974) by @amontanez24
+
 ## v1.15.0 - 2025-03-14
 
 ### New Features

latest_requirements.txt

@@ -1,4 +1,4 @@
-Faker==37.0.0
+Faker==37.1.0
 copulas==0.12.1
 numpy==2.0.2
 pandas==2.2.3

pyproject.toml

@@ -54,15 +54,14 @@ rdt = { main = 'rdt.cli.__main__:main' }
 
 [project.optional-dependencies]
 copulas = ['copulas>=0.12.1',]
-pyarrow = ['pyarrow>=17.0.0']
+pyarrow = ['pyarrow>=17.0.0',]
 test = [
     'rdt[pyarrow]',
     'rdt[copulas]',
 
     'pytest>=3.4.2',
     'pytest-cov>=2.6.0',
     'jupyter>=1.0.0,<2',
-    'rundoc>=0.4.3,<0.5',
     'pytest-subtests>=0.5,<1.0',
     'pytest-runner >= 2.11.1',
     'tomli>=2.0.0,<3',
@@ -72,15 +71,15 @@ dev = [
 
     # general
     'build>=1.0.0,<2',
-    'bump-my-version>=0.18.3,<1',
+    'bump-my-version>=0.18.3',
     'pip>=9.0.1',
     'watchdog>=1.0.1,<5',
 
     # style check
     'ruff>=0.3.2,<1',
 
     # distribute on PyPI
-    'twine>=1.10.0,<6',
+    'twine>=1.10.0',
     'wheel>=0.30.0',
 
     # Advanced testing
@@ -89,8 +88,9 @@ dev = [
     'tabulate>=0.8.9,<1',
 
     # Invoking test commands
-    'invoke'
+    'invoke',
 ]
+readme = ['rundoc>=0.4.3,<0.5',]
 
 [tool.setuptools]
 include-package-data = true
@@ -144,7 +144,7 @@ collect_ignore = ['pyproject.toml']
 exclude_lines = ['NotImplementedError()']
 
 [tool.bumpversion]
-current_version = "1.15.0"
+current_version = "1.15.1.dev1"
 parse = '(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(\.(?P<release>[a-z]+)(?P<candidate>\d+))?'
 serialize = [
     '{major}.{minor}.{patch}.{release}{candidate}',

rdt/__init__.py

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

rdt/transformers/base.py

@@ -327,19 +327,19 @@ def __repr__(self):
         custom_args = []
         args = inspect.getfullargspec(self.__init__)
         keys = args.args[1:]
-        defaults = args.defaults or []
-        defaults = dict(zip(keys, defaults))
         instanced = {
             key: getattr(self, key)
             for key in keys
             if key != 'model_missing_values' and hasattr(self, key)  # Remove after deprecation
         }
 
+        defaults = args.defaults or []
+        defaults = dict(zip(keys, defaults))
         if defaults == instanced:
             return f'{class_name}()'
 
         for arg, value in instanced.items():
-            if defaults[arg] != value:
+            if arg not in defaults or defaults[arg] != value:
                 custom_args.append(f'{arg}={repr(value)}')
 
         args_string = ', '.join(custom_args)

rdt/transformers/pii/anonymizer.py

@@ -155,6 +155,7 @@ def __init__(
 
         self.missing_value_generation = missing_value_generation
         self._nan_frequency = 0.0
+        self._unique_categories = None
 
     @classmethod
     def get_supported_sdtypes(cls):
@@ -192,11 +193,11 @@ def _function(self):
                 faker_attr = self.faker.unique
             else:
                 faker_attr = self.faker
+
         except AttributeError:
             faker_attr = self.faker.unique if self.enforce_uniqueness else self.faker
 
         result = getattr(faker_attr, self.function_name)(**self.function_kwargs)
-
         if isinstance(result, Iterable) and not isinstance(result, str):
             result = ', '.join(map(str, result))
 
@@ -236,39 +237,47 @@ def _get_unique_categories(self, samples):
 
     def _reverse_transform_cardinality_rule_match(self, sample_size):
         """Reverse transform the data when the cardinality rule is 'match'."""
-        reverse_transformed = np.array([], dtype=object)
-        if self.missing_value_generation == 'random':
-            num_nans = int(self._nan_frequency * sample_size)
-            reverse_transformed = np.concatenate([
-                reverse_transformed,
-                np.full(num_nans, np.nan),
-            ])
-        else:
-            num_nans = 0
+        num_nans = self._calculate_num_nans(sample_size)
+        reverse_transformed = self._generate_nans(num_nans)
 
         if sample_size <= num_nans:
             return reverse_transformed
 
-        if sample_size < num_nans + self._data_cardinality:
-            unique_categories = self._get_unique_categories(sample_size - num_nans)
-            reverse_transformed = np.concatenate([
-                reverse_transformed,
-                unique_categories,
-            ])
-        else:
-            unique_categories = self._get_unique_categories(self._data_cardinality)
-            num_copies = sample_size - self._data_cardinality - num_nans
-            copies = np.random.choice(unique_categories, num_copies)
-            reverse_transformed = np.concatenate([
-                reverse_transformed,
-                unique_categories,
-                copies,
-            ])
+        remaining_samples = sample_size - num_nans
+        sampled_values = self._generate_cardinality_match_values(remaining_samples)
 
+        reverse_transformed = np.concatenate([reverse_transformed, sampled_values])
         np.random.shuffle(reverse_transformed)
 
         return reverse_transformed
 
+    def _calculate_num_nans(self, sample_size):
+        """Calculate the number of NaN values to generate."""
+        if self.missing_value_generation == 'random':
+            return int(self._nan_frequency * sample_size)
+
+        return 0
+
+    def _generate_nans(self, num_nans):
+        """Generate an array of NaN values."""
+        return np.full(num_nans, np.nan, dtype=object)
+
+    def _generate_cardinality_match_values(self, remaining_samples):
+        """Generate sampled values while ensuring each unique category appears at least once."""
+        # Backwards compatibility requires us to generate the values at this point
+        if self._unique_categories is None:
+            self._unique_categories = self._get_unique_categories(self._data_cardinality)
+
+        unique_categories = np.array(self._unique_categories)
+        if remaining_samples <= len(unique_categories):
+            return np.random.choice(unique_categories, remaining_samples, replace=False)
+
+        # Ensure all unique categories appear at least once
+        extra_samples_needed = remaining_samples - len(unique_categories)
+        extra_samples = np.random.choice(unique_categories, extra_samples_needed, replace=True)
+
+        return np.concatenate((unique_categories, extra_samples))
+
     def _reverse_transform(self, data):
         """Generate new anonymized data using a ``faker.provider.function``.
 
@@ -328,6 +337,7 @@ def _set_fitted_parameters(self, column_name, nan_frequency=0.0, cardinality=Non
                 raise TransformerInputError(
                     'Cardinality "match" rule must specify a cardinality value.'
                 )
+
         self._data_cardinality = cardinality
         self._nan_frequency = nan_frequency
 

rdt/transformers/utils.py

@@ -15,7 +15,7 @@
 
 LOGGER = logging.getLogger(__name__)
 
-MAX_DECIMALS = sys.float_info.dig - 1
+MAX_DECIMALS = sys.float_info.dig
 DEPRECATED_SDTYPES_MAPPING = {'text': 'id'}
 
 
@@ -270,17 +270,19 @@ def learn_rounding_digits(data):
         data = data.to_numpy()
     roundable_data = data[~(np.isinf(data.astype(float)) | pd.isna(data))]
 
-    # Doesn't contain numbers
+    # Empty dataset
     if len(roundable_data) == 0:
         return None
 
-    # Doesn't contain decimal digits
-    if (roundable_data == roundable_data.astype(int)).all():
-        return 0
+    if roundable_data.dtype == 'object':
+        roundable_data = roundable_data.astype(float)
 
     # Try to round to fewer digits
-    if (roundable_data == roundable_data.round(MAX_DECIMALS)).all():
-        for decimal in range(MAX_DECIMALS + 1):
+    highest_int = int(np.max(np.abs(roundable_data)))
+    most_digits = len(str(highest_int)) if highest_int != 0 else 0
+    max_decimals = max(0, MAX_DECIMALS - most_digits)
+    if (roundable_data == roundable_data.round(max_decimals)).all():
+        for decimal in range(max_decimals + 1):
             if (roundable_data == roundable_data.round(decimal)).all():
                 return decimal
 

static_code_analysis.txt

@@ -1,10 +1,10 @@
-Run started:2025-03-13 20:46:37.629049
+Run started:2025-04-02 20:29:51.424416
 
 Test results:
 	No issues identified.
 
 Code scanned:
-	Total lines of code: 5864
+	Total lines of code: 5867
 	Total lines skipped (#nosec): 0
 	Total potential issues skipped due to specifically being disabled (e.g., #nosec BXXX): 0
 

tests/integration/transformers/pii/test_anonymizer.py

@@ -297,6 +297,30 @@ def test__reverse_transform_from_manually_set_parameters(self):
         # Assert
         assert missing_values / output.size == freq
 
+    def test_anonymized_faker_produces_only_n_values_for_each_reverse_transform_cardinality_match(
+        self,
+    ):
+        """Test `AnonymizedFaker` when `cardinality_rule` is set to `match`.
+
+        Ensure that the AnonymizedFaker transformer with `cardinality_rule='match'`
+        maintains the correct number of unique values across multiple `reverse_transform` calls.
+        """
+        # Setup
+        data = pd.DataFrame(data={'name': ['Amy'] * 10 + ['Bob'] * 20 + ['Carla'] * 50})
+        transformer = AnonymizedFaker(
+            provider_name='person', function_name='name', cardinality_rule='match'
+        )
+
+        # Run
+        transformed_data = transformer.fit_transform(data, 'name')
+        first_reverse_transformed = transformer.reverse_transform(transformed_data)
+
+        transformed_again = transformer.transform(first_reverse_transformed)
+        second_reverse_transformed = transformer.reverse_transform(transformed_again)
+
+        # Assert
+        assert set(first_reverse_transformed['name']) == set(second_reverse_transformed['name'])
+
 
 class TestPsuedoAnonymizedFaker:
     def test_default_settings(self):

tests/unit/transformers/pii/test_anonymizer.py

@@ -603,6 +603,7 @@ def test__reverse_transform_cardinality_rule_match_no_missing_value(self):
         instance = AnonymizedFaker(missing_value_generation=None)
         instance._data_cardinality = 2
         instance._nan_frequency = 0
+        instance._unique_categories = ['a', 'b', 'c']
         function = Mock()
         function.side_effect = ['a', 'b', 'c']
 
@@ -612,25 +613,22 @@ def test__reverse_transform_cardinality_rule_match_no_missing_value(self):
         result = instance._reverse_transform_cardinality_rule_match(3)
 
         # Assert
-        assert function.call_args_list == [call(), call()]
-        assert set(result).issubset({'a', 'b'})
+        assert set(result) == set(['a', 'b', 'c'])
 
     def test__reverse_transform_cardinality_rule_match_not_enough_unique(self):
         """Test it when there are not enough unique values."""
         # Setup
         instance = AnonymizedFaker()
-        instance._data_cardinality = 4
+        instance._data_cardinality = 3
         instance._nan_frequency = 0
         function = Mock()
         function.side_effect = ['a', 'b', 'c', 'd']
-
         instance._function = function
 
         # Run
-        result = instance._reverse_transform_cardinality_rule_match(3)
+        result = instance._reverse_transform_cardinality_rule_match(6)
 
         # Assert
-        assert function.call_args_list == [call(), call(), call()]
         assert set(result) == {'a', 'b', 'c'}
 
     def test__reverse_transform_cardinality_rule_missing_attribute(self):