@@ -12,14 +12,15 @@
 import sys
 import tempfile
 import unittest
+import warnings
 
 REPO_ROOT = pathlib.Path(__file__).resolve().parents[3]
 sys.path.insert(0, str(REPO_ROOT))
 
 from scripts import lavafuncs  # pylint: disable=wrong-import-position
 from scripts.context import Context  # pylint: disable=wrong-import-position
 from leapp_functions.app.artifact_result import ArtifactResult  # pylint: disable=wrong-import-position
-from scripts.ilapfuncs import artifact_processor, OutputParameters  # pylint: disable=wrong-import-position
+from scripts.ilapfuncs import artifact_processor, kmlgen, OutputParameters  # pylint: disable=wrong-import-position
 
 UTC = datetime.timezone.utc
 STAMP = datetime.datetime(2022, 3, 4, 12, 34, 56, tzinfo=UTC)
@@ -281,8 +282,10 @@ def test_list_module_that_raises_leaves_the_same_nothing(self):
         self.assertNotIn('Probe Category', lavafuncs.lava_data['artifacts'])
 
 class TestReplayKeepsPythonText(ArtifactResultTestCase):
-    """Floats and booleans in untyped columns replay exactly as the list path prints them,
-    while the list path's own stored values are unchanged."""
+    """Floats and booleans in untyped LAVA columns, and the coordinates kmlgen keeps in
+    _latlong.db, are stored as the text Python prints for them. The stored text is then the
+    same whatever SQLite library the run links, matches the HTML, TSV and KML output, and
+    replays as the original values."""
 
     def setUp(self):
         super().setUp()
@@ -299,24 +302,53 @@ def test_streamed_rows_replay_as_the_original_values(self):
         replayed = list(lavafuncs.lava_iter_artifact_rows(
             result.table_name, headers, result.object_columns, result.row_count))
         self.assertEqual(replayed, rows)
-        # The stored text is Python's own rendering, not SQLite's 15-digit one.
+        # The stored text is Python's own rendering, not SQLite's, which depends on its version.
         stored = lavafuncs.lava_db.execute(
             f'SELECT latitude, flag FROM {lavafuncs.quote_sql_name(result.table_name)} ORDER BY rowid').fetchall()
         self.assertEqual(stored, [('35.65956623101914', 'True'), ('-78.87282251025944', 'False')])
 
-    def test_list_path_storage_is_unchanged(self):
-        headers = ('Latitude', 'Flag', 'When')
+    def test_list_path_stores_python_text(self):
+        headers = ('Latitude', 'Flag', ('When', 'datetime'))
         table, object_columns, column_map = lavafuncs.lava_process_artifact(
-            'Unit Category', 'unit_module', 'List Artifact', (headers[0], headers[1], (headers[2], 'datetime')),
-            1, func_name='list_artifact')
+            'Unit Category', 'unit_module', 'List Artifact', headers, 2, func_name='list_artifact')
         lavafuncs.lava_insert_sqlite_data(
-            table, [(35.65956623101914, True, '2024-07-21T15:16:47.357843+00:00')],
-            object_columns, (headers[0], headers[1], (headers[2], 'datetime')), column_map)
+            table, [(35.65956623101914, True, '2024-07-21T15:16:47.357843+00:00'),
+                    (670162.147879839, False, '2024-07-21T15:16:47.357843+00:00')],
+            object_columns, headers, column_map)
         stored = lavafuncs.lava_db.execute(
-            f'SELECT latitude, flag, "when" FROM {lavafuncs.quote_sql_name(table)}').fetchone()
-        # SQLite's rendering of a bound float and boolean into TEXT columns, and a whole-second
-        # int epoch for an ISO string: what the list path stored before this change.
-        self.assertEqual(stored, ('35.6595662310191', '1', 1721575007))
+            f'SELECT latitude, flag, "when" FROM {lavafuncs.quote_sql_name(table)} ORDER BY rowid').fetchall()
+        # Bound as numbers, SQLite 3.51 and earlier store the first float as 35.6595662310191,
+        # 3.52.0 and later store the second as 670162.14787983894, and both store a boolean as
+        # 1 or 0. The datetime column still stores the whole-second epoch.
+        self.assertEqual(stored, [('35.65956623101914', 'True', 1721575007),
+                                  ('670162.147879839', 'False', 1721575007)])
+
+    def test_streamed_dates_in_an_untyped_column_are_bound_as_text(self):
+        # As on the list path, sqlite3's default date adapters, deprecated from Python 3.12,
+        # never see a value, and the stored text is what they wrote.
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter('always')
+            result = Context.create_artifact_result(headers=HEADERS)
+            for row in ROWS:
+                result.add_row(row)
+            result.close()
+        self.assertEqual([w for w in caught if issubclass(w.category, DeprecationWarning)
+                          and 'adapter' in str(w.message)], [])
+        stored = [row[0] for row in lavafuncs.lava_db.execute(
+            f'SELECT moment FROM {lavafuncs.quote_sql_name(result.table_name)} ORDER BY rowid')]
+        self.assertEqual(stored, MOMENT_TEXT)
+
+    def test_kml_sidecar_stores_python_text_for_coordinates(self):
+        report_folder = pathlib.Path(self.tmpdir, 'category', 'artifact')
+        report_folder.mkdir(parents=True)
+        kmlgen(str(report_folder), 'Python Text', [(STAMP, 35.65956623101914, -78.87282251025944)],
+               ['Timestamp', 'Latitude', 'Longitude'])
+        db = sqlite3.connect(pathlib.Path(self.tmpdir, '_KML Exports', '_latlong.db'))
+        stored = db.execute('SELECT latitude, longitude FROM data').fetchall()
+        db.close()
+        # Bound as numbers these read 35.6595662310191 and -78.8728225102594 through
+        # SQLite 3.51, and 35.659566231019142 and -78.872822510259439 from 3.52.0.
+        self.assertEqual(stored, [('35.65956623101914', '-78.87282251025944')])
 
     def test_python_text_restore_is_exact_and_leaves_other_text_alone(self):
         restore = lavafuncs._restore_lava_value  # pylint: disable=protected-access
 
@@ -171,7 +171,6 @@ def _flush_batch(self):
             batch_size=self.batch_size,
             async_write=self.async_write,
             queue_size=self.queue_size,
-            keep_python_text=True,
         )
         self.row_count += inserted_count
 
 
@@ -65,7 +65,7 @@
 from scripts.lavafuncs import lava_process_artifact, lava_insert_sqlite_data, lava_iter_artifact_rows, \
     lava_get_media_item, \
     lava_insert_sqlite_media_item, lava_insert_sqlite_media_references, lava_get_media_references, \
-    lava_get_full_media_info, lava_update_record_count, bind_dates_as_text
+    lava_get_full_media_info, lava_update_record_count, bind_dates_as_text, _python_text
 
 os.path.basename = lru_cache(maxsize=None)(os.path.basename)
 
@@ -1318,7 +1318,9 @@ def kmlgen(report_folder, kmlactivity, data_list, data_headers):
             pnt.name = times
             pnt.description = f"{times_header}: {times} - {kmlactivity}"
             pnt.coords = [(lon, lat)]
-            data.append((bind_dates_as_text(times), lat, lon, kmlactivity))
+            # Python's text for the coordinates, as the .kml file carries: bound as floats,
+            # the text SQLite stores depends on its version (see lavafuncs._python_text).
+            data.append((bind_dates_as_text(times), _python_text(lat), _python_text(lon), kmlactivity))
 
     if len(data) > 0:
         report_folder = report_folder.rstrip('/')
 
@@ -179,12 +179,14 @@ def _python_text(value):
     """
     The text Python itself would print for a float or a boolean, or the value unchanged.
 
-    An untyped LAVA column is TEXT, and SQLite renders a bound float into it at 15
-    significant digits and a boolean as 1 or 0. The HTML, TSV, timeline and KML writers
-    print the Python value, so rows replayed out of LAVA would otherwise read
-    35.6595662310191 where the list path wrote 35.65956623101914, and 1 where it wrote
-    True. Storing Python's own text keeps the replayed outputs identical to the list
-    path's; _restore_lava_value turns it back into the value.
+    An untyped LAVA column is TEXT, so a float or boolean bound as a number is turned into
+    text by SQLite, and that text depends on the SQLite library the run links. Through
+    3.51 a float is rounded to 15 significant digits, so 35.65956623101914 is stored as
+    35.6595662310191; 3.52.0 and later round to 17 (https://sqlite.org/releaselog/3_53_0.html),
+    so 670162.147879839 is stored as 670162.14787983894. A boolean is stored as 1 or 0.
+    The HTML, TSV, timeline and KML writers print the Python value, so storing Python's own
+    text keeps LAVA identical to them on every SQLite version; _restore_lava_value turns it
+    back into the value when streamed rows are replayed.
     """
 
     if isinstance(value, bool):
@@ -194,24 +196,23 @@ def _python_text(value):
     return value
 
 
-def _prepare_lava_value(value, column_type=None, keep_python_text=False):
+def _prepare_lava_value(value, column_type=None):
     """
     Convert a Python value into the representation stored in the LAVA SQLite table.
 
     Only column types that need storage conversion get handlers here. Other object
     column types, such as phonenumber, remain normal SQLite TEXT values while their
     type metadata stays available in the LAVA artifact metadata.
 
-    keep_python_text stores a float or boolean in an untyped column as the text Python
-    prints for it (see _python_text). Rows that will be replayed for the other outputs
-    ask for it; the list path does not, so its stored values are unchanged.
+    A float or boolean in an untyped column is stored as the text Python prints for it
+    (see _python_text), whether the artifact returned a list or streamed its rows.
     """
 
     if isinstance(value, (dict, list)):
         return json.dumps(value)
 
-    if keep_python_text and column_type is None:
-        return _python_text(value)
+    if column_type is None:
+        value = _python_text(value)
 
     type_handlers = {
         'datetime': _prepare_datetime_value,
@@ -626,12 +627,12 @@ def lava_insert_sqlite_data(
         column_map,  # pylint: disable=unused-argument
         batch_size=10000,
         async_write=False,
-        queue_size=5000,
-        keep_python_text=False):
+        queue_size=5000):
     """
     Insert data into a SQLite database table with automatic column sanitization and type conversion.
     This function handles the insertion of multiple rows of data into a specified SQLite table,
     with special handling for complex data types (dict, list) and object-column type conversions.
+    Floats and booleans in untyped columns are stored as the text Python prints for them.
     Args:
         table_name (str): The name of the SQLite table to insert data into.
         data (iterable): Rows to insert, where each row is a sequence of values
@@ -645,8 +646,6 @@ def lava_insert_sqlite_data(
         batch_size (int): Maximum rows to insert per SQLite executemany call.
         async_write (bool): If True, prepare and insert rows on a writer thread.
         queue_size (int): Maximum rows waiting for the async writer.
-        keep_python_text (bool): Store floats and booleans in untyped columns as the text
-                                 Python prints for them, for rows that will be replayed.
     Returns:
         int: Number of rows inserted.
     """
@@ -670,7 +669,7 @@ def prepare_row(row):
             row = tuple(row)
         processed_row = []
         for index, value in enumerate(row):
-            processed_row.append(_prepare_lava_value(value, column_types[index], keep_python_text))
+            processed_row.append(_prepare_lava_value(value, column_types[index]))
         return tuple(processed_row)
 
     if async_write:
Original file line number	Diff line number	Diff line change
`@@ -171,7 +171,6 @@ def _flush_batch(self):`
`171`	`171`	`batch_size=self.batch_size,`
`172`	`172`	`async_write=self.async_write,`
`173`	`173`	`queue_size=self.queue_size,`
`174`		`- keep_python_text=True,`
`175`	`174`	`)`
`176`	`175`	`self.row_count += inserted_count`
`177`	`176`