Improve grammar and consistency in some internal docstrings/comments.

Author: nuztalgia

src/humanize/time.py

@@ -348,25 +348,25 @@ def _quotient_and_remainder(
     minimum_unit: Unit,
     suppress: 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)
@@ -391,16 +391,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, [])
@@ -471,7 +471,7 @@ def precisedelta(
     suppress: Iterable[str] = (),
     format: str = "%0.2f",
 ) -> str:
-    """Return a precise representation of a timedelta.
+    """Return a precise representation of a timedelta or number of seconds.
 
     ```pycon
     >>> import datetime as dt
@@ -543,8 +543,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
@@ -593,7 +593,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 = [