Fix upper limit of nb_elements (#2067)

* upper limit nb_elements fix

* upper limit nb_elements fix tests

faker/providers/lorem/__init__.py

@@ -23,40 +23,33 @@ class Provider(BaseProvider):
  word_connector = " "
  sentence_punctuation = "."
 
- def words(
+ def get_words_list(
  self,
- nb: int = 3,
  part_of_speech: Optional[str] = None,
  ext_word_list: Optional[Sequence[str]] = None,
- unique: bool = False,
  ) -> List[str]:
- """Generate a tuple of words.
-
- The ``nb`` argument controls the number of words in the resulting list,
- and if ``ext_word_list`` is provided, words from that list will be used
- instead of those from the locale provider's built-in word list.
+ """Get list of words.
 
- If ``unique`` is ``True``, this method will return a list containing
- unique words. Under the hood, |random_sample| will be used for sampling
- without replacement. If ``unique`` is ``False``, |random_choices| is
- used instead, and the list returned may contain duplicates.
+ ``ext_word_list`` is a parameter that allows the user to provide a list
+ of words to be used instead of the built-in word list. If ``ext_word_list``
+ is provided, then the value of ``part_of_speech`` is ignored.
 
  ``part_of_speech`` is a parameter that defines to what part of speech
  the returned word belongs. If ``ext_word_list`` is not ``None``, then
  ``part_of_speech`` is ignored. If the value of ``part_of_speech`` does
  not correspond to an existent part of speech according to the set locale,
  then an exception is raised.
 
- .. warning::
- Depending on the length of a locale provider's built-in word list or
- on the length of ``ext_word_list`` if provided, a large ``nb`` can
- exhaust said lists if ``unique`` is ``True``, raising an exception.
+ :sample: part_of_speech="abc", ext_word_list=['abc', 'def', 'ghi', 'jkl']
+ :sample: part_of_speech="abc"
+ :sample: ext_word_list=['abc', 'def', 'ghi', 'jkl']
 
- :sample:
- :sample: nb=5
- :sample: nb=5, ext_word_list=['abc', 'def', 'ghi', 'jkl']
- :sample: nb=4, ext_word_list=['abc', 'def', 'ghi', 'jkl'], unique=True
+ .. warning::
+  Depending on the length of a locale provider's built-in word list or
+  on the length of ``ext_word_list`` if provided, a large ``nb`` can
+  exhaust said lists if ``unique`` is ``True``, raising an exception.
  """
+
  if ext_word_list is not None:
  word_list = ext_word_list
  elif part_of_speech:
@@ -67,6 +60,38 @@ def words(
  else:
  word_list = self.word_list # type: ignore[attr-defined]
 
+ return word_list
+
+ def words(
+ self,
+ nb: int = 3,
+ word_list: List[str] = None,
+ unique: bool = False,
+ ) -> List[str]:
+ """Generate a tuple of words.
+
+ The ``nb`` argument controls the number of words in the resulting list,
+ and if ``ext_word_list`` is provided, words from that list will be used
+ instead of those from the locale provider's built-in word list.
+
+ if ``word_list`` is not provided, the method will use a default value of None,
+ which will result in the method calling the ``get_words_list`` method to get the
+ word list. If ``word_list`` is provided, the method will use the provided list.
+
+ If ``unique`` is ``True``, this method will return a list containing
+ unique words. Under the hood, |random_sample| will be used for sampling
+ without replacement. If ``unique`` is ``False``, |random_choices| is
+ used instead, and the list returned may contain duplicates.
+
+ :sample:
+ :sample: nb=5
+ :sample: nb=5, ext_word_list=['abc', 'def', 'ghi', 'jkl']
+ :sample: nb=4, ext_word_list=['abc', 'def', 'ghi', 'jkl'], unique=True
+ """
+
+ if word_list is None:
+ word_list = self.get_words_list()
+
  if unique:
  unique_samples = cast(List[str], self.random_sample(word_list, length=nb))
  return unique_samples
@@ -82,7 +107,9 @@ def word(self, part_of_speech: Optional[str] = None, ext_word_list: Optional[Seq
  :sample:
  :sample: ext_word_list=['abc', 'def', 'ghi', 'jkl']
  """
- return self.words(1, part_of_speech, ext_word_list)[0]
+ word_list = self.get_words_list(part_of_speech, ext_word_list)
+
+ return self.words(1, word_list)[0]
 
  def sentence(
  self, nb_words: int = 6, variable_nb_words: bool = True, ext_word_list: Optional[Sequence[str]] = None
@@ -109,7 +136,8 @@ def sentence(
  if variable_nb_words:
  nb_words = self.randomize_nb_elements(nb_words, min=1)
 
- words = list(self.words(nb=nb_words, ext_word_list=ext_word_list))
+ word_list = self.get_words_list(ext_word_list=ext_word_list)
+ words = list(self.words(nb=nb_words, word_list=word_list))
  words[0] = words[0].title()
 
  return self.word_connector.join(words) + self.sentence_punctuation

faker/providers/lorem/en_PH/__init__.py

@@ -32,7 +32,10 @@ def english_words(self, nb: int = 3, unique: bool = False) -> List[str]:
  :sample: nb=5
  :sample: nb=5, unique=True
  """
- return self.words(nb=nb, ext_word_list=self.english_word_list, unique=unique)
+
+ word_list = self.generator.get_words_list(ext_word_list=self.english_word_list)
+
+ return self.words(nb=nb, word_list=word_list, unique=unique)
 
  def english_sentence(self, nb_words: int = 6, variable_nb_words: bool = True) -> str:
  """Generate a sentence in English.

faker/providers/python/__init__.py

@@ -1,3 +1,4 @@
+import logging
 import math
 import string
 import sys
@@ -16,6 +17,8 @@
 TypesSpec = Union[List[Type], Tuple[Type, ...]]
 TEnum = TypeVar("TEnum", bound=Enum)
 
+logger = logging.getLogger(__name__)
+
 
 class EmptyEnumException(BaseFakerException):
  pass
@@ -466,9 +469,18 @@ def pydict(
  :variable_nb_elements: is use variable number of elements for dictionary
  :value_types: type of dictionary values
  """
+
+ words_list_count = len(self.generator.get_words_list())
+
  if variable_nb_elements:
  nb_elements = self.randomize_nb_elements(nb_elements, min=1)
 
+ if nb_elements > words_list_count:
+ logger.warning(
+ f"Number of nb_elements is greater than the number of words in the list. {words_list_count} words will be used."
+ )
+ nb_elements = words_list_count
+
  return dict(
  zip(
  self.generator.words(nb_elements, unique=True),

faker/proxy.pyi

@@ -1588,6 +1588,32 @@ class Faker:
  def isbn10(self, separator: str = ...) -> str: ...
  def isbn13(self, separator: str = ...) -> str: ...
  def job(self) -> str: ...
+ def get_words_list(
+ self, part_of_speech: Optional[str] = ..., ext_word_list: Optional[Sequence[str]] = ...
+ ) -> List[str]:
+ """
+ Get list of words.
+
+ ``ext_word_list`` is a parameter that allows the user to provide a list
+ of words to be used instead of the built-in word list. If ``ext_word_list``
+ is provided, then the value of ``part_of_speech`` is ignored.
+
+ ``part_of_speech`` is a parameter that defines to what part of speech
+ the returned word belongs. If ``ext_word_list`` is not ``None``, then
+ ``part_of_speech`` is ignored. If the value of ``part_of_speech`` does
+ not correspond to an existent part of speech according to the set locale,
+ then an exception is raised.
+
+ :sample: part_of_speech="abc", ext_word_list=['abc', 'def', 'ghi', 'jkl']
+ :sample: part_of_speech="abc"
+ :sample: ext_word_list=['abc', 'def', 'ghi', 'jkl']
+
+ .. warning::
+ Depending on the length of a locale provider's built-in word list or
+ on the length of ``ext_word_list`` if provided, a large ``nb`` can
+ exhaust said lists if ``unique`` is ``True``, raising an exception.
+ """
+ ...
  def paragraph(
  self, nb_sentences: int = ..., variable_nb_sentences: bool = ..., ext_word_list: Optional[Sequence[str]] = ...
  ) -> str:
@@ -1703,36 +1729,23 @@ class Faker:
  :sample: ext_word_list=['abc', 'def', 'ghi', 'jkl']
  """
  ...
- def words(
- self,
- nb: int = ...,
- part_of_speech: Optional[str] = ...,
- ext_word_list: Optional[Sequence[str]] = ...,
- unique: bool = ...,
- ) -> List[str]:
+ def words(self, nb: int = ..., word_list: List[str] = ..., unique: bool = ...) -> List[str]:
  """
  Generate a tuple of words.
 
  The ``nb`` argument controls the number of words in the resulting list,
  and if ``ext_word_list`` is provided, words from that list will be used
  instead of those from the locale provider's built-in word list.
 
+ if ``word_list`` is not provided, the method will use a default value of None,
+ which will result in the method calling the ``get_words_list`` method to get the
+ word list. If ``word_list`` is provided, the method will use the provided list.
+
  If ``unique`` is ``True``, this method will return a list containing
  unique words. Under the hood, |random_sample| will be used for sampling
  without replacement. If ``unique`` is ``False``, |random_choices| is
  used instead, and the list returned may contain duplicates.
 
- ``part_of_speech`` is a parameter that defines to what part of speech
- the returned word belongs. If ``ext_word_list`` is not ``None``, then
- ``part_of_speech`` is ignored. If the value of ``part_of_speech`` does
- not correspond to an existent part of speech according to the set locale,
- then an exception is raised.
-
- .. warning::
- Depending on the length of a locale provider's built-in word list or
- on the length of ``ext_word_list`` if provided, a large ``nb`` can
- exhaust said lists if ``unique`` is ``True``, raising an exception.
-
  :sample:
  :sample: nb=5
  :sample: nb=5, ext_word_list=['abc', 'def', 'ghi', 'jkl']

tests/providers/test_lorem.py

@@ -44,15 +44,15 @@ def test_words_with_defaults(self, faker, num_samples):
  def test_words_with_custom_word_list(self, faker, num_samples):
  num_words = 5
  for _ in range(num_samples):
- words = faker.words(num_words, ext_word_list=self.custom_word_list)
+ words = faker.words(num_words, word_list=self.custom_word_list)
  assert isinstance(words, list)
  assert len(words) == 5
  assert all(isinstance(word, str) and word in self.custom_word_list for word in words)
 
  def test_words_with_unique_sampling(self, faker, num_samples):
  num_words = 5
  for _ in range(num_samples):
- words = faker.words(num_words, ext_word_list=self.custom_word_list, unique=True)
+ words = faker.words(num_words, word_list=self.custom_word_list, unique=True)
  assert isinstance(words, list)
  assert len(words) == 5
 
@@ -165,29 +165,26 @@ def test_texts(self, faker, num_samples):
  words = re.sub(r"[.\n]+", " ", text.lower()).split()
  assert all(word in self.custom_word_list for word in words)
 
- @pytest.mark.parametrize(
- "nb,part_of_speech", [(10, "verb"), (18, "adverb"), (11, "noun")], ids=["verb", "adverb", "noun"]
- )
- def test_words_part_of_speech(self, faker, nb, part_of_speech):
- words = faker.words(nb=nb, part_of_speech=part_of_speech)
- assert (word in EnUsLoremProvider.parts_of_speech[part_of_speech] for word in words)
+ def test_get_default_words_list(self, faker):
+ words_list = faker.get_words_list()
+ assert all(word in EnUsLoremProvider.word_list for word in words_list)
+
+ @pytest.mark.parametrize("part_of_speech", [("verb"), ("adverb"), ("noun")], ids=["verb", "adverb", "noun"])
+ def test_get_words_list_part_of_speech(self, faker, part_of_speech):
+ words_list = faker.get_words_list(part_of_speech=part_of_speech)
+ assert (word in EnUsLoremProvider.parts_of_speech[part_of_speech] for word in words_list)
+
+ def test_get_words_list_invalid_part_of_speech(self, faker):
+ part_of_speech = "invalid part of speech"
 
- @pytest.mark.parametrize("nb,part_of_speech", [(5, "abcdefg")], ids=["invalid part of speech"])
- def test_words_invalid_part_of_speech(self, faker, nb, part_of_speech):
  with pytest.raises(ValueError) as exc_info:
- faker.words(nb=nb, part_of_speech=part_of_speech)
+ faker.get_words_list(part_of_speech=part_of_speech)
 
  assert exc_info.type is ValueError
  assert exc_info.value.args[0] == f"{part_of_speech} is not recognized as a part of speech."
 
- @pytest.mark.parametrize(
- "nb,part_of_speech",
- [(3, "adverb"), (5, "verb"), (4, "abcdefgh")],
- ids=["ignore adverb", "ignore verb", "ignore invalid part of speech"],
- )
- def test_words_part_of_speech_ignored(self, faker, nb, part_of_speech):
- words = faker.words(nb=nb, part_of_speech=part_of_speech, ext_word_list=self.custom_word_list)
- assert len(words) == nb
+ def test_get_words_list_part_of_speech_ignored(self, faker):
+ words = faker.get_words_list(part_of_speech="ignored part of speech", ext_word_list=self.custom_word_list)
  assert all(word in self.custom_word_list for word in words)
 
 

tests/providers/test_python.py

@@ -1,4 +1,5 @@
 import decimal
+import logging
 import sys
 import unittest
 import warnings
@@ -299,6 +300,37 @@ def test_float_min_and_max_value_with_same_whole(self):
  self.fake.pyfloat(min_value=2.3, max_value=2.5)
 
 
+class TestPyDict(unittest.TestCase):
+ def setUp(self):
+ self.fake = Faker()
+ Faker.seed(0)
+
+ def test_pydict_with_default_nb_elements(self):
+ result = self.fake.pydict()
+
+ self.assertEqual(len(result), 10)
+
+ def test_pydict_with_valid_number_of_nb_elements(self):
+ result = self.fake.pydict(nb_elements=5)
+
+ self.assertEqual(len(result), 5)
+
+ def test_pydict_with_invalid_number_of_nb_elements(self):
+ nb_elements = 10000
+
+ words_list_count = len(self.fake.get_words_list())
+
+ logger = logging.getLogger("faker.providers.python")
+
+ with patch.object(logger, "warning") as mock_warn:
+ result = self.fake.pydict(nb_elements=nb_elements)
+
+ mock_warn.assert_called_once_with(
+ f"Number of nb_elements is greater than the number of words in the list. {words_list_count} words will be used."
+ )
+ self.assertEqual(len(result), words_list_count)
+
+
 class TestPydecimal(unittest.TestCase):
  def setUp(self):
  self.fake = Faker()

tests/pytest/session_overrides/session_locale/__init__.py

@@ -1 +1 @@
-_MODULE_LOCALES = ["en_GB"]
+_MODULE_LOCALES = ["en_US"]