Improve grammar and consistency in some internal docstrings/comments.

Author: nuztalgia

src/humanize/i18n.py

@@ -107,14 +107,14 @@ def _pgettext(msgctxt: str, message: str) -> str:
         return message if translation == key else translation
 
 
-def _ngettext(message: str, plural: str, num: int) -> str:
+def _ngettext(message: str, plural: str, num: int | float) -> str:
     """Plural version of _gettext.
 
     Args:
         message (str): Singular text to translate.
         plural (str): Plural text to translate.
-        num (int): The number (e.g. item count) to determine translation for the
-            respective grammatical number.
+        num (int or float): The number (e.g. item count) to determine translation for
+            the respective grammatical number.
 
     Returns:
         str: Translated text.

src/humanize/time.py

@@ -298,25 +298,25 @@ def _quotient_and_remainder(
     minimum_unit: Unit,
     suppress: collections.abc.Iterable[Unit],
 ) -> tuple[float, float]:
-    """Divide `value` by `divisor` returning the quotient and remainder.
+    """Divide `value` by `divisor`, returning the quotient and remainder.
 
-    If `unit` is `minimum_unit`, makes the quotient a float number and the remainder
-    will be zero. The rational is that if `unit` is the unit of the quotient, we cannot
+    If `unit` is `minimum_unit`, the quotient will be a float number and the remainder
+    will be zero. The rationale is that if `unit` is the unit of the quotient, we cannot
     represent the remainder because it would require a unit smaller than the
     `minimum_unit`.
 
     >>> from humanize.time import _quotient_and_remainder, Unit
     >>> _quotient_and_remainder(36, 24, Unit.DAYS, Unit.DAYS, [])
     (1.5, 0)
 
-    If unit is in `suppress`, the quotient will be zero and the remainder will be the
+    If `unit` is in `suppress`, the quotient will be zero and the remainder will be the
     initial value. The idea is that if we cannot use `unit`, we are forced to use a
-    lower unit so we cannot do the division.
+    lower unit, so we cannot do the division.
 
     >>> _quotient_and_remainder(36, 24, Unit.DAYS, Unit.HOURS, [Unit.DAYS])
     (0, 36)
 
-    In other case return quotient and remainder as `divmod` would do it.
+    In other cases, return the quotient and remainder as `divmod` would do it.
 
     >>> _quotient_and_remainder(36, 24, Unit.DAYS, Unit.HOURS, [])
     (1, 12)
@@ -340,16 +340,16 @@ def _carry(
 ) -> tuple[float, float]:
     """Return a tuple with two values.
 
-    If the unit is in `suppress`, multiply `value1` by `ratio` and add it to `value2`
-    (carry to right). The idea is that if we cannot represent `value1` we need to
+    If `unit` is in `suppress`, multiply `value1` by `ratio` and add it to `value2`
+    (carry to right). The idea is that if we cannot represent `value1`, we need to
     represent it in a lower unit.
 
     >>> from humanize.time import _carry, Unit
     >>> _carry(2, 6, 24, Unit.DAYS, Unit.SECONDS, [Unit.DAYS])
     (0, 54)
 
-    If the unit is the minimum unit, `value2` is divided by `ratio` and added to
-    `value1` (carry to left). We assume that `value2` has a lower unit so we need to
+    If `unit` is the minimum unit, divide `value2` by `ratio` and add it to `value1`
+    (carry to left). We assume that `value2` has a lower unit, so we need to
     carry it to `value1`.
 
     >>> _carry(2, 6, 24, Unit.DAYS, Unit.DAYS, [])
@@ -369,7 +369,7 @@ def _carry(
 
 
 def _suitable_minimum_unit(min_unit: Unit, suppress: typing.Iterable[Unit]) -> Unit:
-    """Return a minimum unit suitable that is not suppressed.
+    """Return a suitable minimum unit that is not suppressed.
 
     If not suppressed, return the same unit:
 
@@ -492,8 +492,8 @@ def precisedelta(
 
     suppress_set = {Unit[s.upper()] for s in suppress}
 
-    # Find a suitable minimum unit (it can be greater the one that the
-    # user gave us if it is suppressed).
+    # Find a suitable minimum unit (it can be greater than the one that the
+    # user gave us, if that one is suppressed).
     min_unit = Unit[minimum_unit.upper()]
     min_unit = _suitable_minimum_unit(min_unit, suppress_set)
     del minimum_unit
@@ -542,7 +542,7 @@ def precisedelta(
         usecs, 1000, MILLISECONDS, min_unit, suppress_set
     )
 
-    # if _unused != 0 we had lost some precision
+    # if _unused != 0 we have lost some precision
     usecs, _unused = _carry(usecs, 0, 1, MICROSECONDS, min_unit, suppress_set)
 
     fmts = [