Merge branch 'pr-2312'

Author: PR Eval

faker2/proxy.py

@@ -2,6 +2,7 @@
 
 import copy
 import functools
+import logging
 import re
 
 from collections import OrderedDict
@@ -19,10 +20,13 @@
 
 RetType = TypeVar("RetType")
 
+logger = logging.getLogger(__name__)
+
 
 class Faker:
     """Proxy class capable of supporting multiple locales"""
 
+    cache_attr_name = "_cached_{method_name}_mapping"
     cache_pattern: Pattern = re.compile(r"^_cached_\w*_mapping$")
     generator_attrs = [
         attr for attr in dir(Generator) if not attr.startswith("__") and attr not in ["seed", "seed_instance", "random"]
@@ -39,8 +43,6 @@ def __init__(
     ) -> None:
         self._factory_map: OrderedDict[str, Generator | Faker] = OrderedDict()
         self._weights = None
-        self._unique_proxy = UniqueProxy(self)
-        self._optional_proxy = OptionalProxy(self)
 
         if isinstance(locale, str):
             locales = [locale.replace("-", "_")]
@@ -146,21 +148,26 @@ def __deepcopy__(self, memodict):
         result._factory_map = copy.deepcopy(self._factory_map, memodict)
         result._factories = list(result._factory_map.values())
         result._weights = copy.deepcopy(self._weights, memodict)
-        result._unique_proxy = UniqueProxy(result)
-        result._unique_proxy._seen = {k: {result._unique_proxy._sentinel} for k in self._unique_proxy._seen.keys()}
-        result._optional_proxy = OptionalProxy(result)
+        result.unique._seen = {k: {result.unique._sentinel} for k in self.unique._seen.keys()}
+        result.preferred_unique._seen = {
+            k: {result.preferred_unique._sentinel} for k in self.preferred_unique._seen.keys()
+        }
         return result
 
     def __setstate__(self, state: Any) -> None:
         self.__dict__.update(state)
 
-    @property
+    @functools.cached_property
     def unique(self) -> UniqueProxy:
-        return self._unique_proxy
+        return UniqueProxy(self)
 
-    @property
+    @functools.cached_property
+    def preferred_unique(self) -> UniqueProxy:
+        return UniqueProxy(self, only_prefer_uniqueness=True)
+
+    @functools.cached_property
     def optional(self) -> OptionalProxy:
-        return self._optional_proxy
+        return OptionalProxy(self)
 
     def _select_factory(self, method_name: str) -> Factory:
         """
@@ -182,6 +189,7 @@ def _select_factory(self, method_name: str) -> Factory:
             factory = self._select_factory_distribution(factories, weights)
         else:
             factory = self._select_factory_choice(factories)
+
         return factory
 
     def _select_factory_distribution(self, factories, weights):
@@ -202,7 +210,7 @@ def _map_provider_method(self, method_name: str) -> tuple[list[Factory], list[fl
         """
 
         # Return cached mapping if it exists for given method
-        attr = f"_cached_{method_name}_mapping"
+        attr = self.cache_attr_name.format(method_name=method_name)
         if hasattr(self, attr):
             return getattr(self, attr)
 
@@ -299,11 +307,16 @@ def items(self) -> list[tuple[str, Generator | Faker]]:
 
 
 class UniqueProxy:
-    def __init__(self, proxy: Faker, excluded_types: tuple[type, ...] = ()):
+    def __init__(self, proxy: Faker, excluded_types: tuple[type, ...] = (), only_prefer_uniqueness: bool = False):
         self._proxy = proxy
         self._seen: dict = {}
         self._sentinel = object()
         self._excluded_types = excluded_types
+        self._only_prefer_uniqueness = only_prefer_uniqueness
+        # Round-robin state for ``current_*`` methods. Kept private to this
+        # proxy so that the factory mapping cached on the ``Faker`` proxy and
+        # shared with regular (non-unique) calls is never mutated.
+        self._current_factory_pool: dict = {}
 
     def clear(self) -> None:
         self._seen = {}
@@ -337,11 +350,13 @@ def __getitem__(self, locale: str) -> UniqueProxy:
         return unique_proxy
 
     def __getattr__(self, name: str) -> Any:
+        if name.startswith("current_"):
+            return self._select_current_factory_method(name)
+
         obj = getattr(self._proxy, name)
-        if callable(obj):
+        if callable(obj) and not name.startswith("__"):
             return self._wrap(name, obj)
-        else:
-            raise TypeError("Accessing non-functions through .unique is not supported.")
+        return obj
 
     def __getstate__(self):
         # Copy the object's state from self.__dict__ which contains
@@ -366,6 +381,9 @@ def _make_hashable(self, value: Any) -> Any:
     def _wrap(self, name: str, function: Callable) -> Callable:
         @functools.wraps(function)
         def wrapper(*args, **kwargs):
+            key = (name, args, tuple(sorted(kwargs.items())))
+            generated = self._seen.setdefault(key, {self._sentinel})
+
             # If types are excluded, call function once to check return type
             if self._excluded_types:
                 retval = function(*args, **kwargs)
@@ -375,8 +393,6 @@ def wrapper(*args, **kwargs):
                 # If not excluded, continue with normal uniqueness logic
                 # but we already have a value, so we'll use it if unique
                 hashable_retval = self._make_hashable(retval)
-                key = (name, args, tuple(sorted(kwargs.items())))
-                generated = self._seen.setdefault(key, {self._sentinel})
 
                 # Check if this first value is unique
                 if hashable_retval not in generated:
@@ -385,26 +401,66 @@ def wrapper(*args, **kwargs):
                 # Not unique, continue with normal loop below
             else:
                 # No exclusions, use original logic
-                key = (name, args, tuple(sorted(kwargs.items())))
-                generated = self._seen.setdefault(key, {self._sentinel})
                 retval = self._sentinel
                 hashable_retval = self._make_hashable(retval)
 
             # Original uniqueness logic (with potential first attempt already done)
-            for i in range(_UNIQUE_ATTEMPTS):
-                if hashable_retval not in generated:
+            for _ in range(_UNIQUE_ATTEMPTS):
+                if hashable_retval is None or hashable_retval not in generated:
                     break
                 retval = function(*args, **kwargs)
                 hashable_retval = self._make_hashable(retval)
             else:
-                raise UniquenessException(f"Got duplicated values after {_UNIQUE_ATTEMPTS:,} iterations.")
+                if self._only_prefer_uniqueness:
+                    logger.warning(
+                        f'There seem to be no more unique values for generator "{name}". '
+                        "Resetting store of generated values as uniqueness is not being enforced."
+                    )
+                    generated.clear()
+                else:
+                    raise UniquenessException(f"Got duplicated values after {_UNIQUE_ATTEMPTS:,} iterations.")
 
             generated.add(hashable_retval)
 
             return retval
 
         return wrapper
 
+    def _select_current_factory_method(self, name: str) -> Any:
+        """Round-robin through the factories supporting a ``current_*`` method.
+
+        The value of a ``current_*`` method is a property of its locale, so it
+        cannot be made unique by re-rolling it. Instead, draw factories without
+        replacement from a pool that is refilled once exhausted, so that
+        consecutive calls go through all possible provider options.
+
+        The pool is stored on this proxy: the factory mapping cached on the
+        ``Faker`` proxy is only ever read here, never mutated, so regular
+        (non-unique) calls keep access to every locale.
+        """
+        # No need to re-roll the factory list if only one is present
+        if len(getattr(self._proxy, "factories", [])) <= 1:
+            return getattr(self._proxy, name)
+
+        factories, weights = self._proxy._map_provider_method(name)
+        if not factories:
+            # Let the proxy raise the usual AttributeError
+            return getattr(self._proxy, name)
+
+        pool = self._current_factory_pool.setdefault(name, list(factories))
+        if weights:
+            pool_weights = [weights[factories.index(factory)] for factory in pool]
+            factory = choices_distribution(pool, pool_weights, self._proxy._factories[0].random, length=1)[0]
+        else:
+            factory = self._proxy._factories[0].random.choice(pool)
+
+        pool.remove(factory)
+        # Refill the pool once every factory has been used
+        if not pool:
+            self._current_factory_pool[name] = list(factories)
+
+        return getattr(factory, name)
+
 
 class OptionalProxy:
     """

tests/test_proxy.py

@@ -427,8 +427,6 @@ def test_dir_include_all_providers_attribute_in_list(self):
                 "_locales",
                 "_factory_map",
                 "_weights",
-                "_unique_proxy",
-                "_optional_proxy",
             ]
         )
         for factory in fake.factories:

tests/test_unique.py

@@ -1,8 +1,13 @@
+import logging
+
 import pytest
 
 from faker2 import Faker
+from faker2.config import AVAILABLE_LOCALES, DEFAULT_LOCALE
 from faker2.exceptions import UniquenessException
 
+LOGGER = logging.getLogger(__name__)
+
 
 class TestUniquenessClass:
     def test_uniqueness(self):
@@ -52,14 +57,13 @@ def test_exclusive_arguments(self):
         # this would throw a sanity exception
         fake.unique.random_int(min=2, max=10)
 
-    def test_functions_only(self):
+    def test_accessing_non_function(self):
         """Accessing non-functions through the `.unique` attribute
-        will throw a TypeError."""
+        is allowed."""
 
         fake = Faker()
 
-        with pytest.raises(TypeError, match="Accessing non-functions through .unique is not supported."):
-            fake.unique.locales
+        assert fake.unique.locales == [DEFAULT_LOCALE]
 
     def test_complex_return_types_is_supported(self):
         """The unique decorator supports complex return types
@@ -95,3 +99,63 @@ def test_unique_locale_access(self):
 
         with pytest.raises(UniquenessException, match=r"Got duplicated values after [\d,]+ iterations."):
             fake.unique["ja_JP"].random_int(min=1, max=10)
+
+    def test_preferred_uniqueness(self, caplog):
+        fake = Faker()
+
+        with caplog.at_level(logging.WARNING):
+            for i in range(3):
+                _ = fake.preferred_unique.boolean()
+        assert (
+            'There seem to be no more unique values for generator "boolean". '
+            "Resetting store of generated values as uniqueness is not being enforced."
+        ) in caplog.text
+
+    def test_current_values_exempt_from_unique_check(self):
+        fake = Faker()
+
+        country_first_attempt = fake.unique.current_country()
+        assert country_first_attempt == fake.unique.current_country()
+
+    def test_initial_current_values_with_multiple_locales_are_unique(self):
+        fake = Faker(AVAILABLE_LOCALES)
+
+        all_country_codes_with_locales = {Faker(locale).current_country_code() for locale in AVAILABLE_LOCALES}
+        generated_country_codes = {fake.unique.current_country_code() for _ in range(len(AVAILABLE_LOCALES))}
+
+        assert all_country_codes_with_locales == generated_country_codes
+
+    def test_current_values_start_repeating_after_locales_exhausted(self):
+        fake = Faker({"en_US": 1, "fr_FR": 2}, use_weighting=True)
+
+        locale_count = len(fake.locales)
+        generated_countries = {fake.unique.current_country() for _ in range(locale_count)}
+        assert len(generated_countries) == locale_count
+        assert fake.unique.current_country() in generated_countries
+
+    def test_unique_current_does_not_shrink_shared_factory_cache(self):
+        """Round-robin over `current_*` factories must stay private to `.unique`.
+
+        Using `fake.unique.current_country()` must not evict locales from the
+        factory mapping cached on the proxy and shared with regular calls.
+        """
+        locales = ["en_US", "fr_FR", "de_DE", "ja_JP"]
+        fake = Faker(locales)
+        expected_countries = {Faker(locale).current_country() for locale in locales}
+
+        # Consume one factory through the unique proxy
+        fake.unique.current_country()
+
+        # Regular calls must still be able to reach every locale
+        generated = {fake.current_country() for _ in range(1000)}
+        assert generated == expected_countries
+
+        # ... and the unique proxy still cycles through all of them
+        remaining = {fake.unique.current_country() for _ in range(len(locales) - 1)}
+        assert len(remaining) == len(locales) - 1
+
+    def test_none_values_exempt_from_unique_check(self):
+        fake = Faker()
+
+        for _ in range(2):
+            assert fake.unique.seed_locale("en_US", 0) is None