gh-111487: Fix csv.Sniffer rejecting a delimiter at 90% consistency

_guess_delimiter counts a candidate delimiter's consistency down from
100% to a documented minimum threshold of 90%, but stepped the counter
by repeatedly subtracting 0.01 from a float.  The accumulated rounding
error left it at 0.8999999999999999 after ten steps, so the loop exited
before making the final pass and a delimiter present on exactly 90% of
the rows was never accepted.

Count down in whole percent and compare with exact integer arithmetic
instead.  `total` no longer needs to be a float, and the loop keeps the
original behaviour of not running once a delimiter has been found in an
earlier chunk.

Author: pikammmmm

Lib/csv.py

@@ -404,18 +404,21 @@ def _guess_delimiter(self, data, delimiters):
 
             # build a list of possible delimiters
             modeList = modes.items()
-            total = float(min(chunkLength * iteration, len(data)))
-            # (rows of consistent data) / (number of rows) = 100%
-            consistency = 1.0
-            # minimum consistency threshold
-            threshold = 0.9
-            while len(delims) == 0 and consistency >= threshold:
+            total = min(chunkLength * iteration, len(data))
+            # (rows of consistent data) / (number of rows) = 100%, counted
+            # down in whole percent to a minimum consistency threshold of 90%.
+            # The comparison uses exact integer arithmetic: stepping a float
+            # down by 0.01 accumulated rounding error, so the counter fell to
+            # 0.8999999999999999 instead of 0.9 and the final pass at the
+            # threshold never ran (gh-111487).
+            for consistency in range(100, 89, -1):
+                if delims:
+                    break
                 for k, v in modeList:
                     if v[0] > 0 and v[1] > 0:
-                        if ((v[1]/total) >= consistency and
+                        if (v[1] * 100 >= consistency * total and
                             (delimiters is None or k in delimiters)):
                             delims[k] = v
-                consistency -= 0.01
 
             if len(delims) == 1:
                 delim = list(delims.keys())[0]

Lib/test/test_csv.py

@@ -1521,6 +1521,20 @@ def test_guess_delimiter_crlf_not_chosen(self):
         self.assertEqual(sniffer.sniff(sample).delimiter, "|")
         self.assertNotEqual(sniffer.sniff(sample).delimiter, "\r")
 
+    def test_guess_delimiter_at_minimum_consistency(self):
+        # gh-111487: a delimiter occurring on exactly 90% of the rows -- the
+        # documented minimum consistency -- used to be rejected, because the
+        # counter was stepped down by repeatedly subtracting 0.01 from a float
+        # and so never reached 0.9 exactly.
+        # Every row uses a different letter, so only ";" is consistent; the
+        # short row is in the first chunk, which keeps that chunk below the
+        # threshold and defers the decision to the 20-row chunk (18/20 == 90%).
+        rows = [(chr(ord('a') + i) + ';') * 3 + chr(ord('a') + i)
+                for i in range(20)]
+        rows[4] = 'e;e;e'
+        sniffer = csv.Sniffer()
+        self.assertEqual(sniffer.sniff('\n'.join(rows)).delimiter, ';')
+
     def test_zero_mode_tie_order_independence(self):
         sniffer = csv.Sniffer()
         # ":" appears in half the rows (1, 0, 1, 0) - a tie between

Misc/NEWS.d/next/Library/2026-07-29-13-21-44.gh-issue-111487.Kw9pTz.rst

@@ -0,0 +1,4 @@
+Fix :meth:`csv.Sniffer.sniff` rejecting a delimiter that occurs on exactly 90%
+of the rows, the documented minimum consistency.  The consistency counter was
+stepped down by repeatedly subtracting ``0.01`` from a float and so never
+reached that threshold exactly; it now uses exact integer arithmetic.